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