blob: be87df506f39dded7f4426bf518f4d36656d46d3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * a.out loader for x86-64
3 *
4 * Copyright (C) 1991, 1992, 1996 Linus Torvalds
5 * Hacked together by Andi Kleen
6 */
7
8#include <linux/module.h>
9
10#include <linux/time.h>
11#include <linux/kernel.h>
12#include <linux/mm.h>
13#include <linux/mman.h>
14#include <linux/a.out.h>
15#include <linux/errno.h>
16#include <linux/signal.h>
17#include <linux/string.h>
18#include <linux/fs.h>
19#include <linux/file.h>
20#include <linux/stat.h>
21#include <linux/fcntl.h>
22#include <linux/ptrace.h>
23#include <linux/user.h>
24#include <linux/slab.h>
25#include <linux/binfmts.h>
26#include <linux/personality.h>
27#include <linux/init.h>
28
29#include <asm/system.h>
30#include <asm/uaccess.h>
31#include <asm/pgalloc.h>
32#include <asm/cacheflush.h>
33#include <asm/user32.h>
34#include <asm/ia32.h>
35
36#undef WARN_OLD
37#undef CORE_DUMP /* probably broken */
38
Linus Torvalds1da177e2005-04-16 15:20:36 -070039static int load_aout_binary(struct linux_binprm *, struct pt_regs * regs);
40static int load_aout_library(struct file*);
41
Olaf Hering44456d32005-07-27 11:45:17 -070042#ifdef CORE_DUMP
Linus Torvalds1da177e2005-04-16 15:20:36 -070043static int aout_core_dump(long signr, struct pt_regs * regs, struct file *file);
44
45/*
46 * fill in the user structure for a core dump..
47 */
48static void dump_thread32(struct pt_regs * regs, struct user32 * dump)
49{
50 u32 fs,gs;
51
52/* changed the size calculations - should hopefully work better. lbt */
53 dump->magic = CMAGIC;
54 dump->start_code = 0;
55 dump->start_stack = regs->rsp & ~(PAGE_SIZE - 1);
56 dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
57 dump->u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1))) >> PAGE_SHIFT;
58 dump->u_dsize -= dump->u_tsize;
59 dump->u_ssize = 0;
60 dump->u_debugreg[0] = current->thread.debugreg0;
61 dump->u_debugreg[1] = current->thread.debugreg1;
62 dump->u_debugreg[2] = current->thread.debugreg2;
63 dump->u_debugreg[3] = current->thread.debugreg3;
64 dump->u_debugreg[4] = 0;
65 dump->u_debugreg[5] = 0;
66 dump->u_debugreg[6] = current->thread.debugreg6;
67 dump->u_debugreg[7] = current->thread.debugreg7;
68
69 if (dump->start_stack < 0xc0000000)
70 dump->u_ssize = ((unsigned long) (0xc0000000 - dump->start_stack)) >> PAGE_SHIFT;
71
72 dump->regs.ebx = regs->rbx;
73 dump->regs.ecx = regs->rcx;
74 dump->regs.edx = regs->rdx;
75 dump->regs.esi = regs->rsi;
76 dump->regs.edi = regs->rdi;
77 dump->regs.ebp = regs->rbp;
78 dump->regs.eax = regs->rax;
79 dump->regs.ds = current->thread.ds;
80 dump->regs.es = current->thread.es;
81 asm("movl %%fs,%0" : "=r" (fs)); dump->regs.fs = fs;
82 asm("movl %%gs,%0" : "=r" (gs)); dump->regs.gs = gs;
83 dump->regs.orig_eax = regs->orig_rax;
84 dump->regs.eip = regs->rip;
85 dump->regs.cs = regs->cs;
86 dump->regs.eflags = regs->eflags;
87 dump->regs.esp = regs->rsp;
88 dump->regs.ss = regs->ss;
89
90#if 1 /* FIXME */
91 dump->u_fpvalid = 0;
92#else
93 dump->u_fpvalid = dump_fpu (regs, &dump->i387);
94#endif
95}
96
97#endif
98
99static struct linux_binfmt aout_format = {
100 .module = THIS_MODULE,
101 .load_binary = load_aout_binary,
102 .load_shlib = load_aout_library,
Olaf Hering44456d32005-07-27 11:45:17 -0700103#ifdef CORE_DUMP
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 .core_dump = aout_core_dump,
105#endif
106 .min_coredump = PAGE_SIZE
107};
108
109static void set_brk(unsigned long start, unsigned long end)
110{
111 start = PAGE_ALIGN(start);
112 end = PAGE_ALIGN(end);
113 if (end <= start)
114 return;
115 down_write(&current->mm->mmap_sem);
116 do_brk(start, end - start);
117 up_write(&current->mm->mmap_sem);
118}
119
Olaf Hering44456d32005-07-27 11:45:17 -0700120#ifdef CORE_DUMP
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121/*
122 * These are the only things you should do on a core-file: use only these
123 * macros to write out all the necessary info.
124 */
125
126static int dump_write(struct file *file, const void *addr, int nr)
127{
128 return file->f_op->write(file, addr, nr, &file->f_pos) == nr;
129}
130
131#define DUMP_WRITE(addr, nr) \
132 if (!dump_write(file, (void *)(addr), (nr))) \
133 goto end_coredump;
134
135#define DUMP_SEEK(offset) \
136if (file->f_op->llseek) { \
137 if (file->f_op->llseek(file,(offset),0) != (offset)) \
138 goto end_coredump; \
139} else file->f_pos = (offset)
140
141/*
142 * Routine writes a core dump image in the current directory.
143 * Currently only a stub-function.
144 *
145 * Note that setuid/setgid files won't make a core-dump if the uid/gid
146 * changed due to the set[u|g]id. It's enforced by the "current->mm->dumpable"
147 * field, which also makes sure the core-dumps won't be recursive if the
148 * dumping of the process results in another error..
149 */
150
151static int aout_core_dump(long signr, struct pt_regs * regs, struct file *file)
152{
153 mm_segment_t fs;
154 int has_dumped = 0;
155 unsigned long dump_start, dump_size;
156 struct user32 dump;
157# define START_DATA(u) (u.u_tsize << PAGE_SHIFT)
158# define START_STACK(u) (u.start_stack)
159
160 fs = get_fs();
161 set_fs(KERNEL_DS);
162 has_dumped = 1;
163 current->flags |= PF_DUMPCORE;
164 strncpy(dump.u_comm, current->comm, sizeof(current->comm));
165 dump.u_ar0 = (u32)(((unsigned long)(&dump.regs)) - ((unsigned long)(&dump)));
166 dump.signal = signr;
167 dump_thread32(regs, &dump);
168
169/* If the size of the dump file exceeds the rlimit, then see what would happen
170 if we wrote the stack, but not the data area. */
171 if ((dump.u_dsize+dump.u_ssize+1) * PAGE_SIZE >
172 current->signal->rlim[RLIMIT_CORE].rlim_cur)
173 dump.u_dsize = 0;
174
175/* Make sure we have enough room to write the stack and data areas. */
176 if ((dump.u_ssize+1) * PAGE_SIZE >
177 current->signal->rlim[RLIMIT_CORE].rlim_cur)
178 dump.u_ssize = 0;
179
180/* make sure we actually have a data and stack area to dump */
181 set_fs(USER_DS);
182 if (!access_ok(VERIFY_READ, (void *) (unsigned long)START_DATA(dump), dump.u_dsize << PAGE_SHIFT))
183 dump.u_dsize = 0;
184 if (!access_ok(VERIFY_READ, (void *) (unsigned long)START_STACK(dump), dump.u_ssize << PAGE_SHIFT))
185 dump.u_ssize = 0;
186
187 set_fs(KERNEL_DS);
188/* struct user */
189 DUMP_WRITE(&dump,sizeof(dump));
190/* Now dump all of the user data. Include malloced stuff as well */
191 DUMP_SEEK(PAGE_SIZE);
192/* now we start writing out the user space info */
193 set_fs(USER_DS);
194/* Dump the data area */
195 if (dump.u_dsize != 0) {
196 dump_start = START_DATA(dump);
197 dump_size = dump.u_dsize << PAGE_SHIFT;
198 DUMP_WRITE(dump_start,dump_size);
199 }
200/* Now prepare to dump the stack area */
201 if (dump.u_ssize != 0) {
202 dump_start = START_STACK(dump);
203 dump_size = dump.u_ssize << PAGE_SHIFT;
204 DUMP_WRITE(dump_start,dump_size);
205 }
206/* Finally dump the task struct. Not be used by gdb, but could be useful */
207 set_fs(KERNEL_DS);
208 DUMP_WRITE(current,sizeof(*current));
209end_coredump:
210 set_fs(fs);
211 return has_dumped;
212}
213#endif
214
215/*
216 * create_aout_tables() parses the env- and arg-strings in new user
217 * memory and creates the pointer tables from them, and puts their
218 * addresses on the "stack", returning the new stack pointer value.
219 */
220static u32 __user *create_aout_tables(char __user *p, struct linux_binprm *bprm)
221{
222 u32 __user *argv;
223 u32 __user *envp;
224 u32 __user *sp;
225 int argc = bprm->argc;
226 int envc = bprm->envc;
227
228 sp = (u32 __user *) ((-(unsigned long)sizeof(u32)) & (unsigned long) p);
229 sp -= envc+1;
230 envp = sp;
231 sp -= argc+1;
232 argv = sp;
233 put_user((unsigned long) envp,--sp);
234 put_user((unsigned long) argv,--sp);
235 put_user(argc,--sp);
236 current->mm->arg_start = (unsigned long) p;
237 while (argc-->0) {
238 char c;
239 put_user((u32)(unsigned long)p,argv++);
240 do {
241 get_user(c,p++);
242 } while (c);
243 }
244 put_user(NULL,argv);
245 current->mm->arg_end = current->mm->env_start = (unsigned long) p;
246 while (envc-->0) {
247 char c;
248 put_user((u32)(unsigned long)p,envp++);
249 do {
250 get_user(c,p++);
251 } while (c);
252 }
253 put_user(NULL,envp);
254 current->mm->env_end = (unsigned long) p;
255 return sp;
256}
257
258/*
259 * These are the functions used to load a.out style executables and shared
260 * libraries. There is no binary dependent code anywhere else.
261 */
262
263static int load_aout_binary(struct linux_binprm * bprm, struct pt_regs * regs)
264{
265 struct exec ex;
266 unsigned long error;
267 unsigned long fd_offset;
268 unsigned long rlim;
269 int retval;
270
271 ex = *((struct exec *) bprm->buf); /* exec-header */
272 if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != OMAGIC &&
273 N_MAGIC(ex) != QMAGIC && N_MAGIC(ex) != NMAGIC) ||
274 N_TRSIZE(ex) || N_DRSIZE(ex) ||
Josef "Jeff" Sipekc9411922006-12-08 02:36:43 -0800275 i_size_read(bprm->file->f_path.dentry->d_inode) < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 return -ENOEXEC;
277 }
278
279 fd_offset = N_TXTOFF(ex);
280
281 /* Check initial limits. This avoids letting people circumvent
282 * size limits imposed on them by creating programs with large
283 * arrays in the data or bss.
284 */
285 rlim = current->signal->rlim[RLIMIT_DATA].rlim_cur;
286 if (rlim >= RLIM_INFINITY)
287 rlim = ~0;
288 if (ex.a_data + ex.a_bss > rlim)
289 return -ENOMEM;
290
291 /* Flush all traces of the currently running executable */
292 retval = flush_old_exec(bprm);
293 if (retval)
294 return retval;
295
296 regs->cs = __USER32_CS;
297 regs->r8 = regs->r9 = regs->r10 = regs->r11 = regs->r12 =
298 regs->r13 = regs->r14 = regs->r15 = 0;
299
300 /* OK, This is the point of no return */
301 set_personality(PER_LINUX);
302 set_thread_flag(TIF_IA32);
303 clear_thread_flag(TIF_ABI_PENDING);
304
305 current->mm->end_code = ex.a_text +
306 (current->mm->start_code = N_TXTADDR(ex));
307 current->mm->end_data = ex.a_data +
308 (current->mm->start_data = N_DATADDR(ex));
309 current->mm->brk = ex.a_bss +
310 (current->mm->start_brk = N_BSSADDR(ex));
311 current->mm->free_area_cache = TASK_UNMAPPED_BASE;
Wolfgang Wander1363c3c2005-06-21 17:14:49 -0700312 current->mm->cached_hole_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 current->mm->mmap = NULL;
315 compute_creds(bprm);
316 current->flags &= ~PF_FORKNOEXEC;
317
318 if (N_MAGIC(ex) == OMAGIC) {
319 unsigned long text_addr, map_size;
320 loff_t pos;
321
322 text_addr = N_TXTADDR(ex);
323
324 pos = 32;
325 map_size = ex.a_text+ex.a_data;
326
327 down_write(&current->mm->mmap_sem);
328 error = do_brk(text_addr & PAGE_MASK, map_size);
329 up_write(&current->mm->mmap_sem);
330
331 if (error != (text_addr & PAGE_MASK)) {
332 send_sig(SIGKILL, current, 0);
333 return error;
334 }
335
Andi Kleen52d522f2006-09-26 10:52:33 +0200336 error = bprm->file->f_op->read(bprm->file,
337 (char __user *)text_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 ex.a_text+ex.a_data, &pos);
339 if ((signed long)error < 0) {
340 send_sig(SIGKILL, current, 0);
341 return error;
342 }
343
344 flush_icache_range(text_addr, text_addr+ex.a_text+ex.a_data);
345 } else {
346#ifdef WARN_OLD
347 static unsigned long error_time, error_time2;
348 if ((ex.a_text & 0xfff || ex.a_data & 0xfff) &&
349 (N_MAGIC(ex) != NMAGIC) && (jiffies-error_time2) > 5*HZ)
350 {
351 printk(KERN_NOTICE "executable not page aligned\n");
352 error_time2 = jiffies;
353 }
354
355 if ((fd_offset & ~PAGE_MASK) != 0 &&
356 (jiffies-error_time) > 5*HZ)
357 {
358 printk(KERN_WARNING
359 "fd_offset is not page aligned. Please convert program: %s\n",
Josef "Jeff" Sipekc9411922006-12-08 02:36:43 -0800360 bprm->file->f_path.dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 error_time = jiffies;
362 }
363#endif
364
365 if (!bprm->file->f_op->mmap||((fd_offset & ~PAGE_MASK) != 0)) {
366 loff_t pos = fd_offset;
367 down_write(&current->mm->mmap_sem);
368 do_brk(N_TXTADDR(ex), ex.a_text+ex.a_data);
369 up_write(&current->mm->mmap_sem);
Andi Kleen52d522f2006-09-26 10:52:33 +0200370 bprm->file->f_op->read(bprm->file,
371 (char __user *)N_TXTADDR(ex),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 ex.a_text+ex.a_data, &pos);
373 flush_icache_range((unsigned long) N_TXTADDR(ex),
374 (unsigned long) N_TXTADDR(ex) +
375 ex.a_text+ex.a_data);
376 goto beyond_if;
377 }
378
379 down_write(&current->mm->mmap_sem);
380 error = do_mmap(bprm->file, N_TXTADDR(ex), ex.a_text,
381 PROT_READ | PROT_EXEC,
382 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE | MAP_32BIT,
383 fd_offset);
384 up_write(&current->mm->mmap_sem);
385
386 if (error != N_TXTADDR(ex)) {
387 send_sig(SIGKILL, current, 0);
388 return error;
389 }
390
391 down_write(&current->mm->mmap_sem);
392 error = do_mmap(bprm->file, N_DATADDR(ex), ex.a_data,
393 PROT_READ | PROT_WRITE | PROT_EXEC,
394 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE | MAP_32BIT,
395 fd_offset + ex.a_text);
396 up_write(&current->mm->mmap_sem);
397 if (error != N_DATADDR(ex)) {
398 send_sig(SIGKILL, current, 0);
399 return error;
400 }
401 }
402beyond_if:
403 set_binfmt(&aout_format);
404
405 set_brk(current->mm->start_brk, current->mm->brk);
406
407 retval = ia32_setup_arg_pages(bprm, IA32_STACK_TOP, EXSTACK_DEFAULT);
408 if (retval < 0) {
409 /* Someone check-me: is this error path enough? */
410 send_sig(SIGKILL, current, 0);
411 return retval;
412 }
413
414 current->mm->start_stack =
415 (unsigned long)create_aout_tables((char __user *)bprm->p, bprm);
416 /* start thread */
417 asm volatile("movl %0,%%fs" :: "r" (0)); \
418 asm volatile("movl %0,%%es; movl %0,%%ds": :"r" (__USER32_DS));
419 load_gs_index(0);
420 (regs)->rip = ex.a_entry;
421 (regs)->rsp = current->mm->start_stack;
422 (regs)->eflags = 0x200;
423 (regs)->cs = __USER32_CS;
424 (regs)->ss = __USER32_DS;
425 set_fs(USER_DS);
426 if (unlikely(current->ptrace & PT_PTRACED)) {
427 if (current->ptrace & PT_TRACE_EXEC)
428 ptrace_notify ((PTRACE_EVENT_EXEC << 8) | SIGTRAP);
429 else
430 send_sig(SIGTRAP, current, 0);
431 }
432 return 0;
433}
434
435static int load_aout_library(struct file *file)
436{
437 struct inode * inode;
438 unsigned long bss, start_addr, len;
439 unsigned long error;
440 int retval;
441 struct exec ex;
442
Josef "Jeff" Sipekc9411922006-12-08 02:36:43 -0800443 inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
445 retval = -ENOEXEC;
446 error = kernel_read(file, 0, (char *) &ex, sizeof(ex));
447 if (error != sizeof(ex))
448 goto out;
449
450 /* We come in here for the regular a.out style of shared libraries */
451 if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != QMAGIC) || N_TRSIZE(ex) ||
452 N_DRSIZE(ex) || ((ex.a_entry & 0xfff) && N_MAGIC(ex) == ZMAGIC) ||
453 i_size_read(inode) < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
454 goto out;
455 }
456
457 if (N_FLAGS(ex))
458 goto out;
459
460 /* For QMAGIC, the starting address is 0x20 into the page. We mask
461 this off to get the starting address for the page */
462
463 start_addr = ex.a_entry & 0xfffff000;
464
465 if ((N_TXTOFF(ex) & ~PAGE_MASK) != 0) {
466 loff_t pos = N_TXTOFF(ex);
467
468#ifdef WARN_OLD
469 static unsigned long error_time;
470 if ((jiffies-error_time) > 5*HZ)
471 {
472 printk(KERN_WARNING
473 "N_TXTOFF is not page aligned. Please convert library: %s\n",
Josef "Jeff" Sipekc9411922006-12-08 02:36:43 -0800474 file->f_path.dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 error_time = jiffies;
476 }
477#endif
478 down_write(&current->mm->mmap_sem);
479 do_brk(start_addr, ex.a_text + ex.a_data + ex.a_bss);
480 up_write(&current->mm->mmap_sem);
481
Andi Kleen52d522f2006-09-26 10:52:33 +0200482 file->f_op->read(file, (char __user *)start_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 ex.a_text + ex.a_data, &pos);
484 flush_icache_range((unsigned long) start_addr,
485 (unsigned long) start_addr + ex.a_text + ex.a_data);
486
487 retval = 0;
488 goto out;
489 }
490 /* Now use mmap to map the library into memory. */
491 down_write(&current->mm->mmap_sem);
492 error = do_mmap(file, start_addr, ex.a_text + ex.a_data,
493 PROT_READ | PROT_WRITE | PROT_EXEC,
494 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_32BIT,
495 N_TXTOFF(ex));
496 up_write(&current->mm->mmap_sem);
497 retval = error;
498 if (error != start_addr)
499 goto out;
500
501 len = PAGE_ALIGN(ex.a_text + ex.a_data);
502 bss = ex.a_text + ex.a_data + ex.a_bss;
503 if (bss > len) {
504 down_write(&current->mm->mmap_sem);
505 error = do_brk(start_addr + len, bss - len);
506 up_write(&current->mm->mmap_sem);
507 retval = error;
508 if (error != start_addr + len)
509 goto out;
510 }
511 retval = 0;
512out:
513 return retval;
514}
515
516static int __init init_aout_binfmt(void)
517{
518 return register_binfmt(&aout_format);
519}
520
521static void __exit exit_aout_binfmt(void)
522{
523 unregister_binfmt(&aout_format);
524}
525
526module_init(init_aout_binfmt);
527module_exit(exit_aout_binfmt);
528MODULE_LICENSE("GPL");