elfload.c 90 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008
  1. /* This is the Linux kernel elf-loading code, ported into user space */
  2. #include <sys/time.h>
  3. #include <sys/param.h>
  4. #include <stdio.h>
  5. #include <sys/types.h>
  6. #include <fcntl.h>
  7. #include <errno.h>
  8. #include <unistd.h>
  9. #include <sys/mman.h>
  10. #include <sys/resource.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <time.h>
  14. #include "qemu.h"
  15. #include "disas/disas.h"
  16. #ifdef _ARCH_PPC64
  17. #undef ARCH_DLINFO
  18. #undef ELF_PLATFORM
  19. #undef ELF_HWCAP
  20. #undef ELF_CLASS
  21. #undef ELF_DATA
  22. #undef ELF_ARCH
  23. #endif
  24. #define ELF_OSABI ELFOSABI_SYSV
  25. /* from personality.h */
  26. /*
  27. * Flags for bug emulation.
  28. *
  29. * These occupy the top three bytes.
  30. */
  31. enum {
  32. ADDR_NO_RANDOMIZE = 0x0040000, /* disable randomization of VA space */
  33. FDPIC_FUNCPTRS = 0x0080000, /* userspace function ptrs point to
  34. descriptors (signal handling) */
  35. MMAP_PAGE_ZERO = 0x0100000,
  36. ADDR_COMPAT_LAYOUT = 0x0200000,
  37. READ_IMPLIES_EXEC = 0x0400000,
  38. ADDR_LIMIT_32BIT = 0x0800000,
  39. SHORT_INODE = 0x1000000,
  40. WHOLE_SECONDS = 0x2000000,
  41. STICKY_TIMEOUTS = 0x4000000,
  42. ADDR_LIMIT_3GB = 0x8000000,
  43. };
  44. /*
  45. * Personality types.
  46. *
  47. * These go in the low byte. Avoid using the top bit, it will
  48. * conflict with error returns.
  49. */
  50. enum {
  51. PER_LINUX = 0x0000,
  52. PER_LINUX_32BIT = 0x0000 | ADDR_LIMIT_32BIT,
  53. PER_LINUX_FDPIC = 0x0000 | FDPIC_FUNCPTRS,
  54. PER_SVR4 = 0x0001 | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
  55. PER_SVR3 = 0x0002 | STICKY_TIMEOUTS | SHORT_INODE,
  56. PER_SCOSVR3 = 0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS | SHORT_INODE,
  57. PER_OSR5 = 0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS,
  58. PER_WYSEV386 = 0x0004 | STICKY_TIMEOUTS | SHORT_INODE,
  59. PER_ISCR4 = 0x0005 | STICKY_TIMEOUTS,
  60. PER_BSD = 0x0006,
  61. PER_SUNOS = 0x0006 | STICKY_TIMEOUTS,
  62. PER_XENIX = 0x0007 | STICKY_TIMEOUTS | SHORT_INODE,
  63. PER_LINUX32 = 0x0008,
  64. PER_LINUX32_3GB = 0x0008 | ADDR_LIMIT_3GB,
  65. PER_IRIX32 = 0x0009 | STICKY_TIMEOUTS,/* IRIX5 32-bit */
  66. PER_IRIXN32 = 0x000a | STICKY_TIMEOUTS,/* IRIX6 new 32-bit */
  67. PER_IRIX64 = 0x000b | STICKY_TIMEOUTS,/* IRIX6 64-bit */
  68. PER_RISCOS = 0x000c,
  69. PER_SOLARIS = 0x000d | STICKY_TIMEOUTS,
  70. PER_UW7 = 0x000e | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
  71. PER_OSF4 = 0x000f, /* OSF/1 v4 */
  72. PER_HPUX = 0x0010,
  73. PER_MASK = 0x00ff,
  74. };
  75. /*
  76. * Return the base personality without flags.
  77. */
  78. #define personality(pers) (pers & PER_MASK)
  79. /* this flag is uneffective under linux too, should be deleted */
  80. #ifndef MAP_DENYWRITE
  81. #define MAP_DENYWRITE 0
  82. #endif
  83. /* should probably go in elf.h */
  84. #ifndef ELIBBAD
  85. #define ELIBBAD 80
  86. #endif
  87. #ifdef TARGET_WORDS_BIGENDIAN
  88. #define ELF_DATA ELFDATA2MSB
  89. #else
  90. #define ELF_DATA ELFDATA2LSB
  91. #endif
  92. #ifdef TARGET_ABI_MIPSN32
  93. typedef abi_ullong target_elf_greg_t;
  94. #define tswapreg(ptr) tswap64(ptr)
  95. #else
  96. typedef abi_ulong target_elf_greg_t;
  97. #define tswapreg(ptr) tswapal(ptr)
  98. #endif
  99. #ifdef USE_UID16
  100. typedef abi_ushort target_uid_t;
  101. typedef abi_ushort target_gid_t;
  102. #else
  103. typedef abi_uint target_uid_t;
  104. typedef abi_uint target_gid_t;
  105. #endif
  106. typedef abi_int target_pid_t;
  107. #ifdef TARGET_I386
  108. #define ELF_PLATFORM get_elf_platform()
  109. static const char *get_elf_platform(void)
  110. {
  111. static char elf_platform[] = "i386";
  112. int family = object_property_get_int(OBJECT(thread_cpu), "family", NULL);
  113. if (family > 6)
  114. family = 6;
  115. if (family >= 3)
  116. elf_platform[1] = '0' + family;
  117. return elf_platform;
  118. }
  119. #define ELF_HWCAP get_elf_hwcap()
  120. static uint32_t get_elf_hwcap(void)
  121. {
  122. X86CPU *cpu = X86_CPU(thread_cpu);
  123. return cpu->env.features[FEAT_1_EDX];
  124. }
  125. #ifdef TARGET_X86_64
  126. #define ELF_START_MMAP 0x2aaaaab000ULL
  127. #define elf_check_arch(x) ( ((x) == ELF_ARCH) )
  128. #define ELF_CLASS ELFCLASS64
  129. #define ELF_ARCH EM_X86_64
  130. static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
  131. {
  132. regs->rax = 0;
  133. regs->rsp = infop->start_stack;
  134. regs->rip = infop->entry;
  135. }
  136. #define ELF_NREG 27
  137. typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
  138. /*
  139. * Note that ELF_NREG should be 29 as there should be place for
  140. * TRAPNO and ERR "registers" as well but linux doesn't dump
  141. * those.
  142. *
  143. * See linux kernel: arch/x86/include/asm/elf.h
  144. */
  145. static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUX86State *env)
  146. {
  147. (*regs)[0] = env->regs[15];
  148. (*regs)[1] = env->regs[14];
  149. (*regs)[2] = env->regs[13];
  150. (*regs)[3] = env->regs[12];
  151. (*regs)[4] = env->regs[R_EBP];
  152. (*regs)[5] = env->regs[R_EBX];
  153. (*regs)[6] = env->regs[11];
  154. (*regs)[7] = env->regs[10];
  155. (*regs)[8] = env->regs[9];
  156. (*regs)[9] = env->regs[8];
  157. (*regs)[10] = env->regs[R_EAX];
  158. (*regs)[11] = env->regs[R_ECX];
  159. (*regs)[12] = env->regs[R_EDX];
  160. (*regs)[13] = env->regs[R_ESI];
  161. (*regs)[14] = env->regs[R_EDI];
  162. (*regs)[15] = env->regs[R_EAX]; /* XXX */
  163. (*regs)[16] = env->eip;
  164. (*regs)[17] = env->segs[R_CS].selector & 0xffff;
  165. (*regs)[18] = env->eflags;
  166. (*regs)[19] = env->regs[R_ESP];
  167. (*regs)[20] = env->segs[R_SS].selector & 0xffff;
  168. (*regs)[21] = env->segs[R_FS].selector & 0xffff;
  169. (*regs)[22] = env->segs[R_GS].selector & 0xffff;
  170. (*regs)[23] = env->segs[R_DS].selector & 0xffff;
  171. (*regs)[24] = env->segs[R_ES].selector & 0xffff;
  172. (*regs)[25] = env->segs[R_FS].selector & 0xffff;
  173. (*regs)[26] = env->segs[R_GS].selector & 0xffff;
  174. }
  175. #else
  176. #define ELF_START_MMAP 0x80000000
  177. /*
  178. * This is used to ensure we don't load something for the wrong architecture.
  179. */
  180. #define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )
  181. /*
  182. * These are used to set parameters in the core dumps.
  183. */
  184. #define ELF_CLASS ELFCLASS32
  185. #define ELF_ARCH EM_386
  186. static inline void init_thread(struct target_pt_regs *regs,
  187. struct image_info *infop)
  188. {
  189. regs->esp = infop->start_stack;
  190. regs->eip = infop->entry;
  191. /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program
  192. starts %edx contains a pointer to a function which might be
  193. registered using `atexit'. This provides a mean for the
  194. dynamic linker to call DT_FINI functions for shared libraries
  195. that have been loaded before the code runs.
  196. A value of 0 tells we have no such handler. */
  197. regs->edx = 0;
  198. }
  199. #define ELF_NREG 17
  200. typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
  201. /*
  202. * Note that ELF_NREG should be 19 as there should be place for
  203. * TRAPNO and ERR "registers" as well but linux doesn't dump
  204. * those.
  205. *
  206. * See linux kernel: arch/x86/include/asm/elf.h
  207. */
  208. static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUX86State *env)
  209. {
  210. (*regs)[0] = env->regs[R_EBX];
  211. (*regs)[1] = env->regs[R_ECX];
  212. (*regs)[2] = env->regs[R_EDX];
  213. (*regs)[3] = env->regs[R_ESI];
  214. (*regs)[4] = env->regs[R_EDI];
  215. (*regs)[5] = env->regs[R_EBP];
  216. (*regs)[6] = env->regs[R_EAX];
  217. (*regs)[7] = env->segs[R_DS].selector & 0xffff;
  218. (*regs)[8] = env->segs[R_ES].selector & 0xffff;
  219. (*regs)[9] = env->segs[R_FS].selector & 0xffff;
  220. (*regs)[10] = env->segs[R_GS].selector & 0xffff;
  221. (*regs)[11] = env->regs[R_EAX]; /* XXX */
  222. (*regs)[12] = env->eip;
  223. (*regs)[13] = env->segs[R_CS].selector & 0xffff;
  224. (*regs)[14] = env->eflags;
  225. (*regs)[15] = env->regs[R_ESP];
  226. (*regs)[16] = env->segs[R_SS].selector & 0xffff;
  227. }
  228. #endif
  229. #define USE_ELF_CORE_DUMP
  230. #define ELF_EXEC_PAGESIZE 4096
  231. #endif
  232. #ifdef TARGET_ARM
  233. #ifndef TARGET_AARCH64
  234. /* 32 bit ARM definitions */
  235. #define ELF_START_MMAP 0x80000000
  236. #define elf_check_arch(x) ((x) == ELF_MACHINE)
  237. #define ELF_ARCH ELF_MACHINE
  238. #define ELF_CLASS ELFCLASS32
  239. static inline void init_thread(struct target_pt_regs *regs,
  240. struct image_info *infop)
  241. {
  242. abi_long stack = infop->start_stack;
  243. memset(regs, 0, sizeof(*regs));
  244. regs->ARM_cpsr = 0x10;
  245. if (infop->entry & 1)
  246. regs->ARM_cpsr |= CPSR_T;
  247. regs->ARM_pc = infop->entry & 0xfffffffe;
  248. regs->ARM_sp = infop->start_stack;
  249. /* FIXME - what to for failure of get_user()? */
  250. get_user_ual(regs->ARM_r2, stack + 8); /* envp */
  251. get_user_ual(regs->ARM_r1, stack + 4); /* envp */
  252. /* XXX: it seems that r0 is zeroed after ! */
  253. regs->ARM_r0 = 0;
  254. /* For uClinux PIC binaries. */
  255. /* XXX: Linux does this only on ARM with no MMU (do we care ?) */
  256. regs->ARM_r10 = infop->start_data;
  257. }
  258. #define ELF_NREG 18
  259. typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
  260. static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUARMState *env)
  261. {
  262. (*regs)[0] = tswapreg(env->regs[0]);
  263. (*regs)[1] = tswapreg(env->regs[1]);
  264. (*regs)[2] = tswapreg(env->regs[2]);
  265. (*regs)[3] = tswapreg(env->regs[3]);
  266. (*regs)[4] = tswapreg(env->regs[4]);
  267. (*regs)[5] = tswapreg(env->regs[5]);
  268. (*regs)[6] = tswapreg(env->regs[6]);
  269. (*regs)[7] = tswapreg(env->regs[7]);
  270. (*regs)[8] = tswapreg(env->regs[8]);
  271. (*regs)[9] = tswapreg(env->regs[9]);
  272. (*regs)[10] = tswapreg(env->regs[10]);
  273. (*regs)[11] = tswapreg(env->regs[11]);
  274. (*regs)[12] = tswapreg(env->regs[12]);
  275. (*regs)[13] = tswapreg(env->regs[13]);
  276. (*regs)[14] = tswapreg(env->regs[14]);
  277. (*regs)[15] = tswapreg(env->regs[15]);
  278. (*regs)[16] = tswapreg(cpsr_read((CPUARMState *)env));
  279. (*regs)[17] = tswapreg(env->regs[0]); /* XXX */
  280. }
  281. #define USE_ELF_CORE_DUMP
  282. #define ELF_EXEC_PAGESIZE 4096
  283. enum
  284. {
  285. ARM_HWCAP_ARM_SWP = 1 << 0,
  286. ARM_HWCAP_ARM_HALF = 1 << 1,
  287. ARM_HWCAP_ARM_THUMB = 1 << 2,
  288. ARM_HWCAP_ARM_26BIT = 1 << 3,
  289. ARM_HWCAP_ARM_FAST_MULT = 1 << 4,
  290. ARM_HWCAP_ARM_FPA = 1 << 5,
  291. ARM_HWCAP_ARM_VFP = 1 << 6,
  292. ARM_HWCAP_ARM_EDSP = 1 << 7,
  293. ARM_HWCAP_ARM_JAVA = 1 << 8,
  294. ARM_HWCAP_ARM_IWMMXT = 1 << 9,
  295. ARM_HWCAP_ARM_CRUNCH = 1 << 10,
  296. ARM_HWCAP_ARM_THUMBEE = 1 << 11,
  297. ARM_HWCAP_ARM_NEON = 1 << 12,
  298. ARM_HWCAP_ARM_VFPv3 = 1 << 13,
  299. ARM_HWCAP_ARM_VFPv3D16 = 1 << 14,
  300. ARM_HWCAP_ARM_TLS = 1 << 15,
  301. ARM_HWCAP_ARM_VFPv4 = 1 << 16,
  302. ARM_HWCAP_ARM_IDIVA = 1 << 17,
  303. ARM_HWCAP_ARM_IDIVT = 1 << 18,
  304. ARM_HWCAP_ARM_VFPD32 = 1 << 19,
  305. ARM_HWCAP_ARM_LPAE = 1 << 20,
  306. ARM_HWCAP_ARM_EVTSTRM = 1 << 21,
  307. };
  308. /* The commpage only exists for 32 bit kernels */
  309. #define TARGET_HAS_VALIDATE_GUEST_SPACE
  310. /* Return 1 if the proposed guest space is suitable for the guest.
  311. * Return 0 if the proposed guest space isn't suitable, but another
  312. * address space should be tried.
  313. * Return -1 if there is no way the proposed guest space can be
  314. * valid regardless of the base.
  315. * The guest code may leave a page mapped and populate it if the
  316. * address is suitable.
  317. */
  318. static int validate_guest_space(unsigned long guest_base,
  319. unsigned long guest_size)
  320. {
  321. unsigned long real_start, test_page_addr;
  322. /* We need to check that we can force a fault on access to the
  323. * commpage at 0xffff0fxx
  324. */
  325. test_page_addr = guest_base + (0xffff0f00 & qemu_host_page_mask);
  326. /* If the commpage lies within the already allocated guest space,
  327. * then there is no way we can allocate it.
  328. */
  329. if (test_page_addr >= guest_base
  330. && test_page_addr <= (guest_base + guest_size)) {
  331. return -1;
  332. }
  333. /* Note it needs to be writeable to let us initialise it */
  334. real_start = (unsigned long)
  335. mmap((void *)test_page_addr, qemu_host_page_size,
  336. PROT_READ | PROT_WRITE,
  337. MAP_ANONYMOUS | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
  338. /* If we can't map it then try another address */
  339. if (real_start == -1ul) {
  340. return 0;
  341. }
  342. if (real_start != test_page_addr) {
  343. /* OS didn't put the page where we asked - unmap and reject */
  344. munmap((void *)real_start, qemu_host_page_size);
  345. return 0;
  346. }
  347. /* Leave the page mapped
  348. * Populate it (mmap should have left it all 0'd)
  349. */
  350. /* Kernel helper versions */
  351. __put_user(5, (uint32_t *)g2h(0xffff0ffcul));
  352. /* Now it's populated make it RO */
  353. if (mprotect((void *)test_page_addr, qemu_host_page_size, PROT_READ)) {
  354. perror("Protecting guest commpage");
  355. exit(-1);
  356. }
  357. return 1; /* All good */
  358. }
  359. #define ELF_HWCAP get_elf_hwcap()
  360. static uint32_t get_elf_hwcap(void)
  361. {
  362. ARMCPU *cpu = ARM_CPU(thread_cpu);
  363. uint32_t hwcaps = 0;
  364. hwcaps |= ARM_HWCAP_ARM_SWP;
  365. hwcaps |= ARM_HWCAP_ARM_HALF;
  366. hwcaps |= ARM_HWCAP_ARM_THUMB;
  367. hwcaps |= ARM_HWCAP_ARM_FAST_MULT;
  368. /* probe for the extra features */
  369. #define GET_FEATURE(feat, hwcap) \
  370. do { if (arm_feature(&cpu->env, feat)) { hwcaps |= hwcap; } } while (0)
  371. /* EDSP is in v5TE and above, but all our v5 CPUs are v5TE */
  372. GET_FEATURE(ARM_FEATURE_V5, ARM_HWCAP_ARM_EDSP);
  373. GET_FEATURE(ARM_FEATURE_VFP, ARM_HWCAP_ARM_VFP);
  374. GET_FEATURE(ARM_FEATURE_IWMMXT, ARM_HWCAP_ARM_IWMMXT);
  375. GET_FEATURE(ARM_FEATURE_THUMB2EE, ARM_HWCAP_ARM_THUMBEE);
  376. GET_FEATURE(ARM_FEATURE_NEON, ARM_HWCAP_ARM_NEON);
  377. GET_FEATURE(ARM_FEATURE_VFP3, ARM_HWCAP_ARM_VFPv3);
  378. GET_FEATURE(ARM_FEATURE_V6K, ARM_HWCAP_ARM_TLS);
  379. GET_FEATURE(ARM_FEATURE_VFP4, ARM_HWCAP_ARM_VFPv4);
  380. GET_FEATURE(ARM_FEATURE_ARM_DIV, ARM_HWCAP_ARM_IDIVA);
  381. GET_FEATURE(ARM_FEATURE_THUMB_DIV, ARM_HWCAP_ARM_IDIVT);
  382. /* All QEMU's VFPv3 CPUs have 32 registers, see VFP_DREG in translate.c.
  383. * Note that the ARM_HWCAP_ARM_VFPv3D16 bit is always the inverse of
  384. * ARM_HWCAP_ARM_VFPD32 (and so always clear for QEMU); it is unrelated
  385. * to our VFP_FP16 feature bit.
  386. */
  387. GET_FEATURE(ARM_FEATURE_VFP3, ARM_HWCAP_ARM_VFPD32);
  388. GET_FEATURE(ARM_FEATURE_LPAE, ARM_HWCAP_ARM_LPAE);
  389. #undef GET_FEATURE
  390. return hwcaps;
  391. }
  392. #else
  393. /* 64 bit ARM definitions */
  394. #define ELF_START_MMAP 0x80000000
  395. #define elf_check_arch(x) ((x) == ELF_MACHINE)
  396. #define ELF_ARCH ELF_MACHINE
  397. #define ELF_CLASS ELFCLASS64
  398. #define ELF_PLATFORM "aarch64"
  399. static inline void init_thread(struct target_pt_regs *regs,
  400. struct image_info *infop)
  401. {
  402. abi_long stack = infop->start_stack;
  403. memset(regs, 0, sizeof(*regs));
  404. regs->pc = infop->entry & ~0x3ULL;
  405. regs->sp = stack;
  406. }
  407. #define ELF_NREG 34
  408. typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
  409. static void elf_core_copy_regs(target_elf_gregset_t *regs,
  410. const CPUARMState *env)
  411. {
  412. int i;
  413. for (i = 0; i < 32; i++) {
  414. (*regs)[i] = tswapreg(env->xregs[i]);
  415. }
  416. (*regs)[32] = tswapreg(env->pc);
  417. (*regs)[33] = tswapreg(pstate_read((CPUARMState *)env));
  418. }
  419. #define USE_ELF_CORE_DUMP
  420. #define ELF_EXEC_PAGESIZE 4096
  421. enum {
  422. ARM_HWCAP_A64_FP = 1 << 0,
  423. ARM_HWCAP_A64_ASIMD = 1 << 1,
  424. ARM_HWCAP_A64_EVTSTRM = 1 << 2,
  425. ARM_HWCAP_A64_AES = 1 << 3,
  426. ARM_HWCAP_A64_PMULL = 1 << 4,
  427. ARM_HWCAP_A64_SHA1 = 1 << 5,
  428. ARM_HWCAP_A64_SHA2 = 1 << 6,
  429. ARM_HWCAP_A64_CRC32 = 1 << 7,
  430. };
  431. #define ELF_HWCAP get_elf_hwcap()
  432. static uint32_t get_elf_hwcap(void)
  433. {
  434. ARMCPU *cpu = ARM_CPU(thread_cpu);
  435. uint32_t hwcaps = 0;
  436. hwcaps |= ARM_HWCAP_A64_FP;
  437. hwcaps |= ARM_HWCAP_A64_ASIMD;
  438. /* probe for the extra features */
  439. #define GET_FEATURE(feat, hwcap) \
  440. do { if (arm_feature(&cpu->env, feat)) { hwcaps |= hwcap; } } while (0)
  441. GET_FEATURE(ARM_FEATURE_V8_AES, ARM_HWCAP_A64_PMULL);
  442. #undef GET_FEATURE
  443. return hwcaps;
  444. }
  445. #endif /* not TARGET_AARCH64 */
  446. #endif /* TARGET_ARM */
  447. #ifdef TARGET_UNICORE32
  448. #define ELF_START_MMAP 0x80000000
  449. #define elf_check_arch(x) ((x) == EM_UNICORE32)
  450. #define ELF_CLASS ELFCLASS32
  451. #define ELF_DATA ELFDATA2LSB
  452. #define ELF_ARCH EM_UNICORE32
  453. static inline void init_thread(struct target_pt_regs *regs,
  454. struct image_info *infop)
  455. {
  456. abi_long stack = infop->start_stack;
  457. memset(regs, 0, sizeof(*regs));
  458. regs->UC32_REG_asr = 0x10;
  459. regs->UC32_REG_pc = infop->entry & 0xfffffffe;
  460. regs->UC32_REG_sp = infop->start_stack;
  461. /* FIXME - what to for failure of get_user()? */
  462. get_user_ual(regs->UC32_REG_02, stack + 8); /* envp */
  463. get_user_ual(regs->UC32_REG_01, stack + 4); /* envp */
  464. /* XXX: it seems that r0 is zeroed after ! */
  465. regs->UC32_REG_00 = 0;
  466. }
  467. #define ELF_NREG 34
  468. typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
  469. static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUUniCore32State *env)
  470. {
  471. (*regs)[0] = env->regs[0];
  472. (*regs)[1] = env->regs[1];
  473. (*regs)[2] = env->regs[2];
  474. (*regs)[3] = env->regs[3];
  475. (*regs)[4] = env->regs[4];
  476. (*regs)[5] = env->regs[5];
  477. (*regs)[6] = env->regs[6];
  478. (*regs)[7] = env->regs[7];
  479. (*regs)[8] = env->regs[8];
  480. (*regs)[9] = env->regs[9];
  481. (*regs)[10] = env->regs[10];
  482. (*regs)[11] = env->regs[11];
  483. (*regs)[12] = env->regs[12];
  484. (*regs)[13] = env->regs[13];
  485. (*regs)[14] = env->regs[14];
  486. (*regs)[15] = env->regs[15];
  487. (*regs)[16] = env->regs[16];
  488. (*regs)[17] = env->regs[17];
  489. (*regs)[18] = env->regs[18];
  490. (*regs)[19] = env->regs[19];
  491. (*regs)[20] = env->regs[20];
  492. (*regs)[21] = env->regs[21];
  493. (*regs)[22] = env->regs[22];
  494. (*regs)[23] = env->regs[23];
  495. (*regs)[24] = env->regs[24];
  496. (*regs)[25] = env->regs[25];
  497. (*regs)[26] = env->regs[26];
  498. (*regs)[27] = env->regs[27];
  499. (*regs)[28] = env->regs[28];
  500. (*regs)[29] = env->regs[29];
  501. (*regs)[30] = env->regs[30];
  502. (*regs)[31] = env->regs[31];
  503. (*regs)[32] = cpu_asr_read((CPUUniCore32State *)env);
  504. (*regs)[33] = env->regs[0]; /* XXX */
  505. }
  506. #define USE_ELF_CORE_DUMP
  507. #define ELF_EXEC_PAGESIZE 4096
  508. #define ELF_HWCAP (UC32_HWCAP_CMOV | UC32_HWCAP_UCF64)
  509. #endif
  510. #ifdef TARGET_SPARC
  511. #ifdef TARGET_SPARC64
  512. #define ELF_START_MMAP 0x80000000
  513. #define ELF_HWCAP (HWCAP_SPARC_FLUSH | HWCAP_SPARC_STBAR | HWCAP_SPARC_SWAP \
  514. | HWCAP_SPARC_MULDIV | HWCAP_SPARC_V9)
  515. #ifndef TARGET_ABI32
  516. #define elf_check_arch(x) ( (x) == EM_SPARCV9 || (x) == EM_SPARC32PLUS )
  517. #else
  518. #define elf_check_arch(x) ( (x) == EM_SPARC32PLUS || (x) == EM_SPARC )
  519. #endif
  520. #define ELF_CLASS ELFCLASS64
  521. #define ELF_ARCH EM_SPARCV9
  522. #define STACK_BIAS 2047
  523. static inline void init_thread(struct target_pt_regs *regs,
  524. struct image_info *infop)
  525. {
  526. #ifndef TARGET_ABI32
  527. regs->tstate = 0;
  528. #endif
  529. regs->pc = infop->entry;
  530. regs->npc = regs->pc + 4;
  531. regs->y = 0;
  532. #ifdef TARGET_ABI32
  533. regs->u_regs[14] = infop->start_stack - 16 * 4;
  534. #else
  535. if (personality(infop->personality) == PER_LINUX32)
  536. regs->u_regs[14] = infop->start_stack - 16 * 4;
  537. else
  538. regs->u_regs[14] = infop->start_stack - 16 * 8 - STACK_BIAS;
  539. #endif
  540. }
  541. #else
  542. #define ELF_START_MMAP 0x80000000
  543. #define ELF_HWCAP (HWCAP_SPARC_FLUSH | HWCAP_SPARC_STBAR | HWCAP_SPARC_SWAP \
  544. | HWCAP_SPARC_MULDIV)
  545. #define elf_check_arch(x) ( (x) == EM_SPARC )
  546. #define ELF_CLASS ELFCLASS32
  547. #define ELF_ARCH EM_SPARC
  548. static inline void init_thread(struct target_pt_regs *regs,
  549. struct image_info *infop)
  550. {
  551. regs->psr = 0;
  552. regs->pc = infop->entry;
  553. regs->npc = regs->pc + 4;
  554. regs->y = 0;
  555. regs->u_regs[14] = infop->start_stack - 16 * 4;
  556. }
  557. #endif
  558. #endif
  559. #ifdef TARGET_PPC
  560. #define ELF_START_MMAP 0x80000000
  561. #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
  562. #define elf_check_arch(x) ( (x) == EM_PPC64 )
  563. #define ELF_CLASS ELFCLASS64
  564. #else
  565. #define elf_check_arch(x) ( (x) == EM_PPC )
  566. #define ELF_CLASS ELFCLASS32
  567. #endif
  568. #define ELF_ARCH EM_PPC
  569. /* Feature masks for the Aux Vector Hardware Capabilities (AT_HWCAP).
  570. See arch/powerpc/include/asm/cputable.h. */
  571. enum {
  572. QEMU_PPC_FEATURE_32 = 0x80000000,
  573. QEMU_PPC_FEATURE_64 = 0x40000000,
  574. QEMU_PPC_FEATURE_601_INSTR = 0x20000000,
  575. QEMU_PPC_FEATURE_HAS_ALTIVEC = 0x10000000,
  576. QEMU_PPC_FEATURE_HAS_FPU = 0x08000000,
  577. QEMU_PPC_FEATURE_HAS_MMU = 0x04000000,
  578. QEMU_PPC_FEATURE_HAS_4xxMAC = 0x02000000,
  579. QEMU_PPC_FEATURE_UNIFIED_CACHE = 0x01000000,
  580. QEMU_PPC_FEATURE_HAS_SPE = 0x00800000,
  581. QEMU_PPC_FEATURE_HAS_EFP_SINGLE = 0x00400000,
  582. QEMU_PPC_FEATURE_HAS_EFP_DOUBLE = 0x00200000,
  583. QEMU_PPC_FEATURE_NO_TB = 0x00100000,
  584. QEMU_PPC_FEATURE_POWER4 = 0x00080000,
  585. QEMU_PPC_FEATURE_POWER5 = 0x00040000,
  586. QEMU_PPC_FEATURE_POWER5_PLUS = 0x00020000,
  587. QEMU_PPC_FEATURE_CELL = 0x00010000,
  588. QEMU_PPC_FEATURE_BOOKE = 0x00008000,
  589. QEMU_PPC_FEATURE_SMT = 0x00004000,
  590. QEMU_PPC_FEATURE_ICACHE_SNOOP = 0x00002000,
  591. QEMU_PPC_FEATURE_ARCH_2_05 = 0x00001000,
  592. QEMU_PPC_FEATURE_PA6T = 0x00000800,
  593. QEMU_PPC_FEATURE_HAS_DFP = 0x00000400,
  594. QEMU_PPC_FEATURE_POWER6_EXT = 0x00000200,
  595. QEMU_PPC_FEATURE_ARCH_2_06 = 0x00000100,
  596. QEMU_PPC_FEATURE_HAS_VSX = 0x00000080,
  597. QEMU_PPC_FEATURE_PSERIES_PERFMON_COMPAT = 0x00000040,
  598. QEMU_PPC_FEATURE_TRUE_LE = 0x00000002,
  599. QEMU_PPC_FEATURE_PPC_LE = 0x00000001,
  600. };
  601. #define ELF_HWCAP get_elf_hwcap()
  602. static uint32_t get_elf_hwcap(void)
  603. {
  604. PowerPCCPU *cpu = POWERPC_CPU(thread_cpu);
  605. uint32_t features = 0;
  606. /* We don't have to be terribly complete here; the high points are
  607. Altivec/FP/SPE support. Anything else is just a bonus. */
  608. #define GET_FEATURE(flag, feature) \
  609. do { if (cpu->env.insns_flags & flag) { features |= feature; } } while (0)
  610. GET_FEATURE(PPC_64B, QEMU_PPC_FEATURE_64);
  611. GET_FEATURE(PPC_FLOAT, QEMU_PPC_FEATURE_HAS_FPU);
  612. GET_FEATURE(PPC_ALTIVEC, QEMU_PPC_FEATURE_HAS_ALTIVEC);
  613. GET_FEATURE(PPC_SPE, QEMU_PPC_FEATURE_HAS_SPE);
  614. GET_FEATURE(PPC_SPE_SINGLE, QEMU_PPC_FEATURE_HAS_EFP_SINGLE);
  615. GET_FEATURE(PPC_SPE_DOUBLE, QEMU_PPC_FEATURE_HAS_EFP_DOUBLE);
  616. GET_FEATURE(PPC_BOOKE, QEMU_PPC_FEATURE_BOOKE);
  617. GET_FEATURE(PPC_405_MAC, QEMU_PPC_FEATURE_HAS_4xxMAC);
  618. #undef GET_FEATURE
  619. return features;
  620. }
  621. /*
  622. * The requirements here are:
  623. * - keep the final alignment of sp (sp & 0xf)
  624. * - make sure the 32-bit value at the first 16 byte aligned position of
  625. * AUXV is greater than 16 for glibc compatibility.
  626. * AT_IGNOREPPC is used for that.
  627. * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,
  628. * even if DLINFO_ARCH_ITEMS goes to zero or is undefined.
  629. */
  630. #define DLINFO_ARCH_ITEMS 5
  631. #define ARCH_DLINFO \
  632. do { \
  633. NEW_AUX_ENT(AT_DCACHEBSIZE, 0x20); \
  634. NEW_AUX_ENT(AT_ICACHEBSIZE, 0x20); \
  635. NEW_AUX_ENT(AT_UCACHEBSIZE, 0); \
  636. /* \
  637. * Now handle glibc compatibility. \
  638. */ \
  639. NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
  640. NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
  641. } while (0)
  642. static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop)
  643. {
  644. _regs->gpr[1] = infop->start_stack;
  645. #if defined(TARGET_PPC64) && !defined(TARGET_ABI32)
  646. _regs->gpr[2] = ldq_raw(infop->entry + 8) + infop->load_bias;
  647. infop->entry = ldq_raw(infop->entry) + infop->load_bias;
  648. #endif
  649. _regs->nip = infop->entry;
  650. }
  651. /* See linux kernel: arch/powerpc/include/asm/elf.h. */
  652. #define ELF_NREG 48
  653. typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
  654. static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUPPCState *env)
  655. {
  656. int i;
  657. target_ulong ccr = 0;
  658. for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
  659. (*regs)[i] = tswapreg(env->gpr[i]);
  660. }
  661. (*regs)[32] = tswapreg(env->nip);
  662. (*regs)[33] = tswapreg(env->msr);
  663. (*regs)[35] = tswapreg(env->ctr);
  664. (*regs)[36] = tswapreg(env->lr);
  665. (*regs)[37] = tswapreg(env->xer);
  666. for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
  667. ccr |= env->crf[i] << (32 - ((i + 1) * 4));
  668. }
  669. (*regs)[38] = tswapreg(ccr);
  670. }
  671. #define USE_ELF_CORE_DUMP
  672. #define ELF_EXEC_PAGESIZE 4096
  673. #endif
  674. #ifdef TARGET_MIPS
  675. #define ELF_START_MMAP 0x80000000
  676. #define elf_check_arch(x) ( (x) == EM_MIPS )
  677. #ifdef TARGET_MIPS64
  678. #define ELF_CLASS ELFCLASS64
  679. #else
  680. #define ELF_CLASS ELFCLASS32
  681. #endif
  682. #define ELF_ARCH EM_MIPS
  683. static inline void init_thread(struct target_pt_regs *regs,
  684. struct image_info *infop)
  685. {
  686. regs->cp0_status = 2 << CP0St_KSU;
  687. regs->cp0_epc = infop->entry;
  688. regs->regs[29] = infop->start_stack;
  689. }
  690. /* See linux kernel: arch/mips/include/asm/elf.h. */
  691. #define ELF_NREG 45
  692. typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
  693. /* See linux kernel: arch/mips/include/asm/reg.h. */
  694. enum {
  695. #ifdef TARGET_MIPS64
  696. TARGET_EF_R0 = 0,
  697. #else
  698. TARGET_EF_R0 = 6,
  699. #endif
  700. TARGET_EF_R26 = TARGET_EF_R0 + 26,
  701. TARGET_EF_R27 = TARGET_EF_R0 + 27,
  702. TARGET_EF_LO = TARGET_EF_R0 + 32,
  703. TARGET_EF_HI = TARGET_EF_R0 + 33,
  704. TARGET_EF_CP0_EPC = TARGET_EF_R0 + 34,
  705. TARGET_EF_CP0_BADVADDR = TARGET_EF_R0 + 35,
  706. TARGET_EF_CP0_STATUS = TARGET_EF_R0 + 36,
  707. TARGET_EF_CP0_CAUSE = TARGET_EF_R0 + 37
  708. };
  709. /* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs. */
  710. static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUMIPSState *env)
  711. {
  712. int i;
  713. for (i = 0; i < TARGET_EF_R0; i++) {
  714. (*regs)[i] = 0;
  715. }
  716. (*regs)[TARGET_EF_R0] = 0;
  717. for (i = 1; i < ARRAY_SIZE(env->active_tc.gpr); i++) {
  718. (*regs)[TARGET_EF_R0 + i] = tswapreg(env->active_tc.gpr[i]);
  719. }
  720. (*regs)[TARGET_EF_R26] = 0;
  721. (*regs)[TARGET_EF_R27] = 0;
  722. (*regs)[TARGET_EF_LO] = tswapreg(env->active_tc.LO[0]);
  723. (*regs)[TARGET_EF_HI] = tswapreg(env->active_tc.HI[0]);
  724. (*regs)[TARGET_EF_CP0_EPC] = tswapreg(env->active_tc.PC);
  725. (*regs)[TARGET_EF_CP0_BADVADDR] = tswapreg(env->CP0_BadVAddr);
  726. (*regs)[TARGET_EF_CP0_STATUS] = tswapreg(env->CP0_Status);
  727. (*regs)[TARGET_EF_CP0_CAUSE] = tswapreg(env->CP0_Cause);
  728. }
  729. #define USE_ELF_CORE_DUMP
  730. #define ELF_EXEC_PAGESIZE 4096
  731. #endif /* TARGET_MIPS */
  732. #ifdef TARGET_MICROBLAZE
  733. #define ELF_START_MMAP 0x80000000
  734. #define elf_check_arch(x) ( (x) == EM_MICROBLAZE || (x) == EM_MICROBLAZE_OLD)
  735. #define ELF_CLASS ELFCLASS32
  736. #define ELF_ARCH EM_MICROBLAZE
  737. static inline void init_thread(struct target_pt_regs *regs,
  738. struct image_info *infop)
  739. {
  740. regs->pc = infop->entry;
  741. regs->r1 = infop->start_stack;
  742. }
  743. #define ELF_EXEC_PAGESIZE 4096
  744. #define USE_ELF_CORE_DUMP
  745. #define ELF_NREG 38
  746. typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
  747. /* See linux kernel: arch/mips/kernel/process.c:elf_dump_regs. */
  748. static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUMBState *env)
  749. {
  750. int i, pos = 0;
  751. for (i = 0; i < 32; i++) {
  752. (*regs)[pos++] = tswapreg(env->regs[i]);
  753. }
  754. for (i = 0; i < 6; i++) {
  755. (*regs)[pos++] = tswapreg(env->sregs[i]);
  756. }
  757. }
  758. #endif /* TARGET_MICROBLAZE */
  759. #ifdef TARGET_OPENRISC
  760. #define ELF_START_MMAP 0x08000000
  761. #define elf_check_arch(x) ((x) == EM_OPENRISC)
  762. #define ELF_ARCH EM_OPENRISC
  763. #define ELF_CLASS ELFCLASS32
  764. #define ELF_DATA ELFDATA2MSB
  765. static inline void init_thread(struct target_pt_regs *regs,
  766. struct image_info *infop)
  767. {
  768. regs->pc = infop->entry;
  769. regs->gpr[1] = infop->start_stack;
  770. }
  771. #define USE_ELF_CORE_DUMP
  772. #define ELF_EXEC_PAGESIZE 8192
  773. /* See linux kernel arch/openrisc/include/asm/elf.h. */
  774. #define ELF_NREG 34 /* gprs and pc, sr */
  775. typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
  776. static void elf_core_copy_regs(target_elf_gregset_t *regs,
  777. const CPUOpenRISCState *env)
  778. {
  779. int i;
  780. for (i = 0; i < 32; i++) {
  781. (*regs)[i] = tswapreg(env->gpr[i]);
  782. }
  783. (*regs)[32] = tswapreg(env->pc);
  784. (*regs)[33] = tswapreg(env->sr);
  785. }
  786. #define ELF_HWCAP 0
  787. #define ELF_PLATFORM NULL
  788. #endif /* TARGET_OPENRISC */
  789. #ifdef TARGET_SH4
  790. #define ELF_START_MMAP 0x80000000
  791. #define elf_check_arch(x) ( (x) == EM_SH )
  792. #define ELF_CLASS ELFCLASS32
  793. #define ELF_ARCH EM_SH
  794. static inline void init_thread(struct target_pt_regs *regs,
  795. struct image_info *infop)
  796. {
  797. /* Check other registers XXXXX */
  798. regs->pc = infop->entry;
  799. regs->regs[15] = infop->start_stack;
  800. }
  801. /* See linux kernel: arch/sh/include/asm/elf.h. */
  802. #define ELF_NREG 23
  803. typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
  804. /* See linux kernel: arch/sh/include/asm/ptrace.h. */
  805. enum {
  806. TARGET_REG_PC = 16,
  807. TARGET_REG_PR = 17,
  808. TARGET_REG_SR = 18,
  809. TARGET_REG_GBR = 19,
  810. TARGET_REG_MACH = 20,
  811. TARGET_REG_MACL = 21,
  812. TARGET_REG_SYSCALL = 22
  813. };
  814. static inline void elf_core_copy_regs(target_elf_gregset_t *regs,
  815. const CPUSH4State *env)
  816. {
  817. int i;
  818. for (i = 0; i < 16; i++) {
  819. (*regs[i]) = tswapreg(env->gregs[i]);
  820. }
  821. (*regs)[TARGET_REG_PC] = tswapreg(env->pc);
  822. (*regs)[TARGET_REG_PR] = tswapreg(env->pr);
  823. (*regs)[TARGET_REG_SR] = tswapreg(env->sr);
  824. (*regs)[TARGET_REG_GBR] = tswapreg(env->gbr);
  825. (*regs)[TARGET_REG_MACH] = tswapreg(env->mach);
  826. (*regs)[TARGET_REG_MACL] = tswapreg(env->macl);
  827. (*regs)[TARGET_REG_SYSCALL] = 0; /* FIXME */
  828. }
  829. #define USE_ELF_CORE_DUMP
  830. #define ELF_EXEC_PAGESIZE 4096
  831. #endif
  832. #ifdef TARGET_CRIS
  833. #define ELF_START_MMAP 0x80000000
  834. #define elf_check_arch(x) ( (x) == EM_CRIS )
  835. #define ELF_CLASS ELFCLASS32
  836. #define ELF_ARCH EM_CRIS
  837. static inline void init_thread(struct target_pt_regs *regs,
  838. struct image_info *infop)
  839. {
  840. regs->erp = infop->entry;
  841. }
  842. #define ELF_EXEC_PAGESIZE 8192
  843. #endif
  844. #ifdef TARGET_M68K
  845. #define ELF_START_MMAP 0x80000000
  846. #define elf_check_arch(x) ( (x) == EM_68K )
  847. #define ELF_CLASS ELFCLASS32
  848. #define ELF_ARCH EM_68K
  849. /* ??? Does this need to do anything?
  850. #define ELF_PLAT_INIT(_r) */
  851. static inline void init_thread(struct target_pt_regs *regs,
  852. struct image_info *infop)
  853. {
  854. regs->usp = infop->start_stack;
  855. regs->sr = 0;
  856. regs->pc = infop->entry;
  857. }
  858. /* See linux kernel: arch/m68k/include/asm/elf.h. */
  859. #define ELF_NREG 20
  860. typedef target_elf_greg_t target_elf_gregset_t[ELF_NREG];
  861. static void elf_core_copy_regs(target_elf_gregset_t *regs, const CPUM68KState *env)
  862. {
  863. (*regs)[0] = tswapreg(env->dregs[1]);
  864. (*regs)[1] = tswapreg(env->dregs[2]);
  865. (*regs)[2] = tswapreg(env->dregs[3]);
  866. (*regs)[3] = tswapreg(env->dregs[4]);
  867. (*regs)[4] = tswapreg(env->dregs[5]);
  868. (*regs)[5] = tswapreg(env->dregs[6]);
  869. (*regs)[6] = tswapreg(env->dregs[7]);
  870. (*regs)[7] = tswapreg(env->aregs[0]);
  871. (*regs)[8] = tswapreg(env->aregs[1]);
  872. (*regs)[9] = tswapreg(env->aregs[2]);
  873. (*regs)[10] = tswapreg(env->aregs[3]);
  874. (*regs)[11] = tswapreg(env->aregs[4]);
  875. (*regs)[12] = tswapreg(env->aregs[5]);
  876. (*regs)[13] = tswapreg(env->aregs[6]);
  877. (*regs)[14] = tswapreg(env->dregs[0]);
  878. (*regs)[15] = tswapreg(env->aregs[7]);
  879. (*regs)[16] = tswapreg(env->dregs[0]); /* FIXME: orig_d0 */
  880. (*regs)[17] = tswapreg(env->sr);
  881. (*regs)[18] = tswapreg(env->pc);
  882. (*regs)[19] = 0; /* FIXME: regs->format | regs->vector */
  883. }
  884. #define USE_ELF_CORE_DUMP
  885. #define ELF_EXEC_PAGESIZE 8192
  886. #endif
  887. #ifdef TARGET_ALPHA
  888. #define ELF_START_MMAP (0x30000000000ULL)
  889. #define elf_check_arch(x) ( (x) == ELF_ARCH )
  890. #define ELF_CLASS ELFCLASS64
  891. #define ELF_ARCH EM_ALPHA
  892. static inline void init_thread(struct target_pt_regs *regs,
  893. struct image_info *infop)
  894. {
  895. regs->pc = infop->entry;
  896. regs->ps = 8;
  897. regs->usp = infop->start_stack;
  898. }
  899. #define ELF_EXEC_PAGESIZE 8192
  900. #endif /* TARGET_ALPHA */
  901. #ifdef TARGET_S390X
  902. #define ELF_START_MMAP (0x20000000000ULL)
  903. #define elf_check_arch(x) ( (x) == ELF_ARCH )
  904. #define ELF_CLASS ELFCLASS64
  905. #define ELF_DATA ELFDATA2MSB
  906. #define ELF_ARCH EM_S390
  907. static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
  908. {
  909. regs->psw.addr = infop->entry;
  910. regs->psw.mask = PSW_MASK_64 | PSW_MASK_32;
  911. regs->gprs[15] = infop->start_stack;
  912. }
  913. #endif /* TARGET_S390X */
  914. #ifndef ELF_PLATFORM
  915. #define ELF_PLATFORM (NULL)
  916. #endif
  917. #ifndef ELF_HWCAP
  918. #define ELF_HWCAP 0
  919. #endif
  920. #ifdef TARGET_ABI32
  921. #undef ELF_CLASS
  922. #define ELF_CLASS ELFCLASS32
  923. #undef bswaptls
  924. #define bswaptls(ptr) bswap32s(ptr)
  925. #endif
  926. #include "elf.h"
  927. struct exec
  928. {
  929. unsigned int a_info; /* Use macros N_MAGIC, etc for access */
  930. unsigned int a_text; /* length of text, in bytes */
  931. unsigned int a_data; /* length of data, in bytes */
  932. unsigned int a_bss; /* length of uninitialized data area, in bytes */
  933. unsigned int a_syms; /* length of symbol table data in file, in bytes */
  934. unsigned int a_entry; /* start address */
  935. unsigned int a_trsize; /* length of relocation info for text, in bytes */
  936. unsigned int a_drsize; /* length of relocation info for data, in bytes */
  937. };
  938. #define N_MAGIC(exec) ((exec).a_info & 0xffff)
  939. #define OMAGIC 0407
  940. #define NMAGIC 0410
  941. #define ZMAGIC 0413
  942. #define QMAGIC 0314
  943. /* Necessary parameters */
  944. #define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE
  945. #define TARGET_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(TARGET_ELF_EXEC_PAGESIZE-1))
  946. #define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))
  947. #define DLINFO_ITEMS 14
  948. static inline void memcpy_fromfs(void * to, const void * from, unsigned long n)
  949. {
  950. memcpy(to, from, n);
  951. }
  952. #ifdef BSWAP_NEEDED
  953. static void bswap_ehdr(struct elfhdr *ehdr)
  954. {
  955. bswap16s(&ehdr->e_type); /* Object file type */
  956. bswap16s(&ehdr->e_machine); /* Architecture */
  957. bswap32s(&ehdr->e_version); /* Object file version */
  958. bswaptls(&ehdr->e_entry); /* Entry point virtual address */
  959. bswaptls(&ehdr->e_phoff); /* Program header table file offset */
  960. bswaptls(&ehdr->e_shoff); /* Section header table file offset */
  961. bswap32s(&ehdr->e_flags); /* Processor-specific flags */
  962. bswap16s(&ehdr->e_ehsize); /* ELF header size in bytes */
  963. bswap16s(&ehdr->e_phentsize); /* Program header table entry size */
  964. bswap16s(&ehdr->e_phnum); /* Program header table entry count */
  965. bswap16s(&ehdr->e_shentsize); /* Section header table entry size */
  966. bswap16s(&ehdr->e_shnum); /* Section header table entry count */
  967. bswap16s(&ehdr->e_shstrndx); /* Section header string table index */
  968. }
  969. static void bswap_phdr(struct elf_phdr *phdr, int phnum)
  970. {
  971. int i;
  972. for (i = 0; i < phnum; ++i, ++phdr) {
  973. bswap32s(&phdr->p_type); /* Segment type */
  974. bswap32s(&phdr->p_flags); /* Segment flags */
  975. bswaptls(&phdr->p_offset); /* Segment file offset */
  976. bswaptls(&phdr->p_vaddr); /* Segment virtual address */
  977. bswaptls(&phdr->p_paddr); /* Segment physical address */
  978. bswaptls(&phdr->p_filesz); /* Segment size in file */
  979. bswaptls(&phdr->p_memsz); /* Segment size in memory */
  980. bswaptls(&phdr->p_align); /* Segment alignment */
  981. }
  982. }
  983. static void bswap_shdr(struct elf_shdr *shdr, int shnum)
  984. {
  985. int i;
  986. for (i = 0; i < shnum; ++i, ++shdr) {
  987. bswap32s(&shdr->sh_name);
  988. bswap32s(&shdr->sh_type);
  989. bswaptls(&shdr->sh_flags);
  990. bswaptls(&shdr->sh_addr);
  991. bswaptls(&shdr->sh_offset);
  992. bswaptls(&shdr->sh_size);
  993. bswap32s(&shdr->sh_link);
  994. bswap32s(&shdr->sh_info);
  995. bswaptls(&shdr->sh_addralign);
  996. bswaptls(&shdr->sh_entsize);
  997. }
  998. }
  999. static void bswap_sym(struct elf_sym *sym)
  1000. {
  1001. bswap32s(&sym->st_name);
  1002. bswaptls(&sym->st_value);
  1003. bswaptls(&sym->st_size);
  1004. bswap16s(&sym->st_shndx);
  1005. }
  1006. #else
  1007. static inline void bswap_ehdr(struct elfhdr *ehdr) { }
  1008. static inline void bswap_phdr(struct elf_phdr *phdr, int phnum) { }
  1009. static inline void bswap_shdr(struct elf_shdr *shdr, int shnum) { }
  1010. static inline void bswap_sym(struct elf_sym *sym) { }
  1011. #endif
  1012. #ifdef USE_ELF_CORE_DUMP
  1013. static int elf_core_dump(int, const CPUArchState *);
  1014. #endif /* USE_ELF_CORE_DUMP */
  1015. static void load_symbols(struct elfhdr *hdr, int fd, abi_ulong load_bias);
  1016. /* Verify the portions of EHDR within E_IDENT for the target.
  1017. This can be performed before bswapping the entire header. */
  1018. static bool elf_check_ident(struct elfhdr *ehdr)
  1019. {
  1020. return (ehdr->e_ident[EI_MAG0] == ELFMAG0
  1021. && ehdr->e_ident[EI_MAG1] == ELFMAG1
  1022. && ehdr->e_ident[EI_MAG2] == ELFMAG2
  1023. && ehdr->e_ident[EI_MAG3] == ELFMAG3
  1024. && ehdr->e_ident[EI_CLASS] == ELF_CLASS
  1025. && ehdr->e_ident[EI_DATA] == ELF_DATA
  1026. && ehdr->e_ident[EI_VERSION] == EV_CURRENT);
  1027. }
  1028. /* Verify the portions of EHDR outside of E_IDENT for the target.
  1029. This has to wait until after bswapping the header. */
  1030. static bool elf_check_ehdr(struct elfhdr *ehdr)
  1031. {
  1032. return (elf_check_arch(ehdr->e_machine)
  1033. && ehdr->e_ehsize == sizeof(struct elfhdr)
  1034. && ehdr->e_phentsize == sizeof(struct elf_phdr)
  1035. && ehdr->e_shentsize == sizeof(struct elf_shdr)
  1036. && (ehdr->e_type == ET_EXEC || ehdr->e_type == ET_DYN));
  1037. }
  1038. /*
  1039. * 'copy_elf_strings()' copies argument/envelope strings from user
  1040. * memory to free pages in kernel mem. These are in a format ready
  1041. * to be put directly into the top of new user memory.
  1042. *
  1043. */
  1044. static abi_ulong copy_elf_strings(int argc,char ** argv, void **page,
  1045. abi_ulong p)
  1046. {
  1047. char *tmp, *tmp1, *pag = NULL;
  1048. int len, offset = 0;
  1049. if (!p) {
  1050. return 0; /* bullet-proofing */
  1051. }
  1052. while (argc-- > 0) {
  1053. tmp = argv[argc];
  1054. if (!tmp) {
  1055. fprintf(stderr, "VFS: argc is wrong");
  1056. exit(-1);
  1057. }
  1058. tmp1 = tmp;
  1059. while (*tmp++);
  1060. len = tmp - tmp1;
  1061. if (p < len) { /* this shouldn't happen - 128kB */
  1062. return 0;
  1063. }
  1064. while (len) {
  1065. --p; --tmp; --len;
  1066. if (--offset < 0) {
  1067. offset = p % TARGET_PAGE_SIZE;
  1068. pag = (char *)page[p/TARGET_PAGE_SIZE];
  1069. if (!pag) {
  1070. pag = g_try_malloc0(TARGET_PAGE_SIZE);
  1071. page[p/TARGET_PAGE_SIZE] = pag;
  1072. if (!pag)
  1073. return 0;
  1074. }
  1075. }
  1076. if (len == 0 || offset == 0) {
  1077. *(pag + offset) = *tmp;
  1078. }
  1079. else {
  1080. int bytes_to_copy = (len > offset) ? offset : len;
  1081. tmp -= bytes_to_copy;
  1082. p -= bytes_to_copy;
  1083. offset -= bytes_to_copy;
  1084. len -= bytes_to_copy;
  1085. memcpy_fromfs(pag + offset, tmp, bytes_to_copy + 1);
  1086. }
  1087. }
  1088. }
  1089. return p;
  1090. }
  1091. static abi_ulong setup_arg_pages(abi_ulong p, struct linux_binprm *bprm,
  1092. struct image_info *info)
  1093. {
  1094. abi_ulong stack_base, size, error, guard;
  1095. int i;
  1096. /* Create enough stack to hold everything. If we don't use
  1097. it for args, we'll use it for something else. */
  1098. size = guest_stack_size;
  1099. if (size < MAX_ARG_PAGES*TARGET_PAGE_SIZE) {
  1100. size = MAX_ARG_PAGES*TARGET_PAGE_SIZE;
  1101. }
  1102. guard = TARGET_PAGE_SIZE;
  1103. if (guard < qemu_real_host_page_size) {
  1104. guard = qemu_real_host_page_size;
  1105. }
  1106. error = target_mmap(0, size + guard, PROT_READ | PROT_WRITE,
  1107. MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
  1108. if (error == -1) {
  1109. perror("mmap stack");
  1110. exit(-1);
  1111. }
  1112. /* We reserve one extra page at the top of the stack as guard. */
  1113. target_mprotect(error, guard, PROT_NONE);
  1114. info->stack_limit = error + guard;
  1115. stack_base = info->stack_limit + size - MAX_ARG_PAGES*TARGET_PAGE_SIZE;
  1116. p += stack_base;
  1117. for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
  1118. if (bprm->page[i]) {
  1119. info->rss++;
  1120. /* FIXME - check return value of memcpy_to_target() for failure */
  1121. memcpy_to_target(stack_base, bprm->page[i], TARGET_PAGE_SIZE);
  1122. g_free(bprm->page[i]);
  1123. }
  1124. stack_base += TARGET_PAGE_SIZE;
  1125. }
  1126. return p;
  1127. }
  1128. /* Map and zero the bss. We need to explicitly zero any fractional pages
  1129. after the data section (i.e. bss). */
  1130. static void zero_bss(abi_ulong elf_bss, abi_ulong last_bss, int prot)
  1131. {
  1132. uintptr_t host_start, host_map_start, host_end;
  1133. last_bss = TARGET_PAGE_ALIGN(last_bss);
  1134. /* ??? There is confusion between qemu_real_host_page_size and
  1135. qemu_host_page_size here and elsewhere in target_mmap, which
  1136. may lead to the end of the data section mapping from the file
  1137. not being mapped. At least there was an explicit test and
  1138. comment for that here, suggesting that "the file size must
  1139. be known". The comment probably pre-dates the introduction
  1140. of the fstat system call in target_mmap which does in fact
  1141. find out the size. What isn't clear is if the workaround
  1142. here is still actually needed. For now, continue with it,
  1143. but merge it with the "normal" mmap that would allocate the bss. */
  1144. host_start = (uintptr_t) g2h(elf_bss);
  1145. host_end = (uintptr_t) g2h(last_bss);
  1146. host_map_start = (host_start + qemu_real_host_page_size - 1);
  1147. host_map_start &= -qemu_real_host_page_size;
  1148. if (host_map_start < host_end) {
  1149. void *p = mmap((void *)host_map_start, host_end - host_map_start,
  1150. prot, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
  1151. if (p == MAP_FAILED) {
  1152. perror("cannot mmap brk");
  1153. exit(-1);
  1154. }
  1155. /* Since we didn't use target_mmap, make sure to record
  1156. the validity of the pages with qemu. */
  1157. page_set_flags(elf_bss & TARGET_PAGE_MASK, last_bss, prot|PAGE_VALID);
  1158. }
  1159. if (host_start < host_map_start) {
  1160. memset((void *)host_start, 0, host_map_start - host_start);
  1161. }
  1162. }
  1163. #ifdef CONFIG_USE_FDPIC
  1164. static abi_ulong loader_build_fdpic_loadmap(struct image_info *info, abi_ulong sp)
  1165. {
  1166. uint16_t n;
  1167. struct elf32_fdpic_loadseg *loadsegs = info->loadsegs;
  1168. /* elf32_fdpic_loadseg */
  1169. n = info->nsegs;
  1170. while (n--) {
  1171. sp -= 12;
  1172. put_user_u32(loadsegs[n].addr, sp+0);
  1173. put_user_u32(loadsegs[n].p_vaddr, sp+4);
  1174. put_user_u32(loadsegs[n].p_memsz, sp+8);
  1175. }
  1176. /* elf32_fdpic_loadmap */
  1177. sp -= 4;
  1178. put_user_u16(0, sp+0); /* version */
  1179. put_user_u16(info->nsegs, sp+2); /* nsegs */
  1180. info->personality = PER_LINUX_FDPIC;
  1181. info->loadmap_addr = sp;
  1182. return sp;
  1183. }
  1184. #endif
  1185. static abi_ulong create_elf_tables(abi_ulong p, int argc, int envc,
  1186. struct elfhdr *exec,
  1187. struct image_info *info,
  1188. struct image_info *interp_info)
  1189. {
  1190. abi_ulong sp;
  1191. abi_ulong sp_auxv;
  1192. int size;
  1193. int i;
  1194. abi_ulong u_rand_bytes;
  1195. uint8_t k_rand_bytes[16];
  1196. abi_ulong u_platform;
  1197. const char *k_platform;
  1198. const int n = sizeof(elf_addr_t);
  1199. sp = p;
  1200. #ifdef CONFIG_USE_FDPIC
  1201. /* Needs to be before we load the env/argc/... */
  1202. if (elf_is_fdpic(exec)) {
  1203. /* Need 4 byte alignment for these structs */
  1204. sp &= ~3;
  1205. sp = loader_build_fdpic_loadmap(info, sp);
  1206. info->other_info = interp_info;
  1207. if (interp_info) {
  1208. interp_info->other_info = info;
  1209. sp = loader_build_fdpic_loadmap(interp_info, sp);
  1210. }
  1211. }
  1212. #endif
  1213. u_platform = 0;
  1214. k_platform = ELF_PLATFORM;
  1215. if (k_platform) {
  1216. size_t len = strlen(k_platform) + 1;
  1217. sp -= (len + n - 1) & ~(n - 1);
  1218. u_platform = sp;
  1219. /* FIXME - check return value of memcpy_to_target() for failure */
  1220. memcpy_to_target(sp, k_platform, len);
  1221. }
  1222. /*
  1223. * Generate 16 random bytes for userspace PRNG seeding (not
  1224. * cryptically secure but it's not the aim of QEMU).
  1225. */
  1226. srand((unsigned int) time(NULL));
  1227. for (i = 0; i < 16; i++) {
  1228. k_rand_bytes[i] = rand();
  1229. }
  1230. sp -= 16;
  1231. u_rand_bytes = sp;
  1232. /* FIXME - check return value of memcpy_to_target() for failure */
  1233. memcpy_to_target(sp, k_rand_bytes, 16);
  1234. /*
  1235. * Force 16 byte _final_ alignment here for generality.
  1236. */
  1237. sp = sp &~ (abi_ulong)15;
  1238. size = (DLINFO_ITEMS + 1) * 2;
  1239. if (k_platform)
  1240. size += 2;
  1241. #ifdef DLINFO_ARCH_ITEMS
  1242. size += DLINFO_ARCH_ITEMS * 2;
  1243. #endif
  1244. size += envc + argc + 2;
  1245. size += 1; /* argc itself */
  1246. size *= n;
  1247. if (size & 15)
  1248. sp -= 16 - (size & 15);
  1249. /* This is correct because Linux defines
  1250. * elf_addr_t as Elf32_Off / Elf64_Off
  1251. */
  1252. #define NEW_AUX_ENT(id, val) do { \
  1253. sp -= n; put_user_ual(val, sp); \
  1254. sp -= n; put_user_ual(id, sp); \
  1255. } while(0)
  1256. sp_auxv = sp;
  1257. NEW_AUX_ENT (AT_NULL, 0);
  1258. /* There must be exactly DLINFO_ITEMS entries here. */
  1259. NEW_AUX_ENT(AT_PHDR, (abi_ulong)(info->load_addr + exec->e_phoff));
  1260. NEW_AUX_ENT(AT_PHENT, (abi_ulong)(sizeof (struct elf_phdr)));
  1261. NEW_AUX_ENT(AT_PHNUM, (abi_ulong)(exec->e_phnum));
  1262. NEW_AUX_ENT(AT_PAGESZ, (abi_ulong)(TARGET_PAGE_SIZE));
  1263. NEW_AUX_ENT(AT_BASE, (abi_ulong)(interp_info ? interp_info->load_addr : 0));
  1264. NEW_AUX_ENT(AT_FLAGS, (abi_ulong)0);
  1265. NEW_AUX_ENT(AT_ENTRY, info->entry);
  1266. NEW_AUX_ENT(AT_UID, (abi_ulong) getuid());
  1267. NEW_AUX_ENT(AT_EUID, (abi_ulong) geteuid());
  1268. NEW_AUX_ENT(AT_GID, (abi_ulong) getgid());
  1269. NEW_AUX_ENT(AT_EGID, (abi_ulong) getegid());
  1270. NEW_AUX_ENT(AT_HWCAP, (abi_ulong) ELF_HWCAP);
  1271. NEW_AUX_ENT(AT_CLKTCK, (abi_ulong) sysconf(_SC_CLK_TCK));
  1272. NEW_AUX_ENT(AT_RANDOM, (abi_ulong) u_rand_bytes);
  1273. if (k_platform)
  1274. NEW_AUX_ENT(AT_PLATFORM, u_platform);
  1275. #ifdef ARCH_DLINFO
  1276. /*
  1277. * ARCH_DLINFO must come last so platform specific code can enforce
  1278. * special alignment requirements on the AUXV if necessary (eg. PPC).
  1279. */
  1280. ARCH_DLINFO;
  1281. #endif
  1282. #undef NEW_AUX_ENT
  1283. info->saved_auxv = sp;
  1284. info->auxv_len = sp_auxv - sp;
  1285. sp = loader_build_argptr(envc, argc, sp, p, 0);
  1286. return sp;
  1287. }
  1288. #ifndef TARGET_HAS_VALIDATE_GUEST_SPACE
  1289. /* If the guest doesn't have a validation function just agree */
  1290. static int validate_guest_space(unsigned long guest_base,
  1291. unsigned long guest_size)
  1292. {
  1293. return 1;
  1294. }
  1295. #endif
  1296. unsigned long init_guest_space(unsigned long host_start,
  1297. unsigned long host_size,
  1298. unsigned long guest_start,
  1299. bool fixed)
  1300. {
  1301. unsigned long current_start, real_start;
  1302. int flags;
  1303. assert(host_start || host_size);
  1304. /* If just a starting address is given, then just verify that
  1305. * address. */
  1306. if (host_start && !host_size) {
  1307. if (validate_guest_space(host_start, host_size) == 1) {
  1308. return host_start;
  1309. } else {
  1310. return (unsigned long)-1;
  1311. }
  1312. }
  1313. /* Setup the initial flags and start address. */
  1314. current_start = host_start & qemu_host_page_mask;
  1315. flags = MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE;
  1316. if (fixed) {
  1317. flags |= MAP_FIXED;
  1318. }
  1319. /* Otherwise, a non-zero size region of memory needs to be mapped
  1320. * and validated. */
  1321. while (1) {
  1322. unsigned long real_size = host_size;
  1323. /* Do not use mmap_find_vma here because that is limited to the
  1324. * guest address space. We are going to make the
  1325. * guest address space fit whatever we're given.
  1326. */
  1327. real_start = (unsigned long)
  1328. mmap((void *)current_start, host_size, PROT_NONE, flags, -1, 0);
  1329. if (real_start == (unsigned long)-1) {
  1330. return (unsigned long)-1;
  1331. }
  1332. /* Ensure the address is properly aligned. */
  1333. if (real_start & ~qemu_host_page_mask) {
  1334. munmap((void *)real_start, host_size);
  1335. real_size = host_size + qemu_host_page_size;
  1336. real_start = (unsigned long)
  1337. mmap((void *)real_start, real_size, PROT_NONE, flags, -1, 0);
  1338. if (real_start == (unsigned long)-1) {
  1339. return (unsigned long)-1;
  1340. }
  1341. real_start = HOST_PAGE_ALIGN(real_start);
  1342. }
  1343. /* Check to see if the address is valid. */
  1344. if (!host_start || real_start == current_start) {
  1345. int valid = validate_guest_space(real_start - guest_start,
  1346. real_size);
  1347. if (valid == 1) {
  1348. break;
  1349. } else if (valid == -1) {
  1350. return (unsigned long)-1;
  1351. }
  1352. /* valid == 0, so try again. */
  1353. }
  1354. /* That address didn't work. Unmap and try a different one.
  1355. * The address the host picked because is typically right at
  1356. * the top of the host address space and leaves the guest with
  1357. * no usable address space. Resort to a linear search. We
  1358. * already compensated for mmap_min_addr, so this should not
  1359. * happen often. Probably means we got unlucky and host
  1360. * address space randomization put a shared library somewhere
  1361. * inconvenient.
  1362. */
  1363. munmap((void *)real_start, host_size);
  1364. current_start += qemu_host_page_size;
  1365. if (host_start == current_start) {
  1366. /* Theoretically possible if host doesn't have any suitably
  1367. * aligned areas. Normally the first mmap will fail.
  1368. */
  1369. return (unsigned long)-1;
  1370. }
  1371. }
  1372. qemu_log("Reserved 0x%lx bytes of guest address space\n", host_size);
  1373. return real_start;
  1374. }
  1375. static void probe_guest_base(const char *image_name,
  1376. abi_ulong loaddr, abi_ulong hiaddr)
  1377. {
  1378. /* Probe for a suitable guest base address, if the user has not set
  1379. * it explicitly, and set guest_base appropriately.
  1380. * In case of error we will print a suitable message and exit.
  1381. */
  1382. #if defined(CONFIG_USE_GUEST_BASE)
  1383. const char *errmsg;
  1384. if (!have_guest_base && !reserved_va) {
  1385. unsigned long host_start, real_start, host_size;
  1386. /* Round addresses to page boundaries. */
  1387. loaddr &= qemu_host_page_mask;
  1388. hiaddr = HOST_PAGE_ALIGN(hiaddr);
  1389. if (loaddr < mmap_min_addr) {
  1390. host_start = HOST_PAGE_ALIGN(mmap_min_addr);
  1391. } else {
  1392. host_start = loaddr;
  1393. if (host_start != loaddr) {
  1394. errmsg = "Address overflow loading ELF binary";
  1395. goto exit_errmsg;
  1396. }
  1397. }
  1398. host_size = hiaddr - loaddr;
  1399. /* Setup the initial guest memory space with ranges gleaned from
  1400. * the ELF image that is being loaded.
  1401. */
  1402. real_start = init_guest_space(host_start, host_size, loaddr, false);
  1403. if (real_start == (unsigned long)-1) {
  1404. errmsg = "Unable to find space for application";
  1405. goto exit_errmsg;
  1406. }
  1407. guest_base = real_start - loaddr;
  1408. qemu_log("Relocating guest address space from 0x"
  1409. TARGET_ABI_FMT_lx " to 0x%lx\n",
  1410. loaddr, real_start);
  1411. }
  1412. return;
  1413. exit_errmsg:
  1414. fprintf(stderr, "%s: %s\n", image_name, errmsg);
  1415. exit(-1);
  1416. #endif
  1417. }
  1418. /* Load an ELF image into the address space.
  1419. IMAGE_NAME is the filename of the image, to use in error messages.
  1420. IMAGE_FD is the open file descriptor for the image.
  1421. BPRM_BUF is a copy of the beginning of the file; this of course
  1422. contains the elf file header at offset 0. It is assumed that this
  1423. buffer is sufficiently aligned to present no problems to the host
  1424. in accessing data at aligned offsets within the buffer.
  1425. On return: INFO values will be filled in, as necessary or available. */
  1426. static void load_elf_image(const char *image_name, int image_fd,
  1427. struct image_info *info, char **pinterp_name,
  1428. char bprm_buf[BPRM_BUF_SIZE])
  1429. {
  1430. struct elfhdr *ehdr = (struct elfhdr *)bprm_buf;
  1431. struct elf_phdr *phdr;
  1432. abi_ulong load_addr, load_bias, loaddr, hiaddr, error;
  1433. int i, retval;
  1434. const char *errmsg;
  1435. /* First of all, some simple consistency checks */
  1436. errmsg = "Invalid ELF image for this architecture";
  1437. if (!elf_check_ident(ehdr)) {
  1438. goto exit_errmsg;
  1439. }
  1440. bswap_ehdr(ehdr);
  1441. if (!elf_check_ehdr(ehdr)) {
  1442. goto exit_errmsg;
  1443. }
  1444. i = ehdr->e_phnum * sizeof(struct elf_phdr);
  1445. if (ehdr->e_phoff + i <= BPRM_BUF_SIZE) {
  1446. phdr = (struct elf_phdr *)(bprm_buf + ehdr->e_phoff);
  1447. } else {
  1448. phdr = (struct elf_phdr *) alloca(i);
  1449. retval = pread(image_fd, phdr, i, ehdr->e_phoff);
  1450. if (retval != i) {
  1451. goto exit_read;
  1452. }
  1453. }
  1454. bswap_phdr(phdr, ehdr->e_phnum);
  1455. #ifdef CONFIG_USE_FDPIC
  1456. info->nsegs = 0;
  1457. info->pt_dynamic_addr = 0;
  1458. #endif
  1459. /* Find the maximum size of the image and allocate an appropriate
  1460. amount of memory to handle that. */
  1461. loaddr = -1, hiaddr = 0;
  1462. for (i = 0; i < ehdr->e_phnum; ++i) {
  1463. if (phdr[i].p_type == PT_LOAD) {
  1464. abi_ulong a = phdr[i].p_vaddr;
  1465. if (a < loaddr) {
  1466. loaddr = a;
  1467. }
  1468. a += phdr[i].p_memsz;
  1469. if (a > hiaddr) {
  1470. hiaddr = a;
  1471. }
  1472. #ifdef CONFIG_USE_FDPIC
  1473. ++info->nsegs;
  1474. #endif
  1475. }
  1476. }
  1477. load_addr = loaddr;
  1478. if (ehdr->e_type == ET_DYN) {
  1479. /* The image indicates that it can be loaded anywhere. Find a
  1480. location that can hold the memory space required. If the
  1481. image is pre-linked, LOADDR will be non-zero. Since we do
  1482. not supply MAP_FIXED here we'll use that address if and
  1483. only if it remains available. */
  1484. load_addr = target_mmap(loaddr, hiaddr - loaddr, PROT_NONE,
  1485. MAP_PRIVATE | MAP_ANON | MAP_NORESERVE,
  1486. -1, 0);
  1487. if (load_addr == -1) {
  1488. goto exit_perror;
  1489. }
  1490. } else if (pinterp_name != NULL) {
  1491. /* This is the main executable. Make sure that the low
  1492. address does not conflict with MMAP_MIN_ADDR or the
  1493. QEMU application itself. */
  1494. probe_guest_base(image_name, loaddr, hiaddr);
  1495. }
  1496. load_bias = load_addr - loaddr;
  1497. #ifdef CONFIG_USE_FDPIC
  1498. {
  1499. struct elf32_fdpic_loadseg *loadsegs = info->loadsegs =
  1500. g_malloc(sizeof(*loadsegs) * info->nsegs);
  1501. for (i = 0; i < ehdr->e_phnum; ++i) {
  1502. switch (phdr[i].p_type) {
  1503. case PT_DYNAMIC:
  1504. info->pt_dynamic_addr = phdr[i].p_vaddr + load_bias;
  1505. break;
  1506. case PT_LOAD:
  1507. loadsegs->addr = phdr[i].p_vaddr + load_bias;
  1508. loadsegs->p_vaddr = phdr[i].p_vaddr;
  1509. loadsegs->p_memsz = phdr[i].p_memsz;
  1510. ++loadsegs;
  1511. break;
  1512. }
  1513. }
  1514. }
  1515. #endif
  1516. info->load_bias = load_bias;
  1517. info->load_addr = load_addr;
  1518. info->entry = ehdr->e_entry + load_bias;
  1519. info->start_code = -1;
  1520. info->end_code = 0;
  1521. info->start_data = -1;
  1522. info->end_data = 0;
  1523. info->brk = 0;
  1524. info->elf_flags = ehdr->e_flags;
  1525. for (i = 0; i < ehdr->e_phnum; i++) {
  1526. struct elf_phdr *eppnt = phdr + i;
  1527. if (eppnt->p_type == PT_LOAD) {
  1528. abi_ulong vaddr, vaddr_po, vaddr_ps, vaddr_ef, vaddr_em;
  1529. int elf_prot = 0;
  1530. if (eppnt->p_flags & PF_R) elf_prot = PROT_READ;
  1531. if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
  1532. if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
  1533. vaddr = load_bias + eppnt->p_vaddr;
  1534. vaddr_po = TARGET_ELF_PAGEOFFSET(vaddr);
  1535. vaddr_ps = TARGET_ELF_PAGESTART(vaddr);
  1536. error = target_mmap(vaddr_ps, eppnt->p_filesz + vaddr_po,
  1537. elf_prot, MAP_PRIVATE | MAP_FIXED,
  1538. image_fd, eppnt->p_offset - vaddr_po);
  1539. if (error == -1) {
  1540. goto exit_perror;
  1541. }
  1542. vaddr_ef = vaddr + eppnt->p_filesz;
  1543. vaddr_em = vaddr + eppnt->p_memsz;
  1544. /* If the load segment requests extra zeros (e.g. bss), map it. */
  1545. if (vaddr_ef < vaddr_em) {
  1546. zero_bss(vaddr_ef, vaddr_em, elf_prot);
  1547. }
  1548. /* Find the full program boundaries. */
  1549. if (elf_prot & PROT_EXEC) {
  1550. if (vaddr < info->start_code) {
  1551. info->start_code = vaddr;
  1552. }
  1553. if (vaddr_ef > info->end_code) {
  1554. info->end_code = vaddr_ef;
  1555. }
  1556. }
  1557. if (elf_prot & PROT_WRITE) {
  1558. if (vaddr < info->start_data) {
  1559. info->start_data = vaddr;
  1560. }
  1561. if (vaddr_ef > info->end_data) {
  1562. info->end_data = vaddr_ef;
  1563. }
  1564. if (vaddr_em > info->brk) {
  1565. info->brk = vaddr_em;
  1566. }
  1567. }
  1568. } else if (eppnt->p_type == PT_INTERP && pinterp_name) {
  1569. char *interp_name;
  1570. if (*pinterp_name) {
  1571. errmsg = "Multiple PT_INTERP entries";
  1572. goto exit_errmsg;
  1573. }
  1574. interp_name = malloc(eppnt->p_filesz);
  1575. if (!interp_name) {
  1576. goto exit_perror;
  1577. }
  1578. if (eppnt->p_offset + eppnt->p_filesz <= BPRM_BUF_SIZE) {
  1579. memcpy(interp_name, bprm_buf + eppnt->p_offset,
  1580. eppnt->p_filesz);
  1581. } else {
  1582. retval = pread(image_fd, interp_name, eppnt->p_filesz,
  1583. eppnt->p_offset);
  1584. if (retval != eppnt->p_filesz) {
  1585. goto exit_perror;
  1586. }
  1587. }
  1588. if (interp_name[eppnt->p_filesz - 1] != 0) {
  1589. errmsg = "Invalid PT_INTERP entry";
  1590. goto exit_errmsg;
  1591. }
  1592. *pinterp_name = interp_name;
  1593. }
  1594. }
  1595. if (info->end_data == 0) {
  1596. info->start_data = info->end_code;
  1597. info->end_data = info->end_code;
  1598. info->brk = info->end_code;
  1599. }
  1600. if (qemu_log_enabled()) {
  1601. load_symbols(ehdr, image_fd, load_bias);
  1602. }
  1603. close(image_fd);
  1604. return;
  1605. exit_read:
  1606. if (retval >= 0) {
  1607. errmsg = "Incomplete read of file header";
  1608. goto exit_errmsg;
  1609. }
  1610. exit_perror:
  1611. errmsg = strerror(errno);
  1612. exit_errmsg:
  1613. fprintf(stderr, "%s: %s\n", image_name, errmsg);
  1614. exit(-1);
  1615. }
  1616. static void load_elf_interp(const char *filename, struct image_info *info,
  1617. char bprm_buf[BPRM_BUF_SIZE])
  1618. {
  1619. int fd, retval;
  1620. fd = open(path(filename), O_RDONLY);
  1621. if (fd < 0) {
  1622. goto exit_perror;
  1623. }
  1624. retval = read(fd, bprm_buf, BPRM_BUF_SIZE);
  1625. if (retval < 0) {
  1626. goto exit_perror;
  1627. }
  1628. if (retval < BPRM_BUF_SIZE) {
  1629. memset(bprm_buf + retval, 0, BPRM_BUF_SIZE - retval);
  1630. }
  1631. load_elf_image(filename, fd, info, NULL, bprm_buf);
  1632. return;
  1633. exit_perror:
  1634. fprintf(stderr, "%s: %s\n", filename, strerror(errno));
  1635. exit(-1);
  1636. }
  1637. static int symfind(const void *s0, const void *s1)
  1638. {
  1639. target_ulong addr = *(target_ulong *)s0;
  1640. struct elf_sym *sym = (struct elf_sym *)s1;
  1641. int result = 0;
  1642. if (addr < sym->st_value) {
  1643. result = -1;
  1644. } else if (addr >= sym->st_value + sym->st_size) {
  1645. result = 1;
  1646. }
  1647. return result;
  1648. }
  1649. static const char *lookup_symbolxx(struct syminfo *s, target_ulong orig_addr)
  1650. {
  1651. #if ELF_CLASS == ELFCLASS32
  1652. struct elf_sym *syms = s->disas_symtab.elf32;
  1653. #else
  1654. struct elf_sym *syms = s->disas_symtab.elf64;
  1655. #endif
  1656. // binary search
  1657. struct elf_sym *sym;
  1658. sym = bsearch(&orig_addr, syms, s->disas_num_syms, sizeof(*syms), symfind);
  1659. if (sym != NULL) {
  1660. return s->disas_strtab + sym->st_name;
  1661. }
  1662. return "";
  1663. }
  1664. /* FIXME: This should use elf_ops.h */
  1665. static int symcmp(const void *s0, const void *s1)
  1666. {
  1667. struct elf_sym *sym0 = (struct elf_sym *)s0;
  1668. struct elf_sym *sym1 = (struct elf_sym *)s1;
  1669. return (sym0->st_value < sym1->st_value)
  1670. ? -1
  1671. : ((sym0->st_value > sym1->st_value) ? 1 : 0);
  1672. }
  1673. /* Best attempt to load symbols from this ELF object. */
  1674. static void load_symbols(struct elfhdr *hdr, int fd, abi_ulong load_bias)
  1675. {
  1676. int i, shnum, nsyms, sym_idx = 0, str_idx = 0;
  1677. struct elf_shdr *shdr;
  1678. char *strings = NULL;
  1679. struct syminfo *s = NULL;
  1680. struct elf_sym *new_syms, *syms = NULL;
  1681. shnum = hdr->e_shnum;
  1682. i = shnum * sizeof(struct elf_shdr);
  1683. shdr = (struct elf_shdr *)alloca(i);
  1684. if (pread(fd, shdr, i, hdr->e_shoff) != i) {
  1685. return;
  1686. }
  1687. bswap_shdr(shdr, shnum);
  1688. for (i = 0; i < shnum; ++i) {
  1689. if (shdr[i].sh_type == SHT_SYMTAB) {
  1690. sym_idx = i;
  1691. str_idx = shdr[i].sh_link;
  1692. goto found;
  1693. }
  1694. }
  1695. /* There will be no symbol table if the file was stripped. */
  1696. return;
  1697. found:
  1698. /* Now know where the strtab and symtab are. Snarf them. */
  1699. s = malloc(sizeof(*s));
  1700. if (!s) {
  1701. goto give_up;
  1702. }
  1703. i = shdr[str_idx].sh_size;
  1704. s->disas_strtab = strings = malloc(i);
  1705. if (!strings || pread(fd, strings, i, shdr[str_idx].sh_offset) != i) {
  1706. goto give_up;
  1707. }
  1708. i = shdr[sym_idx].sh_size;
  1709. syms = malloc(i);
  1710. if (!syms || pread(fd, syms, i, shdr[sym_idx].sh_offset) != i) {
  1711. goto give_up;
  1712. }
  1713. nsyms = i / sizeof(struct elf_sym);
  1714. for (i = 0; i < nsyms; ) {
  1715. bswap_sym(syms + i);
  1716. /* Throw away entries which we do not need. */
  1717. if (syms[i].st_shndx == SHN_UNDEF
  1718. || syms[i].st_shndx >= SHN_LORESERVE
  1719. || ELF_ST_TYPE(syms[i].st_info) != STT_FUNC) {
  1720. if (i < --nsyms) {
  1721. syms[i] = syms[nsyms];
  1722. }
  1723. } else {
  1724. #if defined(TARGET_ARM) || defined (TARGET_MIPS)
  1725. /* The bottom address bit marks a Thumb or MIPS16 symbol. */
  1726. syms[i].st_value &= ~(target_ulong)1;
  1727. #endif
  1728. syms[i].st_value += load_bias;
  1729. i++;
  1730. }
  1731. }
  1732. /* No "useful" symbol. */
  1733. if (nsyms == 0) {
  1734. goto give_up;
  1735. }
  1736. /* Attempt to free the storage associated with the local symbols
  1737. that we threw away. Whether or not this has any effect on the
  1738. memory allocation depends on the malloc implementation and how
  1739. many symbols we managed to discard. */
  1740. new_syms = realloc(syms, nsyms * sizeof(*syms));
  1741. if (new_syms == NULL) {
  1742. goto give_up;
  1743. }
  1744. syms = new_syms;
  1745. qsort(syms, nsyms, sizeof(*syms), symcmp);
  1746. s->disas_num_syms = nsyms;
  1747. #if ELF_CLASS == ELFCLASS32
  1748. s->disas_symtab.elf32 = syms;
  1749. #else
  1750. s->disas_symtab.elf64 = syms;
  1751. #endif
  1752. s->lookup_symbol = lookup_symbolxx;
  1753. s->next = syminfos;
  1754. syminfos = s;
  1755. return;
  1756. give_up:
  1757. free(s);
  1758. free(strings);
  1759. free(syms);
  1760. }
  1761. int load_elf_binary(struct linux_binprm *bprm, struct image_info *info)
  1762. {
  1763. struct image_info interp_info;
  1764. struct elfhdr elf_ex;
  1765. char *elf_interpreter = NULL;
  1766. info->start_mmap = (abi_ulong)ELF_START_MMAP;
  1767. info->mmap = 0;
  1768. info->rss = 0;
  1769. load_elf_image(bprm->filename, bprm->fd, info,
  1770. &elf_interpreter, bprm->buf);
  1771. /* ??? We need a copy of the elf header for passing to create_elf_tables.
  1772. If we do nothing, we'll have overwritten this when we re-use bprm->buf
  1773. when we load the interpreter. */
  1774. elf_ex = *(struct elfhdr *)bprm->buf;
  1775. bprm->p = copy_elf_strings(1, &bprm->filename, bprm->page, bprm->p);
  1776. bprm->p = copy_elf_strings(bprm->envc,bprm->envp,bprm->page,bprm->p);
  1777. bprm->p = copy_elf_strings(bprm->argc,bprm->argv,bprm->page,bprm->p);
  1778. if (!bprm->p) {
  1779. fprintf(stderr, "%s: %s\n", bprm->filename, strerror(E2BIG));
  1780. exit(-1);
  1781. }
  1782. /* Do this so that we can load the interpreter, if need be. We will
  1783. change some of these later */
  1784. bprm->p = setup_arg_pages(bprm->p, bprm, info);
  1785. if (elf_interpreter) {
  1786. load_elf_interp(elf_interpreter, &interp_info, bprm->buf);
  1787. /* If the program interpreter is one of these two, then assume
  1788. an iBCS2 image. Otherwise assume a native linux image. */
  1789. if (strcmp(elf_interpreter, "/usr/lib/libc.so.1") == 0
  1790. || strcmp(elf_interpreter, "/usr/lib/ld.so.1") == 0) {
  1791. info->personality = PER_SVR4;
  1792. /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
  1793. and some applications "depend" upon this behavior. Since
  1794. we do not have the power to recompile these, we emulate
  1795. the SVr4 behavior. Sigh. */
  1796. target_mmap(0, qemu_host_page_size, PROT_READ | PROT_EXEC,
  1797. MAP_FIXED | MAP_PRIVATE, -1, 0);
  1798. }
  1799. }
  1800. bprm->p = create_elf_tables(bprm->p, bprm->argc, bprm->envc, &elf_ex,
  1801. info, (elf_interpreter ? &interp_info : NULL));
  1802. info->start_stack = bprm->p;
  1803. /* If we have an interpreter, set that as the program's entry point.
  1804. Copy the load_bias as well, to help PPC64 interpret the entry
  1805. point as a function descriptor. Do this after creating elf tables
  1806. so that we copy the original program entry point into the AUXV. */
  1807. if (elf_interpreter) {
  1808. info->load_bias = interp_info.load_bias;
  1809. info->entry = interp_info.entry;
  1810. free(elf_interpreter);
  1811. }
  1812. #ifdef USE_ELF_CORE_DUMP
  1813. bprm->core_dump = &elf_core_dump;
  1814. #endif
  1815. return 0;
  1816. }
  1817. #ifdef USE_ELF_CORE_DUMP
  1818. /*
  1819. * Definitions to generate Intel SVR4-like core files.
  1820. * These mostly have the same names as the SVR4 types with "target_elf_"
  1821. * tacked on the front to prevent clashes with linux definitions,
  1822. * and the typedef forms have been avoided. This is mostly like
  1823. * the SVR4 structure, but more Linuxy, with things that Linux does
  1824. * not support and which gdb doesn't really use excluded.
  1825. *
  1826. * Fields we don't dump (their contents is zero) in linux-user qemu
  1827. * are marked with XXX.
  1828. *
  1829. * Core dump code is copied from linux kernel (fs/binfmt_elf.c).
  1830. *
  1831. * Porting ELF coredump for target is (quite) simple process. First you
  1832. * define USE_ELF_CORE_DUMP in target ELF code (where init_thread() for
  1833. * the target resides):
  1834. *
  1835. * #define USE_ELF_CORE_DUMP
  1836. *
  1837. * Next you define type of register set used for dumping. ELF specification
  1838. * says that it needs to be array of elf_greg_t that has size of ELF_NREG.
  1839. *
  1840. * typedef <target_regtype> target_elf_greg_t;
  1841. * #define ELF_NREG <number of registers>
  1842. * typedef taret_elf_greg_t target_elf_gregset_t[ELF_NREG];
  1843. *
  1844. * Last step is to implement target specific function that copies registers
  1845. * from given cpu into just specified register set. Prototype is:
  1846. *
  1847. * static void elf_core_copy_regs(taret_elf_gregset_t *regs,
  1848. * const CPUArchState *env);
  1849. *
  1850. * Parameters:
  1851. * regs - copy register values into here (allocated and zeroed by caller)
  1852. * env - copy registers from here
  1853. *
  1854. * Example for ARM target is provided in this file.
  1855. */
  1856. /* An ELF note in memory */
  1857. struct memelfnote {
  1858. const char *name;
  1859. size_t namesz;
  1860. size_t namesz_rounded;
  1861. int type;
  1862. size_t datasz;
  1863. size_t datasz_rounded;
  1864. void *data;
  1865. size_t notesz;
  1866. };
  1867. struct target_elf_siginfo {
  1868. abi_int si_signo; /* signal number */
  1869. abi_int si_code; /* extra code */
  1870. abi_int si_errno; /* errno */
  1871. };
  1872. struct target_elf_prstatus {
  1873. struct target_elf_siginfo pr_info; /* Info associated with signal */
  1874. abi_short pr_cursig; /* Current signal */
  1875. abi_ulong pr_sigpend; /* XXX */
  1876. abi_ulong pr_sighold; /* XXX */
  1877. target_pid_t pr_pid;
  1878. target_pid_t pr_ppid;
  1879. target_pid_t pr_pgrp;
  1880. target_pid_t pr_sid;
  1881. struct target_timeval pr_utime; /* XXX User time */
  1882. struct target_timeval pr_stime; /* XXX System time */
  1883. struct target_timeval pr_cutime; /* XXX Cumulative user time */
  1884. struct target_timeval pr_cstime; /* XXX Cumulative system time */
  1885. target_elf_gregset_t pr_reg; /* GP registers */
  1886. abi_int pr_fpvalid; /* XXX */
  1887. };
  1888. #define ELF_PRARGSZ (80) /* Number of chars for args */
  1889. struct target_elf_prpsinfo {
  1890. char pr_state; /* numeric process state */
  1891. char pr_sname; /* char for pr_state */
  1892. char pr_zomb; /* zombie */
  1893. char pr_nice; /* nice val */
  1894. abi_ulong pr_flag; /* flags */
  1895. target_uid_t pr_uid;
  1896. target_gid_t pr_gid;
  1897. target_pid_t pr_pid, pr_ppid, pr_pgrp, pr_sid;
  1898. /* Lots missing */
  1899. char pr_fname[16]; /* filename of executable */
  1900. char pr_psargs[ELF_PRARGSZ]; /* initial part of arg list */
  1901. };
  1902. /* Here is the structure in which status of each thread is captured. */
  1903. struct elf_thread_status {
  1904. QTAILQ_ENTRY(elf_thread_status) ets_link;
  1905. struct target_elf_prstatus prstatus; /* NT_PRSTATUS */
  1906. #if 0
  1907. elf_fpregset_t fpu; /* NT_PRFPREG */
  1908. struct task_struct *thread;
  1909. elf_fpxregset_t xfpu; /* ELF_CORE_XFPREG_TYPE */
  1910. #endif
  1911. struct memelfnote notes[1];
  1912. int num_notes;
  1913. };
  1914. struct elf_note_info {
  1915. struct memelfnote *notes;
  1916. struct target_elf_prstatus *prstatus; /* NT_PRSTATUS */
  1917. struct target_elf_prpsinfo *psinfo; /* NT_PRPSINFO */
  1918. QTAILQ_HEAD(thread_list_head, elf_thread_status) thread_list;
  1919. #if 0
  1920. /*
  1921. * Current version of ELF coredump doesn't support
  1922. * dumping fp regs etc.
  1923. */
  1924. elf_fpregset_t *fpu;
  1925. elf_fpxregset_t *xfpu;
  1926. int thread_status_size;
  1927. #endif
  1928. int notes_size;
  1929. int numnote;
  1930. };
  1931. struct vm_area_struct {
  1932. abi_ulong vma_start; /* start vaddr of memory region */
  1933. abi_ulong vma_end; /* end vaddr of memory region */
  1934. abi_ulong vma_flags; /* protection etc. flags for the region */
  1935. QTAILQ_ENTRY(vm_area_struct) vma_link;
  1936. };
  1937. struct mm_struct {
  1938. QTAILQ_HEAD(, vm_area_struct) mm_mmap;
  1939. int mm_count; /* number of mappings */
  1940. };
  1941. static struct mm_struct *vma_init(void);
  1942. static void vma_delete(struct mm_struct *);
  1943. static int vma_add_mapping(struct mm_struct *, abi_ulong,
  1944. abi_ulong, abi_ulong);
  1945. static int vma_get_mapping_count(const struct mm_struct *);
  1946. static struct vm_area_struct *vma_first(const struct mm_struct *);
  1947. static struct vm_area_struct *vma_next(struct vm_area_struct *);
  1948. static abi_ulong vma_dump_size(const struct vm_area_struct *);
  1949. static int vma_walker(void *priv, abi_ulong start, abi_ulong end,
  1950. unsigned long flags);
  1951. static void fill_elf_header(struct elfhdr *, int, uint16_t, uint32_t);
  1952. static void fill_note(struct memelfnote *, const char *, int,
  1953. unsigned int, void *);
  1954. static void fill_prstatus(struct target_elf_prstatus *, const TaskState *, int);
  1955. static int fill_psinfo(struct target_elf_prpsinfo *, const TaskState *);
  1956. static void fill_auxv_note(struct memelfnote *, const TaskState *);
  1957. static void fill_elf_note_phdr(struct elf_phdr *, int, off_t);
  1958. static size_t note_size(const struct memelfnote *);
  1959. static void free_note_info(struct elf_note_info *);
  1960. static int fill_note_info(struct elf_note_info *, long, const CPUArchState *);
  1961. static void fill_thread_info(struct elf_note_info *, const CPUArchState *);
  1962. static int core_dump_filename(const TaskState *, char *, size_t);
  1963. static int dump_write(int, const void *, size_t);
  1964. static int write_note(struct memelfnote *, int);
  1965. static int write_note_info(struct elf_note_info *, int);
  1966. #ifdef BSWAP_NEEDED
  1967. static void bswap_prstatus(struct target_elf_prstatus *prstatus)
  1968. {
  1969. prstatus->pr_info.si_signo = tswap32(prstatus->pr_info.si_signo);
  1970. prstatus->pr_info.si_code = tswap32(prstatus->pr_info.si_code);
  1971. prstatus->pr_info.si_errno = tswap32(prstatus->pr_info.si_errno);
  1972. prstatus->pr_cursig = tswap16(prstatus->pr_cursig);
  1973. prstatus->pr_sigpend = tswapal(prstatus->pr_sigpend);
  1974. prstatus->pr_sighold = tswapal(prstatus->pr_sighold);
  1975. prstatus->pr_pid = tswap32(prstatus->pr_pid);
  1976. prstatus->pr_ppid = tswap32(prstatus->pr_ppid);
  1977. prstatus->pr_pgrp = tswap32(prstatus->pr_pgrp);
  1978. prstatus->pr_sid = tswap32(prstatus->pr_sid);
  1979. /* cpu times are not filled, so we skip them */
  1980. /* regs should be in correct format already */
  1981. prstatus->pr_fpvalid = tswap32(prstatus->pr_fpvalid);
  1982. }
  1983. static void bswap_psinfo(struct target_elf_prpsinfo *psinfo)
  1984. {
  1985. psinfo->pr_flag = tswapal(psinfo->pr_flag);
  1986. psinfo->pr_uid = tswap16(psinfo->pr_uid);
  1987. psinfo->pr_gid = tswap16(psinfo->pr_gid);
  1988. psinfo->pr_pid = tswap32(psinfo->pr_pid);
  1989. psinfo->pr_ppid = tswap32(psinfo->pr_ppid);
  1990. psinfo->pr_pgrp = tswap32(psinfo->pr_pgrp);
  1991. psinfo->pr_sid = tswap32(psinfo->pr_sid);
  1992. }
  1993. static void bswap_note(struct elf_note *en)
  1994. {
  1995. bswap32s(&en->n_namesz);
  1996. bswap32s(&en->n_descsz);
  1997. bswap32s(&en->n_type);
  1998. }
  1999. #else
  2000. static inline void bswap_prstatus(struct target_elf_prstatus *p) { }
  2001. static inline void bswap_psinfo(struct target_elf_prpsinfo *p) {}
  2002. static inline void bswap_note(struct elf_note *en) { }
  2003. #endif /* BSWAP_NEEDED */
  2004. /*
  2005. * Minimal support for linux memory regions. These are needed
  2006. * when we are finding out what memory exactly belongs to
  2007. * emulated process. No locks needed here, as long as
  2008. * thread that received the signal is stopped.
  2009. */
  2010. static struct mm_struct *vma_init(void)
  2011. {
  2012. struct mm_struct *mm;
  2013. if ((mm = g_malloc(sizeof (*mm))) == NULL)
  2014. return (NULL);
  2015. mm->mm_count = 0;
  2016. QTAILQ_INIT(&mm->mm_mmap);
  2017. return (mm);
  2018. }
  2019. static void vma_delete(struct mm_struct *mm)
  2020. {
  2021. struct vm_area_struct *vma;
  2022. while ((vma = vma_first(mm)) != NULL) {
  2023. QTAILQ_REMOVE(&mm->mm_mmap, vma, vma_link);
  2024. g_free(vma);
  2025. }
  2026. g_free(mm);
  2027. }
  2028. static int vma_add_mapping(struct mm_struct *mm, abi_ulong start,
  2029. abi_ulong end, abi_ulong flags)
  2030. {
  2031. struct vm_area_struct *vma;
  2032. if ((vma = g_malloc0(sizeof (*vma))) == NULL)
  2033. return (-1);
  2034. vma->vma_start = start;
  2035. vma->vma_end = end;
  2036. vma->vma_flags = flags;
  2037. QTAILQ_INSERT_TAIL(&mm->mm_mmap, vma, vma_link);
  2038. mm->mm_count++;
  2039. return (0);
  2040. }
  2041. static struct vm_area_struct *vma_first(const struct mm_struct *mm)
  2042. {
  2043. return (QTAILQ_FIRST(&mm->mm_mmap));
  2044. }
  2045. static struct vm_area_struct *vma_next(struct vm_area_struct *vma)
  2046. {
  2047. return (QTAILQ_NEXT(vma, vma_link));
  2048. }
  2049. static int vma_get_mapping_count(const struct mm_struct *mm)
  2050. {
  2051. return (mm->mm_count);
  2052. }
  2053. /*
  2054. * Calculate file (dump) size of given memory region.
  2055. */
  2056. static abi_ulong vma_dump_size(const struct vm_area_struct *vma)
  2057. {
  2058. /* if we cannot even read the first page, skip it */
  2059. if (!access_ok(VERIFY_READ, vma->vma_start, TARGET_PAGE_SIZE))
  2060. return (0);
  2061. /*
  2062. * Usually we don't dump executable pages as they contain
  2063. * non-writable code that debugger can read directly from
  2064. * target library etc. However, thread stacks are marked
  2065. * also executable so we read in first page of given region
  2066. * and check whether it contains elf header. If there is
  2067. * no elf header, we dump it.
  2068. */
  2069. if (vma->vma_flags & PROT_EXEC) {
  2070. char page[TARGET_PAGE_SIZE];
  2071. copy_from_user(page, vma->vma_start, sizeof (page));
  2072. if ((page[EI_MAG0] == ELFMAG0) &&
  2073. (page[EI_MAG1] == ELFMAG1) &&
  2074. (page[EI_MAG2] == ELFMAG2) &&
  2075. (page[EI_MAG3] == ELFMAG3)) {
  2076. /*
  2077. * Mappings are possibly from ELF binary. Don't dump
  2078. * them.
  2079. */
  2080. return (0);
  2081. }
  2082. }
  2083. return (vma->vma_end - vma->vma_start);
  2084. }
  2085. static int vma_walker(void *priv, abi_ulong start, abi_ulong end,
  2086. unsigned long flags)
  2087. {
  2088. struct mm_struct *mm = (struct mm_struct *)priv;
  2089. vma_add_mapping(mm, start, end, flags);
  2090. return (0);
  2091. }
  2092. static void fill_note(struct memelfnote *note, const char *name, int type,
  2093. unsigned int sz, void *data)
  2094. {
  2095. unsigned int namesz;
  2096. namesz = strlen(name) + 1;
  2097. note->name = name;
  2098. note->namesz = namesz;
  2099. note->namesz_rounded = roundup(namesz, sizeof (int32_t));
  2100. note->type = type;
  2101. note->datasz = sz;
  2102. note->datasz_rounded = roundup(sz, sizeof (int32_t));
  2103. note->data = data;
  2104. /*
  2105. * We calculate rounded up note size here as specified by
  2106. * ELF document.
  2107. */
  2108. note->notesz = sizeof (struct elf_note) +
  2109. note->namesz_rounded + note->datasz_rounded;
  2110. }
  2111. static void fill_elf_header(struct elfhdr *elf, int segs, uint16_t machine,
  2112. uint32_t flags)
  2113. {
  2114. (void) memset(elf, 0, sizeof(*elf));
  2115. (void) memcpy(elf->e_ident, ELFMAG, SELFMAG);
  2116. elf->e_ident[EI_CLASS] = ELF_CLASS;
  2117. elf->e_ident[EI_DATA] = ELF_DATA;
  2118. elf->e_ident[EI_VERSION] = EV_CURRENT;
  2119. elf->e_ident[EI_OSABI] = ELF_OSABI;
  2120. elf->e_type = ET_CORE;
  2121. elf->e_machine = machine;
  2122. elf->e_version = EV_CURRENT;
  2123. elf->e_phoff = sizeof(struct elfhdr);
  2124. elf->e_flags = flags;
  2125. elf->e_ehsize = sizeof(struct elfhdr);
  2126. elf->e_phentsize = sizeof(struct elf_phdr);
  2127. elf->e_phnum = segs;
  2128. bswap_ehdr(elf);
  2129. }
  2130. static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, off_t offset)
  2131. {
  2132. phdr->p_type = PT_NOTE;
  2133. phdr->p_offset = offset;
  2134. phdr->p_vaddr = 0;
  2135. phdr->p_paddr = 0;
  2136. phdr->p_filesz = sz;
  2137. phdr->p_memsz = 0;
  2138. phdr->p_flags = 0;
  2139. phdr->p_align = 0;
  2140. bswap_phdr(phdr, 1);
  2141. }
  2142. static size_t note_size(const struct memelfnote *note)
  2143. {
  2144. return (note->notesz);
  2145. }
  2146. static void fill_prstatus(struct target_elf_prstatus *prstatus,
  2147. const TaskState *ts, int signr)
  2148. {
  2149. (void) memset(prstatus, 0, sizeof (*prstatus));
  2150. prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
  2151. prstatus->pr_pid = ts->ts_tid;
  2152. prstatus->pr_ppid = getppid();
  2153. prstatus->pr_pgrp = getpgrp();
  2154. prstatus->pr_sid = getsid(0);
  2155. bswap_prstatus(prstatus);
  2156. }
  2157. static int fill_psinfo(struct target_elf_prpsinfo *psinfo, const TaskState *ts)
  2158. {
  2159. char *base_filename;
  2160. unsigned int i, len;
  2161. (void) memset(psinfo, 0, sizeof (*psinfo));
  2162. len = ts->info->arg_end - ts->info->arg_start;
  2163. if (len >= ELF_PRARGSZ)
  2164. len = ELF_PRARGSZ - 1;
  2165. if (copy_from_user(&psinfo->pr_psargs, ts->info->arg_start, len))
  2166. return -EFAULT;
  2167. for (i = 0; i < len; i++)
  2168. if (psinfo->pr_psargs[i] == 0)
  2169. psinfo->pr_psargs[i] = ' ';
  2170. psinfo->pr_psargs[len] = 0;
  2171. psinfo->pr_pid = getpid();
  2172. psinfo->pr_ppid = getppid();
  2173. psinfo->pr_pgrp = getpgrp();
  2174. psinfo->pr_sid = getsid(0);
  2175. psinfo->pr_uid = getuid();
  2176. psinfo->pr_gid = getgid();
  2177. base_filename = g_path_get_basename(ts->bprm->filename);
  2178. /*
  2179. * Using strncpy here is fine: at max-length,
  2180. * this field is not NUL-terminated.
  2181. */
  2182. (void) strncpy(psinfo->pr_fname, base_filename,
  2183. sizeof(psinfo->pr_fname));
  2184. g_free(base_filename);
  2185. bswap_psinfo(psinfo);
  2186. return (0);
  2187. }
  2188. static void fill_auxv_note(struct memelfnote *note, const TaskState *ts)
  2189. {
  2190. elf_addr_t auxv = (elf_addr_t)ts->info->saved_auxv;
  2191. elf_addr_t orig_auxv = auxv;
  2192. void *ptr;
  2193. int len = ts->info->auxv_len;
  2194. /*
  2195. * Auxiliary vector is stored in target process stack. It contains
  2196. * {type, value} pairs that we need to dump into note. This is not
  2197. * strictly necessary but we do it here for sake of completeness.
  2198. */
  2199. /* read in whole auxv vector and copy it to memelfnote */
  2200. ptr = lock_user(VERIFY_READ, orig_auxv, len, 0);
  2201. if (ptr != NULL) {
  2202. fill_note(note, "CORE", NT_AUXV, len, ptr);
  2203. unlock_user(ptr, auxv, len);
  2204. }
  2205. }
  2206. /*
  2207. * Constructs name of coredump file. We have following convention
  2208. * for the name:
  2209. * qemu_<basename-of-target-binary>_<date>-<time>_<pid>.core
  2210. *
  2211. * Returns 0 in case of success, -1 otherwise (errno is set).
  2212. */
  2213. static int core_dump_filename(const TaskState *ts, char *buf,
  2214. size_t bufsize)
  2215. {
  2216. char timestamp[64];
  2217. char *filename = NULL;
  2218. char *base_filename = NULL;
  2219. struct timeval tv;
  2220. struct tm tm;
  2221. assert(bufsize >= PATH_MAX);
  2222. if (gettimeofday(&tv, NULL) < 0) {
  2223. (void) fprintf(stderr, "unable to get current timestamp: %s",
  2224. strerror(errno));
  2225. return (-1);
  2226. }
  2227. filename = strdup(ts->bprm->filename);
  2228. base_filename = strdup(basename(filename));
  2229. (void) strftime(timestamp, sizeof (timestamp), "%Y%m%d-%H%M%S",
  2230. localtime_r(&tv.tv_sec, &tm));
  2231. (void) snprintf(buf, bufsize, "qemu_%s_%s_%d.core",
  2232. base_filename, timestamp, (int)getpid());
  2233. free(base_filename);
  2234. free(filename);
  2235. return (0);
  2236. }
  2237. static int dump_write(int fd, const void *ptr, size_t size)
  2238. {
  2239. const char *bufp = (const char *)ptr;
  2240. ssize_t bytes_written, bytes_left;
  2241. struct rlimit dumpsize;
  2242. off_t pos;
  2243. bytes_written = 0;
  2244. getrlimit(RLIMIT_CORE, &dumpsize);
  2245. if ((pos = lseek(fd, 0, SEEK_CUR))==-1) {
  2246. if (errno == ESPIPE) { /* not a seekable stream */
  2247. bytes_left = size;
  2248. } else {
  2249. return pos;
  2250. }
  2251. } else {
  2252. if (dumpsize.rlim_cur <= pos) {
  2253. return -1;
  2254. } else if (dumpsize.rlim_cur == RLIM_INFINITY) {
  2255. bytes_left = size;
  2256. } else {
  2257. size_t limit_left=dumpsize.rlim_cur - pos;
  2258. bytes_left = limit_left >= size ? size : limit_left ;
  2259. }
  2260. }
  2261. /*
  2262. * In normal conditions, single write(2) should do but
  2263. * in case of socket etc. this mechanism is more portable.
  2264. */
  2265. do {
  2266. bytes_written = write(fd, bufp, bytes_left);
  2267. if (bytes_written < 0) {
  2268. if (errno == EINTR)
  2269. continue;
  2270. return (-1);
  2271. } else if (bytes_written == 0) { /* eof */
  2272. return (-1);
  2273. }
  2274. bufp += bytes_written;
  2275. bytes_left -= bytes_written;
  2276. } while (bytes_left > 0);
  2277. return (0);
  2278. }
  2279. static int write_note(struct memelfnote *men, int fd)
  2280. {
  2281. struct elf_note en;
  2282. en.n_namesz = men->namesz;
  2283. en.n_type = men->type;
  2284. en.n_descsz = men->datasz;
  2285. bswap_note(&en);
  2286. if (dump_write(fd, &en, sizeof(en)) != 0)
  2287. return (-1);
  2288. if (dump_write(fd, men->name, men->namesz_rounded) != 0)
  2289. return (-1);
  2290. if (dump_write(fd, men->data, men->datasz_rounded) != 0)
  2291. return (-1);
  2292. return (0);
  2293. }
  2294. static void fill_thread_info(struct elf_note_info *info, const CPUArchState *env)
  2295. {
  2296. CPUState *cpu = ENV_GET_CPU((CPUArchState *)env);
  2297. TaskState *ts = (TaskState *)cpu->opaque;
  2298. struct elf_thread_status *ets;
  2299. ets = g_malloc0(sizeof (*ets));
  2300. ets->num_notes = 1; /* only prstatus is dumped */
  2301. fill_prstatus(&ets->prstatus, ts, 0);
  2302. elf_core_copy_regs(&ets->prstatus.pr_reg, env);
  2303. fill_note(&ets->notes[0], "CORE", NT_PRSTATUS, sizeof (ets->prstatus),
  2304. &ets->prstatus);
  2305. QTAILQ_INSERT_TAIL(&info->thread_list, ets, ets_link);
  2306. info->notes_size += note_size(&ets->notes[0]);
  2307. }
  2308. static void init_note_info(struct elf_note_info *info)
  2309. {
  2310. /* Initialize the elf_note_info structure so that it is at
  2311. * least safe to call free_note_info() on it. Must be
  2312. * called before calling fill_note_info().
  2313. */
  2314. memset(info, 0, sizeof (*info));
  2315. QTAILQ_INIT(&info->thread_list);
  2316. }
  2317. static int fill_note_info(struct elf_note_info *info,
  2318. long signr, const CPUArchState *env)
  2319. {
  2320. #define NUMNOTES 3
  2321. CPUState *cpu = ENV_GET_CPU((CPUArchState *)env);
  2322. TaskState *ts = (TaskState *)cpu->opaque;
  2323. int i;
  2324. info->notes = g_malloc0(NUMNOTES * sizeof (struct memelfnote));
  2325. if (info->notes == NULL)
  2326. return (-ENOMEM);
  2327. info->prstatus = g_malloc0(sizeof (*info->prstatus));
  2328. if (info->prstatus == NULL)
  2329. return (-ENOMEM);
  2330. info->psinfo = g_malloc0(sizeof (*info->psinfo));
  2331. if (info->prstatus == NULL)
  2332. return (-ENOMEM);
  2333. /*
  2334. * First fill in status (and registers) of current thread
  2335. * including process info & aux vector.
  2336. */
  2337. fill_prstatus(info->prstatus, ts, signr);
  2338. elf_core_copy_regs(&info->prstatus->pr_reg, env);
  2339. fill_note(&info->notes[0], "CORE", NT_PRSTATUS,
  2340. sizeof (*info->prstatus), info->prstatus);
  2341. fill_psinfo(info->psinfo, ts);
  2342. fill_note(&info->notes[1], "CORE", NT_PRPSINFO,
  2343. sizeof (*info->psinfo), info->psinfo);
  2344. fill_auxv_note(&info->notes[2], ts);
  2345. info->numnote = 3;
  2346. info->notes_size = 0;
  2347. for (i = 0; i < info->numnote; i++)
  2348. info->notes_size += note_size(&info->notes[i]);
  2349. /* read and fill status of all threads */
  2350. cpu_list_lock();
  2351. CPU_FOREACH(cpu) {
  2352. if (cpu == thread_cpu) {
  2353. continue;
  2354. }
  2355. fill_thread_info(info, (CPUArchState *)cpu->env_ptr);
  2356. }
  2357. cpu_list_unlock();
  2358. return (0);
  2359. }
  2360. static void free_note_info(struct elf_note_info *info)
  2361. {
  2362. struct elf_thread_status *ets;
  2363. while (!QTAILQ_EMPTY(&info->thread_list)) {
  2364. ets = QTAILQ_FIRST(&info->thread_list);
  2365. QTAILQ_REMOVE(&info->thread_list, ets, ets_link);
  2366. g_free(ets);
  2367. }
  2368. g_free(info->prstatus);
  2369. g_free(info->psinfo);
  2370. g_free(info->notes);
  2371. }
  2372. static int write_note_info(struct elf_note_info *info, int fd)
  2373. {
  2374. struct elf_thread_status *ets;
  2375. int i, error = 0;
  2376. /* write prstatus, psinfo and auxv for current thread */
  2377. for (i = 0; i < info->numnote; i++)
  2378. if ((error = write_note(&info->notes[i], fd)) != 0)
  2379. return (error);
  2380. /* write prstatus for each thread */
  2381. for (ets = info->thread_list.tqh_first; ets != NULL;
  2382. ets = ets->ets_link.tqe_next) {
  2383. if ((error = write_note(&ets->notes[0], fd)) != 0)
  2384. return (error);
  2385. }
  2386. return (0);
  2387. }
  2388. /*
  2389. * Write out ELF coredump.
  2390. *
  2391. * See documentation of ELF object file format in:
  2392. * http://www.caldera.com/developers/devspecs/gabi41.pdf
  2393. *
  2394. * Coredump format in linux is following:
  2395. *
  2396. * 0 +----------------------+ \
  2397. * | ELF header | ET_CORE |
  2398. * +----------------------+ |
  2399. * | ELF program headers | |--- headers
  2400. * | - NOTE section | |
  2401. * | - PT_LOAD sections | |
  2402. * +----------------------+ /
  2403. * | NOTEs: |
  2404. * | - NT_PRSTATUS |
  2405. * | - NT_PRSINFO |
  2406. * | - NT_AUXV |
  2407. * +----------------------+ <-- aligned to target page
  2408. * | Process memory dump |
  2409. * : :
  2410. * . .
  2411. * : :
  2412. * | |
  2413. * +----------------------+
  2414. *
  2415. * NT_PRSTATUS -> struct elf_prstatus (per thread)
  2416. * NT_PRSINFO -> struct elf_prpsinfo
  2417. * NT_AUXV is array of { type, value } pairs (see fill_auxv_note()).
  2418. *
  2419. * Format follows System V format as close as possible. Current
  2420. * version limitations are as follows:
  2421. * - no floating point registers are dumped
  2422. *
  2423. * Function returns 0 in case of success, negative errno otherwise.
  2424. *
  2425. * TODO: make this work also during runtime: it should be
  2426. * possible to force coredump from running process and then
  2427. * continue processing. For example qemu could set up SIGUSR2
  2428. * handler (provided that target process haven't registered
  2429. * handler for that) that does the dump when signal is received.
  2430. */
  2431. static int elf_core_dump(int signr, const CPUArchState *env)
  2432. {
  2433. const CPUState *cpu = ENV_GET_CPU((CPUArchState *)env);
  2434. const TaskState *ts = (const TaskState *)cpu->opaque;
  2435. struct vm_area_struct *vma = NULL;
  2436. char corefile[PATH_MAX];
  2437. struct elf_note_info info;
  2438. struct elfhdr elf;
  2439. struct elf_phdr phdr;
  2440. struct rlimit dumpsize;
  2441. struct mm_struct *mm = NULL;
  2442. off_t offset = 0, data_offset = 0;
  2443. int segs = 0;
  2444. int fd = -1;
  2445. init_note_info(&info);
  2446. errno = 0;
  2447. getrlimit(RLIMIT_CORE, &dumpsize);
  2448. if (dumpsize.rlim_cur == 0)
  2449. return 0;
  2450. if (core_dump_filename(ts, corefile, sizeof (corefile)) < 0)
  2451. return (-errno);
  2452. if ((fd = open(corefile, O_WRONLY | O_CREAT,
  2453. S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
  2454. return (-errno);
  2455. /*
  2456. * Walk through target process memory mappings and
  2457. * set up structure containing this information. After
  2458. * this point vma_xxx functions can be used.
  2459. */
  2460. if ((mm = vma_init()) == NULL)
  2461. goto out;
  2462. walk_memory_regions(mm, vma_walker);
  2463. segs = vma_get_mapping_count(mm);
  2464. /*
  2465. * Construct valid coredump ELF header. We also
  2466. * add one more segment for notes.
  2467. */
  2468. fill_elf_header(&elf, segs + 1, ELF_MACHINE, 0);
  2469. if (dump_write(fd, &elf, sizeof (elf)) != 0)
  2470. goto out;
  2471. /* fill in in-memory version of notes */
  2472. if (fill_note_info(&info, signr, env) < 0)
  2473. goto out;
  2474. offset += sizeof (elf); /* elf header */
  2475. offset += (segs + 1) * sizeof (struct elf_phdr); /* program headers */
  2476. /* write out notes program header */
  2477. fill_elf_note_phdr(&phdr, info.notes_size, offset);
  2478. offset += info.notes_size;
  2479. if (dump_write(fd, &phdr, sizeof (phdr)) != 0)
  2480. goto out;
  2481. /*
  2482. * ELF specification wants data to start at page boundary so
  2483. * we align it here.
  2484. */
  2485. data_offset = offset = roundup(offset, ELF_EXEC_PAGESIZE);
  2486. /*
  2487. * Write program headers for memory regions mapped in
  2488. * the target process.
  2489. */
  2490. for (vma = vma_first(mm); vma != NULL; vma = vma_next(vma)) {
  2491. (void) memset(&phdr, 0, sizeof (phdr));
  2492. phdr.p_type = PT_LOAD;
  2493. phdr.p_offset = offset;
  2494. phdr.p_vaddr = vma->vma_start;
  2495. phdr.p_paddr = 0;
  2496. phdr.p_filesz = vma_dump_size(vma);
  2497. offset += phdr.p_filesz;
  2498. phdr.p_memsz = vma->vma_end - vma->vma_start;
  2499. phdr.p_flags = vma->vma_flags & PROT_READ ? PF_R : 0;
  2500. if (vma->vma_flags & PROT_WRITE)
  2501. phdr.p_flags |= PF_W;
  2502. if (vma->vma_flags & PROT_EXEC)
  2503. phdr.p_flags |= PF_X;
  2504. phdr.p_align = ELF_EXEC_PAGESIZE;
  2505. bswap_phdr(&phdr, 1);
  2506. dump_write(fd, &phdr, sizeof (phdr));
  2507. }
  2508. /*
  2509. * Next we write notes just after program headers. No
  2510. * alignment needed here.
  2511. */
  2512. if (write_note_info(&info, fd) < 0)
  2513. goto out;
  2514. /* align data to page boundary */
  2515. if (lseek(fd, data_offset, SEEK_SET) != data_offset)
  2516. goto out;
  2517. /*
  2518. * Finally we can dump process memory into corefile as well.
  2519. */
  2520. for (vma = vma_first(mm); vma != NULL; vma = vma_next(vma)) {
  2521. abi_ulong addr;
  2522. abi_ulong end;
  2523. end = vma->vma_start + vma_dump_size(vma);
  2524. for (addr = vma->vma_start; addr < end;
  2525. addr += TARGET_PAGE_SIZE) {
  2526. char page[TARGET_PAGE_SIZE];
  2527. int error;
  2528. /*
  2529. * Read in page from target process memory and
  2530. * write it to coredump file.
  2531. */
  2532. error = copy_from_user(page, addr, sizeof (page));
  2533. if (error != 0) {
  2534. (void) fprintf(stderr, "unable to dump " TARGET_ABI_FMT_lx "\n",
  2535. addr);
  2536. errno = -error;
  2537. goto out;
  2538. }
  2539. if (dump_write(fd, page, TARGET_PAGE_SIZE) < 0)
  2540. goto out;
  2541. }
  2542. }
  2543. out:
  2544. free_note_info(&info);
  2545. if (mm != NULL)
  2546. vma_delete(mm);
  2547. (void) close(fd);
  2548. if (errno != 0)
  2549. return (-errno);
  2550. return (0);
  2551. }
  2552. #endif /* USE_ELF_CORE_DUMP */
  2553. void do_init_thread(struct target_pt_regs *regs, struct image_info *infop)
  2554. {
  2555. init_thread(regs, infop);
  2556. }