fs/binfmt_elf.c: free PT_INTERP filename ASAP
[sfrench/cifs-2.6.git] / fs / binfmt_elf.c
1 /*
2  * linux/fs/binfmt_elf.c
3  *
4  * These are the functions used to load ELF format executables as used
5  * on SVr4 machines.  Information on the format may be found in the book
6  * "UNIX SYSTEM V RELEASE 4 Programmers Guide: Ansi C and Programming Support
7  * Tools".
8  *
9  * Copyright 1993, 1994: Eric Youngdale (ericy@cais.com).
10  */
11
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/fs.h>
15 #include <linux/mm.h>
16 #include <linux/mman.h>
17 #include <linux/errno.h>
18 #include <linux/signal.h>
19 #include <linux/binfmts.h>
20 #include <linux/string.h>
21 #include <linux/file.h>
22 #include <linux/slab.h>
23 #include <linux/personality.h>
24 #include <linux/elfcore.h>
25 #include <linux/init.h>
26 #include <linux/highuid.h>
27 #include <linux/compiler.h>
28 #include <linux/highmem.h>
29 #include <linux/pagemap.h>
30 #include <linux/vmalloc.h>
31 #include <linux/security.h>
32 #include <linux/random.h>
33 #include <linux/elf.h>
34 #include <linux/elf-randomize.h>
35 #include <linux/utsname.h>
36 #include <linux/coredump.h>
37 #include <linux/sched.h>
38 #include <linux/sched/coredump.h>
39 #include <linux/sched/task_stack.h>
40 #include <linux/sched/cputime.h>
41 #include <linux/cred.h>
42 #include <linux/dax.h>
43 #include <linux/uaccess.h>
44 #include <asm/param.h>
45 #include <asm/page.h>
46
47 #ifndef user_long_t
48 #define user_long_t long
49 #endif
50 #ifndef user_siginfo_t
51 #define user_siginfo_t siginfo_t
52 #endif
53
54 /* That's for binfmt_elf_fdpic to deal with */
55 #ifndef elf_check_fdpic
56 #define elf_check_fdpic(ex) false
57 #endif
58
59 static int load_elf_binary(struct linux_binprm *bprm);
60
61 #ifdef CONFIG_USELIB
62 static int load_elf_library(struct file *);
63 #else
64 #define load_elf_library NULL
65 #endif
66
67 /*
68  * If we don't support core dumping, then supply a NULL so we
69  * don't even try.
70  */
71 #ifdef CONFIG_ELF_CORE
72 static int elf_core_dump(struct coredump_params *cprm);
73 #else
74 #define elf_core_dump   NULL
75 #endif
76
77 #if ELF_EXEC_PAGESIZE > PAGE_SIZE
78 #define ELF_MIN_ALIGN   ELF_EXEC_PAGESIZE
79 #else
80 #define ELF_MIN_ALIGN   PAGE_SIZE
81 #endif
82
83 #ifndef ELF_CORE_EFLAGS
84 #define ELF_CORE_EFLAGS 0
85 #endif
86
87 #define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
88 #define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
89 #define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
90
91 static struct linux_binfmt elf_format = {
92         .module         = THIS_MODULE,
93         .load_binary    = load_elf_binary,
94         .load_shlib     = load_elf_library,
95         .core_dump      = elf_core_dump,
96         .min_coredump   = ELF_EXEC_PAGESIZE,
97 };
98
99 #define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
100
101 static int set_brk(unsigned long start, unsigned long end, int prot)
102 {
103         start = ELF_PAGEALIGN(start);
104         end = ELF_PAGEALIGN(end);
105         if (end > start) {
106                 /*
107                  * Map the last of the bss segment.
108                  * If the header is requesting these pages to be
109                  * executable, honour that (ppc32 needs this).
110                  */
111                 int error = vm_brk_flags(start, end - start,
112                                 prot & PROT_EXEC ? VM_EXEC : 0);
113                 if (error)
114                         return error;
115         }
116         current->mm->start_brk = current->mm->brk = end;
117         return 0;
118 }
119
120 /* We need to explicitly zero any fractional pages
121    after the data section (i.e. bss).  This would
122    contain the junk from the file that should not
123    be in memory
124  */
125 static int padzero(unsigned long elf_bss)
126 {
127         unsigned long nbyte;
128
129         nbyte = ELF_PAGEOFFSET(elf_bss);
130         if (nbyte) {
131                 nbyte = ELF_MIN_ALIGN - nbyte;
132                 if (clear_user((void __user *) elf_bss, nbyte))
133                         return -EFAULT;
134         }
135         return 0;
136 }
137
138 /* Let's use some macros to make this stack manipulation a little clearer */
139 #ifdef CONFIG_STACK_GROWSUP
140 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))
141 #define STACK_ROUND(sp, items) \
142         ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
143 #define STACK_ALLOC(sp, len) ({ \
144         elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; \
145         old_sp; })
146 #else
147 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))
148 #define STACK_ROUND(sp, items) \
149         (((unsigned long) (sp - items)) &~ 15UL)
150 #define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })
151 #endif
152
153 #ifndef ELF_BASE_PLATFORM
154 /*
155  * AT_BASE_PLATFORM indicates the "real" hardware/microarchitecture.
156  * If the arch defines ELF_BASE_PLATFORM (in asm/elf.h), the value
157  * will be copied to the user stack in the same manner as AT_PLATFORM.
158  */
159 #define ELF_BASE_PLATFORM NULL
160 #endif
161
162 static int
163 create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
164                 unsigned long load_addr, unsigned long interp_load_addr)
165 {
166         unsigned long p = bprm->p;
167         int argc = bprm->argc;
168         int envc = bprm->envc;
169         elf_addr_t __user *sp;
170         elf_addr_t __user *u_platform;
171         elf_addr_t __user *u_base_platform;
172         elf_addr_t __user *u_rand_bytes;
173         const char *k_platform = ELF_PLATFORM;
174         const char *k_base_platform = ELF_BASE_PLATFORM;
175         unsigned char k_rand_bytes[16];
176         int items;
177         elf_addr_t *elf_info;
178         int ei_index = 0;
179         const struct cred *cred = current_cred();
180         struct vm_area_struct *vma;
181
182         /*
183          * In some cases (e.g. Hyper-Threading), we want to avoid L1
184          * evictions by the processes running on the same package. One
185          * thing we can do is to shuffle the initial stack for them.
186          */
187
188         p = arch_align_stack(p);
189
190         /*
191          * If this architecture has a platform capability string, copy it
192          * to userspace.  In some cases (Sparc), this info is impossible
193          * for userspace to get any other way, in others (i386) it is
194          * merely difficult.
195          */
196         u_platform = NULL;
197         if (k_platform) {
198                 size_t len = strlen(k_platform) + 1;
199
200                 u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
201                 if (__copy_to_user(u_platform, k_platform, len))
202                         return -EFAULT;
203         }
204
205         /*
206          * If this architecture has a "base" platform capability
207          * string, copy it to userspace.
208          */
209         u_base_platform = NULL;
210         if (k_base_platform) {
211                 size_t len = strlen(k_base_platform) + 1;
212
213                 u_base_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
214                 if (__copy_to_user(u_base_platform, k_base_platform, len))
215                         return -EFAULT;
216         }
217
218         /*
219          * Generate 16 random bytes for userspace PRNG seeding.
220          */
221         get_random_bytes(k_rand_bytes, sizeof(k_rand_bytes));
222         u_rand_bytes = (elf_addr_t __user *)
223                        STACK_ALLOC(p, sizeof(k_rand_bytes));
224         if (__copy_to_user(u_rand_bytes, k_rand_bytes, sizeof(k_rand_bytes)))
225                 return -EFAULT;
226
227         /* Create the ELF interpreter info */
228         elf_info = (elf_addr_t *)current->mm->saved_auxv;
229         /* update AT_VECTOR_SIZE_BASE if the number of NEW_AUX_ENT() changes */
230 #define NEW_AUX_ENT(id, val) \
231         do { \
232                 elf_info[ei_index++] = id; \
233                 elf_info[ei_index++] = val; \
234         } while (0)
235
236 #ifdef ARCH_DLINFO
237         /* 
238          * ARCH_DLINFO must come first so PPC can do its special alignment of
239          * AUXV.
240          * update AT_VECTOR_SIZE_ARCH if the number of NEW_AUX_ENT() in
241          * ARCH_DLINFO changes
242          */
243         ARCH_DLINFO;
244 #endif
245         NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);
246         NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
247         NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
248         NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);
249         NEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));
250         NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);
251         NEW_AUX_ENT(AT_BASE, interp_load_addr);
252         NEW_AUX_ENT(AT_FLAGS, 0);
253         NEW_AUX_ENT(AT_ENTRY, exec->e_entry);
254         NEW_AUX_ENT(AT_UID, from_kuid_munged(cred->user_ns, cred->uid));
255         NEW_AUX_ENT(AT_EUID, from_kuid_munged(cred->user_ns, cred->euid));
256         NEW_AUX_ENT(AT_GID, from_kgid_munged(cred->user_ns, cred->gid));
257         NEW_AUX_ENT(AT_EGID, from_kgid_munged(cred->user_ns, cred->egid));
258         NEW_AUX_ENT(AT_SECURE, bprm->secureexec);
259         NEW_AUX_ENT(AT_RANDOM, (elf_addr_t)(unsigned long)u_rand_bytes);
260 #ifdef ELF_HWCAP2
261         NEW_AUX_ENT(AT_HWCAP2, ELF_HWCAP2);
262 #endif
263         NEW_AUX_ENT(AT_EXECFN, bprm->exec);
264         if (k_platform) {
265                 NEW_AUX_ENT(AT_PLATFORM,
266                             (elf_addr_t)(unsigned long)u_platform);
267         }
268         if (k_base_platform) {
269                 NEW_AUX_ENT(AT_BASE_PLATFORM,
270                             (elf_addr_t)(unsigned long)u_base_platform);
271         }
272         if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
273                 NEW_AUX_ENT(AT_EXECFD, bprm->interp_data);
274         }
275 #undef NEW_AUX_ENT
276         /* AT_NULL is zero; clear the rest too */
277         memset(&elf_info[ei_index], 0,
278                sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);
279
280         /* And advance past the AT_NULL entry.  */
281         ei_index += 2;
282
283         sp = STACK_ADD(p, ei_index);
284
285         items = (argc + 1) + (envc + 1) + 1;
286         bprm->p = STACK_ROUND(sp, items);
287
288         /* Point sp at the lowest address on the stack */
289 #ifdef CONFIG_STACK_GROWSUP
290         sp = (elf_addr_t __user *)bprm->p - items - ei_index;
291         bprm->exec = (unsigned long)sp; /* XXX: PARISC HACK */
292 #else
293         sp = (elf_addr_t __user *)bprm->p;
294 #endif
295
296
297         /*
298          * Grow the stack manually; some architectures have a limit on how
299          * far ahead a user-space access may be in order to grow the stack.
300          */
301         vma = find_extend_vma(current->mm, bprm->p);
302         if (!vma)
303                 return -EFAULT;
304
305         /* Now, let's put argc (and argv, envp if appropriate) on the stack */
306         if (__put_user(argc, sp++))
307                 return -EFAULT;
308
309         /* Populate list of argv pointers back to argv strings. */
310         p = current->mm->arg_end = current->mm->arg_start;
311         while (argc-- > 0) {
312                 size_t len;
313                 if (__put_user((elf_addr_t)p, sp++))
314                         return -EFAULT;
315                 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
316                 if (!len || len > MAX_ARG_STRLEN)
317                         return -EINVAL;
318                 p += len;
319         }
320         if (__put_user(0, sp++))
321                 return -EFAULT;
322         current->mm->arg_end = p;
323
324         /* Populate list of envp pointers back to envp strings. */
325         current->mm->env_end = current->mm->env_start = p;
326         while (envc-- > 0) {
327                 size_t len;
328                 if (__put_user((elf_addr_t)p, sp++))
329                         return -EFAULT;
330                 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
331                 if (!len || len > MAX_ARG_STRLEN)
332                         return -EINVAL;
333                 p += len;
334         }
335         if (__put_user(0, sp++))
336                 return -EFAULT;
337         current->mm->env_end = p;
338
339         /* Put the elf_info on the stack in the right place.  */
340         if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))
341                 return -EFAULT;
342         return 0;
343 }
344
345 #ifndef elf_map
346
347 static unsigned long elf_map(struct file *filep, unsigned long addr,
348                 const struct elf_phdr *eppnt, int prot, int type,
349                 unsigned long total_size)
350 {
351         unsigned long map_addr;
352         unsigned long size = eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr);
353         unsigned long off = eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr);
354         addr = ELF_PAGESTART(addr);
355         size = ELF_PAGEALIGN(size);
356
357         /* mmap() will return -EINVAL if given a zero size, but a
358          * segment with zero filesize is perfectly valid */
359         if (!size)
360                 return addr;
361
362         /*
363         * total_size is the size of the ELF (interpreter) image.
364         * The _first_ mmap needs to know the full size, otherwise
365         * randomization might put this image into an overlapping
366         * position with the ELF binary image. (since size < total_size)
367         * So we first map the 'big' image - and unmap the remainder at
368         * the end. (which unmap is needed for ELF images with holes.)
369         */
370         if (total_size) {
371                 total_size = ELF_PAGEALIGN(total_size);
372                 map_addr = vm_mmap(filep, addr, total_size, prot, type, off);
373                 if (!BAD_ADDR(map_addr))
374                         vm_munmap(map_addr+size, total_size-size);
375         } else
376                 map_addr = vm_mmap(filep, addr, size, prot, type, off);
377
378         if ((type & MAP_FIXED_NOREPLACE) &&
379             PTR_ERR((void *)map_addr) == -EEXIST)
380                 pr_info("%d (%s): Uhuuh, elf segment at %px requested but the memory is mapped already\n",
381                         task_pid_nr(current), current->comm, (void *)addr);
382
383         return(map_addr);
384 }
385
386 #endif /* !elf_map */
387
388 static unsigned long total_mapping_size(const struct elf_phdr *cmds, int nr)
389 {
390         int i, first_idx = -1, last_idx = -1;
391
392         for (i = 0; i < nr; i++) {
393                 if (cmds[i].p_type == PT_LOAD) {
394                         last_idx = i;
395                         if (first_idx == -1)
396                                 first_idx = i;
397                 }
398         }
399         if (first_idx == -1)
400                 return 0;
401
402         return cmds[last_idx].p_vaddr + cmds[last_idx].p_memsz -
403                                 ELF_PAGESTART(cmds[first_idx].p_vaddr);
404 }
405
406 /**
407  * load_elf_phdrs() - load ELF program headers
408  * @elf_ex:   ELF header of the binary whose program headers should be loaded
409  * @elf_file: the opened ELF binary file
410  *
411  * Loads ELF program headers from the binary file elf_file, which has the ELF
412  * header pointed to by elf_ex, into a newly allocated array. The caller is
413  * responsible for freeing the allocated data. Returns an ERR_PTR upon failure.
414  */
415 static struct elf_phdr *load_elf_phdrs(const struct elfhdr *elf_ex,
416                                        struct file *elf_file)
417 {
418         struct elf_phdr *elf_phdata = NULL;
419         int retval, err = -1;
420         loff_t pos = elf_ex->e_phoff;
421         unsigned int size;
422
423         /*
424          * If the size of this structure has changed, then punt, since
425          * we will be doing the wrong thing.
426          */
427         if (elf_ex->e_phentsize != sizeof(struct elf_phdr))
428                 goto out;
429
430         /* Sanity check the number of program headers... */
431         /* ...and their total size. */
432         size = sizeof(struct elf_phdr) * elf_ex->e_phnum;
433         if (size == 0 || size > 65536 || size > ELF_MIN_ALIGN)
434                 goto out;
435
436         elf_phdata = kmalloc(size, GFP_KERNEL);
437         if (!elf_phdata)
438                 goto out;
439
440         /* Read in the program headers */
441         retval = kernel_read(elf_file, elf_phdata, size, &pos);
442         if (retval != size) {
443                 err = (retval < 0) ? retval : -EIO;
444                 goto out;
445         }
446
447         /* Success! */
448         err = 0;
449 out:
450         if (err) {
451                 kfree(elf_phdata);
452                 elf_phdata = NULL;
453         }
454         return elf_phdata;
455 }
456
457 #ifndef CONFIG_ARCH_BINFMT_ELF_STATE
458
459 /**
460  * struct arch_elf_state - arch-specific ELF loading state
461  *
462  * This structure is used to preserve architecture specific data during
463  * the loading of an ELF file, throughout the checking of architecture
464  * specific ELF headers & through to the point where the ELF load is
465  * known to be proceeding (ie. SET_PERSONALITY).
466  *
467  * This implementation is a dummy for architectures which require no
468  * specific state.
469  */
470 struct arch_elf_state {
471 };
472
473 #define INIT_ARCH_ELF_STATE {}
474
475 /**
476  * arch_elf_pt_proc() - check a PT_LOPROC..PT_HIPROC ELF program header
477  * @ehdr:       The main ELF header
478  * @phdr:       The program header to check
479  * @elf:        The open ELF file
480  * @is_interp:  True if the phdr is from the interpreter of the ELF being
481  *              loaded, else false.
482  * @state:      Architecture-specific state preserved throughout the process
483  *              of loading the ELF.
484  *
485  * Inspects the program header phdr to validate its correctness and/or
486  * suitability for the system. Called once per ELF program header in the
487  * range PT_LOPROC to PT_HIPROC, for both the ELF being loaded and its
488  * interpreter.
489  *
490  * Return: Zero to proceed with the ELF load, non-zero to fail the ELF load
491  *         with that return code.
492  */
493 static inline int arch_elf_pt_proc(struct elfhdr *ehdr,
494                                    struct elf_phdr *phdr,
495                                    struct file *elf, bool is_interp,
496                                    struct arch_elf_state *state)
497 {
498         /* Dummy implementation, always proceed */
499         return 0;
500 }
501
502 /**
503  * arch_check_elf() - check an ELF executable
504  * @ehdr:       The main ELF header
505  * @has_interp: True if the ELF has an interpreter, else false.
506  * @interp_ehdr: The interpreter's ELF header
507  * @state:      Architecture-specific state preserved throughout the process
508  *              of loading the ELF.
509  *
510  * Provides a final opportunity for architecture code to reject the loading
511  * of the ELF & cause an exec syscall to return an error. This is called after
512  * all program headers to be checked by arch_elf_pt_proc have been.
513  *
514  * Return: Zero to proceed with the ELF load, non-zero to fail the ELF load
515  *         with that return code.
516  */
517 static inline int arch_check_elf(struct elfhdr *ehdr, bool has_interp,
518                                  struct elfhdr *interp_ehdr,
519                                  struct arch_elf_state *state)
520 {
521         /* Dummy implementation, always proceed */
522         return 0;
523 }
524
525 #endif /* !CONFIG_ARCH_BINFMT_ELF_STATE */
526
527 /* This is much more generalized than the library routine read function,
528    so we keep this separate.  Technically the library read function
529    is only provided so that we can read a.out libraries that have
530    an ELF header */
531
532 static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
533                 struct file *interpreter, unsigned long *interp_map_addr,
534                 unsigned long no_base, struct elf_phdr *interp_elf_phdata)
535 {
536         struct elf_phdr *eppnt;
537         unsigned long load_addr = 0;
538         int load_addr_set = 0;
539         unsigned long last_bss = 0, elf_bss = 0;
540         int bss_prot = 0;
541         unsigned long error = ~0UL;
542         unsigned long total_size;
543         int i;
544
545         /* First of all, some simple consistency checks */
546         if (interp_elf_ex->e_type != ET_EXEC &&
547             interp_elf_ex->e_type != ET_DYN)
548                 goto out;
549         if (!elf_check_arch(interp_elf_ex) ||
550             elf_check_fdpic(interp_elf_ex))
551                 goto out;
552         if (!interpreter->f_op->mmap)
553                 goto out;
554
555         total_size = total_mapping_size(interp_elf_phdata,
556                                         interp_elf_ex->e_phnum);
557         if (!total_size) {
558                 error = -EINVAL;
559                 goto out;
560         }
561
562         eppnt = interp_elf_phdata;
563         for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
564                 if (eppnt->p_type == PT_LOAD) {
565                         int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
566                         int elf_prot = 0;
567                         unsigned long vaddr = 0;
568                         unsigned long k, map_addr;
569
570                         if (eppnt->p_flags & PF_R)
571                                 elf_prot = PROT_READ;
572                         if (eppnt->p_flags & PF_W)
573                                 elf_prot |= PROT_WRITE;
574                         if (eppnt->p_flags & PF_X)
575                                 elf_prot |= PROT_EXEC;
576                         vaddr = eppnt->p_vaddr;
577                         if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
578                                 elf_type |= MAP_FIXED_NOREPLACE;
579                         else if (no_base && interp_elf_ex->e_type == ET_DYN)
580                                 load_addr = -vaddr;
581
582                         map_addr = elf_map(interpreter, load_addr + vaddr,
583                                         eppnt, elf_prot, elf_type, total_size);
584                         total_size = 0;
585                         if (!*interp_map_addr)
586                                 *interp_map_addr = map_addr;
587                         error = map_addr;
588                         if (BAD_ADDR(map_addr))
589                                 goto out;
590
591                         if (!load_addr_set &&
592                             interp_elf_ex->e_type == ET_DYN) {
593                                 load_addr = map_addr - ELF_PAGESTART(vaddr);
594                                 load_addr_set = 1;
595                         }
596
597                         /*
598                          * Check to see if the section's size will overflow the
599                          * allowed task size. Note that p_filesz must always be
600                          * <= p_memsize so it's only necessary to check p_memsz.
601                          */
602                         k = load_addr + eppnt->p_vaddr;
603                         if (BAD_ADDR(k) ||
604                             eppnt->p_filesz > eppnt->p_memsz ||
605                             eppnt->p_memsz > TASK_SIZE ||
606                             TASK_SIZE - eppnt->p_memsz < k) {
607                                 error = -ENOMEM;
608                                 goto out;
609                         }
610
611                         /*
612                          * Find the end of the file mapping for this phdr, and
613                          * keep track of the largest address we see for this.
614                          */
615                         k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
616                         if (k > elf_bss)
617                                 elf_bss = k;
618
619                         /*
620                          * Do the same thing for the memory mapping - between
621                          * elf_bss and last_bss is the bss section.
622                          */
623                         k = load_addr + eppnt->p_vaddr + eppnt->p_memsz;
624                         if (k > last_bss) {
625                                 last_bss = k;
626                                 bss_prot = elf_prot;
627                         }
628                 }
629         }
630
631         /*
632          * Now fill out the bss section: first pad the last page from
633          * the file up to the page boundary, and zero it from elf_bss
634          * up to the end of the page.
635          */
636         if (padzero(elf_bss)) {
637                 error = -EFAULT;
638                 goto out;
639         }
640         /*
641          * Next, align both the file and mem bss up to the page size,
642          * since this is where elf_bss was just zeroed up to, and where
643          * last_bss will end after the vm_brk_flags() below.
644          */
645         elf_bss = ELF_PAGEALIGN(elf_bss);
646         last_bss = ELF_PAGEALIGN(last_bss);
647         /* Finally, if there is still more bss to allocate, do it. */
648         if (last_bss > elf_bss) {
649                 error = vm_brk_flags(elf_bss, last_bss - elf_bss,
650                                 bss_prot & PROT_EXEC ? VM_EXEC : 0);
651                 if (error)
652                         goto out;
653         }
654
655         error = load_addr;
656 out:
657         return error;
658 }
659
660 /*
661  * These are the functions used to load ELF style executables and shared
662  * libraries.  There is no binary dependent code anywhere else.
663  */
664
665 #ifndef STACK_RND_MASK
666 #define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12))     /* 8MB of VA */
667 #endif
668
669 static unsigned long randomize_stack_top(unsigned long stack_top)
670 {
671         unsigned long random_variable = 0;
672
673         if (current->flags & PF_RANDOMIZE) {
674                 random_variable = get_random_long();
675                 random_variable &= STACK_RND_MASK;
676                 random_variable <<= PAGE_SHIFT;
677         }
678 #ifdef CONFIG_STACK_GROWSUP
679         return PAGE_ALIGN(stack_top) + random_variable;
680 #else
681         return PAGE_ALIGN(stack_top) - random_variable;
682 #endif
683 }
684
685 static int load_elf_binary(struct linux_binprm *bprm)
686 {
687         struct file *interpreter = NULL; /* to shut gcc up */
688         unsigned long load_addr = 0, load_bias = 0;
689         int load_addr_set = 0;
690         unsigned long error;
691         struct elf_phdr *elf_ppnt, *elf_phdata, *interp_elf_phdata = NULL;
692         unsigned long elf_bss, elf_brk;
693         int bss_prot = 0;
694         int retval, i;
695         unsigned long elf_entry;
696         unsigned long interp_load_addr = 0;
697         unsigned long start_code, end_code, start_data, end_data;
698         unsigned long reloc_func_desc __maybe_unused = 0;
699         int executable_stack = EXSTACK_DEFAULT;
700         struct pt_regs *regs = current_pt_regs();
701         struct {
702                 struct elfhdr elf_ex;
703                 struct elfhdr interp_elf_ex;
704         } *loc;
705         struct arch_elf_state arch_state = INIT_ARCH_ELF_STATE;
706
707         loc = kmalloc(sizeof(*loc), GFP_KERNEL);
708         if (!loc) {
709                 retval = -ENOMEM;
710                 goto out_ret;
711         }
712         
713         /* Get the exec-header */
714         loc->elf_ex = *((struct elfhdr *)bprm->buf);
715
716         retval = -ENOEXEC;
717         /* First of all, some simple consistency checks */
718         if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
719                 goto out;
720
721         if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
722                 goto out;
723         if (!elf_check_arch(&loc->elf_ex))
724                 goto out;
725         if (elf_check_fdpic(&loc->elf_ex))
726                 goto out;
727         if (!bprm->file->f_op->mmap)
728                 goto out;
729
730         elf_phdata = load_elf_phdrs(&loc->elf_ex, bprm->file);
731         if (!elf_phdata)
732                 goto out;
733
734         elf_ppnt = elf_phdata;
735         elf_bss = 0;
736         elf_brk = 0;
737
738         start_code = ~0UL;
739         end_code = 0;
740         start_data = 0;
741         end_data = 0;
742
743         for (i = 0; i < loc->elf_ex.e_phnum; i++) {
744                 if (elf_ppnt->p_type == PT_INTERP) {
745                         char *elf_interpreter;
746                         loff_t pos;
747
748                         /* This is the program interpreter used for
749                          * shared libraries - for now assume that this
750                          * is an a.out format binary
751                          */
752                         retval = -ENOEXEC;
753                         if (elf_ppnt->p_filesz > PATH_MAX || 
754                             elf_ppnt->p_filesz < 2)
755                                 goto out_free_ph;
756
757                         retval = -ENOMEM;
758                         elf_interpreter = kmalloc(elf_ppnt->p_filesz,
759                                                   GFP_KERNEL);
760                         if (!elf_interpreter)
761                                 goto out_free_ph;
762
763                         pos = elf_ppnt->p_offset;
764                         retval = kernel_read(bprm->file, elf_interpreter,
765                                              elf_ppnt->p_filesz, &pos);
766                         if (retval != elf_ppnt->p_filesz) {
767                                 if (retval >= 0)
768                                         retval = -EIO;
769                                 goto out_free_interp;
770                         }
771                         /* make sure path is NULL terminated */
772                         retval = -ENOEXEC;
773                         if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
774                                 goto out_free_interp;
775
776                         interpreter = open_exec(elf_interpreter);
777                         kfree(elf_interpreter);
778                         retval = PTR_ERR(interpreter);
779                         if (IS_ERR(interpreter))
780                                 goto out_free_ph;
781
782                         /*
783                          * If the binary is not readable then enforce
784                          * mm->dumpable = 0 regardless of the interpreter's
785                          * permissions.
786                          */
787                         would_dump(bprm, interpreter);
788
789                         /* Get the exec headers */
790                         pos = 0;
791                         retval = kernel_read(interpreter, &loc->interp_elf_ex,
792                                              sizeof(loc->interp_elf_ex), &pos);
793                         if (retval != sizeof(loc->interp_elf_ex)) {
794                                 if (retval >= 0)
795                                         retval = -EIO;
796                                 goto out_free_dentry;
797                         }
798
799                         break;
800
801 out_free_interp:
802                         kfree(elf_interpreter);
803                         goto out_free_ph;
804                 }
805                 elf_ppnt++;
806         }
807
808         elf_ppnt = elf_phdata;
809         for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
810                 switch (elf_ppnt->p_type) {
811                 case PT_GNU_STACK:
812                         if (elf_ppnt->p_flags & PF_X)
813                                 executable_stack = EXSTACK_ENABLE_X;
814                         else
815                                 executable_stack = EXSTACK_DISABLE_X;
816                         break;
817
818                 case PT_LOPROC ... PT_HIPROC:
819                         retval = arch_elf_pt_proc(&loc->elf_ex, elf_ppnt,
820                                                   bprm->file, false,
821                                                   &arch_state);
822                         if (retval)
823                                 goto out_free_dentry;
824                         break;
825                 }
826
827         /* Some simple consistency checks for the interpreter */
828         if (interpreter) {
829                 retval = -ELIBBAD;
830                 /* Not an ELF interpreter */
831                 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
832                         goto out_free_dentry;
833                 /* Verify the interpreter has a valid arch */
834                 if (!elf_check_arch(&loc->interp_elf_ex) ||
835                     elf_check_fdpic(&loc->interp_elf_ex))
836                         goto out_free_dentry;
837
838                 /* Load the interpreter program headers */
839                 interp_elf_phdata = load_elf_phdrs(&loc->interp_elf_ex,
840                                                    interpreter);
841                 if (!interp_elf_phdata)
842                         goto out_free_dentry;
843
844                 /* Pass PT_LOPROC..PT_HIPROC headers to arch code */
845                 elf_ppnt = interp_elf_phdata;
846                 for (i = 0; i < loc->interp_elf_ex.e_phnum; i++, elf_ppnt++)
847                         switch (elf_ppnt->p_type) {
848                         case PT_LOPROC ... PT_HIPROC:
849                                 retval = arch_elf_pt_proc(&loc->interp_elf_ex,
850                                                           elf_ppnt, interpreter,
851                                                           true, &arch_state);
852                                 if (retval)
853                                         goto out_free_dentry;
854                                 break;
855                         }
856         }
857
858         /*
859          * Allow arch code to reject the ELF at this point, whilst it's
860          * still possible to return an error to the code that invoked
861          * the exec syscall.
862          */
863         retval = arch_check_elf(&loc->elf_ex,
864                                 !!interpreter, &loc->interp_elf_ex,
865                                 &arch_state);
866         if (retval)
867                 goto out_free_dentry;
868
869         /* Flush all traces of the currently running executable */
870         retval = flush_old_exec(bprm);
871         if (retval)
872                 goto out_free_dentry;
873
874         /* Do this immediately, since STACK_TOP as used in setup_arg_pages
875            may depend on the personality.  */
876         SET_PERSONALITY2(loc->elf_ex, &arch_state);
877         if (elf_read_implies_exec(loc->elf_ex, executable_stack))
878                 current->personality |= READ_IMPLIES_EXEC;
879
880         if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
881                 current->flags |= PF_RANDOMIZE;
882
883         setup_new_exec(bprm);
884         install_exec_creds(bprm);
885
886         /* Do this so that we can load the interpreter, if need be.  We will
887            change some of these later */
888         retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
889                                  executable_stack);
890         if (retval < 0)
891                 goto out_free_dentry;
892         
893         /* Now we do a little grungy work by mmapping the ELF image into
894            the correct location in memory. */
895         for(i = 0, elf_ppnt = elf_phdata;
896             i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
897                 int elf_prot = 0, elf_flags, elf_fixed = MAP_FIXED_NOREPLACE;
898                 unsigned long k, vaddr;
899                 unsigned long total_size = 0;
900
901                 if (elf_ppnt->p_type != PT_LOAD)
902                         continue;
903
904                 if (unlikely (elf_brk > elf_bss)) {
905                         unsigned long nbyte;
906                     
907                         /* There was a PT_LOAD segment with p_memsz > p_filesz
908                            before this one. Map anonymous pages, if needed,
909                            and clear the area.  */
910                         retval = set_brk(elf_bss + load_bias,
911                                          elf_brk + load_bias,
912                                          bss_prot);
913                         if (retval)
914                                 goto out_free_dentry;
915                         nbyte = ELF_PAGEOFFSET(elf_bss);
916                         if (nbyte) {
917                                 nbyte = ELF_MIN_ALIGN - nbyte;
918                                 if (nbyte > elf_brk - elf_bss)
919                                         nbyte = elf_brk - elf_bss;
920                                 if (clear_user((void __user *)elf_bss +
921                                                         load_bias, nbyte)) {
922                                         /*
923                                          * This bss-zeroing can fail if the ELF
924                                          * file specifies odd protections. So
925                                          * we don't check the return value
926                                          */
927                                 }
928                         }
929
930                         /*
931                          * Some binaries have overlapping elf segments and then
932                          * we have to forcefully map over an existing mapping
933                          * e.g. over this newly established brk mapping.
934                          */
935                         elf_fixed = MAP_FIXED;
936                 }
937
938                 if (elf_ppnt->p_flags & PF_R)
939                         elf_prot |= PROT_READ;
940                 if (elf_ppnt->p_flags & PF_W)
941                         elf_prot |= PROT_WRITE;
942                 if (elf_ppnt->p_flags & PF_X)
943                         elf_prot |= PROT_EXEC;
944
945                 elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
946
947                 vaddr = elf_ppnt->p_vaddr;
948                 /*
949                  * If we are loading ET_EXEC or we have already performed
950                  * the ET_DYN load_addr calculations, proceed normally.
951                  */
952                 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
953                         elf_flags |= elf_fixed;
954                 } else if (loc->elf_ex.e_type == ET_DYN) {
955                         /*
956                          * This logic is run once for the first LOAD Program
957                          * Header for ET_DYN binaries to calculate the
958                          * randomization (load_bias) for all the LOAD
959                          * Program Headers, and to calculate the entire
960                          * size of the ELF mapping (total_size). (Note that
961                          * load_addr_set is set to true later once the
962                          * initial mapping is performed.)
963                          *
964                          * There are effectively two types of ET_DYN
965                          * binaries: programs (i.e. PIE: ET_DYN with INTERP)
966                          * and loaders (ET_DYN without INTERP, since they
967                          * _are_ the ELF interpreter). The loaders must
968                          * be loaded away from programs since the program
969                          * may otherwise collide with the loader (especially
970                          * for ET_EXEC which does not have a randomized
971                          * position). For example to handle invocations of
972                          * "./ld.so someprog" to test out a new version of
973                          * the loader, the subsequent program that the
974                          * loader loads must avoid the loader itself, so
975                          * they cannot share the same load range. Sufficient
976                          * room for the brk must be allocated with the
977                          * loader as well, since brk must be available with
978                          * the loader.
979                          *
980                          * Therefore, programs are loaded offset from
981                          * ELF_ET_DYN_BASE and loaders are loaded into the
982                          * independently randomized mmap region (0 load_bias
983                          * without MAP_FIXED).
984                          */
985                         if (interpreter) {
986                                 load_bias = ELF_ET_DYN_BASE;
987                                 if (current->flags & PF_RANDOMIZE)
988                                         load_bias += arch_mmap_rnd();
989                                 elf_flags |= elf_fixed;
990                         } else
991                                 load_bias = 0;
992
993                         /*
994                          * Since load_bias is used for all subsequent loading
995                          * calculations, we must lower it by the first vaddr
996                          * so that the remaining calculations based on the
997                          * ELF vaddrs will be correctly offset. The result
998                          * is then page aligned.
999                          */
1000                         load_bias = ELF_PAGESTART(load_bias - vaddr);
1001
1002                         total_size = total_mapping_size(elf_phdata,
1003                                                         loc->elf_ex.e_phnum);
1004                         if (!total_size) {
1005                                 retval = -EINVAL;
1006                                 goto out_free_dentry;
1007                         }
1008                 }
1009
1010                 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
1011                                 elf_prot, elf_flags, total_size);
1012                 if (BAD_ADDR(error)) {
1013                         retval = IS_ERR((void *)error) ?
1014                                 PTR_ERR((void*)error) : -EINVAL;
1015                         goto out_free_dentry;
1016                 }
1017
1018                 if (!load_addr_set) {
1019                         load_addr_set = 1;
1020                         load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
1021                         if (loc->elf_ex.e_type == ET_DYN) {
1022                                 load_bias += error -
1023                                              ELF_PAGESTART(load_bias + vaddr);
1024                                 load_addr += load_bias;
1025                                 reloc_func_desc = load_bias;
1026                         }
1027                 }
1028                 k = elf_ppnt->p_vaddr;
1029                 if (k < start_code)
1030                         start_code = k;
1031                 if (start_data < k)
1032                         start_data = k;
1033
1034                 /*
1035                  * Check to see if the section's size will overflow the
1036                  * allowed task size. Note that p_filesz must always be
1037                  * <= p_memsz so it is only necessary to check p_memsz.
1038                  */
1039                 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
1040                     elf_ppnt->p_memsz > TASK_SIZE ||
1041                     TASK_SIZE - elf_ppnt->p_memsz < k) {
1042                         /* set_brk can never work. Avoid overflows. */
1043                         retval = -EINVAL;
1044                         goto out_free_dentry;
1045                 }
1046
1047                 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
1048
1049                 if (k > elf_bss)
1050                         elf_bss = k;
1051                 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
1052                         end_code = k;
1053                 if (end_data < k)
1054                         end_data = k;
1055                 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
1056                 if (k > elf_brk) {
1057                         bss_prot = elf_prot;
1058                         elf_brk = k;
1059                 }
1060         }
1061
1062         loc->elf_ex.e_entry += load_bias;
1063         elf_bss += load_bias;
1064         elf_brk += load_bias;
1065         start_code += load_bias;
1066         end_code += load_bias;
1067         start_data += load_bias;
1068         end_data += load_bias;
1069
1070         /* Calling set_brk effectively mmaps the pages that we need
1071          * for the bss and break sections.  We must do this before
1072          * mapping in the interpreter, to make sure it doesn't wind
1073          * up getting placed where the bss needs to go.
1074          */
1075         retval = set_brk(elf_bss, elf_brk, bss_prot);
1076         if (retval)
1077                 goto out_free_dentry;
1078         if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
1079                 retval = -EFAULT; /* Nobody gets to see this, but.. */
1080                 goto out_free_dentry;
1081         }
1082
1083         if (interpreter) {
1084                 unsigned long interp_map_addr = 0;
1085
1086                 elf_entry = load_elf_interp(&loc->interp_elf_ex,
1087                                             interpreter,
1088                                             &interp_map_addr,
1089                                             load_bias, interp_elf_phdata);
1090                 if (!IS_ERR((void *)elf_entry)) {
1091                         /*
1092                          * load_elf_interp() returns relocation
1093                          * adjustment
1094                          */
1095                         interp_load_addr = elf_entry;
1096                         elf_entry += loc->interp_elf_ex.e_entry;
1097                 }
1098                 if (BAD_ADDR(elf_entry)) {
1099                         retval = IS_ERR((void *)elf_entry) ?
1100                                         (int)elf_entry : -EINVAL;
1101                         goto out_free_dentry;
1102                 }
1103                 reloc_func_desc = interp_load_addr;
1104
1105                 allow_write_access(interpreter);
1106                 fput(interpreter);
1107         } else {
1108                 elf_entry = loc->elf_ex.e_entry;
1109                 if (BAD_ADDR(elf_entry)) {
1110                         retval = -EINVAL;
1111                         goto out_free_dentry;
1112                 }
1113         }
1114
1115         kfree(interp_elf_phdata);
1116         kfree(elf_phdata);
1117
1118         set_binfmt(&elf_format);
1119
1120 #ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
1121         retval = arch_setup_additional_pages(bprm, !!interpreter);
1122         if (retval < 0)
1123                 goto out;
1124 #endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
1125
1126         retval = create_elf_tables(bprm, &loc->elf_ex,
1127                           load_addr, interp_load_addr);
1128         if (retval < 0)
1129                 goto out;
1130         /* N.B. passed_fileno might not be initialized? */
1131         current->mm->end_code = end_code;
1132         current->mm->start_code = start_code;
1133         current->mm->start_data = start_data;
1134         current->mm->end_data = end_data;
1135         current->mm->start_stack = bprm->p;
1136
1137         if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
1138                 current->mm->brk = current->mm->start_brk =
1139                         arch_randomize_brk(current->mm);
1140 #ifdef compat_brk_randomized
1141                 current->brk_randomized = 1;
1142 #endif
1143         }
1144
1145         if (current->personality & MMAP_PAGE_ZERO) {
1146                 /* Why this, you ask???  Well SVr4 maps page 0 as read-only,
1147                    and some applications "depend" upon this behavior.
1148                    Since we do not have the power to recompile these, we
1149                    emulate the SVr4 behavior. Sigh. */
1150                 error = vm_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
1151                                 MAP_FIXED | MAP_PRIVATE, 0);
1152         }
1153
1154 #ifdef ELF_PLAT_INIT
1155         /*
1156          * The ABI may specify that certain registers be set up in special
1157          * ways (on i386 %edx is the address of a DT_FINI function, for
1158          * example.  In addition, it may also specify (eg, PowerPC64 ELF)
1159          * that the e_entry field is the address of the function descriptor
1160          * for the startup routine, rather than the address of the startup
1161          * routine itself.  This macro performs whatever initialization to
1162          * the regs structure is required as well as any relocations to the
1163          * function descriptor entries when executing dynamically links apps.
1164          */
1165         ELF_PLAT_INIT(regs, reloc_func_desc);
1166 #endif
1167
1168         finalize_exec(bprm);
1169         start_thread(regs, elf_entry, bprm->p);
1170         retval = 0;
1171 out:
1172         kfree(loc);
1173 out_ret:
1174         return retval;
1175
1176         /* error cleanup */
1177 out_free_dentry:
1178         kfree(interp_elf_phdata);
1179         allow_write_access(interpreter);
1180         if (interpreter)
1181                 fput(interpreter);
1182 out_free_ph:
1183         kfree(elf_phdata);
1184         goto out;
1185 }
1186
1187 #ifdef CONFIG_USELIB
1188 /* This is really simpleminded and specialized - we are loading an
1189    a.out library that is given an ELF header. */
1190 static int load_elf_library(struct file *file)
1191 {
1192         struct elf_phdr *elf_phdata;
1193         struct elf_phdr *eppnt;
1194         unsigned long elf_bss, bss, len;
1195         int retval, error, i, j;
1196         struct elfhdr elf_ex;
1197         loff_t pos = 0;
1198
1199         error = -ENOEXEC;
1200         retval = kernel_read(file, &elf_ex, sizeof(elf_ex), &pos);
1201         if (retval != sizeof(elf_ex))
1202                 goto out;
1203
1204         if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1205                 goto out;
1206
1207         /* First of all, some simple consistency checks */
1208         if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
1209             !elf_check_arch(&elf_ex) || !file->f_op->mmap)
1210                 goto out;
1211         if (elf_check_fdpic(&elf_ex))
1212                 goto out;
1213
1214         /* Now read in all of the header information */
1215
1216         j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1217         /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1218
1219         error = -ENOMEM;
1220         elf_phdata = kmalloc(j, GFP_KERNEL);
1221         if (!elf_phdata)
1222                 goto out;
1223
1224         eppnt = elf_phdata;
1225         error = -ENOEXEC;
1226         pos =  elf_ex.e_phoff;
1227         retval = kernel_read(file, eppnt, j, &pos);
1228         if (retval != j)
1229                 goto out_free_ph;
1230
1231         for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1232                 if ((eppnt + i)->p_type == PT_LOAD)
1233                         j++;
1234         if (j != 1)
1235                 goto out_free_ph;
1236
1237         while (eppnt->p_type != PT_LOAD)
1238                 eppnt++;
1239
1240         /* Now use mmap to map the library into memory. */
1241         error = vm_mmap(file,
1242                         ELF_PAGESTART(eppnt->p_vaddr),
1243                         (eppnt->p_filesz +
1244                          ELF_PAGEOFFSET(eppnt->p_vaddr)),
1245                         PROT_READ | PROT_WRITE | PROT_EXEC,
1246                         MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_DENYWRITE,
1247                         (eppnt->p_offset -
1248                          ELF_PAGEOFFSET(eppnt->p_vaddr)));
1249         if (error != ELF_PAGESTART(eppnt->p_vaddr))
1250                 goto out_free_ph;
1251
1252         elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1253         if (padzero(elf_bss)) {
1254                 error = -EFAULT;
1255                 goto out_free_ph;
1256         }
1257
1258         len = ELF_PAGEALIGN(eppnt->p_filesz + eppnt->p_vaddr);
1259         bss = ELF_PAGEALIGN(eppnt->p_memsz + eppnt->p_vaddr);
1260         if (bss > len) {
1261                 error = vm_brk(len, bss - len);
1262                 if (error)
1263                         goto out_free_ph;
1264         }
1265         error = 0;
1266
1267 out_free_ph:
1268         kfree(elf_phdata);
1269 out:
1270         return error;
1271 }
1272 #endif /* #ifdef CONFIG_USELIB */
1273
1274 #ifdef CONFIG_ELF_CORE
1275 /*
1276  * ELF core dumper
1277  *
1278  * Modelled on fs/exec.c:aout_core_dump()
1279  * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1280  */
1281
1282 /*
1283  * The purpose of always_dump_vma() is to make sure that special kernel mappings
1284  * that are useful for post-mortem analysis are included in every core dump.
1285  * In that way we ensure that the core dump is fully interpretable later
1286  * without matching up the same kernel and hardware config to see what PC values
1287  * meant. These special mappings include - vDSO, vsyscall, and other
1288  * architecture specific mappings
1289  */
1290 static bool always_dump_vma(struct vm_area_struct *vma)
1291 {
1292         /* Any vsyscall mappings? */
1293         if (vma == get_gate_vma(vma->vm_mm))
1294                 return true;
1295
1296         /*
1297          * Assume that all vmas with a .name op should always be dumped.
1298          * If this changes, a new vm_ops field can easily be added.
1299          */
1300         if (vma->vm_ops && vma->vm_ops->name && vma->vm_ops->name(vma))
1301                 return true;
1302
1303         /*
1304          * arch_vma_name() returns non-NULL for special architecture mappings,
1305          * such as vDSO sections.
1306          */
1307         if (arch_vma_name(vma))
1308                 return true;
1309
1310         return false;
1311 }
1312
1313 /*
1314  * Decide what to dump of a segment, part, all or none.
1315  */
1316 static unsigned long vma_dump_size(struct vm_area_struct *vma,
1317                                    unsigned long mm_flags)
1318 {
1319 #define FILTER(type)    (mm_flags & (1UL << MMF_DUMP_##type))
1320
1321         /* always dump the vdso and vsyscall sections */
1322         if (always_dump_vma(vma))
1323                 goto whole;
1324
1325         if (vma->vm_flags & VM_DONTDUMP)
1326                 return 0;
1327
1328         /* support for DAX */
1329         if (vma_is_dax(vma)) {
1330                 if ((vma->vm_flags & VM_SHARED) && FILTER(DAX_SHARED))
1331                         goto whole;
1332                 if (!(vma->vm_flags & VM_SHARED) && FILTER(DAX_PRIVATE))
1333                         goto whole;
1334                 return 0;
1335         }
1336
1337         /* Hugetlb memory check */
1338         if (vma->vm_flags & VM_HUGETLB) {
1339                 if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))
1340                         goto whole;
1341                 if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))
1342                         goto whole;
1343                 return 0;
1344         }
1345
1346         /* Do not dump I/O mapped devices or special mappings */
1347         if (vma->vm_flags & VM_IO)
1348                 return 0;
1349
1350         /* By default, dump shared memory if mapped from an anonymous file. */
1351         if (vma->vm_flags & VM_SHARED) {
1352                 if (file_inode(vma->vm_file)->i_nlink == 0 ?
1353                     FILTER(ANON_SHARED) : FILTER(MAPPED_SHARED))
1354                         goto whole;
1355                 return 0;
1356         }
1357
1358         /* Dump segments that have been written to.  */
1359         if (vma->anon_vma && FILTER(ANON_PRIVATE))
1360                 goto whole;
1361         if (vma->vm_file == NULL)
1362                 return 0;
1363
1364         if (FILTER(MAPPED_PRIVATE))
1365                 goto whole;
1366
1367         /*
1368          * If this looks like the beginning of a DSO or executable mapping,
1369          * check for an ELF header.  If we find one, dump the first page to
1370          * aid in determining what was mapped here.
1371          */
1372         if (FILTER(ELF_HEADERS) &&
1373             vma->vm_pgoff == 0 && (vma->vm_flags & VM_READ)) {
1374                 u32 __user *header = (u32 __user *) vma->vm_start;
1375                 u32 word;
1376                 mm_segment_t fs = get_fs();
1377                 /*
1378                  * Doing it this way gets the constant folded by GCC.
1379                  */
1380                 union {
1381                         u32 cmp;
1382                         char elfmag[SELFMAG];
1383                 } magic;
1384                 BUILD_BUG_ON(SELFMAG != sizeof word);
1385                 magic.elfmag[EI_MAG0] = ELFMAG0;
1386                 magic.elfmag[EI_MAG1] = ELFMAG1;
1387                 magic.elfmag[EI_MAG2] = ELFMAG2;
1388                 magic.elfmag[EI_MAG3] = ELFMAG3;
1389                 /*
1390                  * Switch to the user "segment" for get_user(),
1391                  * then put back what elf_core_dump() had in place.
1392                  */
1393                 set_fs(USER_DS);
1394                 if (unlikely(get_user(word, header)))
1395                         word = 0;
1396                 set_fs(fs);
1397                 if (word == magic.cmp)
1398                         return PAGE_SIZE;
1399         }
1400
1401 #undef  FILTER
1402
1403         return 0;
1404
1405 whole:
1406         return vma->vm_end - vma->vm_start;
1407 }
1408
1409 /* An ELF note in memory */
1410 struct memelfnote
1411 {
1412         const char *name;
1413         int type;
1414         unsigned int datasz;
1415         void *data;
1416 };
1417
1418 static int notesize(struct memelfnote *en)
1419 {
1420         int sz;
1421
1422         sz = sizeof(struct elf_note);
1423         sz += roundup(strlen(en->name) + 1, 4);
1424         sz += roundup(en->datasz, 4);
1425
1426         return sz;
1427 }
1428
1429 static int writenote(struct memelfnote *men, struct coredump_params *cprm)
1430 {
1431         struct elf_note en;
1432         en.n_namesz = strlen(men->name) + 1;
1433         en.n_descsz = men->datasz;
1434         en.n_type = men->type;
1435
1436         return dump_emit(cprm, &en, sizeof(en)) &&
1437             dump_emit(cprm, men->name, en.n_namesz) && dump_align(cprm, 4) &&
1438             dump_emit(cprm, men->data, men->datasz) && dump_align(cprm, 4);
1439 }
1440
1441 static void fill_elf_header(struct elfhdr *elf, int segs,
1442                             u16 machine, u32 flags)
1443 {
1444         memset(elf, 0, sizeof(*elf));
1445
1446         memcpy(elf->e_ident, ELFMAG, SELFMAG);
1447         elf->e_ident[EI_CLASS] = ELF_CLASS;
1448         elf->e_ident[EI_DATA] = ELF_DATA;
1449         elf->e_ident[EI_VERSION] = EV_CURRENT;
1450         elf->e_ident[EI_OSABI] = ELF_OSABI;
1451
1452         elf->e_type = ET_CORE;
1453         elf->e_machine = machine;
1454         elf->e_version = EV_CURRENT;
1455         elf->e_phoff = sizeof(struct elfhdr);
1456         elf->e_flags = flags;
1457         elf->e_ehsize = sizeof(struct elfhdr);
1458         elf->e_phentsize = sizeof(struct elf_phdr);
1459         elf->e_phnum = segs;
1460
1461         return;
1462 }
1463
1464 static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
1465 {
1466         phdr->p_type = PT_NOTE;
1467         phdr->p_offset = offset;
1468         phdr->p_vaddr = 0;
1469         phdr->p_paddr = 0;
1470         phdr->p_filesz = sz;
1471         phdr->p_memsz = 0;
1472         phdr->p_flags = 0;
1473         phdr->p_align = 0;
1474         return;
1475 }
1476
1477 static void fill_note(struct memelfnote *note, const char *name, int type, 
1478                 unsigned int sz, void *data)
1479 {
1480         note->name = name;
1481         note->type = type;
1482         note->datasz = sz;
1483         note->data = data;
1484         return;
1485 }
1486
1487 /*
1488  * fill up all the fields in prstatus from the given task struct, except
1489  * registers which need to be filled up separately.
1490  */
1491 static void fill_prstatus(struct elf_prstatus *prstatus,
1492                 struct task_struct *p, long signr)
1493 {
1494         prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1495         prstatus->pr_sigpend = p->pending.signal.sig[0];
1496         prstatus->pr_sighold = p->blocked.sig[0];
1497         rcu_read_lock();
1498         prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1499         rcu_read_unlock();
1500         prstatus->pr_pid = task_pid_vnr(p);
1501         prstatus->pr_pgrp = task_pgrp_vnr(p);
1502         prstatus->pr_sid = task_session_vnr(p);
1503         if (thread_group_leader(p)) {
1504                 struct task_cputime cputime;
1505
1506                 /*
1507                  * This is the record for the group leader.  It shows the
1508                  * group-wide total, not its individual thread total.
1509                  */
1510                 thread_group_cputime(p, &cputime);
1511                 prstatus->pr_utime = ns_to_timeval(cputime.utime);
1512                 prstatus->pr_stime = ns_to_timeval(cputime.stime);
1513         } else {
1514                 u64 utime, stime;
1515
1516                 task_cputime(p, &utime, &stime);
1517                 prstatus->pr_utime = ns_to_timeval(utime);
1518                 prstatus->pr_stime = ns_to_timeval(stime);
1519         }
1520
1521         prstatus->pr_cutime = ns_to_timeval(p->signal->cutime);
1522         prstatus->pr_cstime = ns_to_timeval(p->signal->cstime);
1523 }
1524
1525 static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1526                        struct mm_struct *mm)
1527 {
1528         const struct cred *cred;
1529         unsigned int i, len;
1530         
1531         /* first copy the parameters from user space */
1532         memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1533
1534         len = mm->arg_end - mm->arg_start;
1535         if (len >= ELF_PRARGSZ)
1536                 len = ELF_PRARGSZ-1;
1537         if (copy_from_user(&psinfo->pr_psargs,
1538                            (const char __user *)mm->arg_start, len))
1539                 return -EFAULT;
1540         for(i = 0; i < len; i++)
1541                 if (psinfo->pr_psargs[i] == 0)
1542                         psinfo->pr_psargs[i] = ' ';
1543         psinfo->pr_psargs[len] = 0;
1544
1545         rcu_read_lock();
1546         psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1547         rcu_read_unlock();
1548         psinfo->pr_pid = task_pid_vnr(p);
1549         psinfo->pr_pgrp = task_pgrp_vnr(p);
1550         psinfo->pr_sid = task_session_vnr(p);
1551
1552         i = p->state ? ffz(~p->state) + 1 : 0;
1553         psinfo->pr_state = i;
1554         psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
1555         psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1556         psinfo->pr_nice = task_nice(p);
1557         psinfo->pr_flag = p->flags;
1558         rcu_read_lock();
1559         cred = __task_cred(p);
1560         SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
1561         SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
1562         rcu_read_unlock();
1563         strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1564         
1565         return 0;
1566 }
1567
1568 static void fill_auxv_note(struct memelfnote *note, struct mm_struct *mm)
1569 {
1570         elf_addr_t *auxv = (elf_addr_t *) mm->saved_auxv;
1571         int i = 0;
1572         do
1573                 i += 2;
1574         while (auxv[i - 2] != AT_NULL);
1575         fill_note(note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);
1576 }
1577
1578 static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,
1579                 const kernel_siginfo_t *siginfo)
1580 {
1581         mm_segment_t old_fs = get_fs();
1582         set_fs(KERNEL_DS);
1583         copy_siginfo_to_user((user_siginfo_t __user *) csigdata, siginfo);
1584         set_fs(old_fs);
1585         fill_note(note, "CORE", NT_SIGINFO, sizeof(*csigdata), csigdata);
1586 }
1587
1588 #define MAX_FILE_NOTE_SIZE (4*1024*1024)
1589 /*
1590  * Format of NT_FILE note:
1591  *
1592  * long count     -- how many files are mapped
1593  * long page_size -- units for file_ofs
1594  * array of [COUNT] elements of
1595  *   long start
1596  *   long end
1597  *   long file_ofs
1598  * followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1599  */
1600 static int fill_files_note(struct memelfnote *note)
1601 {
1602         struct vm_area_struct *vma;
1603         unsigned count, size, names_ofs, remaining, n;
1604         user_long_t *data;
1605         user_long_t *start_end_ofs;
1606         char *name_base, *name_curpos;
1607
1608         /* *Estimated* file count and total data size needed */
1609         count = current->mm->map_count;
1610         if (count > UINT_MAX / 64)
1611                 return -EINVAL;
1612         size = count * 64;
1613
1614         names_ofs = (2 + 3 * count) * sizeof(data[0]);
1615  alloc:
1616         if (size >= MAX_FILE_NOTE_SIZE) /* paranoia check */
1617                 return -EINVAL;
1618         size = round_up(size, PAGE_SIZE);
1619         data = kvmalloc(size, GFP_KERNEL);
1620         if (ZERO_OR_NULL_PTR(data))
1621                 return -ENOMEM;
1622
1623         start_end_ofs = data + 2;
1624         name_base = name_curpos = ((char *)data) + names_ofs;
1625         remaining = size - names_ofs;
1626         count = 0;
1627         for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1628                 struct file *file;
1629                 const char *filename;
1630
1631                 file = vma->vm_file;
1632                 if (!file)
1633                         continue;
1634                 filename = file_path(file, name_curpos, remaining);
1635                 if (IS_ERR(filename)) {
1636                         if (PTR_ERR(filename) == -ENAMETOOLONG) {
1637                                 kvfree(data);
1638                                 size = size * 5 / 4;
1639                                 goto alloc;
1640                         }
1641                         continue;
1642                 }
1643
1644                 /* file_path() fills at the end, move name down */
1645                 /* n = strlen(filename) + 1: */
1646                 n = (name_curpos + remaining) - filename;
1647                 remaining = filename - name_curpos;
1648                 memmove(name_curpos, filename, n);
1649                 name_curpos += n;
1650
1651                 *start_end_ofs++ = vma->vm_start;
1652                 *start_end_ofs++ = vma->vm_end;
1653                 *start_end_ofs++ = vma->vm_pgoff;
1654                 count++;
1655         }
1656
1657         /* Now we know exact count of files, can store it */
1658         data[0] = count;
1659         data[1] = PAGE_SIZE;
1660         /*
1661          * Count usually is less than current->mm->map_count,
1662          * we need to move filenames down.
1663          */
1664         n = current->mm->map_count - count;
1665         if (n != 0) {
1666                 unsigned shift_bytes = n * 3 * sizeof(data[0]);
1667                 memmove(name_base - shift_bytes, name_base,
1668                         name_curpos - name_base);
1669                 name_curpos -= shift_bytes;
1670         }
1671
1672         size = name_curpos - (char *)data;
1673         fill_note(note, "CORE", NT_FILE, size, data);
1674         return 0;
1675 }
1676
1677 #ifdef CORE_DUMP_USE_REGSET
1678 #include <linux/regset.h>
1679
1680 struct elf_thread_core_info {
1681         struct elf_thread_core_info *next;
1682         struct task_struct *task;
1683         struct elf_prstatus prstatus;
1684         struct memelfnote notes[0];
1685 };
1686
1687 struct elf_note_info {
1688         struct elf_thread_core_info *thread;
1689         struct memelfnote psinfo;
1690         struct memelfnote signote;
1691         struct memelfnote auxv;
1692         struct memelfnote files;
1693         user_siginfo_t csigdata;
1694         size_t size;
1695         int thread_notes;
1696 };
1697
1698 /*
1699  * When a regset has a writeback hook, we call it on each thread before
1700  * dumping user memory.  On register window machines, this makes sure the
1701  * user memory backing the register data is up to date before we read it.
1702  */
1703 static void do_thread_regset_writeback(struct task_struct *task,
1704                                        const struct user_regset *regset)
1705 {
1706         if (regset->writeback)
1707                 regset->writeback(task, regset, 1);
1708 }
1709
1710 #ifndef PRSTATUS_SIZE
1711 #define PRSTATUS_SIZE(S, R) sizeof(S)
1712 #endif
1713
1714 #ifndef SET_PR_FPVALID
1715 #define SET_PR_FPVALID(S, V, R) ((S)->pr_fpvalid = (V))
1716 #endif
1717
1718 static int fill_thread_core_info(struct elf_thread_core_info *t,
1719                                  const struct user_regset_view *view,
1720                                  long signr, size_t *total)
1721 {
1722         unsigned int i;
1723         unsigned int regset0_size = regset_size(t->task, &view->regsets[0]);
1724
1725         /*
1726          * NT_PRSTATUS is the one special case, because the regset data
1727          * goes into the pr_reg field inside the note contents, rather
1728          * than being the whole note contents.  We fill the reset in here.
1729          * We assume that regset 0 is NT_PRSTATUS.
1730          */
1731         fill_prstatus(&t->prstatus, t->task, signr);
1732         (void) view->regsets[0].get(t->task, &view->regsets[0], 0, regset0_size,
1733                                     &t->prstatus.pr_reg, NULL);
1734
1735         fill_note(&t->notes[0], "CORE", NT_PRSTATUS,
1736                   PRSTATUS_SIZE(t->prstatus, regset0_size), &t->prstatus);
1737         *total += notesize(&t->notes[0]);
1738
1739         do_thread_regset_writeback(t->task, &view->regsets[0]);
1740
1741         /*
1742          * Each other regset might generate a note too.  For each regset
1743          * that has no core_note_type or is inactive, we leave t->notes[i]
1744          * all zero and we'll know to skip writing it later.
1745          */
1746         for (i = 1; i < view->n; ++i) {
1747                 const struct user_regset *regset = &view->regsets[i];
1748                 do_thread_regset_writeback(t->task, regset);
1749                 if (regset->core_note_type && regset->get &&
1750                     (!regset->active || regset->active(t->task, regset) > 0)) {
1751                         int ret;
1752                         size_t size = regset_size(t->task, regset);
1753                         void *data = kmalloc(size, GFP_KERNEL);
1754                         if (unlikely(!data))
1755                                 return 0;
1756                         ret = regset->get(t->task, regset,
1757                                           0, size, data, NULL);
1758                         if (unlikely(ret))
1759                                 kfree(data);
1760                         else {
1761                                 if (regset->core_note_type != NT_PRFPREG)
1762                                         fill_note(&t->notes[i], "LINUX",
1763                                                   regset->core_note_type,
1764                                                   size, data);
1765                                 else {
1766                                         SET_PR_FPVALID(&t->prstatus,
1767                                                         1, regset0_size);
1768                                         fill_note(&t->notes[i], "CORE",
1769                                                   NT_PRFPREG, size, data);
1770                                 }
1771                                 *total += notesize(&t->notes[i]);
1772                         }
1773                 }
1774         }
1775
1776         return 1;
1777 }
1778
1779 static int fill_note_info(struct elfhdr *elf, int phdrs,
1780                           struct elf_note_info *info,
1781                           const kernel_siginfo_t *siginfo, struct pt_regs *regs)
1782 {
1783         struct task_struct *dump_task = current;
1784         const struct user_regset_view *view = task_user_regset_view(dump_task);
1785         struct elf_thread_core_info *t;
1786         struct elf_prpsinfo *psinfo;
1787         struct core_thread *ct;
1788         unsigned int i;
1789
1790         info->size = 0;
1791         info->thread = NULL;
1792
1793         psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
1794         if (psinfo == NULL) {
1795                 info->psinfo.data = NULL; /* So we don't free this wrongly */
1796                 return 0;
1797         }
1798
1799         fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1800
1801         /*
1802          * Figure out how many notes we're going to need for each thread.
1803          */
1804         info->thread_notes = 0;
1805         for (i = 0; i < view->n; ++i)
1806                 if (view->regsets[i].core_note_type != 0)
1807                         ++info->thread_notes;
1808
1809         /*
1810          * Sanity check.  We rely on regset 0 being in NT_PRSTATUS,
1811          * since it is our one special case.
1812          */
1813         if (unlikely(info->thread_notes == 0) ||
1814             unlikely(view->regsets[0].core_note_type != NT_PRSTATUS)) {
1815                 WARN_ON(1);
1816                 return 0;
1817         }
1818
1819         /*
1820          * Initialize the ELF file header.
1821          */
1822         fill_elf_header(elf, phdrs,
1823                         view->e_machine, view->e_flags);
1824
1825         /*
1826          * Allocate a structure for each thread.
1827          */
1828         for (ct = &dump_task->mm->core_state->dumper; ct; ct = ct->next) {
1829                 t = kzalloc(offsetof(struct elf_thread_core_info,
1830                                      notes[info->thread_notes]),
1831                             GFP_KERNEL);
1832                 if (unlikely(!t))
1833                         return 0;
1834
1835                 t->task = ct->task;
1836                 if (ct->task == dump_task || !info->thread) {
1837                         t->next = info->thread;
1838                         info->thread = t;
1839                 } else {
1840                         /*
1841                          * Make sure to keep the original task at
1842                          * the head of the list.
1843                          */
1844                         t->next = info->thread->next;
1845                         info->thread->next = t;
1846                 }
1847         }
1848
1849         /*
1850          * Now fill in each thread's information.
1851          */
1852         for (t = info->thread; t != NULL; t = t->next)
1853                 if (!fill_thread_core_info(t, view, siginfo->si_signo, &info->size))
1854                         return 0;
1855
1856         /*
1857          * Fill in the two process-wide notes.
1858          */
1859         fill_psinfo(psinfo, dump_task->group_leader, dump_task->mm);
1860         info->size += notesize(&info->psinfo);
1861
1862         fill_siginfo_note(&info->signote, &info->csigdata, siginfo);
1863         info->size += notesize(&info->signote);
1864
1865         fill_auxv_note(&info->auxv, current->mm);
1866         info->size += notesize(&info->auxv);
1867
1868         if (fill_files_note(&info->files) == 0)
1869                 info->size += notesize(&info->files);
1870
1871         return 1;
1872 }
1873
1874 static size_t get_note_info_size(struct elf_note_info *info)
1875 {
1876         return info->size;
1877 }
1878
1879 /*
1880  * Write all the notes for each thread.  When writing the first thread, the
1881  * process-wide notes are interleaved after the first thread-specific note.
1882  */
1883 static int write_note_info(struct elf_note_info *info,
1884                            struct coredump_params *cprm)
1885 {
1886         bool first = true;
1887         struct elf_thread_core_info *t = info->thread;
1888
1889         do {
1890                 int i;
1891
1892                 if (!writenote(&t->notes[0], cprm))
1893                         return 0;
1894
1895                 if (first && !writenote(&info->psinfo, cprm))
1896                         return 0;
1897                 if (first && !writenote(&info->signote, cprm))
1898                         return 0;
1899                 if (first && !writenote(&info->auxv, cprm))
1900                         return 0;
1901                 if (first && info->files.data &&
1902                                 !writenote(&info->files, cprm))
1903                         return 0;
1904
1905                 for (i = 1; i < info->thread_notes; ++i)
1906                         if (t->notes[i].data &&
1907                             !writenote(&t->notes[i], cprm))
1908                                 return 0;
1909
1910                 first = false;
1911                 t = t->next;
1912         } while (t);
1913
1914         return 1;
1915 }
1916
1917 static void free_note_info(struct elf_note_info *info)
1918 {
1919         struct elf_thread_core_info *threads = info->thread;
1920         while (threads) {
1921                 unsigned int i;
1922                 struct elf_thread_core_info *t = threads;
1923                 threads = t->next;
1924                 WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);
1925                 for (i = 1; i < info->thread_notes; ++i)
1926                         kfree(t->notes[i].data);
1927                 kfree(t);
1928         }
1929         kfree(info->psinfo.data);
1930         kvfree(info->files.data);
1931 }
1932
1933 #else
1934
1935 /* Here is the structure in which status of each thread is captured. */
1936 struct elf_thread_status
1937 {
1938         struct list_head list;
1939         struct elf_prstatus prstatus;   /* NT_PRSTATUS */
1940         elf_fpregset_t fpu;             /* NT_PRFPREG */
1941         struct task_struct *thread;
1942 #ifdef ELF_CORE_COPY_XFPREGS
1943         elf_fpxregset_t xfpu;           /* ELF_CORE_XFPREG_TYPE */
1944 #endif
1945         struct memelfnote notes[3];
1946         int num_notes;
1947 };
1948
1949 /*
1950  * In order to add the specific thread information for the elf file format,
1951  * we need to keep a linked list of every threads pr_status and then create
1952  * a single section for them in the final core file.
1953  */
1954 static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1955 {
1956         int sz = 0;
1957         struct task_struct *p = t->thread;
1958         t->num_notes = 0;
1959
1960         fill_prstatus(&t->prstatus, p, signr);
1961         elf_core_copy_task_regs(p, &t->prstatus.pr_reg);        
1962         
1963         fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1964                   &(t->prstatus));
1965         t->num_notes++;
1966         sz += notesize(&t->notes[0]);
1967
1968         if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1969                                                                 &t->fpu))) {
1970                 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1971                           &(t->fpu));
1972                 t->num_notes++;
1973                 sz += notesize(&t->notes[1]);
1974         }
1975
1976 #ifdef ELF_CORE_COPY_XFPREGS
1977         if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
1978                 fill_note(&t->notes[2], "LINUX", ELF_CORE_XFPREG_TYPE,
1979                           sizeof(t->xfpu), &t->xfpu);
1980                 t->num_notes++;
1981                 sz += notesize(&t->notes[2]);
1982         }
1983 #endif  
1984         return sz;
1985 }
1986
1987 struct elf_note_info {
1988         struct memelfnote *notes;
1989         struct memelfnote *notes_files;
1990         struct elf_prstatus *prstatus;  /* NT_PRSTATUS */
1991         struct elf_prpsinfo *psinfo;    /* NT_PRPSINFO */
1992         struct list_head thread_list;
1993         elf_fpregset_t *fpu;
1994 #ifdef ELF_CORE_COPY_XFPREGS
1995         elf_fpxregset_t *xfpu;
1996 #endif
1997         user_siginfo_t csigdata;
1998         int thread_status_size;
1999         int numnote;
2000 };
2001
2002 static int elf_note_info_init(struct elf_note_info *info)
2003 {
2004         memset(info, 0, sizeof(*info));
2005         INIT_LIST_HEAD(&info->thread_list);
2006
2007         /* Allocate space for ELF notes */
2008         info->notes = kmalloc_array(8, sizeof(struct memelfnote), GFP_KERNEL);
2009         if (!info->notes)
2010                 return 0;
2011         info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL);
2012         if (!info->psinfo)
2013                 return 0;
2014         info->prstatus = kmalloc(sizeof(*info->prstatus), GFP_KERNEL);
2015         if (!info->prstatus)
2016                 return 0;
2017         info->fpu = kmalloc(sizeof(*info->fpu), GFP_KERNEL);
2018         if (!info->fpu)
2019                 return 0;
2020 #ifdef ELF_CORE_COPY_XFPREGS
2021         info->xfpu = kmalloc(sizeof(*info->xfpu), GFP_KERNEL);
2022         if (!info->xfpu)
2023                 return 0;
2024 #endif
2025         return 1;
2026 }
2027
2028 static int fill_note_info(struct elfhdr *elf, int phdrs,
2029                           struct elf_note_info *info,
2030                           const kernel_siginfo_t *siginfo, struct pt_regs *regs)
2031 {
2032         struct core_thread *ct;
2033         struct elf_thread_status *ets;
2034
2035         if (!elf_note_info_init(info))
2036                 return 0;
2037
2038         for (ct = current->mm->core_state->dumper.next;
2039                                         ct; ct = ct->next) {
2040                 ets = kzalloc(sizeof(*ets), GFP_KERNEL);
2041                 if (!ets)
2042                         return 0;
2043
2044                 ets->thread = ct->task;
2045                 list_add(&ets->list, &info->thread_list);
2046         }
2047
2048         list_for_each_entry(ets, &info->thread_list, list) {
2049                 int sz;
2050
2051                 sz = elf_dump_thread_status(siginfo->si_signo, ets);
2052                 info->thread_status_size += sz;
2053         }
2054         /* now collect the dump for the current */
2055         memset(info->prstatus, 0, sizeof(*info->prstatus));
2056         fill_prstatus(info->prstatus, current, siginfo->si_signo);
2057         elf_core_copy_regs(&info->prstatus->pr_reg, regs);
2058
2059         /* Set up header */
2060         fill_elf_header(elf, phdrs, ELF_ARCH, ELF_CORE_EFLAGS);
2061
2062         /*
2063          * Set up the notes in similar form to SVR4 core dumps made
2064          * with info from their /proc.
2065          */
2066
2067         fill_note(info->notes + 0, "CORE", NT_PRSTATUS,
2068                   sizeof(*info->prstatus), info->prstatus);
2069         fill_psinfo(info->psinfo, current->group_leader, current->mm);
2070         fill_note(info->notes + 1, "CORE", NT_PRPSINFO,
2071                   sizeof(*info->psinfo), info->psinfo);
2072
2073         fill_siginfo_note(info->notes + 2, &info->csigdata, siginfo);
2074         fill_auxv_note(info->notes + 3, current->mm);
2075         info->numnote = 4;
2076
2077         if (fill_files_note(info->notes + info->numnote) == 0) {
2078                 info->notes_files = info->notes + info->numnote;
2079                 info->numnote++;
2080         }
2081
2082         /* Try to dump the FPU. */
2083         info->prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs,
2084                                                                info->fpu);
2085         if (info->prstatus->pr_fpvalid)
2086                 fill_note(info->notes + info->numnote++,
2087                           "CORE", NT_PRFPREG, sizeof(*info->fpu), info->fpu);
2088 #ifdef ELF_CORE_COPY_XFPREGS
2089         if (elf_core_copy_task_xfpregs(current, info->xfpu))
2090                 fill_note(info->notes + info->numnote++,
2091                           "LINUX", ELF_CORE_XFPREG_TYPE,
2092                           sizeof(*info->xfpu), info->xfpu);
2093 #endif
2094
2095         return 1;
2096 }
2097
2098 static size_t get_note_info_size(struct elf_note_info *info)
2099 {
2100         int sz = 0;
2101         int i;
2102
2103         for (i = 0; i < info->numnote; i++)
2104                 sz += notesize(info->notes + i);
2105
2106         sz += info->thread_status_size;
2107
2108         return sz;
2109 }
2110
2111 static int write_note_info(struct elf_note_info *info,
2112                            struct coredump_params *cprm)
2113 {
2114         struct elf_thread_status *ets;
2115         int i;
2116
2117         for (i = 0; i < info->numnote; i++)
2118                 if (!writenote(info->notes + i, cprm))
2119                         return 0;
2120
2121         /* write out the thread status notes section */
2122         list_for_each_entry(ets, &info->thread_list, list) {
2123                 for (i = 0; i < ets->num_notes; i++)
2124                         if (!writenote(&ets->notes[i], cprm))
2125                                 return 0;
2126         }
2127
2128         return 1;
2129 }
2130
2131 static void free_note_info(struct elf_note_info *info)
2132 {
2133         while (!list_empty(&info->thread_list)) {
2134                 struct list_head *tmp = info->thread_list.next;
2135                 list_del(tmp);
2136                 kfree(list_entry(tmp, struct elf_thread_status, list));
2137         }
2138
2139         /* Free data possibly allocated by fill_files_note(): */
2140         if (info->notes_files)
2141                 kvfree(info->notes_files->data);
2142
2143         kfree(info->prstatus);
2144         kfree(info->psinfo);
2145         kfree(info->notes);
2146         kfree(info->fpu);
2147 #ifdef ELF_CORE_COPY_XFPREGS
2148         kfree(info->xfpu);
2149 #endif
2150 }
2151
2152 #endif
2153
2154 static struct vm_area_struct *first_vma(struct task_struct *tsk,
2155                                         struct vm_area_struct *gate_vma)
2156 {
2157         struct vm_area_struct *ret = tsk->mm->mmap;
2158
2159         if (ret)
2160                 return ret;
2161         return gate_vma;
2162 }
2163 /*
2164  * Helper function for iterating across a vma list.  It ensures that the caller
2165  * will visit `gate_vma' prior to terminating the search.
2166  */
2167 static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
2168                                         struct vm_area_struct *gate_vma)
2169 {
2170         struct vm_area_struct *ret;
2171
2172         ret = this_vma->vm_next;
2173         if (ret)
2174                 return ret;
2175         if (this_vma == gate_vma)
2176                 return NULL;
2177         return gate_vma;
2178 }
2179
2180 static void fill_extnum_info(struct elfhdr *elf, struct elf_shdr *shdr4extnum,
2181                              elf_addr_t e_shoff, int segs)
2182 {
2183         elf->e_shoff = e_shoff;
2184         elf->e_shentsize = sizeof(*shdr4extnum);
2185         elf->e_shnum = 1;
2186         elf->e_shstrndx = SHN_UNDEF;
2187
2188         memset(shdr4extnum, 0, sizeof(*shdr4extnum));
2189
2190         shdr4extnum->sh_type = SHT_NULL;
2191         shdr4extnum->sh_size = elf->e_shnum;
2192         shdr4extnum->sh_link = elf->e_shstrndx;
2193         shdr4extnum->sh_info = segs;
2194 }
2195
2196 /*
2197  * Actual dumper
2198  *
2199  * This is a two-pass process; first we find the offsets of the bits,
2200  * and then they are actually written out.  If we run out of core limit
2201  * we just truncate.
2202  */
2203 static int elf_core_dump(struct coredump_params *cprm)
2204 {
2205         int has_dumped = 0;
2206         mm_segment_t fs;
2207         int segs, i;
2208         size_t vma_data_size = 0;
2209         struct vm_area_struct *vma, *gate_vma;
2210         struct elfhdr *elf = NULL;
2211         loff_t offset = 0, dataoff;
2212         struct elf_note_info info = { };
2213         struct elf_phdr *phdr4note = NULL;
2214         struct elf_shdr *shdr4extnum = NULL;
2215         Elf_Half e_phnum;
2216         elf_addr_t e_shoff;
2217         elf_addr_t *vma_filesz = NULL;
2218
2219         /*
2220          * We no longer stop all VM operations.
2221          * 
2222          * This is because those proceses that could possibly change map_count
2223          * or the mmap / vma pages are now blocked in do_exit on current
2224          * finishing this core dump.
2225          *
2226          * Only ptrace can touch these memory addresses, but it doesn't change
2227          * the map_count or the pages allocated. So no possibility of crashing
2228          * exists while dumping the mm->vm_next areas to the core file.
2229          */
2230   
2231         /* alloc memory for large data structures: too large to be on stack */
2232         elf = kmalloc(sizeof(*elf), GFP_KERNEL);
2233         if (!elf)
2234                 goto out;
2235         /*
2236          * The number of segs are recored into ELF header as 16bit value.
2237          * Please check DEFAULT_MAX_MAP_COUNT definition when you modify here.
2238          */
2239         segs = current->mm->map_count;
2240         segs += elf_core_extra_phdrs();
2241
2242         gate_vma = get_gate_vma(current->mm);
2243         if (gate_vma != NULL)
2244                 segs++;
2245
2246         /* for notes section */
2247         segs++;
2248
2249         /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
2250          * this, kernel supports extended numbering. Have a look at
2251          * include/linux/elf.h for further information. */
2252         e_phnum = segs > PN_XNUM ? PN_XNUM : segs;
2253
2254         /*
2255          * Collect all the non-memory information about the process for the
2256          * notes.  This also sets up the file header.
2257          */
2258         if (!fill_note_info(elf, e_phnum, &info, cprm->siginfo, cprm->regs))
2259                 goto cleanup;
2260
2261         has_dumped = 1;
2262
2263         fs = get_fs();
2264         set_fs(KERNEL_DS);
2265
2266         offset += sizeof(*elf);                         /* Elf header */
2267         offset += segs * sizeof(struct elf_phdr);       /* Program headers */
2268
2269         /* Write notes phdr entry */
2270         {
2271                 size_t sz = get_note_info_size(&info);
2272
2273                 sz += elf_coredump_extra_notes_size();
2274
2275                 phdr4note = kmalloc(sizeof(*phdr4note), GFP_KERNEL);
2276                 if (!phdr4note)
2277                         goto end_coredump;
2278
2279                 fill_elf_note_phdr(phdr4note, sz, offset);
2280                 offset += sz;
2281         }
2282
2283         dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
2284
2285         if (segs - 1 > ULONG_MAX / sizeof(*vma_filesz))
2286                 goto end_coredump;
2287         vma_filesz = kvmalloc(array_size(sizeof(*vma_filesz), (segs - 1)),
2288                               GFP_KERNEL);
2289         if (ZERO_OR_NULL_PTR(vma_filesz))
2290                 goto end_coredump;
2291
2292         for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2293                         vma = next_vma(vma, gate_vma)) {
2294                 unsigned long dump_size;
2295
2296                 dump_size = vma_dump_size(vma, cprm->mm_flags);
2297                 vma_filesz[i++] = dump_size;
2298                 vma_data_size += dump_size;
2299         }
2300
2301         offset += vma_data_size;
2302         offset += elf_core_extra_data_size();
2303         e_shoff = offset;
2304
2305         if (e_phnum == PN_XNUM) {
2306                 shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);
2307                 if (!shdr4extnum)
2308                         goto end_coredump;
2309                 fill_extnum_info(elf, shdr4extnum, e_shoff, segs);
2310         }
2311
2312         offset = dataoff;
2313
2314         if (!dump_emit(cprm, elf, sizeof(*elf)))
2315                 goto end_coredump;
2316
2317         if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note)))
2318                 goto end_coredump;
2319
2320         /* Write program headers for segments dump */
2321         for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2322                         vma = next_vma(vma, gate_vma)) {
2323                 struct elf_phdr phdr;
2324
2325                 phdr.p_type = PT_LOAD;
2326                 phdr.p_offset = offset;
2327                 phdr.p_vaddr = vma->vm_start;
2328                 phdr.p_paddr = 0;
2329                 phdr.p_filesz = vma_filesz[i++];
2330                 phdr.p_memsz = vma->vm_end - vma->vm_start;
2331                 offset += phdr.p_filesz;
2332                 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
2333                 if (vma->vm_flags & VM_WRITE)
2334                         phdr.p_flags |= PF_W;
2335                 if (vma->vm_flags & VM_EXEC)
2336                         phdr.p_flags |= PF_X;
2337                 phdr.p_align = ELF_EXEC_PAGESIZE;
2338
2339                 if (!dump_emit(cprm, &phdr, sizeof(phdr)))
2340                         goto end_coredump;
2341         }
2342
2343         if (!elf_core_write_extra_phdrs(cprm, offset))
2344                 goto end_coredump;
2345
2346         /* write out the notes section */
2347         if (!write_note_info(&info, cprm))
2348                 goto end_coredump;
2349
2350         if (elf_coredump_extra_notes_write(cprm))
2351                 goto end_coredump;
2352
2353         /* Align to page */
2354         if (!dump_skip(cprm, dataoff - cprm->pos))
2355                 goto end_coredump;
2356
2357         for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2358                         vma = next_vma(vma, gate_vma)) {
2359                 unsigned long addr;
2360                 unsigned long end;
2361
2362                 end = vma->vm_start + vma_filesz[i++];
2363
2364                 for (addr = vma->vm_start; addr < end; addr += PAGE_SIZE) {
2365                         struct page *page;
2366                         int stop;
2367
2368                         page = get_dump_page(addr);
2369                         if (page) {
2370                                 void *kaddr = kmap(page);
2371                                 stop = !dump_emit(cprm, kaddr, PAGE_SIZE);
2372                                 kunmap(page);
2373                                 put_page(page);
2374                         } else
2375                                 stop = !dump_skip(cprm, PAGE_SIZE);
2376                         if (stop)
2377                                 goto end_coredump;
2378                 }
2379         }
2380         dump_truncate(cprm);
2381
2382         if (!elf_core_write_extra_data(cprm))
2383                 goto end_coredump;
2384
2385         if (e_phnum == PN_XNUM) {
2386                 if (!dump_emit(cprm, shdr4extnum, sizeof(*shdr4extnum)))
2387                         goto end_coredump;
2388         }
2389
2390 end_coredump:
2391         set_fs(fs);
2392
2393 cleanup:
2394         free_note_info(&info);
2395         kfree(shdr4extnum);
2396         kvfree(vma_filesz);
2397         kfree(phdr4note);
2398         kfree(elf);
2399 out:
2400         return has_dumped;
2401 }
2402
2403 #endif          /* CONFIG_ELF_CORE */
2404
2405 static int __init init_elf_binfmt(void)
2406 {
2407         register_binfmt(&elf_format);
2408         return 0;
2409 }
2410
2411 static void __exit exit_elf_binfmt(void)
2412 {
2413         /* Remove the COFF and ELF loaders. */
2414         unregister_binfmt(&elf_format);
2415 }
2416
2417 core_initcall(init_elf_binfmt);
2418 module_exit(exit_elf_binfmt);
2419 MODULE_LICENSE("GPL");