vserver 1.9.3

[linux-2.6.git] / fs / binfmt_elf.c

diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index fee8d14..cb0db6e 100644 (file)
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -37,10 +37,11 @@
 #include <linux/pagemap.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>
 #include <linux/pagemap.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>

+#include <linux/vs_memory.h>

 
 #include <asm/uaccess.h>
 #include <asm/param.h>
 
 #include <asm/uaccess.h>
 #include <asm/param.h>

-#include <asm/pgalloc.h>
+#include <asm/page.h>

 
 #include <linux/elf.h>
 
 
 #include <linux/elf.h>
 


@@ -110,18 +111,18 @@ static void padzero(unsigned long elf_bss)
        nbyte = ELF_PAGEOFFSET(elf_bss);
        if (nbyte) {
                nbyte = ELF_MIN_ALIGN - nbyte;
        nbyte = ELF_PAGEOFFSET(elf_bss);
        if (nbyte) {
                nbyte = ELF_MIN_ALIGN - nbyte;

-               clear_user((void *) elf_bss, nbyte);
+               clear_user((void __user *) elf_bss, nbyte);

        }
 }
 
 /* Let's use some macros to make this stack manipulation a litle clearer */
 #ifdef CONFIG_STACK_GROWSUP
        }
 }
 
 /* Let's use some macros to make this stack manipulation a litle clearer */
 #ifdef CONFIG_STACK_GROWSUP

-#define STACK_ADD(sp, items) ((elf_addr_t *)(sp) + (items))
+#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))

 #define STACK_ROUND(sp, items) \
        ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
 #define STACK_ROUND(sp, items) \
        ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)

-#define STACK_ALLOC(sp, len) ({ elf_addr_t *old_sp = (elf_addr_t *)sp; sp += len; old_sp; })
+#define STACK_ALLOC(sp, len) ({ elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; old_sp; })

 #else
 #else

-#define STACK_ADD(sp, items) ((elf_addr_t *)(sp) - (items))
+#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))

 #define STACK_ROUND(sp, items) \
        (((unsigned long) (sp - items)) &~ 15UL)
 #define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })
 #define STACK_ROUND(sp, items) \
        (((unsigned long) (sp - items)) &~ 15UL)
 #define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })


@@ -135,8 +136,10 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
        unsigned long p = bprm->p;
        int argc = bprm->argc;
        int envc = bprm->envc;
        unsigned long p = bprm->p;
        int argc = bprm->argc;
        int envc = bprm->envc;

-       elf_addr_t *argv, *envp;
-       elf_addr_t *sp, *u_platform;
+       elf_addr_t __user *argv;
+       elf_addr_t __user *envp;
+       elf_addr_t __user *sp;
+       elf_addr_t __user *u_platform;

        const char *k_platform = ELF_PLATFORM;
        int items;
        elf_addr_t *elf_info;
        const char *k_platform = ELF_PLATFORM;
        int items;
        elf_addr_t *elf_info;


@@ -169,7 +172,7 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
                if (smp_num_siblings > 1)
                        STACK_ALLOC(p, ((current->pid % 64) << 7));
 #endif
                if (smp_num_siblings > 1)
                        STACK_ALLOC(p, ((current->pid % 64) << 7));
 #endif

-               u_platform = (elf_addr_t *)STACK_ALLOC(p, len);
+               u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);

                __copy_to_user(u_platform, k_platform, len);
        }
 
                __copy_to_user(u_platform, k_platform, len);
        }
 


@@ -200,7 +203,10 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
        NEW_AUX_ENT(AT_EGID, (elf_addr_t) tsk->egid);
        NEW_AUX_ENT(AT_SECURE, (elf_addr_t) security_bprm_secureexec(bprm));
        if (k_platform) {
        NEW_AUX_ENT(AT_EGID, (elf_addr_t) tsk->egid);
        NEW_AUX_ENT(AT_SECURE, (elf_addr_t) security_bprm_secureexec(bprm));
        if (k_platform) {

-               NEW_AUX_ENT(AT_PLATFORM, (elf_addr_t)(long)u_platform);
+               NEW_AUX_ENT(AT_PLATFORM, (elf_addr_t)(unsigned long)u_platform);
+       }
+       if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
+               NEW_AUX_ENT(AT_EXECFD, (elf_addr_t) bprm->interp_data);

        }
 #undef NEW_AUX_ENT
        /* AT_NULL is zero; clear the rest too */
        }
 #undef NEW_AUX_ENT
        /* AT_NULL is zero; clear the rest too */


@@ -222,10 +228,10 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
 
        /* Point sp at the lowest address on the stack */
 #ifdef CONFIG_STACK_GROWSUP
 
        /* Point sp at the lowest address on the stack */
 #ifdef CONFIG_STACK_GROWSUP

-       sp = (elf_addr_t *)bprm->p - items - ei_index;
+       sp = (elf_addr_t __user *)bprm->p - items - ei_index;

        bprm->exec = (unsigned long) sp; /* XXX: PARISC HACK */
 #else
        bprm->exec = (unsigned long) sp; /* XXX: PARISC HACK */
 #else

-       sp = (elf_addr_t *)bprm->p;
+       sp = (elf_addr_t __user *)bprm->p;

 #endif
 
        /* Now, let's put argc (and argv, envp if appropriate) on the stack */
 #endif
 
        /* Now, let's put argc (and argv, envp if appropriate) on the stack */


@@ -233,8 +239,8 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
        if (interp_aout) {
                argv = sp + 2;
                envp = argv + argc + 1;
        if (interp_aout) {
                argv = sp + 2;
                envp = argv + argc + 1;

-               __put_user((elf_addr_t)(long)argv, sp++);
-               __put_user((elf_addr_t)(long)envp, sp++);
+               __put_user((elf_addr_t)(unsigned long)argv, sp++);
+               __put_user((elf_addr_t)(unsigned long)envp, sp++);

        } else {
                argv = sp;
                envp = argv + argc + 1;
        } else {
                argv = sp;
                envp = argv + argc + 1;


@@ -245,7 +251,7 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
        while (argc-- > 0) {
                size_t len;
                __put_user((elf_addr_t)p, argv++);
        while (argc-- > 0) {
                size_t len;
                __put_user((elf_addr_t)p, argv++);

-               len = strnlen_user((void *)p, PAGE_SIZE*MAX_ARG_PAGES);
+               len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);

                if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
                        return;
                p += len;
                if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
                        return;
                p += len;


@@ -255,7 +261,7 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
        while (envc-- > 0) {
                size_t len;
                __put_user((elf_addr_t)p, envp++);
        while (envc-- > 0) {
                size_t len;
                __put_user((elf_addr_t)p, envp++);

-               len = strnlen_user((void *)p, PAGE_SIZE*MAX_ARG_PAGES);
+               len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);

                if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
                        return;
                p += len;
                if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
                        return;
                p += len;


@@ -264,7 +270,7 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
        current->mm->env_end = p;
 
        /* Put the elf_info on the stack in the right place.  */
        current->mm->env_end = p;
 
        /* Put the elf_info on the stack in the right place.  */

-       sp = (elf_addr_t *)envp + 1;
+       sp = (elf_addr_t __user *)envp + 1;

        copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t));
 }
 
        copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t));
 }
 


@@ -418,7 +424,7 @@ static unsigned long load_aout_interp(struct exec * interp_ex,
                             struct file * interpreter)
 {
        unsigned long text_data, elf_entry = ~0UL;
                             struct file * interpreter)
 {
        unsigned long text_data, elf_entry = ~0UL;

-       char * addr;
+       char __user * addr;

        loff_t offset;
 
        current->mm->end_code = interp_ex->a_text;
        loff_t offset;
 
        current->mm->end_code = interp_ex->a_text;


@@ -429,12 +435,12 @@ static unsigned long load_aout_interp(struct exec * interp_ex,
        switch (N_MAGIC(*interp_ex)) {
        case OMAGIC:
                offset = 32;
        switch (N_MAGIC(*interp_ex)) {
        case OMAGIC:
                offset = 32;

-               addr = (char *) 0;
+               addr = (char __user *)0;

                break;
        case ZMAGIC:
        case QMAGIC:
                offset = N_TXTOFF(*interp_ex);
                break;
        case ZMAGIC:
        case QMAGIC:
                offset = N_TXTOFF(*interp_ex);

-               addr = (char *) N_TXTADDR(*interp_ex);
+               addr = (char __user *) N_TXTADDR(*interp_ex);

                break;
        default:
                goto out;
                break;
        default:
                goto out;


@@ -483,24 +489,33 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
        unsigned long elf_entry, interp_load_addr = 0;
        unsigned long start_code, end_code, start_data, end_data;
        unsigned long reloc_func_desc = 0;
        unsigned long elf_entry, interp_load_addr = 0;
        unsigned long start_code, end_code, start_data, end_data;
        unsigned long reloc_func_desc = 0;

-       struct elfhdr elf_ex;
-       struct elfhdr interp_elf_ex;
-       struct exec interp_ex;

        char passed_fileno[6];
        struct files_struct *files;
        char passed_fileno[6];
        struct files_struct *files;

-       int executable_stack = EXSTACK_DEFAULT;
+       int have_pt_gnu_stack, executable_stack = EXSTACK_DEFAULT;
+       unsigned long def_flags = 0;
+       struct {
+               struct elfhdr elf_ex;
+               struct elfhdr interp_elf_ex;
+               struct exec interp_ex;
+       } *loc;
+
+       loc = kmalloc(sizeof(*loc), GFP_KERNEL);
+       if (!loc) {
+               retval = -ENOMEM;
+               goto out_ret;
+       }

        
        /* Get the exec-header */
        
        /* Get the exec-header */

-       elf_ex = *((struct elfhdr *) bprm->buf);
+       loc->elf_ex = *((struct elfhdr *) bprm->buf);

 
        retval = -ENOEXEC;
        /* First of all, some simple consistency checks */
 
        retval = -ENOEXEC;
        /* First of all, some simple consistency checks */

-       if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
+       if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)

                goto out;
 
                goto out;
 

-       if (elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN)
+       if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)

                goto out;
                goto out;

-       if (!elf_check_arch(&elf_ex))
+       if (!elf_check_arch(&loc->elf_ex))

                goto out;
        if (!bprm->file->f_op||!bprm->file->f_op->mmap)
                goto out;
                goto out;
        if (!bprm->file->f_op||!bprm->file->f_op->mmap)
                goto out;


@@ -508,16 +523,16 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
        /* Now read in all of the header information */
 
        retval = -ENOMEM;
        /* Now read in all of the header information */
 
        retval = -ENOMEM;

-       if (elf_ex.e_phentsize != sizeof(struct elf_phdr))
+       if (loc->elf_ex.e_phentsize != sizeof(struct elf_phdr))

                goto out;
                goto out;

-       if (elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))
+       if (loc->elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))

                goto out;
                goto out;

-       size = elf_ex.e_phnum * sizeof(struct elf_phdr);
+       size = loc->elf_ex.e_phnum * sizeof(struct elf_phdr);

        elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);
        if (!elf_phdata)
                goto out;
 
        elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);
        if (!elf_phdata)
                goto out;
 

-       retval = kernel_read(bprm->file, elf_ex.e_phoff, (char *) elf_phdata, size);
+       retval = kernel_read(bprm->file, loc->elf_ex.e_phoff, (char *) elf_phdata, size);

        if (retval < 0)
                goto out_free_ph;
 
        if (retval < 0)
                goto out_free_ph;
 


@@ -548,7 +563,7 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
        start_data = 0;
        end_data = 0;
 
        start_data = 0;
        end_data = 0;
 

-       for (i = 0; i < elf_ex.e_phnum; i++) {
+       for (i = 0; i < loc->elf_ex.e_phnum; i++) {

                if (elf_ppnt->p_type == PT_INTERP) {
                        /* This is the program interpreter used for
                         * shared libraries - for now assume that this
                if (elf_ppnt->p_type == PT_INTERP) {
                        /* This is the program interpreter used for
                         * shared libraries - for now assume that this


@@ -595,7 +610,7 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                         * switch really is going to happen - do this in
                         * flush_thread().      - akpm
                         */
                         * switch really is going to happen - do this in
                         * flush_thread().      - akpm
                         */

-                       SET_PERSONALITY(elf_ex, ibcs2_interpreter);
+                       SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);

 
                        interpreter = open_exec(elf_interpreter);
                        retval = PTR_ERR(interpreter);
 
                        interpreter = open_exec(elf_interpreter);
                        retval = PTR_ERR(interpreter);


@@ -606,33 +621,35 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                                goto out_free_dentry;
 
                        /* Get the exec headers */
                                goto out_free_dentry;
 
                        /* Get the exec headers */

-                       interp_ex = *((struct exec *) bprm->buf);
-                       interp_elf_ex = *((struct elfhdr *) bprm->buf);
+                       loc->interp_ex = *((struct exec *) bprm->buf);
+                       loc->interp_elf_ex = *((struct elfhdr *) bprm->buf);

                        break;
                }
                elf_ppnt++;
        }
 
        elf_ppnt = elf_phdata;
                        break;
                }
                elf_ppnt++;
        }
 
        elf_ppnt = elf_phdata;

-       for (i = 0; i < elf_ex.e_phnum; i++, elf_ppnt++)
+       for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)

                if (elf_ppnt->p_type == PT_GNU_STACK) {
                        if (elf_ppnt->p_flags & PF_X)
                                executable_stack = EXSTACK_ENABLE_X;
                        else
                                executable_stack = EXSTACK_DISABLE_X;
                if (elf_ppnt->p_type == PT_GNU_STACK) {
                        if (elf_ppnt->p_flags & PF_X)
                                executable_stack = EXSTACK_ENABLE_X;
                        else
                                executable_stack = EXSTACK_DISABLE_X;

+                       break;

                }
                }

+       have_pt_gnu_stack = (i < loc->elf_ex.e_phnum);

 
        /* Some simple consistency checks for the interpreter */
        if (elf_interpreter) {
                interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
 
                /* Now figure out which format our binary is */
 
        /* Some simple consistency checks for the interpreter */
        if (elf_interpreter) {
                interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
 
                /* Now figure out which format our binary is */

-               if ((N_MAGIC(interp_ex) != OMAGIC) &&
-                   (N_MAGIC(interp_ex) != ZMAGIC) &&
-                   (N_MAGIC(interp_ex) != QMAGIC))
+               if ((N_MAGIC(loc->interp_ex) != OMAGIC) &&
+                   (N_MAGIC(loc->interp_ex) != ZMAGIC) &&
+                   (N_MAGIC(loc->interp_ex) != QMAGIC))

                        interpreter_type = INTERPRETER_ELF;
 
                        interpreter_type = INTERPRETER_ELF;
 

-               if (memcmp(interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
+               if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)

                        interpreter_type &= ~INTERPRETER_ELF;
 
                retval = -ELIBBAD;
                        interpreter_type &= ~INTERPRETER_ELF;
 
                retval = -ELIBBAD;


@@ -648,11 +665,11 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                }
                /* Verify the interpreter has a valid arch */
                if ((interpreter_type == INTERPRETER_ELF) &&
                }
                /* Verify the interpreter has a valid arch */
                if ((interpreter_type == INTERPRETER_ELF) &&

-                   !elf_check_arch(&interp_elf_ex))
+                   !elf_check_arch(&loc->interp_elf_ex))

                        goto out_free_dentry;
        } else {
                /* Executables without an interpreter also need a personality  */
                        goto out_free_dentry;
        } else {
                /* Executables without an interpreter also need a personality  */

-               SET_PERSONALITY(elf_ex, ibcs2_interpreter);
+               SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);

        }
 
        /* OK, we are done with that, now set up the arg stuff,
        }
 
        /* OK, we are done with that, now set up the arg stuff,


@@ -688,16 +705,21 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
        current->mm->end_code = 0;
        current->mm->mmap = NULL;
        current->flags &= ~PF_FORKNOEXEC;
        current->mm->end_code = 0;
        current->mm->mmap = NULL;
        current->flags &= ~PF_FORKNOEXEC;

+       current->mm->def_flags = def_flags;

 
        /* Do this immediately, since STACK_TOP as used in setup_arg_pages
           may depend on the personality.  */
 
        /* Do this immediately, since STACK_TOP as used in setup_arg_pages
           may depend on the personality.  */

-       SET_PERSONALITY(elf_ex, ibcs2_interpreter);
+       SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);
+       if (elf_read_implies_exec(loc->elf_ex, have_pt_gnu_stack))
+               current->personality |= READ_IMPLIES_EXEC;
+
+       arch_pick_mmap_layout(current->mm);

 
        /* Do this so that we can load the interpreter, if need be.  We will
           change some of these later */
        // current->mm->rss = 0;
        vx_rsspages_sub(current->mm, current->mm->rss);
 
        /* Do this so that we can load the interpreter, if need be.  We will
           change some of these later */
        // current->mm->rss = 0;
        vx_rsspages_sub(current->mm, current->mm->rss);

-       current->mm->free_area_cache = TASK_UNMAPPED_BASE;
+       current->mm->free_area_cache = current->mm->mmap_base;

        retval = setup_arg_pages(bprm, executable_stack);
        if (retval < 0) {
                send_sig(SIGKILL, current, 0);
        retval = setup_arg_pages(bprm, executable_stack);
        if (retval < 0) {
                send_sig(SIGKILL, current, 0);


@@ -711,7 +733,7 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
           the image should be loaded at fixed address, not at a variable
           address. */
 
           the image should be loaded at fixed address, not at a variable
           address. */
 

-       for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {
+       for(i = 0, elf_ppnt = elf_phdata; i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {

                int elf_prot = 0, elf_flags;
                unsigned long k, vaddr;
 
                int elf_prot = 0, elf_flags;
                unsigned long k, vaddr;
 


@@ -735,7 +757,7 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                                nbyte = ELF_MIN_ALIGN - nbyte;
                                if (nbyte > elf_brk - elf_bss)
                                        nbyte = elf_brk - elf_bss;
                                nbyte = ELF_MIN_ALIGN - nbyte;
                                if (nbyte > elf_brk - elf_bss)
                                        nbyte = elf_brk - elf_bss;

-                               clear_user((void *) elf_bss + load_bias, nbyte);
+                               clear_user((void __user *) elf_bss + load_bias, nbyte);

                        }
                }
 
                        }
                }
 


@@ -746,9 +768,9 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                elf_flags = MAP_PRIVATE|MAP_DENYWRITE|MAP_EXECUTABLE;
 
                vaddr = elf_ppnt->p_vaddr;
                elf_flags = MAP_PRIVATE|MAP_DENYWRITE|MAP_EXECUTABLE;
 
                vaddr = elf_ppnt->p_vaddr;

-               if (elf_ex.e_type == ET_EXEC || load_addr_set) {
+               if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {

                        elf_flags |= MAP_FIXED;
                        elf_flags |= MAP_FIXED;

-               } else if (elf_ex.e_type == ET_DYN) {
+               } else if (loc->elf_ex.e_type == ET_DYN) {

                        /* Try and get dynamic programs out of the way of the default mmap
                           base, as well as whatever program they might try to exec.  This
                           is because the brk will follow the loader, and is not movable.  */
                        /* Try and get dynamic programs out of the way of the default mmap
                           base, as well as whatever program they might try to exec.  This
                           is because the brk will follow the loader, and is not movable.  */


@@ -762,7 +784,7 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                if (!load_addr_set) {
                        load_addr_set = 1;
                        load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
                if (!load_addr_set) {
                        load_addr_set = 1;
                        load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);

-                       if (elf_ex.e_type == ET_DYN) {
+                       if (loc->elf_ex.e_type == ET_DYN) {

                                load_bias += error -
                                             ELF_PAGESTART(load_bias + vaddr);
                                load_addr += load_bias;
                                load_bias += error -
                                             ELF_PAGESTART(load_bias + vaddr);
                                load_addr += load_bias;


@@ -799,7 +821,7 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                        elf_brk = k;
        }
 
                        elf_brk = k;
        }
 

-       elf_ex.e_entry += load_bias;
+       loc->elf_ex.e_entry += load_bias;

        elf_bss += load_bias;
        elf_brk += load_bias;
        start_code += load_bias;
        elf_bss += load_bias;
        elf_brk += load_bias;
        start_code += load_bias;


@@ -821,10 +843,10 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
 
        if (elf_interpreter) {
                if (interpreter_type == INTERPRETER_AOUT)
 
        if (elf_interpreter) {
                if (interpreter_type == INTERPRETER_AOUT)

-                       elf_entry = load_aout_interp(&interp_ex,
+                       elf_entry = load_aout_interp(&loc->interp_ex,

                                                     interpreter);
                else
                                                     interpreter);
                else

-                       elf_entry = load_elf_interp(&interp_elf_ex,
+                       elf_entry = load_elf_interp(&loc->interp_elf_ex,

                                                    interpreter,
                                                    &interp_load_addr);
                if (BAD_ADDR(elf_entry)) {
                                                    interpreter,
                                                    &interp_load_addr);
                if (BAD_ADDR(elf_entry)) {


@@ -839,7 +861,7 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
                fput(interpreter);
                kfree(elf_interpreter);
        } else {
                fput(interpreter);
                kfree(elf_interpreter);
        } else {

-               elf_entry = elf_ex.e_entry;
+               elf_entry = loc->elf_ex.e_entry;

        }
 
        kfree(elf_phdata);
        }
 
        kfree(elf_phdata);


@@ -851,7 +873,7 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
 
        compute_creds(bprm);
        current->flags &= ~PF_FORKNOEXEC;
 
        compute_creds(bprm);
        current->flags &= ~PF_FORKNOEXEC;

-       create_elf_tables(bprm, &elf_ex, (interpreter_type == INTERPRETER_AOUT),
+       create_elf_tables(bprm, &loc->elf_ex, (interpreter_type == INTERPRETER_AOUT),

                        load_addr, interp_load_addr);
        /* N.B. passed_fileno might not be initialized? */
        if (interpreter_type == INTERPRETER_AOUT)
                        load_addr, interp_load_addr);
        /* N.B. passed_fileno might not be initialized? */
        if (interpreter_type == INTERPRETER_AOUT)


@@ -896,6 +918,8 @@ static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
        }
        retval = 0;
 out:
        }
        retval = 0;
 out:

+       kfree(loc);
+out_ret:

        return retval;
 
        /* error cleanup */
        return retval;
 
        /* error cleanup */


@@ -1167,10 +1191,27 @@ static void fill_prstatus(struct elf_prstatus *prstatus,
        prstatus->pr_ppid = p->parent->pid;
        prstatus->pr_pgrp = process_group(p);
        prstatus->pr_sid = p->signal->session;
        prstatus->pr_ppid = p->parent->pid;
        prstatus->pr_pgrp = process_group(p);
        prstatus->pr_sid = p->signal->session;

-       jiffies_to_timeval(p->utime, &prstatus->pr_utime);
-       jiffies_to_timeval(p->stime, &prstatus->pr_stime);
-       jiffies_to_timeval(p->cutime, &prstatus->pr_cutime);
-       jiffies_to_timeval(p->cstime, &prstatus->pr_cstime);
+       if (p->pid == p->tgid) {
+               /*
+                * This is the record for the group leader.  Add in the
+                * cumulative times of previous dead threads.  This total
+                * won't include the time of each live thread whose state
+                * is included in the core dump.  The final total reported
+                * to our parent process when it calls wait4 will include
+                * those sums as well as the little bit more time it takes
+                * this and each other thread to finish dying after the
+                * core dump synchronization phase.
+                */
+               jiffies_to_timeval(p->utime + p->signal->utime,
+                                  &prstatus->pr_utime);
+               jiffies_to_timeval(p->stime + p->signal->stime,
+                                  &prstatus->pr_stime);
+       } else {
+               jiffies_to_timeval(p->utime, &prstatus->pr_utime);
+               jiffies_to_timeval(p->stime, &prstatus->pr_stime);
+       }
+       jiffies_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
+       jiffies_to_timeval(p->signal->cstime, &prstatus->pr_cstime);

 }
 
 static void fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
 }
 
 static void fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,


@@ -1185,7 +1226,7 @@ static void fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
        if (len >= ELF_PRARGSZ)
                len = ELF_PRARGSZ-1;
        copy_from_user(&psinfo->pr_psargs,
        if (len >= ELF_PRARGSZ)
                len = ELF_PRARGSZ-1;
        copy_from_user(&psinfo->pr_psargs,

-                      (const char *)mm->arg_start, len);
+                      (const char __user *)mm->arg_start, len);

        for(i = 0; i < len; i++)
                if (psinfo->pr_psargs[i] == 0)
                        psinfo->pr_psargs[i] = ' ';
        for(i = 0; i < len; i++)
                if (psinfo->pr_psargs[i] == 0)
                        psinfo->pr_psargs[i] = ' ';


@@ -1215,6 +1256,7 @@ struct elf_thread_status
        struct list_head list;
        struct elf_prstatus prstatus;   /* NT_PRSTATUS */
        elf_fpregset_t fpu;             /* NT_PRFPREG */
        struct list_head list;
        struct elf_prstatus prstatus;   /* NT_PRSTATUS */
        elf_fpregset_t fpu;             /* NT_PRFPREG */

+       struct task_struct *thread;

 #ifdef ELF_CORE_COPY_XFPREGS
        elf_fpxregset_t xfpu;           /* NT_PRXFPREG */
 #endif
 #ifdef ELF_CORE_COPY_XFPREGS
        elf_fpxregset_t xfpu;           /* NT_PRXFPREG */
 #endif


@@ -1227,18 +1269,10 @@ struct elf_thread_status
  * we need to keep a linked list of every threads pr_status and then
  * create a single section for them in the final core file.
  */
  * we need to keep a linked list of every threads pr_status and then
  * create a single section for them in the final core file.
  */

-static int elf_dump_thread_status(long signr, struct task_struct * p, struct list_head * thread_list)
+static int elf_dump_thread_status(long signr, struct elf_thread_status *t)

 {
 {

-
-       struct elf_thread_status *t;

        int sz = 0;
        int sz = 0;

-
-       t = kmalloc(sizeof(*t), GFP_ATOMIC);
-       if (!t)
-               return 0;
-       memset(t, 0, sizeof(*t));
-
-       INIT_LIST_HEAD(&t->list);
+       struct task_struct *p = t->thread;

        t->num_notes = 0;
 
        fill_prstatus(&t->prstatus, p, signr);
        t->num_notes = 0;
 
        fill_prstatus(&t->prstatus, p, signr);


@@ -1261,7 +1295,6 @@ static int elf_dump_thread_status(long signr, struct task_struct * p, struct lis
                sz += notesize(&t->notes[2]);
        }
 #endif 
                sz += notesize(&t->notes[2]);
        }
 #endif 

-       list_add(&t->list, thread_list);

        return sz;
 }
 
        return sz;
 }
 


@@ -1332,22 +1365,32 @@ static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
                goto cleanup;
 #endif
 
                goto cleanup;
 #endif
 

-       /* capture the status of all other threads */

        if (signr) {
        if (signr) {

+               struct elf_thread_status *tmp;

                read_lock(&tasklist_lock);
                do_each_thread(g,p)
                        if (current->mm == p->mm && current != p) {
                read_lock(&tasklist_lock);
                do_each_thread(g,p)
                        if (current->mm == p->mm && current != p) {

-                               int sz = elf_dump_thread_status(signr, p, &thread_list);
-                               if (!sz) {
+                               tmp = kmalloc(sizeof(*tmp), GFP_ATOMIC);
+                               if (!tmp) {

                                        read_unlock(&tasklist_lock);
                                        goto cleanup;
                                        read_unlock(&tasklist_lock);
                                        goto cleanup;

-                               } else
-                                       thread_status_size += sz;
+                               }
+                               memset(tmp, 0, sizeof(*tmp));
+                               INIT_LIST_HEAD(&tmp->list);
+                               tmp->thread = p;
+                               list_add(&tmp->list, &thread_list);

                        }
                while_each_thread(g,p);
                read_unlock(&tasklist_lock);
                        }
                while_each_thread(g,p);
                read_unlock(&tasklist_lock);

-       }
+               list_for_each(t, &thread_list) {
+                       struct elf_thread_status *tmp;
+                       int sz;

 
 

+                       tmp = list_entry(t, struct elf_thread_status, list);
+                       sz = elf_dump_thread_status(signr, tmp);
+                       thread_status_size += sz;
+               }
+       }

        /* now collect the dump for the current */
        memset(prstatus, 0, sizeof(*prstatus));
        fill_prstatus(prstatus, current, signr);
        /* now collect the dump for the current */
        memset(prstatus, 0, sizeof(*prstatus));
        fill_prstatus(prstatus, current, signr);


@@ -1544,6 +1587,6 @@ static void __exit exit_elf_binfmt(void)
        unregister_binfmt(&elf_format);
 }
 
        unregister_binfmt(&elf_format);
 }
 

-module_init(init_elf_binfmt)
-module_exit(exit_elf_binfmt)
+core_initcall(init_elf_binfmt);
+module_exit(exit_elf_binfmt);

 MODULE_LICENSE("GPL");
 MODULE_LICENSE("GPL");