ia32_aout.c 8.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * a.out loader for x86-64
  4. *
  5. * Copyright (C) 1991, 1992, 1996 Linus Torvalds
  6. * Hacked together by Andi Kleen
  7. */
  8. #include <linux/module.h>
  9. #include <linux/time.h>
  10. #include <linux/kernel.h>
  11. #include <linux/mm.h>
  12. #include <linux/mman.h>
  13. #include <linux/a.out.h>
  14. #include <linux/errno.h>
  15. #include <linux/signal.h>
  16. #include <linux/string.h>
  17. #include <linux/fs.h>
  18. #include <linux/file.h>
  19. #include <linux/stat.h>
  20. #include <linux/fcntl.h>
  21. #include <linux/ptrace.h>
  22. #include <linux/user.h>
  23. #include <linux/binfmts.h>
  24. #include <linux/personality.h>
  25. #include <linux/init.h>
  26. #include <linux/jiffies.h>
  27. #include <linux/perf_event.h>
  28. #include <linux/sched/task_stack.h>
  29. #include <linux/uaccess.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. static struct linux_binfmt aout_format = {
  37. .module = THIS_MODULE,
  38. .load_binary = load_aout_binary,
  39. .load_shlib = load_aout_library,
  40. };
  41. static int set_brk(unsigned long start, unsigned long end)
  42. {
  43. start = PAGE_ALIGN(start);
  44. end = PAGE_ALIGN(end);
  45. if (end <= start)
  46. return 0;
  47. return vm_brk(start, end - start);
  48. }
  49. /*
  50. * create_aout_tables() parses the env- and arg-strings in new user
  51. * memory and creates the pointer tables from them, and puts their
  52. * addresses on the "stack", returning the new stack pointer value.
  53. */
  54. static u32 __user *create_aout_tables(char __user *p, struct linux_binprm *bprm)
  55. {
  56. u32 __user *argv, *envp, *sp;
  57. int argc = bprm->argc, envc = bprm->envc;
  58. sp = (u32 __user *) ((-(unsigned long)sizeof(u32)) & (unsigned long) p);
  59. sp -= envc+1;
  60. envp = sp;
  61. sp -= argc+1;
  62. argv = sp;
  63. put_user((unsigned long) envp, --sp);
  64. put_user((unsigned long) argv, --sp);
  65. put_user(argc, --sp);
  66. current->mm->arg_start = (unsigned long) p;
  67. while (argc-- > 0) {
  68. char c;
  69. put_user((u32)(unsigned long)p, argv++);
  70. do {
  71. get_user(c, p++);
  72. } while (c);
  73. }
  74. put_user(0, argv);
  75. current->mm->arg_end = current->mm->env_start = (unsigned long) p;
  76. while (envc-- > 0) {
  77. char c;
  78. put_user((u32)(unsigned long)p, envp++);
  79. do {
  80. get_user(c, p++);
  81. } while (c);
  82. }
  83. put_user(0, envp);
  84. current->mm->env_end = (unsigned long) p;
  85. return sp;
  86. }
  87. /*
  88. * These are the functions used to load a.out style executables and shared
  89. * libraries. There is no binary dependent code anywhere else.
  90. */
  91. static int load_aout_binary(struct linux_binprm *bprm)
  92. {
  93. unsigned long error, fd_offset, rlim;
  94. struct pt_regs *regs = current_pt_regs();
  95. struct exec ex;
  96. int retval;
  97. ex = *((struct exec *) bprm->buf); /* exec-header */
  98. if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != OMAGIC &&
  99. N_MAGIC(ex) != QMAGIC && N_MAGIC(ex) != NMAGIC) ||
  100. N_TRSIZE(ex) || N_DRSIZE(ex) ||
  101. i_size_read(file_inode(bprm->file)) <
  102. ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
  103. return -ENOEXEC;
  104. }
  105. fd_offset = N_TXTOFF(ex);
  106. /* Check initial limits. This avoids letting people circumvent
  107. * size limits imposed on them by creating programs with large
  108. * arrays in the data or bss.
  109. */
  110. rlim = rlimit(RLIMIT_DATA);
  111. if (rlim >= RLIM_INFINITY)
  112. rlim = ~0;
  113. if (ex.a_data + ex.a_bss > rlim)
  114. return -ENOMEM;
  115. /* Flush all traces of the currently running executable */
  116. retval = begin_new_exec(bprm);
  117. if (retval)
  118. return retval;
  119. /* OK, This is the point of no return */
  120. set_personality(PER_LINUX);
  121. set_personality_ia32(false);
  122. setup_new_exec(bprm);
  123. regs->cs = __USER32_CS;
  124. regs->r8 = regs->r9 = regs->r10 = regs->r11 = regs->r12 =
  125. regs->r13 = regs->r14 = regs->r15 = 0;
  126. current->mm->end_code = ex.a_text +
  127. (current->mm->start_code = N_TXTADDR(ex));
  128. current->mm->end_data = ex.a_data +
  129. (current->mm->start_data = N_DATADDR(ex));
  130. current->mm->brk = ex.a_bss +
  131. (current->mm->start_brk = N_BSSADDR(ex));
  132. retval = setup_arg_pages(bprm, IA32_STACK_TOP, EXSTACK_DEFAULT);
  133. if (retval < 0)
  134. return retval;
  135. if (N_MAGIC(ex) == OMAGIC) {
  136. unsigned long text_addr, map_size;
  137. text_addr = N_TXTADDR(ex);
  138. map_size = ex.a_text+ex.a_data;
  139. error = vm_brk(text_addr & PAGE_MASK, map_size);
  140. if (error)
  141. return error;
  142. error = read_code(bprm->file, text_addr, 32,
  143. ex.a_text + ex.a_data);
  144. if ((signed long)error < 0)
  145. return error;
  146. } else {
  147. #ifdef WARN_OLD
  148. static unsigned long error_time, error_time2;
  149. if ((ex.a_text & 0xfff || ex.a_data & 0xfff) &&
  150. (N_MAGIC(ex) != NMAGIC) &&
  151. time_after(jiffies, error_time2 + 5*HZ)) {
  152. printk(KERN_NOTICE "executable not page aligned\n");
  153. error_time2 = jiffies;
  154. }
  155. if ((fd_offset & ~PAGE_MASK) != 0 &&
  156. time_after(jiffies, error_time + 5*HZ)) {
  157. printk(KERN_WARNING
  158. "fd_offset is not page aligned. Please convert "
  159. "program: %pD\n",
  160. bprm->file);
  161. error_time = jiffies;
  162. }
  163. #endif
  164. if (!bprm->file->f_op->mmap || (fd_offset & ~PAGE_MASK) != 0) {
  165. error = vm_brk(N_TXTADDR(ex), ex.a_text+ex.a_data);
  166. if (error)
  167. return error;
  168. read_code(bprm->file, N_TXTADDR(ex), fd_offset,
  169. ex.a_text+ex.a_data);
  170. goto beyond_if;
  171. }
  172. error = vm_mmap(bprm->file, N_TXTADDR(ex), ex.a_text,
  173. PROT_READ | PROT_EXEC,
  174. MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE |
  175. MAP_EXECUTABLE | MAP_32BIT,
  176. fd_offset);
  177. if (error != N_TXTADDR(ex))
  178. return error;
  179. error = vm_mmap(bprm->file, N_DATADDR(ex), ex.a_data,
  180. PROT_READ | PROT_WRITE | PROT_EXEC,
  181. MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE |
  182. MAP_EXECUTABLE | MAP_32BIT,
  183. fd_offset + ex.a_text);
  184. if (error != N_DATADDR(ex))
  185. return error;
  186. }
  187. beyond_if:
  188. error = set_brk(current->mm->start_brk, current->mm->brk);
  189. if (error)
  190. return error;
  191. set_binfmt(&aout_format);
  192. current->mm->start_stack =
  193. (unsigned long)create_aout_tables((char __user *)bprm->p, bprm);
  194. /* start thread */
  195. loadsegment(fs, 0);
  196. loadsegment(ds, __USER32_DS);
  197. loadsegment(es, __USER32_DS);
  198. load_gs_index(0);
  199. (regs)->ip = ex.a_entry;
  200. (regs)->sp = current->mm->start_stack;
  201. (regs)->flags = 0x200;
  202. (regs)->cs = __USER32_CS;
  203. (regs)->ss = __USER32_DS;
  204. regs->r8 = regs->r9 = regs->r10 = regs->r11 =
  205. regs->r12 = regs->r13 = regs->r14 = regs->r15 = 0;
  206. return 0;
  207. }
  208. static int load_aout_library(struct file *file)
  209. {
  210. unsigned long bss, start_addr, len, error;
  211. int retval;
  212. struct exec ex;
  213. loff_t pos = 0;
  214. retval = -ENOEXEC;
  215. error = kernel_read(file, &ex, sizeof(ex), &pos);
  216. if (error != sizeof(ex))
  217. goto out;
  218. /* We come in here for the regular a.out style of shared libraries */
  219. if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != QMAGIC) || N_TRSIZE(ex) ||
  220. N_DRSIZE(ex) || ((ex.a_entry & 0xfff) && N_MAGIC(ex) == ZMAGIC) ||
  221. i_size_read(file_inode(file)) <
  222. ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
  223. goto out;
  224. }
  225. if (N_FLAGS(ex))
  226. goto out;
  227. /* For QMAGIC, the starting address is 0x20 into the page. We mask
  228. this off to get the starting address for the page */
  229. start_addr = ex.a_entry & 0xfffff000;
  230. if ((N_TXTOFF(ex) & ~PAGE_MASK) != 0) {
  231. #ifdef WARN_OLD
  232. static unsigned long error_time;
  233. if (time_after(jiffies, error_time + 5*HZ)) {
  234. printk(KERN_WARNING
  235. "N_TXTOFF is not page aligned. Please convert "
  236. "library: %pD\n",
  237. file);
  238. error_time = jiffies;
  239. }
  240. #endif
  241. retval = vm_brk(start_addr, ex.a_text + ex.a_data + ex.a_bss);
  242. if (retval)
  243. goto out;
  244. read_code(file, start_addr, N_TXTOFF(ex),
  245. ex.a_text + ex.a_data);
  246. retval = 0;
  247. goto out;
  248. }
  249. /* Now use mmap to map the library into memory. */
  250. error = vm_mmap(file, start_addr, ex.a_text + ex.a_data,
  251. PROT_READ | PROT_WRITE | PROT_EXEC,
  252. MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_32BIT,
  253. N_TXTOFF(ex));
  254. retval = error;
  255. if (error != start_addr)
  256. goto out;
  257. len = PAGE_ALIGN(ex.a_text + ex.a_data);
  258. bss = ex.a_text + ex.a_data + ex.a_bss;
  259. if (bss > len) {
  260. retval = vm_brk(start_addr + len, bss - len);
  261. if (retval)
  262. goto out;
  263. }
  264. retval = 0;
  265. out:
  266. return retval;
  267. }
  268. static int __init init_aout_binfmt(void)
  269. {
  270. register_binfmt(&aout_format);
  271. return 0;
  272. }
  273. static void __exit exit_aout_binfmt(void)
  274. {
  275. unregister_binfmt(&aout_format);
  276. }
  277. module_init(init_aout_binfmt);
  278. module_exit(exit_aout_binfmt);
  279. MODULE_LICENSE("GPL");