2 * linux/fs/binfmt_aout.c
4 * Copyright (C) 1991, 1992, 1996 Linus Torvalds
6 * Hacked a bit by DaveM to make it work with 32-bit SunOS
7 * binaries on the sparc64 port.
10 #include <linux/module.h>
12 #include <linux/sched.h>
13 #include <linux/kernel.h>
15 #include <linux/mman.h>
16 #include <linux/a.out.h>
17 #include <linux/errno.h>
18 #include <linux/signal.h>
19 #include <linux/string.h>
21 #include <linux/file.h>
22 #include <linux/stat.h>
23 #include <linux/fcntl.h>
24 #include <linux/ptrace.h>
25 #include <linux/user.h>
26 #include <linux/slab.h>
27 #include <linux/binfmts.h>
28 #include <linux/personality.h>
29 #include <linux/init.h>
31 #include <asm/system.h>
32 #include <asm/uaccess.h>
33 #include <asm/pgalloc.h>
35 static int load_aout32_binary(struct linux_binprm
*, struct pt_regs
* regs
);
36 static int load_aout32_library(struct file
*);
37 static int aout32_core_dump(long signr
, struct pt_regs
* regs
, struct file
*file
);
39 static struct linux_binfmt aout32_format
= {
40 NULL
, THIS_MODULE
, load_aout32_binary
, load_aout32_library
, aout32_core_dump
,
44 static void set_brk(unsigned long start
, unsigned long end
)
46 start
= PAGE_ALIGN(start
);
47 end
= PAGE_ALIGN(end
);
50 down_write(¤t
->mm
->mmap_sem
);
51 do_brk(start
, end
- start
);
52 up_write(¤t
->mm
->mmap_sem
);
56 * These are the only things you should do on a core-file: use only these
57 * macros to write out all the necessary info.
60 static int dump_write(struct file
*file
, const void *addr
, int nr
)
62 return file
->f_op
->write(file
, addr
, nr
, &file
->f_pos
) == nr
;
65 #define DUMP_WRITE(addr, nr) \
66 if (!dump_write(file, (void *)(addr), (nr))) \
69 #define DUMP_SEEK(offset) \
70 if (file->f_op->llseek) { \
71 if (file->f_op->llseek(file,(offset),0) != (offset)) \
73 } else file->f_pos = (offset)
76 * Routine writes a core dump image in the current directory.
77 * Currently only a stub-function.
79 * Note that setuid/setgid files won't make a core-dump if the uid/gid
80 * changed due to the set[u|g]id. It's enforced by the "current->mm->dumpable"
81 * field, which also makes sure the core-dumps won't be recursive if the
82 * dumping of the process results in another error..
85 static int aout32_core_dump(long signr
, struct pt_regs
*regs
, struct file
*file
)
89 unsigned long dump_start
, dump_size
;
91 # define START_DATA(u) (u.u_tsize)
92 # define START_STACK(u) ((regs->u_regs[UREG_FP]) & ~(PAGE_SIZE - 1))
97 current
->flags
|= PF_DUMPCORE
;
98 strncpy(dump
.u_comm
, current
->comm
, sizeof(dump
.u_comm
));
100 dump_thread(regs
, &dump
);
102 /* If the size of the dump file exceeds the rlimit, then see what would happen
103 if we wrote the stack, but not the data area. */
104 if ((dump
.u_dsize
+dump
.u_ssize
) >
105 current
->signal
->rlim
[RLIMIT_CORE
].rlim_cur
)
108 /* Make sure we have enough room to write the stack and data areas. */
110 current
->signal
->rlim
[RLIMIT_CORE
].rlim_cur
)
113 /* make sure we actually have a data and stack area to dump */
115 if (!access_ok(VERIFY_READ
, (void __user
*) START_DATA(dump
), dump
.u_dsize
))
117 if (!access_ok(VERIFY_READ
, (void __user
*) START_STACK(dump
), dump
.u_ssize
))
122 DUMP_WRITE(&dump
,sizeof(dump
));
123 /* now we start writing out the user space info */
125 /* Dump the data area */
126 if (dump
.u_dsize
!= 0) {
127 dump_start
= START_DATA(dump
);
128 dump_size
= dump
.u_dsize
;
129 DUMP_WRITE(dump_start
,dump_size
);
131 /* Now prepare to dump the stack area */
132 if (dump
.u_ssize
!= 0) {
133 dump_start
= START_STACK(dump
);
134 dump_size
= dump
.u_ssize
;
135 DUMP_WRITE(dump_start
,dump_size
);
137 /* Finally dump the task struct. Not be used by gdb, but could be useful */
139 DUMP_WRITE(current
,sizeof(*current
));
146 * create_aout32_tables() parses the env- and arg-strings in new user
147 * memory and creates the pointer tables from them, and puts their
148 * addresses on the "stack", returning the new stack pointer value.
151 static u32 __user
*create_aout32_tables(char __user
*p
, struct linux_binprm
*bprm
)
156 int argc
= bprm
->argc
;
157 int envc
= bprm
->envc
;
159 sp
= (u32 __user
*)((-(unsigned long)sizeof(char *))&(unsigned long)p
);
161 /* This imposes the proper stack alignment for a new process. */
162 sp
= (u32 __user
*) (((unsigned long) sp
) & ~7);
171 current
->mm
->arg_start
= (unsigned long) p
;
174 put_user(((u32
)(unsigned long)(p
)),argv
++);
180 current
->mm
->arg_end
= current
->mm
->env_start
= (unsigned long) p
;
183 put_user(((u32
)(unsigned long)(p
)),envp
++);
189 current
->mm
->env_end
= (unsigned long) p
;
194 * These are the functions used to load a.out style executables and shared
195 * libraries. There is no binary dependent code anywhere else.
198 static int load_aout32_binary(struct linux_binprm
* bprm
, struct pt_regs
* regs
)
202 unsigned long fd_offset
;
204 unsigned long orig_thr_flags
;
207 ex
= *((struct exec
*) bprm
->buf
); /* exec-header */
208 if ((N_MAGIC(ex
) != ZMAGIC
&& N_MAGIC(ex
) != OMAGIC
&&
209 N_MAGIC(ex
) != QMAGIC
&& N_MAGIC(ex
) != NMAGIC
) ||
210 N_TRSIZE(ex
) || N_DRSIZE(ex
) ||
211 bprm
->file
->f_dentry
->d_inode
->i_size
< ex
.a_text
+ex
.a_data
+N_SYMSIZE(ex
)+N_TXTOFF(ex
)) {
215 fd_offset
= N_TXTOFF(ex
);
217 /* Check initial limits. This avoids letting people circumvent
218 * size limits imposed on them by creating programs with large
219 * arrays in the data or bss.
221 rlim
= current
->signal
->rlim
[RLIMIT_DATA
].rlim_cur
;
222 if (rlim
>= RLIM_INFINITY
)
224 if (ex
.a_data
+ ex
.a_bss
> rlim
)
227 /* Flush all traces of the currently running executable */
228 retval
= flush_old_exec(bprm
);
232 /* OK, This is the point of no return */
233 set_personality(PER_SUNOS
);
235 current
->mm
->end_code
= ex
.a_text
+
236 (current
->mm
->start_code
= N_TXTADDR(ex
));
237 current
->mm
->end_data
= ex
.a_data
+
238 (current
->mm
->start_data
= N_DATADDR(ex
));
239 current
->mm
->brk
= ex
.a_bss
+
240 (current
->mm
->start_brk
= N_BSSADDR(ex
));
242 current
->mm
->mmap
= NULL
;
244 current
->flags
&= ~PF_FORKNOEXEC
;
245 if (N_MAGIC(ex
) == NMAGIC
) {
246 loff_t pos
= fd_offset
;
247 /* Fuck me plenty... */
248 down_write(¤t
->mm
->mmap_sem
);
249 error
= do_brk(N_TXTADDR(ex
), ex
.a_text
);
250 up_write(¤t
->mm
->mmap_sem
);
251 bprm
->file
->f_op
->read(bprm
->file
, (char __user
*)N_TXTADDR(ex
),
253 down_write(¤t
->mm
->mmap_sem
);
254 error
= do_brk(N_DATADDR(ex
), ex
.a_data
);
255 up_write(¤t
->mm
->mmap_sem
);
256 bprm
->file
->f_op
->read(bprm
->file
, (char __user
*)N_DATADDR(ex
),
261 if (N_MAGIC(ex
) == OMAGIC
) {
262 loff_t pos
= fd_offset
;
263 down_write(¤t
->mm
->mmap_sem
);
264 do_brk(N_TXTADDR(ex
) & PAGE_MASK
,
265 ex
.a_text
+ex
.a_data
+ PAGE_SIZE
- 1);
266 up_write(¤t
->mm
->mmap_sem
);
267 bprm
->file
->f_op
->read(bprm
->file
, (char __user
*)N_TXTADDR(ex
),
268 ex
.a_text
+ex
.a_data
, &pos
);
270 static unsigned long error_time
;
271 if ((ex
.a_text
& 0xfff || ex
.a_data
& 0xfff) &&
272 (N_MAGIC(ex
) != NMAGIC
) && (jiffies
-error_time
) > 5*HZ
)
274 printk(KERN_NOTICE
"executable not page aligned\n");
275 error_time
= jiffies
;
278 if (!bprm
->file
->f_op
->mmap
) {
279 loff_t pos
= fd_offset
;
280 down_write(¤t
->mm
->mmap_sem
);
281 do_brk(0, ex
.a_text
+ex
.a_data
);
282 up_write(¤t
->mm
->mmap_sem
);
283 bprm
->file
->f_op
->read(bprm
->file
,
284 (char __user
*)N_TXTADDR(ex
),
285 ex
.a_text
+ex
.a_data
, &pos
);
289 down_write(¤t
->mm
->mmap_sem
);
290 error
= do_mmap(bprm
->file
, N_TXTADDR(ex
), ex
.a_text
,
291 PROT_READ
| PROT_EXEC
,
292 MAP_FIXED
| MAP_PRIVATE
| MAP_DENYWRITE
| MAP_EXECUTABLE
,
294 up_write(¤t
->mm
->mmap_sem
);
296 if (error
!= N_TXTADDR(ex
)) {
297 send_sig(SIGKILL
, current
, 0);
301 down_write(¤t
->mm
->mmap_sem
);
302 error
= do_mmap(bprm
->file
, N_DATADDR(ex
), ex
.a_data
,
303 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
304 MAP_FIXED
| MAP_PRIVATE
| MAP_DENYWRITE
| MAP_EXECUTABLE
,
305 fd_offset
+ ex
.a_text
);
306 up_write(¤t
->mm
->mmap_sem
);
307 if (error
!= N_DATADDR(ex
)) {
308 send_sig(SIGKILL
, current
, 0);
313 set_binfmt(&aout32_format
);
315 set_brk(current
->mm
->start_brk
, current
->mm
->brk
);
317 /* Make sure STACK_TOP returns the right thing. */
318 orig_thr_flags
= current_thread_info()->flags
;
319 current_thread_info()->flags
|= _TIF_32BIT
;
321 retval
= setup_arg_pages(bprm
, STACK_TOP
, EXSTACK_DEFAULT
);
323 current_thread_info()->flags
= orig_thr_flags
;
325 /* Someone check-me: is this error path enough? */
326 send_sig(SIGKILL
, current
, 0);
330 current
->mm
->start_stack
=
331 (unsigned long) create_aout32_tables((char __user
*)bprm
->p
, bprm
);
332 if (!(orig_thr_flags
& _TIF_32BIT
)) {
333 unsigned long pgd_cache
= get_pgd_cache(current
->mm
->pgd
);
335 __asm__
__volatile__("stxa\t%0, [%1] %2\n\t"
339 "r" (TSB_REG
), "i" (ASI_DMMU
));
341 start_thread32(regs
, ex
.a_entry
, current
->mm
->start_stack
);
342 if (current
->ptrace
& PT_PTRACED
)
343 send_sig(SIGTRAP
, current
, 0);
347 /* N.B. Move to .h file and use code in fs/binfmt_aout.c? */
348 static int load_aout32_library(struct file
*file
)
350 struct inode
* inode
;
351 unsigned long bss
, start_addr
, len
;
356 inode
= file
->f_dentry
->d_inode
;
359 error
= kernel_read(file
, 0, (char *) &ex
, sizeof(ex
));
360 if (error
!= sizeof(ex
))
363 /* We come in here for the regular a.out style of shared libraries */
364 if ((N_MAGIC(ex
) != ZMAGIC
&& N_MAGIC(ex
) != QMAGIC
) || N_TRSIZE(ex
) ||
365 N_DRSIZE(ex
) || ((ex
.a_entry
& 0xfff) && N_MAGIC(ex
) == ZMAGIC
) ||
366 inode
->i_size
< ex
.a_text
+ex
.a_data
+N_SYMSIZE(ex
)+N_TXTOFF(ex
)) {
370 if (N_MAGIC(ex
) == ZMAGIC
&& N_TXTOFF(ex
) &&
371 (N_TXTOFF(ex
) < inode
->i_sb
->s_blocksize
)) {
372 printk("N_TXTOFF < BLOCK_SIZE. Please convert library\n");
379 /* For QMAGIC, the starting address is 0x20 into the page. We mask
380 this off to get the starting address for the page */
382 start_addr
= ex
.a_entry
& 0xfffff000;
384 /* Now use mmap to map the library into memory. */
385 down_write(¤t
->mm
->mmap_sem
);
386 error
= do_mmap(file
, start_addr
, ex
.a_text
+ ex
.a_data
,
387 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
388 MAP_FIXED
| MAP_PRIVATE
| MAP_DENYWRITE
,
390 up_write(¤t
->mm
->mmap_sem
);
392 if (error
!= start_addr
)
395 len
= PAGE_ALIGN(ex
.a_text
+ ex
.a_data
);
396 bss
= ex
.a_text
+ ex
.a_data
+ ex
.a_bss
;
398 down_write(¤t
->mm
->mmap_sem
);
399 error
= do_brk(start_addr
+ len
, bss
- len
);
400 up_write(¤t
->mm
->mmap_sem
);
402 if (error
!= start_addr
+ len
)
410 static int __init
init_aout32_binfmt(void)
412 return register_binfmt(&aout32_format
);
415 static void __exit
exit_aout32_binfmt(void)
417 unregister_binfmt(&aout32_format
);
420 module_init(init_aout32_binfmt
);
421 module_exit(exit_aout32_binfmt
);