1 files changed, 40 insertions, 18 deletions

diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 08e4414b8374..4482a0673b15 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -148,6 +148,7 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
         elf_addr_t *elf_info;
         int ei_index = 0;
         struct task_struct *tsk = current;
+        struct vm_area_struct *vma;
 
         /*
          * If this architecture has a platform capability string, copy it
@@ -234,6 +235,15 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
         sp = (elf_addr_t __user *)bprm->p;
 #endif
 
+
+        /*
+         * Grow the stack manually; some architectures have a limit on how
+         * far ahead a user-space access may be in order to grow the stack.
+         */
+        vma = find_extend_vma(current->mm, bprm->p);
+        if (!vma)
+                return -EFAULT;
+
         /* Now, let's put argc (and argv, envp if appropriate) on the stack */
         if (__put_user(argc, sp++))
                 return -EFAULT;
@@ -254,8 +264,8 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
                 size_t len;
                 if (__put_user((elf_addr_t)p, argv++))
                         return -EFAULT;
-                len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);
-                if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
+                len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
+                if (!len || len > MAX_ARG_STRLEN)
                         return 0;
                 p += len;
         }
@@ -266,8 +276,8 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
                 size_t len;
                 if (__put_user((elf_addr_t)p, envp++))
                         return -EFAULT;
-                len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);
-                if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
+                len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
+                if (!len || len > MAX_ARG_STRLEN)
                         return 0;
                 p += len;
         }
@@ -777,10 +787,6 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
         }
 
         /* OK, This is the point of no return */
-        current->mm->start_data = 0;
-        current->mm->end_data = 0;
-        current->mm->end_code = 0;
-        current->mm->mmap = NULL;
         current->flags &= ~PF_FORKNOEXEC;
         current->mm->def_flags = def_flags;
 
@@ -988,9 +994,13 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
 
         compute_creds(bprm);
         current->flags &= ~PF_FORKNOEXEC;
-        create_elf_tables(bprm, &loc->elf_ex,
+        retval = create_elf_tables(bprm, &loc->elf_ex,
                           (interpreter_type == INTERPRETER_AOUT),
                           load_addr, interp_load_addr);
+        if (retval < 0) {
+                send_sig(SIGKILL, current, 0);
+                goto out;
+        }
         /* N.B. passed_fileno might not be initialized? */
         if (interpreter_type == INTERPRETER_AOUT)
                 current->mm->arg_start += strlen(passed_fileno) + 1;
@@ -1189,7 +1199,7 @@ static int dump_seek(struct file *file, loff_t off)
  *
  * I think we should skip something. But I am not sure how. H.J.
  */
-static int maydump(struct vm_area_struct *vma)
+static int maydump(struct vm_area_struct *vma, unsigned long mm_flags)
 {
         /* The vma can be set up to tell us the answer directly.  */
         if (vma->vm_flags & VM_ALWAYSDUMP)
@@ -1199,15 +1209,19 @@ static int maydump(struct vm_area_struct *vma)
         if (vma->vm_flags & (VM_IO | VM_RESERVED))
                 return 0;
 
-        /* Dump shared memory only if mapped from an anonymous file. */
-        if (vma->vm_flags & VM_SHARED)
-                return vma->vm_file->f_path.dentry->d_inode->i_nlink == 0;
+        /* By default, dump shared memory if mapped from an anonymous file. */
+        if (vma->vm_flags & VM_SHARED) {
+                if (vma->vm_file->f_path.dentry->d_inode->i_nlink == 0)
+                        return test_bit(MMF_DUMP_ANON_SHARED, &mm_flags);
+                else
+                        return test_bit(MMF_DUMP_MAPPED_SHARED, &mm_flags);
+        }
 
-        /* If it hasn't been written to, don't write it out */
+        /* By default, if it hasn't been written to, don't write it out. */
         if (!vma->anon_vma)
-                return 0;
+                return test_bit(MMF_DUMP_MAPPED_PRIVATE, &mm_flags);
 
-        return 1;
+        return test_bit(MMF_DUMP_ANON_PRIVATE, &mm_flags);
 }
 
 /* An ELF note in memory */
@@ -1499,6 +1513,7 @@ static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file)
 #endif
         int thread_status_size = 0;
         elf_addr_t *auxv;
+        unsigned long mm_flags;
 #ifdef ELF_CORE_WRITE_EXTRA_NOTES
         int extra_notes_size;
 #endif
@@ -1642,6 +1657,13 @@ static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file)
 
         dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
 
+        /*
+         * We must use the same mm->flags while dumping core to avoid
+         * inconsistency between the program headers and bodies, otherwise an
+         * unusable core file can be generated.
+         */
+        mm_flags = current->mm->flags;
+
         /* Write program headers for segments dump */
         for (vma = first_vma(current, gate_vma); vma != NULL;
                         vma = next_vma(vma, gate_vma)) {
@@ -1654,7 +1676,7 @@ static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file)
                 phdr.p_offset = offset;
                 phdr.p_vaddr = vma->vm_start;
                 phdr.p_paddr = 0;
-                phdr.p_filesz = maydump(vma) ? sz : 0;
+                phdr.p_filesz = maydump(vma, mm_flags) ? sz : 0;
                 phdr.p_memsz = sz;
                 offset += phdr.p_filesz;
                 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
@@ -1698,7 +1720,7 @@ static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file)
                         vma = next_vma(vma, gate_vma)) {
                 unsigned long addr;
 
-                if (!maydump(vma))
+                if (!maydump(vma, mm_flags))
                         continue;
 
                 for (addr = vma->vm_start;