fs/binfmt_aout.c

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