blob: 3bf58af98936fda96afff0f79b873ea4c61750ed [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) ||
275 i_size_read(bprm->file->f_dentry->d_inode) < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
276 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
336 error = bprm->file->f_op->read(bprm->file, (char *)text_addr,
337 ex.a_text+ex.a_data, &pos);
338 if ((signed long)error < 0) {
339 send_sig(SIGKILL, current, 0);
340 return error;
341 }
342
343 flush_icache_range(text_addr, text_addr+ex.a_text+ex.a_data);
344 } else {
345#ifdef WARN_OLD
346 static unsigned long error_time, error_time2;
347 if ((ex.a_text & 0xfff || ex.a_data & 0xfff) &&
348 (N_MAGIC(ex) != NMAGIC) && (jiffies-error_time2) > 5*HZ)
349 {
350 printk(KERN_NOTICE "executable not page aligned\n");
351 error_time2 = jiffies;
352 }
353
354 if ((fd_offset & ~PAGE_MASK) != 0 &&
355 (jiffies-error_time) > 5*HZ)
356 {
357 printk(KERN_WARNING
358 "fd_offset is not page aligned. Please convert program: %s\n",
359 bprm->file->f_dentry->d_name.name);
360 error_time = jiffies;
361 }
362#endif
363
364 if (!bprm->file->f_op->mmap||((fd_offset & ~PAGE_MASK) != 0)) {
365 loff_t pos = fd_offset;
366 down_write(&current->mm->mmap_sem);
367 do_brk(N_TXTADDR(ex), ex.a_text+ex.a_data);
368 up_write(&current->mm->mmap_sem);
369 bprm->file->f_op->read(bprm->file,(char *)N_TXTADDR(ex),
370 ex.a_text+ex.a_data, &pos);
371 flush_icache_range((unsigned long) N_TXTADDR(ex),
372 (unsigned long) N_TXTADDR(ex) +
373 ex.a_text+ex.a_data);
374 goto beyond_if;
375 }
376
377 down_write(&current->mm->mmap_sem);
378 error = do_mmap(bprm->file, N_TXTADDR(ex), ex.a_text,
379 PROT_READ | PROT_EXEC,
380 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE | MAP_32BIT,
381 fd_offset);
382 up_write(&current->mm->mmap_sem);
383
384 if (error != N_TXTADDR(ex)) {
385 send_sig(SIGKILL, current, 0);
386 return error;
387 }
388
389 down_write(&current->mm->mmap_sem);
390 error = do_mmap(bprm->file, N_DATADDR(ex), ex.a_data,
391 PROT_READ | PROT_WRITE | PROT_EXEC,
392 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE | MAP_32BIT,
393 fd_offset + ex.a_text);
394 up_write(&current->mm->mmap_sem);
395 if (error != N_DATADDR(ex)) {
396 send_sig(SIGKILL, current, 0);
397 return error;
398 }
399 }
400beyond_if:
401 set_binfmt(&aout_format);
402
403 set_brk(current->mm->start_brk, current->mm->brk);
404
405 retval = ia32_setup_arg_pages(bprm, IA32_STACK_TOP, EXSTACK_DEFAULT);
406 if (retval < 0) {
407 /* Someone check-me: is this error path enough? */
408 send_sig(SIGKILL, current, 0);
409 return retval;
410 }
411
412 current->mm->start_stack =
413 (unsigned long)create_aout_tables((char __user *)bprm->p, bprm);
414 /* start thread */
415 asm volatile("movl %0,%%fs" :: "r" (0)); \
416 asm volatile("movl %0,%%es; movl %0,%%ds": :"r" (__USER32_DS));
417 load_gs_index(0);
418 (regs)->rip = ex.a_entry;
419 (regs)->rsp = current->mm->start_stack;
420 (regs)->eflags = 0x200;
421 (regs)->cs = __USER32_CS;
422 (regs)->ss = __USER32_DS;
423 set_fs(USER_DS);
424 if (unlikely(current->ptrace & PT_PTRACED)) {
425 if (current->ptrace & PT_TRACE_EXEC)
426 ptrace_notify ((PTRACE_EVENT_EXEC << 8) | SIGTRAP);
427 else
428 send_sig(SIGTRAP, current, 0);
429 }
430 return 0;
431}
432
433static int load_aout_library(struct file *file)
434{
435 struct inode * inode;
436 unsigned long bss, start_addr, len;
437 unsigned long error;
438 int retval;
439 struct exec ex;
440
441 inode = file->f_dentry->d_inode;
442
443 retval = -ENOEXEC;
444 error = kernel_read(file, 0, (char *) &ex, sizeof(ex));
445 if (error != sizeof(ex))
446 goto out;
447
448 /* We come in here for the regular a.out style of shared libraries */
449 if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != QMAGIC) || N_TRSIZE(ex) ||
450 N_DRSIZE(ex) || ((ex.a_entry & 0xfff) && N_MAGIC(ex) == ZMAGIC) ||
451 i_size_read(inode) < ex.a_text+ex.a_data+N_SYMSIZE(ex)+N_TXTOFF(ex)) {
452 goto out;
453 }
454
455 if (N_FLAGS(ex))
456 goto out;
457
458 /* For QMAGIC, the starting address is 0x20 into the page. We mask
459 this off to get the starting address for the page */
460
461 start_addr = ex.a_entry & 0xfffff000;
462
463 if ((N_TXTOFF(ex) & ~PAGE_MASK) != 0) {
464 loff_t pos = N_TXTOFF(ex);
465
466#ifdef WARN_OLD
467 static unsigned long error_time;
468 if ((jiffies-error_time) > 5*HZ)
469 {
470 printk(KERN_WARNING
471 "N_TXTOFF is not page aligned. Please convert library: %s\n",
472 file->f_dentry->d_name.name);
473 error_time = jiffies;
474 }
475#endif
476 down_write(&current->mm->mmap_sem);
477 do_brk(start_addr, ex.a_text + ex.a_data + ex.a_bss);
478 up_write(&current->mm->mmap_sem);
479
480 file->f_op->read(file, (char *)start_addr,
481 ex.a_text + ex.a_data, &pos);
482 flush_icache_range((unsigned long) start_addr,
483 (unsigned long) start_addr + ex.a_text + ex.a_data);
484
485 retval = 0;
486 goto out;
487 }
488 /* Now use mmap to map the library into memory. */
489 down_write(&current->mm->mmap_sem);
490 error = do_mmap(file, start_addr, ex.a_text + ex.a_data,
491 PROT_READ | PROT_WRITE | PROT_EXEC,
492 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_32BIT,
493 N_TXTOFF(ex));
494 up_write(&current->mm->mmap_sem);
495 retval = error;
496 if (error != start_addr)
497 goto out;
498
499 len = PAGE_ALIGN(ex.a_text + ex.a_data);
500 bss = ex.a_text + ex.a_data + ex.a_bss;
501 if (bss > len) {
502 down_write(&current->mm->mmap_sem);
503 error = do_brk(start_addr + len, bss - len);
504 up_write(&current->mm->mmap_sem);
505 retval = error;
506 if (error != start_addr + len)
507 goto out;
508 }
509 retval = 0;
510out:
511 return retval;
512}
513
514static int __init init_aout_binfmt(void)
515{
516 return register_binfmt(&aout_format);
517}
518
519static void __exit exit_aout_binfmt(void)
520{
521 unregister_binfmt(&aout_format);
522}
523
524module_init(init_aout_binfmt);
525module_exit(exit_aout_binfmt);
526MODULE_LICENSE("GPL");