ia32_aout.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489
  1. /*
  2. * a.out loader for x86-64
  3. *
  4. * Copyright (C) 1991, 1992, 1996 Linus Torvalds
  5. * Hacked together by Andi Kleen
  6. */
  7. #include <linux/module.h>
  8. #include <linux/time.h>
  9. #include <linux/kernel.h>
  10. #include <linux/mm.h>
  11. #include <linux/mman.h>
  12. #include <linux/a.out.h>
  13. #include <linux/errno.h>
  14. #include <linux/signal.h>
  15. #include <linux/string.h>
  16. #include <linux/fs.h>
  17. #include <linux/file.h>
  18. #include <linux/stat.h>
  19. #include <linux/fcntl.h>
  20. #include <linux/ptrace.h>
  21. #include <linux/user.h>
  22. #include <linux/binfmts.h>
  23. #include <linux/personality.h>
  24. #include <linux/init.h>
  25. #include <linux/jiffies.h>
  26. #include <linux/perf_event.h>
  27. #include <linux/sched/task_stack.h>
  28. #include <linux/uaccess.h>
  29. #include <asm/pgalloc.h>
  30. #include <asm/cacheflush.h>
  31. #include <asm/user32.h>
  32. #include <asm/ia32.h>
  33. #undef WARN_OLD
  34. static int load_aout_binary(struct linux_binprm *);
  35. static int load_aout_library(struct file *);
  36. #ifdef CONFIG_COREDUMP
  37. static int aout_core_dump(struct coredump_params *);
  38. static unsigned long get_dr(int n)
  39. {
  40. struct perf_event *bp = current->thread.ptrace_bps[n];
  41. return bp ? bp->hw.info.address : 0;
  42. }
  43. /*
  44. * fill in the user structure for a core dump..
  45. */
  46. static void fill_dump(struct pt_regs *regs, struct user32 *dump)
  47. {
  48. u32 fs, gs;
  49. memset(dump, 0, sizeof(*dump));
  50. /* changed the size calculations - should hopefully work better. lbt */
  51. dump->magic = CMAGIC;
  52. dump->start_code = 0;
  53. dump->start_stack = regs->sp & ~(PAGE_SIZE - 1);
  54. dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
  55. dump->u_dsize = ((unsigned long)
  56. (current->mm->brk + (PAGE_SIZE-1))) >> PAGE_SHIFT;
  57. dump->u_dsize -= dump->u_tsize;
  58. dump->u_debugreg[0] = get_dr(0);
  59. dump->u_debugreg[1] = get_dr(1);
  60. dump->u_debugreg[2] = get_dr(2);
  61. dump->u_debugreg[3] = get_dr(3);
  62. dump->u_debugreg[6] = current->thread.debugreg6;
  63. dump->u_debugreg[7] = current->thread.ptrace_dr7;
  64. if (dump->start_stack < 0xc0000000) {
  65. unsigned long tmp;
  66. tmp = (unsigned long) (0xc0000000 - dump->start_stack);
  67. dump->u_ssize = tmp >> PAGE_SHIFT;
  68. }
  69. dump->regs.ebx = regs->bx;
  70. dump->regs.ecx = regs->cx;
  71. dump->regs.edx = regs->dx;
  72. dump->regs.esi = regs->si;
  73. dump->regs.edi = regs->di;
  74. dump->regs.ebp = regs->bp;
  75. dump->regs.eax = regs->ax;
  76. dump->regs.ds = current->thread.ds;
  77. dump->regs.es = current->thread.es;
  78. savesegment(fs, fs);
  79. dump->regs.fs = fs;
  80. savesegment(gs, gs);
  81. dump->regs.gs = gs;
  82. dump->regs.orig_eax = regs->orig_ax;
  83. dump->regs.eip = regs->ip;
  84. dump->regs.cs = regs->cs;
  85. dump->regs.eflags = regs->flags;
  86. dump->regs.esp = regs->sp;
  87. dump->regs.ss = regs->ss;
  88. #if 1 /* FIXME */
  89. dump->u_fpvalid = 0;
  90. #else
  91. dump->u_fpvalid = dump_fpu(regs, &dump->i387);
  92. #endif
  93. }
  94. #endif
  95. static struct linux_binfmt aout_format = {
  96. .module = THIS_MODULE,
  97. .load_binary = load_aout_binary,
  98. .load_shlib = load_aout_library,
  99. #ifdef CONFIG_COREDUMP
  100. .core_dump = aout_core_dump,
  101. #endif
  102. .min_coredump = PAGE_SIZE
  103. };
  104. static int set_brk(unsigned long start, unsigned long end)
  105. {
  106. start = PAGE_ALIGN(start);
  107. end = PAGE_ALIGN(end);
  108. if (end <= start)
  109. return 0;
  110. return vm_brk(start, end - start);
  111. }
  112. #ifdef CONFIG_COREDUMP
  113. /*
  114. * These are the only things you should do on a core-file: use only these
  115. * macros to write out all the necessary info.
  116. */
  117. #include <linux/coredump.h>
  118. #define START_DATA(u) (u.u_tsize << PAGE_SHIFT)
  119. #define START_STACK(u) (u.start_stack)
  120. /*
  121. * Routine writes a core dump image in the current directory.
  122. * Currently only a stub-function.
  123. *
  124. * Note that setuid/setgid files won't make a core-dump if the uid/gid
  125. * changed due to the set[u|g]id. It's enforced by the "current->mm->dumpable"
  126. * field, which also makes sure the core-dumps won't be recursive if the
  127. * dumping of the process results in another error..
  128. */
  129. static int aout_core_dump(struct coredump_params *cprm)
  130. {
  131. mm_segment_t fs;
  132. int has_dumped = 0;
  133. unsigned long dump_start, dump_size;
  134. struct user32 dump;
  135. fs = get_fs();
  136. set_fs(KERNEL_DS);
  137. has_dumped = 1;
  138. fill_dump(cprm->regs, &dump);
  139. strncpy(dump.u_comm, current->comm, sizeof(current->comm));
  140. dump.u_ar0 = offsetof(struct user32, regs);
  141. dump.signal = cprm->siginfo->si_signo;
  142. /*
  143. * If the size of the dump file exceeds the rlimit, then see
  144. * what would happen if we wrote the stack, but not the data
  145. * area.
  146. */
  147. if ((dump.u_dsize + dump.u_ssize + 1) * PAGE_SIZE > cprm->limit)
  148. dump.u_dsize = 0;
  149. /* Make sure we have enough room to write the stack and data areas. */
  150. if ((dump.u_ssize + 1) * PAGE_SIZE > cprm->limit)
  151. dump.u_ssize = 0;
  152. /* make sure we actually have a data and stack area to dump */
  153. set_fs(USER_DS);
  154. if (!access_ok(VERIFY_READ, (void *) (unsigned long)START_DATA(dump),
  155. dump.u_dsize << PAGE_SHIFT))
  156. dump.u_dsize = 0;
  157. if (!access_ok(VERIFY_READ, (void *) (unsigned long)START_STACK(dump),
  158. dump.u_ssize << PAGE_SHIFT))
  159. dump.u_ssize = 0;
  160. set_fs(KERNEL_DS);
  161. /* struct user */
  162. if (!dump_emit(cprm, &dump, sizeof(dump)))
  163. goto end_coredump;
  164. /* Now dump all of the user data. Include malloced stuff as well */
  165. if (!dump_skip(cprm, PAGE_SIZE - sizeof(dump)))
  166. goto end_coredump;
  167. /* now we start writing out the user space info */
  168. set_fs(USER_DS);
  169. /* Dump the data area */
  170. if (dump.u_dsize != 0) {
  171. dump_start = START_DATA(dump);
  172. dump_size = dump.u_dsize << PAGE_SHIFT;
  173. if (!dump_emit(cprm, (void *)dump_start, dump_size))
  174. goto end_coredump;
  175. }
  176. /* Now prepare to dump the stack area */
  177. if (dump.u_ssize != 0) {
  178. dump_start = START_STACK(dump);
  179. dump_size = dump.u_ssize << PAGE_SHIFT;
  180. if (!dump_emit(cprm, (void *)dump_start, dump_size))
  181. goto end_coredump;
  182. }
  183. end_coredump:
  184. set_fs(fs);
  185. return has_dumped;
  186. }
  187. #endif
  188. /*
  189. * create_aout_tables() parses the env- and arg-strings in new user
  190. * memory and creates the pointer tables from them, and puts their
  191. * addresses on the "stack", returning the new stack pointer value.
  192. */
  193. static u32 __user *create_aout_tables(char __user *p, struct linux_binprm *bprm)
  194. {
  195. u32 __user *argv, *envp, *sp;
  196. int argc = bprm->argc, envc = bprm->envc;
  197. sp = (u32 __user *) ((-(unsigned long)sizeof(u32)) & (unsigned long) p);
  198. sp -= envc+1;
  199. envp = sp;
  200. sp -= argc+1;
  201. argv = sp;
  202. put_user((unsigned long) envp, --sp);
  203. put_user((unsigned long) argv, --sp);
  204. put_user(argc, --sp);
  205. current->mm->arg_start = (unsigned long) p;
  206. while (argc-- > 0) {
  207. char c;
  208. put_user((u32)(unsigned long)p, argv++);
  209. do {
  210. get_user(c, p++);
  211. } while (c);
  212. }
  213. put_user(0, argv);
  214. current->mm->arg_end = current->mm->env_start = (unsigned long) p;
  215. while (envc-- > 0) {
  216. char c;
  217. put_user((u32)(unsigned long)p, envp++);
  218. do {
  219. get_user(c, p++);
  220. } while (c);
  221. }
  222. put_user(0, envp);
  223. current->mm->env_end = (unsigned long) p;
  224. return sp;
  225. }
  226. /*
  227. * These are the functions used to load a.out style executables and shared
  228. * libraries. There is no binary dependent code anywhere else.
  229. */
  230. static int load_aout_binary(struct linux_binprm *bprm)
  231. {
  232. unsigned long error, fd_offset, rlim;
  233. struct pt_regs *regs = current_pt_regs();
  234. struct exec ex;
  235. int retval;
  236. ex = *((struct exec *) bprm->buf); /* exec-header */
  237. if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != OMAGIC &&
  238. N_MAGIC(ex) != QMAGIC && N_MAGIC(ex) != NMAGIC) ||
  239. N_TRSIZE(ex) || N_DRSIZE(ex) ||
  240. i_size_read(file_inode(bprm->file)) <
  241. ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
  242. return -ENOEXEC;
  243. }
  244. fd_offset = N_TXTOFF(ex);
  245. /* Check initial limits. This avoids letting people circumvent
  246. * size limits imposed on them by creating programs with large
  247. * arrays in the data or bss.
  248. */
  249. rlim = rlimit(RLIMIT_DATA);
  250. if (rlim >= RLIM_INFINITY)
  251. rlim = ~0;
  252. if (ex.a_data + ex.a_bss > rlim)
  253. return -ENOMEM;
  254. /* Flush all traces of the currently running executable */
  255. retval = flush_old_exec(bprm);
  256. if (retval)
  257. return retval;
  258. /* OK, This is the point of no return */
  259. set_personality(PER_LINUX);
  260. set_personality_ia32(false);
  261. setup_new_exec(bprm);
  262. regs->cs = __USER32_CS;
  263. regs->r8 = regs->r9 = regs->r10 = regs->r11 = regs->r12 =
  264. regs->r13 = regs->r14 = regs->r15 = 0;
  265. current->mm->end_code = ex.a_text +
  266. (current->mm->start_code = N_TXTADDR(ex));
  267. current->mm->end_data = ex.a_data +
  268. (current->mm->start_data = N_DATADDR(ex));
  269. current->mm->brk = ex.a_bss +
  270. (current->mm->start_brk = N_BSSADDR(ex));
  271. retval = setup_arg_pages(bprm, IA32_STACK_TOP, EXSTACK_DEFAULT);
  272. if (retval < 0)
  273. return retval;
  274. install_exec_creds(bprm);
  275. if (N_MAGIC(ex) == OMAGIC) {
  276. unsigned long text_addr, map_size;
  277. text_addr = N_TXTADDR(ex);
  278. map_size = ex.a_text+ex.a_data;
  279. error = vm_brk(text_addr & PAGE_MASK, map_size);
  280. if (error)
  281. return error;
  282. error = read_code(bprm->file, text_addr, 32,
  283. ex.a_text + ex.a_data);
  284. if ((signed long)error < 0)
  285. return error;
  286. } else {
  287. #ifdef WARN_OLD
  288. static unsigned long error_time, error_time2;
  289. if ((ex.a_text & 0xfff || ex.a_data & 0xfff) &&
  290. (N_MAGIC(ex) != NMAGIC) &&
  291. time_after(jiffies, error_time2 + 5*HZ)) {
  292. printk(KERN_NOTICE "executable not page aligned\n");
  293. error_time2 = jiffies;
  294. }
  295. if ((fd_offset & ~PAGE_MASK) != 0 &&
  296. time_after(jiffies, error_time + 5*HZ)) {
  297. printk(KERN_WARNING
  298. "fd_offset is not page aligned. Please convert "
  299. "program: %pD\n",
  300. bprm->file);
  301. error_time = jiffies;
  302. }
  303. #endif
  304. if (!bprm->file->f_op->mmap || (fd_offset & ~PAGE_MASK) != 0) {
  305. error = vm_brk(N_TXTADDR(ex), ex.a_text+ex.a_data);
  306. if (error)
  307. return error;
  308. read_code(bprm->file, N_TXTADDR(ex), fd_offset,
  309. ex.a_text+ex.a_data);
  310. goto beyond_if;
  311. }
  312. error = vm_mmap(bprm->file, N_TXTADDR(ex), ex.a_text,
  313. PROT_READ | PROT_EXEC,
  314. MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE |
  315. MAP_EXECUTABLE | MAP_32BIT,
  316. fd_offset);
  317. if (error != N_TXTADDR(ex))
  318. return error;
  319. error = vm_mmap(bprm->file, N_DATADDR(ex), ex.a_data,
  320. PROT_READ | PROT_WRITE | PROT_EXEC,
  321. MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE |
  322. MAP_EXECUTABLE | MAP_32BIT,
  323. fd_offset + ex.a_text);
  324. if (error != N_DATADDR(ex))
  325. return error;
  326. }
  327. beyond_if:
  328. error = set_brk(current->mm->start_brk, current->mm->brk);
  329. if (error)
  330. return error;
  331. set_binfmt(&aout_format);
  332. current->mm->start_stack =
  333. (unsigned long)create_aout_tables((char __user *)bprm->p, bprm);
  334. /* start thread */
  335. loadsegment(fs, 0);
  336. loadsegment(ds, __USER32_DS);
  337. loadsegment(es, __USER32_DS);
  338. load_gs_index(0);
  339. (regs)->ip = ex.a_entry;
  340. (regs)->sp = current->mm->start_stack;
  341. (regs)->flags = 0x200;
  342. (regs)->cs = __USER32_CS;
  343. (regs)->ss = __USER32_DS;
  344. regs->r8 = regs->r9 = regs->r10 = regs->r11 =
  345. regs->r12 = regs->r13 = regs->r14 = regs->r15 = 0;
  346. set_fs(USER_DS);
  347. return 0;
  348. }
  349. static int load_aout_library(struct file *file)
  350. {
  351. unsigned long bss, start_addr, len, error;
  352. int retval;
  353. struct exec ex;
  354. loff_t pos = 0;
  355. retval = -ENOEXEC;
  356. error = kernel_read(file, &ex, sizeof(ex), &pos);
  357. if (error != sizeof(ex))
  358. goto out;
  359. /* We come in here for the regular a.out style of shared libraries */
  360. if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != QMAGIC) || N_TRSIZE(ex) ||
  361. N_DRSIZE(ex) || ((ex.a_entry & 0xfff) && N_MAGIC(ex) == ZMAGIC) ||
  362. i_size_read(file_inode(file)) <
  363. ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
  364. goto out;
  365. }
  366. if (N_FLAGS(ex))
  367. goto out;
  368. /* For QMAGIC, the starting address is 0x20 into the page. We mask
  369. this off to get the starting address for the page */
  370. start_addr = ex.a_entry & 0xfffff000;
  371. if ((N_TXTOFF(ex) & ~PAGE_MASK) != 0) {
  372. #ifdef WARN_OLD
  373. static unsigned long error_time;
  374. if (time_after(jiffies, error_time + 5*HZ)) {
  375. printk(KERN_WARNING
  376. "N_TXTOFF is not page aligned. Please convert "
  377. "library: %pD\n",
  378. file);
  379. error_time = jiffies;
  380. }
  381. #endif
  382. retval = vm_brk(start_addr, ex.a_text + ex.a_data + ex.a_bss);
  383. if (retval)
  384. goto out;
  385. read_code(file, start_addr, N_TXTOFF(ex),
  386. ex.a_text + ex.a_data);
  387. retval = 0;
  388. goto out;
  389. }
  390. /* Now use mmap to map the library into memory. */
  391. error = vm_mmap(file, start_addr, ex.a_text + ex.a_data,
  392. PROT_READ | PROT_WRITE | PROT_EXEC,
  393. MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_32BIT,
  394. N_TXTOFF(ex));
  395. retval = error;
  396. if (error != start_addr)
  397. goto out;
  398. len = PAGE_ALIGN(ex.a_text + ex.a_data);
  399. bss = ex.a_text + ex.a_data + ex.a_bss;
  400. if (bss > len) {
  401. retval = vm_brk(start_addr + len, bss - len);
  402. if (retval)
  403. goto out;
  404. }
  405. retval = 0;
  406. out:
  407. return retval;
  408. }
  409. static int __init init_aout_binfmt(void)
  410. {
  411. register_binfmt(&aout_format);
  412. return 0;
  413. }
  414. static void __exit exit_aout_binfmt(void)
  415. {
  416. unregister_binfmt(&aout_format);
  417. }
  418. module_init(init_aout_binfmt);
  419. module_exit(exit_aout_binfmt);
  420. MODULE_LICENSE("GPL");