blob: 0c42cdbabecff0c4c8d9d0e597273ff4fce79507 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/mm.h>
16#include <linux/mman.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/errno.h>
18#include <linux/signal.h>
19#include <linux/binfmts.h>
20#include <linux/string.h>
21#include <linux/file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/personality.h>
24#include <linux/elfcore.h>
25#include <linux/init.h>
26#include <linux/highuid.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/compiler.h>
28#include <linux/highmem.h>
29#include <linux/pagemap.h>
Denys Vlasenko2aa362c2012-10-04 17:15:36 -070030#include <linux/vmalloc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/security.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/random.h>
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070033#include <linux/elf.h>
Alexey Dobriyan7e80d0d2007-05-08 00:28:59 -070034#include <linux/utsname.h>
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -080035#include <linux/coredump.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <asm/uaccess.h>
37#include <asm/param.h>
38#include <asm/page.h>
39
Denys Vlasenko2aa362c2012-10-04 17:15:36 -070040#ifndef user_long_t
41#define user_long_t long
42#endif
Denys Vlasenko49ae4d42012-10-04 17:15:35 -070043#ifndef user_siginfo_t
44#define user_siginfo_t siginfo_t
45#endif
46
Al Viro71613c32012-10-20 22:00:48 -040047static int load_elf_binary(struct linux_binprm *bprm);
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070048static int load_elf_library(struct file *);
Andrew Mortonbb1ad822008-01-30 13:31:07 +010049static unsigned long elf_map(struct file *, unsigned long, struct elf_phdr *,
50 int, int, unsigned long);
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
Linus Torvalds1da177e2005-04-16 15:20:36 -070052/*
53 * If we don't support core dumping, then supply a NULL so we
54 * don't even try.
55 */
Christoph Hellwig698ba7b2009-12-15 16:47:37 -080056#ifdef CONFIG_ELF_CORE
Masami Hiramatsuf6151df2009-12-17 15:27:16 -080057static int elf_core_dump(struct coredump_params *cprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#else
59#define elf_core_dump NULL
60#endif
61
62#if ELF_EXEC_PAGESIZE > PAGE_SIZE
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070063#define ELF_MIN_ALIGN ELF_EXEC_PAGESIZE
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#else
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070065#define ELF_MIN_ALIGN PAGE_SIZE
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#endif
67
68#ifndef ELF_CORE_EFLAGS
69#define ELF_CORE_EFLAGS 0
70#endif
71
72#define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
73#define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
74#define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
75
76static struct linux_binfmt elf_format = {
Mikael Petterssonf670d0e2011-01-12 17:00:02 -080077 .module = THIS_MODULE,
78 .load_binary = load_elf_binary,
79 .load_shlib = load_elf_library,
80 .core_dump = elf_core_dump,
81 .min_coredump = ELF_EXEC_PAGESIZE,
Linus Torvalds1da177e2005-04-16 15:20:36 -070082};
83
Andrew Mortond4e3cc32007-07-21 04:37:32 -070084#define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
86static int set_brk(unsigned long start, unsigned long end)
87{
88 start = ELF_PAGEALIGN(start);
89 end = ELF_PAGEALIGN(end);
90 if (end > start) {
91 unsigned long addr;
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -070092 addr = vm_brk(start, end - start);
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 if (BAD_ADDR(addr))
94 return addr;
95 }
96 current->mm->start_brk = current->mm->brk = end;
97 return 0;
98}
99
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100/* We need to explicitly zero any fractional pages
101 after the data section (i.e. bss). This would
102 contain the junk from the file that should not
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700103 be in memory
104 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105static int padzero(unsigned long elf_bss)
106{
107 unsigned long nbyte;
108
109 nbyte = ELF_PAGEOFFSET(elf_bss);
110 if (nbyte) {
111 nbyte = ELF_MIN_ALIGN - nbyte;
112 if (clear_user((void __user *) elf_bss, nbyte))
113 return -EFAULT;
114 }
115 return 0;
116}
117
Ohad Ben-Cohen09c6dd32008-02-03 18:05:15 +0200118/* Let's use some macros to make this stack manipulation a little clearer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119#ifdef CONFIG_STACK_GROWSUP
120#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))
121#define STACK_ROUND(sp, items) \
122 ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700123#define STACK_ALLOC(sp, len) ({ \
124 elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; \
125 old_sp; })
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126#else
127#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))
128#define STACK_ROUND(sp, items) \
129 (((unsigned long) (sp - items)) &~ 15UL)
130#define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })
131#endif
132
Nathan Lynch483fad12008-07-22 04:48:46 +1000133#ifndef ELF_BASE_PLATFORM
134/*
135 * AT_BASE_PLATFORM indicates the "real" hardware/microarchitecture.
136 * If the arch defines ELF_BASE_PLATFORM (in asm/elf.h), the value
137 * will be copied to the user stack in the same manner as AT_PLATFORM.
138 */
139#define ELF_BASE_PLATFORM NULL
140#endif
141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142static int
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700143create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
Andi Kleend20894a2008-02-08 04:21:54 -0800144 unsigned long load_addr, unsigned long interp_load_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145{
146 unsigned long p = bprm->p;
147 int argc = bprm->argc;
148 int envc = bprm->envc;
149 elf_addr_t __user *argv;
150 elf_addr_t __user *envp;
151 elf_addr_t __user *sp;
152 elf_addr_t __user *u_platform;
Nathan Lynch483fad12008-07-22 04:48:46 +1000153 elf_addr_t __user *u_base_platform;
Kees Cookf06295b2009-01-07 18:08:52 -0800154 elf_addr_t __user *u_rand_bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 const char *k_platform = ELF_PLATFORM;
Nathan Lynch483fad12008-07-22 04:48:46 +1000156 const char *k_base_platform = ELF_BASE_PLATFORM;
Kees Cookf06295b2009-01-07 18:08:52 -0800157 unsigned char k_rand_bytes[16];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 int items;
159 elf_addr_t *elf_info;
160 int ei_index = 0;
David Howells86a264a2008-11-14 10:39:18 +1100161 const struct cred *cred = current_cred();
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700162 struct vm_area_struct *vma;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
164 /*
Franck Bui-Huud68c9d62007-10-16 23:30:24 -0700165 * In some cases (e.g. Hyper-Threading), we want to avoid L1
166 * evictions by the processes running on the same package. One
167 * thing we can do is to shuffle the initial stack for them.
168 */
169
170 p = arch_align_stack(p);
171
172 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 * If this architecture has a platform capability string, copy it
174 * to userspace. In some cases (Sparc), this info is impossible
175 * for userspace to get any other way, in others (i386) it is
176 * merely difficult.
177 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 u_platform = NULL;
179 if (k_platform) {
180 size_t len = strlen(k_platform) + 1;
181
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
183 if (__copy_to_user(u_platform, k_platform, len))
184 return -EFAULT;
185 }
186
Nathan Lynch483fad12008-07-22 04:48:46 +1000187 /*
188 * If this architecture has a "base" platform capability
189 * string, copy it to userspace.
190 */
191 u_base_platform = NULL;
192 if (k_base_platform) {
193 size_t len = strlen(k_base_platform) + 1;
194
195 u_base_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
196 if (__copy_to_user(u_base_platform, k_base_platform, len))
197 return -EFAULT;
198 }
199
Kees Cookf06295b2009-01-07 18:08:52 -0800200 /*
201 * Generate 16 random bytes for userspace PRNG seeding.
202 */
203 get_random_bytes(k_rand_bytes, sizeof(k_rand_bytes));
204 u_rand_bytes = (elf_addr_t __user *)
205 STACK_ALLOC(p, sizeof(k_rand_bytes));
206 if (__copy_to_user(u_rand_bytes, k_rand_bytes, sizeof(k_rand_bytes)))
207 return -EFAULT;
208
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 /* Create the ELF interpreter info */
Jesper Juhl785d5572006-06-23 02:05:35 -0700210 elf_info = (elf_addr_t *)current->mm->saved_auxv;
Olaf Hering4f9a58d2007-10-16 23:30:12 -0700211 /* update AT_VECTOR_SIZE_BASE if the number of NEW_AUX_ENT() changes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212#define NEW_AUX_ENT(id, val) \
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700213 do { \
Jesper Juhl785d5572006-06-23 02:05:35 -0700214 elf_info[ei_index++] = id; \
215 elf_info[ei_index++] = val; \
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700216 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
218#ifdef ARCH_DLINFO
219 /*
220 * ARCH_DLINFO must come first so PPC can do its special alignment of
221 * AUXV.
Olaf Hering4f9a58d2007-10-16 23:30:12 -0700222 * update AT_VECTOR_SIZE_ARCH if the number of NEW_AUX_ENT() in
223 * ARCH_DLINFO changes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 */
225 ARCH_DLINFO;
226#endif
227 NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);
228 NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
229 NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
230 NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700231 NEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);
233 NEW_AUX_ENT(AT_BASE, interp_load_addr);
234 NEW_AUX_ENT(AT_FLAGS, 0);
235 NEW_AUX_ENT(AT_ENTRY, exec->e_entry);
Eric W. Biedermanebc887b2012-02-07 18:36:10 -0800236 NEW_AUX_ENT(AT_UID, from_kuid_munged(cred->user_ns, cred->uid));
237 NEW_AUX_ENT(AT_EUID, from_kuid_munged(cred->user_ns, cred->euid));
238 NEW_AUX_ENT(AT_GID, from_kgid_munged(cred->user_ns, cred->gid));
239 NEW_AUX_ENT(AT_EGID, from_kgid_munged(cred->user_ns, cred->egid));
Jesper Juhl785d5572006-06-23 02:05:35 -0700240 NEW_AUX_ENT(AT_SECURE, security_bprm_secureexec(bprm));
Kees Cookf06295b2009-01-07 18:08:52 -0800241 NEW_AUX_ENT(AT_RANDOM, (elf_addr_t)(unsigned long)u_rand_bytes);
John Reiser65191082008-07-21 14:21:32 -0700242 NEW_AUX_ENT(AT_EXECFN, bprm->exec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 if (k_platform) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700244 NEW_AUX_ENT(AT_PLATFORM,
Jesper Juhl785d5572006-06-23 02:05:35 -0700245 (elf_addr_t)(unsigned long)u_platform);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 }
Nathan Lynch483fad12008-07-22 04:48:46 +1000247 if (k_base_platform) {
248 NEW_AUX_ENT(AT_BASE_PLATFORM,
249 (elf_addr_t)(unsigned long)u_base_platform);
250 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
Jesper Juhl785d5572006-06-23 02:05:35 -0700252 NEW_AUX_ENT(AT_EXECFD, bprm->interp_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 }
254#undef NEW_AUX_ENT
255 /* AT_NULL is zero; clear the rest too */
256 memset(&elf_info[ei_index], 0,
257 sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);
258
259 /* And advance past the AT_NULL entry. */
260 ei_index += 2;
261
262 sp = STACK_ADD(p, ei_index);
263
Andi Kleend20894a2008-02-08 04:21:54 -0800264 items = (argc + 1) + (envc + 1) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 bprm->p = STACK_ROUND(sp, items);
266
267 /* Point sp at the lowest address on the stack */
268#ifdef CONFIG_STACK_GROWSUP
269 sp = (elf_addr_t __user *)bprm->p - items - ei_index;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700270 bprm->exec = (unsigned long)sp; /* XXX: PARISC HACK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271#else
272 sp = (elf_addr_t __user *)bprm->p;
273#endif
274
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700275
276 /*
277 * Grow the stack manually; some architectures have a limit on how
278 * far ahead a user-space access may be in order to grow the stack.
279 */
280 vma = find_extend_vma(current->mm, bprm->p);
281 if (!vma)
282 return -EFAULT;
283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 /* Now, let's put argc (and argv, envp if appropriate) on the stack */
285 if (__put_user(argc, sp++))
286 return -EFAULT;
Andi Kleend20894a2008-02-08 04:21:54 -0800287 argv = sp;
288 envp = argv + argc + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289
290 /* Populate argv and envp */
Greg Kroah-Hartmana84a5052005-05-11 00:10:44 -0700291 p = current->mm->arg_end = current->mm->arg_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 while (argc-- > 0) {
293 size_t len;
Heiko Carstens841d5fb2006-12-06 20:36:35 -0800294 if (__put_user((elf_addr_t)p, argv++))
295 return -EFAULT;
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700296 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
297 if (!len || len > MAX_ARG_STRLEN)
WANG Cong23c49712008-05-08 21:52:33 +0800298 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 p += len;
300 }
301 if (__put_user(0, argv))
302 return -EFAULT;
303 current->mm->arg_end = current->mm->env_start = p;
304 while (envc-- > 0) {
305 size_t len;
Heiko Carstens841d5fb2006-12-06 20:36:35 -0800306 if (__put_user((elf_addr_t)p, envp++))
307 return -EFAULT;
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700308 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
309 if (!len || len > MAX_ARG_STRLEN)
WANG Cong23c49712008-05-08 21:52:33 +0800310 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 p += len;
312 }
313 if (__put_user(0, envp))
314 return -EFAULT;
315 current->mm->env_end = p;
316
317 /* Put the elf_info on the stack in the right place. */
318 sp = (elf_addr_t __user *)envp + 1;
319 if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))
320 return -EFAULT;
321 return 0;
322}
323
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324static unsigned long elf_map(struct file *filep, unsigned long addr,
Jiri Kosinacc503c12008-01-30 13:31:07 +0100325 struct elf_phdr *eppnt, int prot, int type,
326 unsigned long total_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327{
328 unsigned long map_addr;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100329 unsigned long size = eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr);
330 unsigned long off = eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr);
331 addr = ELF_PAGESTART(addr);
332 size = ELF_PAGEALIGN(size);
Jan Kratochvil60bfba72007-07-15 23:40:06 -0700333
Andrew Mortond4e3cc32007-07-21 04:37:32 -0700334 /* mmap() will return -EINVAL if given a zero size, but a
335 * segment with zero filesize is perfectly valid */
Jiri Kosinacc503c12008-01-30 13:31:07 +0100336 if (!size)
337 return addr;
338
Jiri Kosinacc503c12008-01-30 13:31:07 +0100339 /*
340 * total_size is the size of the ELF (interpreter) image.
341 * The _first_ mmap needs to know the full size, otherwise
342 * randomization might put this image into an overlapping
343 * position with the ELF binary image. (since size < total_size)
344 * So we first map the 'big' image - and unmap the remainder at
345 * the end. (which unmap is needed for ELF images with holes.)
346 */
347 if (total_size) {
348 total_size = ELF_PAGEALIGN(total_size);
Al Viro5a5e4c22012-05-30 01:49:38 -0400349 map_addr = vm_mmap(filep, addr, total_size, prot, type, off);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100350 if (!BAD_ADDR(map_addr))
Al Viro5a5e4c22012-05-30 01:49:38 -0400351 vm_munmap(map_addr+size, total_size-size);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100352 } else
Al Viro5a5e4c22012-05-30 01:49:38 -0400353 map_addr = vm_mmap(filep, addr, size, prot, type, off);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 return(map_addr);
356}
357
Jiri Kosinacc503c12008-01-30 13:31:07 +0100358static unsigned long total_mapping_size(struct elf_phdr *cmds, int nr)
359{
360 int i, first_idx = -1, last_idx = -1;
361
362 for (i = 0; i < nr; i++) {
363 if (cmds[i].p_type == PT_LOAD) {
364 last_idx = i;
365 if (first_idx == -1)
366 first_idx = i;
367 }
368 }
369 if (first_idx == -1)
370 return 0;
371
372 return cmds[last_idx].p_vaddr + cmds[last_idx].p_memsz -
373 ELF_PAGESTART(cmds[first_idx].p_vaddr);
374}
375
376
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377/* This is much more generalized than the library routine read function,
378 so we keep this separate. Technically the library read function
379 is only provided so that we can read a.out libraries that have
380 an ELF header */
381
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700382static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
Jiri Kosinacc503c12008-01-30 13:31:07 +0100383 struct file *interpreter, unsigned long *interp_map_addr,
384 unsigned long no_base)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385{
386 struct elf_phdr *elf_phdata;
387 struct elf_phdr *eppnt;
388 unsigned long load_addr = 0;
389 int load_addr_set = 0;
390 unsigned long last_bss = 0, elf_bss = 0;
391 unsigned long error = ~0UL;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100392 unsigned long total_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 int retval, i, size;
394
395 /* First of all, some simple consistency checks */
396 if (interp_elf_ex->e_type != ET_EXEC &&
397 interp_elf_ex->e_type != ET_DYN)
398 goto out;
399 if (!elf_check_arch(interp_elf_ex))
400 goto out;
401 if (!interpreter->f_op || !interpreter->f_op->mmap)
402 goto out;
403
404 /*
405 * If the size of this structure has changed, then punt, since
406 * we will be doing the wrong thing.
407 */
408 if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr))
409 goto out;
410 if (interp_elf_ex->e_phnum < 1 ||
411 interp_elf_ex->e_phnum > 65536U / sizeof(struct elf_phdr))
412 goto out;
413
414 /* Now read in all of the header information */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 size = sizeof(struct elf_phdr) * interp_elf_ex->e_phnum;
416 if (size > ELF_MIN_ALIGN)
417 goto out;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700418 elf_phdata = kmalloc(size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 if (!elf_phdata)
420 goto out;
421
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700422 retval = kernel_read(interpreter, interp_elf_ex->e_phoff,
Mikael Petterssonf670d0e2011-01-12 17:00:02 -0800423 (char *)elf_phdata, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 error = -EIO;
425 if (retval != size) {
426 if (retval < 0)
427 error = retval;
428 goto out_close;
429 }
430
Jiri Kosinacc503c12008-01-30 13:31:07 +0100431 total_size = total_mapping_size(elf_phdata, interp_elf_ex->e_phnum);
432 if (!total_size) {
433 error = -EINVAL;
434 goto out_close;
435 }
436
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 eppnt = elf_phdata;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700438 for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
439 if (eppnt->p_type == PT_LOAD) {
440 int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
441 int elf_prot = 0;
442 unsigned long vaddr = 0;
443 unsigned long k, map_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700445 if (eppnt->p_flags & PF_R)
446 elf_prot = PROT_READ;
447 if (eppnt->p_flags & PF_W)
448 elf_prot |= PROT_WRITE;
449 if (eppnt->p_flags & PF_X)
450 elf_prot |= PROT_EXEC;
451 vaddr = eppnt->p_vaddr;
452 if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
453 elf_type |= MAP_FIXED;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100454 else if (no_base && interp_elf_ex->e_type == ET_DYN)
455 load_addr = -vaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700457 map_addr = elf_map(interpreter, load_addr + vaddr,
Andrew Mortonbb1ad822008-01-30 13:31:07 +0100458 eppnt, elf_prot, elf_type, total_size);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100459 total_size = 0;
460 if (!*interp_map_addr)
461 *interp_map_addr = map_addr;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700462 error = map_addr;
463 if (BAD_ADDR(map_addr))
464 goto out_close;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700466 if (!load_addr_set &&
467 interp_elf_ex->e_type == ET_DYN) {
468 load_addr = map_addr - ELF_PAGESTART(vaddr);
469 load_addr_set = 1;
470 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700472 /*
473 * Check to see if the section's size will overflow the
474 * allowed task size. Note that p_filesz must always be
475 * <= p_memsize so it's only necessary to check p_memsz.
476 */
477 k = load_addr + eppnt->p_vaddr;
Chuck Ebbertce510592006-07-03 00:24:14 -0700478 if (BAD_ADDR(k) ||
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700479 eppnt->p_filesz > eppnt->p_memsz ||
480 eppnt->p_memsz > TASK_SIZE ||
481 TASK_SIZE - eppnt->p_memsz < k) {
482 error = -ENOMEM;
483 goto out_close;
484 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700486 /*
487 * Find the end of the file mapping for this phdr, and
488 * keep track of the largest address we see for this.
489 */
490 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
491 if (k > elf_bss)
492 elf_bss = k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700494 /*
495 * Do the same thing for the memory mapping - between
496 * elf_bss and last_bss is the bss section.
497 */
498 k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
499 if (k > last_bss)
500 last_bss = k;
501 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 }
503
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 if (last_bss > elf_bss) {
Roland McGrath752015d2009-09-08 19:49:40 -0700505 /*
506 * Now fill out the bss section. First pad the last page up
507 * to the page boundary, and then perform a mmap to make sure
508 * that there are zero-mapped pages up to and including the
509 * last bss page.
510 */
511 if (padzero(elf_bss)) {
512 error = -EFAULT;
513 goto out_close;
514 }
515
516 /* What we have mapped so far */
517 elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1);
518
519 /* Map the last of the bss segment */
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -0700520 error = vm_brk(elf_bss, last_bss - elf_bss);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 if (BAD_ADDR(error))
522 goto out_close;
523 }
524
Jiri Kosinacc503c12008-01-30 13:31:07 +0100525 error = load_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526
527out_close:
528 kfree(elf_phdata);
529out:
530 return error;
531}
532
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533/*
534 * These are the functions used to load ELF style executables and shared
535 * libraries. There is no binary dependent code anywhere else.
536 */
537
538#define INTERPRETER_NONE 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539#define INTERPRETER_ELF 2
540
Andi Kleen913bd902006-03-25 16:29:09 +0100541#ifndef STACK_RND_MASK
James Bottomleyd1cabd62007-03-16 13:38:35 -0800542#define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12)) /* 8MB of VA */
Andi Kleen913bd902006-03-25 16:29:09 +0100543#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
545static unsigned long randomize_stack_top(unsigned long stack_top)
546{
547 unsigned int random_variable = 0;
548
Andi Kleenc16b63e02006-09-26 10:52:28 +0200549 if ((current->flags & PF_RANDOMIZE) &&
550 !(current->personality & ADDR_NO_RANDOMIZE)) {
Andi Kleen913bd902006-03-25 16:29:09 +0100551 random_variable = get_random_int() & STACK_RND_MASK;
552 random_variable <<= PAGE_SHIFT;
553 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554#ifdef CONFIG_STACK_GROWSUP
Andi Kleen913bd902006-03-25 16:29:09 +0100555 return PAGE_ALIGN(stack_top) + random_variable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556#else
Andi Kleen913bd902006-03-25 16:29:09 +0100557 return PAGE_ALIGN(stack_top) - random_variable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558#endif
559}
560
Al Viro71613c32012-10-20 22:00:48 -0400561static int load_elf_binary(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562{
563 struct file *interpreter = NULL; /* to shut gcc up */
564 unsigned long load_addr = 0, load_bias = 0;
565 int load_addr_set = 0;
566 char * elf_interpreter = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 unsigned long error;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700568 struct elf_phdr *elf_ppnt, *elf_phdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 unsigned long elf_bss, elf_brk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 int retval, i;
571 unsigned int size;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100572 unsigned long elf_entry;
573 unsigned long interp_load_addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 unsigned long start_code, end_code, start_data, end_data;
David Daney1a530a62011-03-22 16:34:48 -0700575 unsigned long reloc_func_desc __maybe_unused = 0;
David Rientjes8de61e62006-12-06 20:40:16 -0800576 int executable_stack = EXSTACK_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 unsigned long def_flags = 0;
Al Viro71613c32012-10-20 22:00:48 -0400578 struct pt_regs *regs = current_pt_regs();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 struct {
580 struct elfhdr elf_ex;
581 struct elfhdr interp_elf_ex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 } *loc;
583
584 loc = kmalloc(sizeof(*loc), GFP_KERNEL);
585 if (!loc) {
586 retval = -ENOMEM;
587 goto out_ret;
588 }
589
590 /* Get the exec-header */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700591 loc->elf_ex = *((struct elfhdr *)bprm->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
593 retval = -ENOEXEC;
594 /* First of all, some simple consistency checks */
595 if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
596 goto out;
597
598 if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
599 goto out;
600 if (!elf_check_arch(&loc->elf_ex))
601 goto out;
Mikael Petterssonf670d0e2011-01-12 17:00:02 -0800602 if (!bprm->file->f_op || !bprm->file->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 goto out;
604
605 /* Now read in all of the header information */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 if (loc->elf_ex.e_phentsize != sizeof(struct elf_phdr))
607 goto out;
608 if (loc->elf_ex.e_phnum < 1 ||
609 loc->elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))
610 goto out;
611 size = loc->elf_ex.e_phnum * sizeof(struct elf_phdr);
612 retval = -ENOMEM;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700613 elf_phdata = kmalloc(size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 if (!elf_phdata)
615 goto out;
616
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700617 retval = kernel_read(bprm->file, loc->elf_ex.e_phoff,
618 (char *)elf_phdata, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 if (retval != size) {
620 if (retval >= 0)
621 retval = -EIO;
622 goto out_free_ph;
623 }
624
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 elf_ppnt = elf_phdata;
626 elf_bss = 0;
627 elf_brk = 0;
628
629 start_code = ~0UL;
630 end_code = 0;
631 start_data = 0;
632 end_data = 0;
633
634 for (i = 0; i < loc->elf_ex.e_phnum; i++) {
635 if (elf_ppnt->p_type == PT_INTERP) {
636 /* This is the program interpreter used for
637 * shared libraries - for now assume that this
638 * is an a.out format binary
639 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 retval = -ENOEXEC;
641 if (elf_ppnt->p_filesz > PATH_MAX ||
642 elf_ppnt->p_filesz < 2)
Al Viroe7b9b552009-03-29 16:31:16 -0400643 goto out_free_ph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
645 retval = -ENOMEM;
Jesper Juhl792db3a2006-01-09 20:54:45 -0800646 elf_interpreter = kmalloc(elf_ppnt->p_filesz,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700647 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 if (!elf_interpreter)
Al Viroe7b9b552009-03-29 16:31:16 -0400649 goto out_free_ph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
651 retval = kernel_read(bprm->file, elf_ppnt->p_offset,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700652 elf_interpreter,
653 elf_ppnt->p_filesz);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 if (retval != elf_ppnt->p_filesz) {
655 if (retval >= 0)
656 retval = -EIO;
657 goto out_free_interp;
658 }
659 /* make sure path is NULL terminated */
660 retval = -ENOEXEC;
661 if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
662 goto out_free_interp;
663
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 interpreter = open_exec(elf_interpreter);
665 retval = PTR_ERR(interpreter);
666 if (IS_ERR(interpreter))
667 goto out_free_interp;
Alexey Dobriyan1fb84492007-01-26 00:57:16 -0800668
669 /*
670 * If the binary is not readable then enforce
671 * mm->dumpable = 0 regardless of the interpreter's
672 * permissions.
673 */
Al Viro1b5d7832011-06-19 12:49:47 -0400674 would_dump(bprm, interpreter);
Alexey Dobriyan1fb84492007-01-26 00:57:16 -0800675
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700676 retval = kernel_read(interpreter, 0, bprm->buf,
677 BINPRM_BUF_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 if (retval != BINPRM_BUF_SIZE) {
679 if (retval >= 0)
680 retval = -EIO;
681 goto out_free_dentry;
682 }
683
684 /* Get the exec headers */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700685 loc->interp_elf_ex = *((struct elfhdr *)bprm->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 break;
687 }
688 elf_ppnt++;
689 }
690
691 elf_ppnt = elf_phdata;
692 for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
693 if (elf_ppnt->p_type == PT_GNU_STACK) {
694 if (elf_ppnt->p_flags & PF_X)
695 executable_stack = EXSTACK_ENABLE_X;
696 else
697 executable_stack = EXSTACK_DISABLE_X;
698 break;
699 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
701 /* Some simple consistency checks for the interpreter */
702 if (elf_interpreter) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 retval = -ELIBBAD;
Andi Kleend20894a2008-02-08 04:21:54 -0800704 /* Not an ELF interpreter */
705 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 /* Verify the interpreter has a valid arch */
Andi Kleend20894a2008-02-08 04:21:54 -0800708 if (!elf_check_arch(&loc->interp_elf_ex))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 }
711
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 /* Flush all traces of the currently running executable */
713 retval = flush_old_exec(bprm);
714 if (retval)
715 goto out_free_dentry;
716
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 /* OK, This is the point of no return */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 current->mm->def_flags = def_flags;
719
720 /* Do this immediately, since STACK_TOP as used in setup_arg_pages
721 may depend on the personality. */
Martin Schwidefsky0b592682008-10-16 15:39:57 +0200722 SET_PERSONALITY(loc->elf_ex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 if (elf_read_implies_exec(loc->elf_ex, executable_stack))
724 current->personality |= READ_IMPLIES_EXEC;
725
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700726 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 current->flags |= PF_RANDOMIZE;
Linus Torvalds221af7f2010-01-28 22:14:42 -0800728
729 setup_new_exec(bprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730
731 /* Do this so that we can load the interpreter, if need be. We will
732 change some of these later */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 current->mm->free_area_cache = current->mm->mmap_base;
Wolfgang Wander1363c3c2005-06-21 17:14:49 -0700734 current->mm->cached_hole_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
736 executable_stack);
737 if (retval < 0) {
738 send_sig(SIGKILL, current, 0);
739 goto out_free_dentry;
740 }
741
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 current->mm->start_stack = bprm->p;
743
André Goddard Rosaaf901ca2009-11-14 13:09:05 -0200744 /* Now we do a little grungy work by mmapping the ELF image into
Jiri Kosinacc503c12008-01-30 13:31:07 +0100745 the correct location in memory. */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700746 for(i = 0, elf_ppnt = elf_phdata;
747 i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 int elf_prot = 0, elf_flags;
749 unsigned long k, vaddr;
750
751 if (elf_ppnt->p_type != PT_LOAD)
752 continue;
753
754 if (unlikely (elf_brk > elf_bss)) {
755 unsigned long nbyte;
756
757 /* There was a PT_LOAD segment with p_memsz > p_filesz
758 before this one. Map anonymous pages, if needed,
759 and clear the area. */
Mikael Petterssonf670d0e2011-01-12 17:00:02 -0800760 retval = set_brk(elf_bss + load_bias,
761 elf_brk + load_bias);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 if (retval) {
763 send_sig(SIGKILL, current, 0);
764 goto out_free_dentry;
765 }
766 nbyte = ELF_PAGEOFFSET(elf_bss);
767 if (nbyte) {
768 nbyte = ELF_MIN_ALIGN - nbyte;
769 if (nbyte > elf_brk - elf_bss)
770 nbyte = elf_brk - elf_bss;
771 if (clear_user((void __user *)elf_bss +
772 load_bias, nbyte)) {
773 /*
774 * This bss-zeroing can fail if the ELF
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700775 * file specifies odd protections. So
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 * we don't check the return value
777 */
778 }
779 }
780 }
781
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700782 if (elf_ppnt->p_flags & PF_R)
783 elf_prot |= PROT_READ;
784 if (elf_ppnt->p_flags & PF_W)
785 elf_prot |= PROT_WRITE;
786 if (elf_ppnt->p_flags & PF_X)
787 elf_prot |= PROT_EXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700789 elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790
791 vaddr = elf_ppnt->p_vaddr;
792 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
793 elf_flags |= MAP_FIXED;
794 } else if (loc->elf_ex.e_type == ET_DYN) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700795 /* Try and get dynamic programs out of the way of the
796 * default mmap base, as well as whatever program they
797 * might try to exec. This is because the brk will
798 * follow the loader, and is not movable. */
David Daneye39f5602012-01-10 15:10:21 -0800799#ifdef CONFIG_ARCH_BINFMT_ELF_RANDOMIZE_PIE
Jiri Kosinaa3defbe2011-11-02 13:37:41 -0700800 /* Memory randomization might have been switched off
801 * in runtime via sysctl.
802 * If that is the case, retain the original non-zero
803 * load_bias value in order to establish proper
804 * non-randomized mappings.
805 */
806 if (current->flags & PF_RANDOMIZE)
807 load_bias = 0;
808 else
809 load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100810#else
Linus Torvalds90cb28e2007-01-06 13:28:21 -0800811 load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100812#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 }
814
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700815 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
Andrew Mortonbb1ad822008-01-30 13:31:07 +0100816 elf_prot, elf_flags, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 if (BAD_ADDR(error)) {
818 send_sig(SIGKILL, current, 0);
Alexey Kuznetsovb140f2512007-05-08 00:31:57 -0700819 retval = IS_ERR((void *)error) ?
820 PTR_ERR((void*)error) : -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 goto out_free_dentry;
822 }
823
824 if (!load_addr_set) {
825 load_addr_set = 1;
826 load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
827 if (loc->elf_ex.e_type == ET_DYN) {
828 load_bias += error -
829 ELF_PAGESTART(load_bias + vaddr);
830 load_addr += load_bias;
831 reloc_func_desc = load_bias;
832 }
833 }
834 k = elf_ppnt->p_vaddr;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700835 if (k < start_code)
836 start_code = k;
837 if (start_data < k)
838 start_data = k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
840 /*
841 * Check to see if the section's size will overflow the
842 * allowed task size. Note that p_filesz must always be
843 * <= p_memsz so it is only necessary to check p_memsz.
844 */
Chuck Ebbertce510592006-07-03 00:24:14 -0700845 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 elf_ppnt->p_memsz > TASK_SIZE ||
847 TASK_SIZE - elf_ppnt->p_memsz < k) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700848 /* set_brk can never work. Avoid overflows. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 send_sig(SIGKILL, current, 0);
Alexey Kuznetsovb140f2512007-05-08 00:31:57 -0700850 retval = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 goto out_free_dentry;
852 }
853
854 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
855
856 if (k > elf_bss)
857 elf_bss = k;
858 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
859 end_code = k;
860 if (end_data < k)
861 end_data = k;
862 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
863 if (k > elf_brk)
864 elf_brk = k;
865 }
866
867 loc->elf_ex.e_entry += load_bias;
868 elf_bss += load_bias;
869 elf_brk += load_bias;
870 start_code += load_bias;
871 end_code += load_bias;
872 start_data += load_bias;
873 end_data += load_bias;
874
875 /* Calling set_brk effectively mmaps the pages that we need
876 * for the bss and break sections. We must do this before
877 * mapping in the interpreter, to make sure it doesn't wind
878 * up getting placed where the bss needs to go.
879 */
880 retval = set_brk(elf_bss, elf_brk);
881 if (retval) {
882 send_sig(SIGKILL, current, 0);
883 goto out_free_dentry;
884 }
akpm@osdl.org6de50512005-10-11 08:29:08 -0700885 if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 send_sig(SIGSEGV, current, 0);
887 retval = -EFAULT; /* Nobody gets to see this, but.. */
888 goto out_free_dentry;
889 }
890
891 if (elf_interpreter) {
Alan Cox6eec4822012-10-04 17:13:42 -0700892 unsigned long interp_map_addr = 0;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100893
Andi Kleend20894a2008-02-08 04:21:54 -0800894 elf_entry = load_elf_interp(&loc->interp_elf_ex,
895 interpreter,
896 &interp_map_addr,
897 load_bias);
898 if (!IS_ERR((void *)elf_entry)) {
899 /*
900 * load_elf_interp() returns relocation
901 * adjustment
902 */
903 interp_load_addr = elf_entry;
904 elf_entry += loc->interp_elf_ex.e_entry;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100905 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 if (BAD_ADDR(elf_entry)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 force_sig(SIGSEGV, current);
Chuck Ebbertce510592006-07-03 00:24:14 -0700908 retval = IS_ERR((void *)elf_entry) ?
909 (int)elf_entry : -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 goto out_free_dentry;
911 }
912 reloc_func_desc = interp_load_addr;
913
914 allow_write_access(interpreter);
915 fput(interpreter);
916 kfree(elf_interpreter);
917 } else {
918 elf_entry = loc->elf_ex.e_entry;
Suresh Siddha5342fba2006-02-26 04:18:28 +0100919 if (BAD_ADDR(elf_entry)) {
Chuck Ebbertce510592006-07-03 00:24:14 -0700920 force_sig(SIGSEGV, current);
921 retval = -EINVAL;
Suresh Siddha5342fba2006-02-26 04:18:28 +0100922 goto out_free_dentry;
923 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 }
925
926 kfree(elf_phdata);
927
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 set_binfmt(&elf_format);
929
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -0700930#ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
Martin Schwidefskyfc5243d2008-12-25 13:38:35 +0100931 retval = arch_setup_additional_pages(bprm, !!elf_interpreter);
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -0700932 if (retval < 0) {
933 send_sig(SIGKILL, current, 0);
Roland McGrath18c8baf2005-04-28 15:17:19 -0700934 goto out;
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -0700935 }
936#endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
937
David Howellsa6f76f22008-11-14 10:39:24 +1100938 install_exec_creds(bprm);
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700939 retval = create_elf_tables(bprm, &loc->elf_ex,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700940 load_addr, interp_load_addr);
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700941 if (retval < 0) {
942 send_sig(SIGKILL, current, 0);
943 goto out;
944 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 /* N.B. passed_fileno might not be initialized? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 current->mm->end_code = end_code;
947 current->mm->start_code = start_code;
948 current->mm->start_data = start_data;
949 current->mm->end_data = end_data;
950 current->mm->start_stack = bprm->p;
951
Jiri Kosinac1d171a2008-01-30 13:30:40 +0100952#ifdef arch_randomize_brk
Jiri Kosina4471a672011-04-14 15:22:09 -0700953 if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
Jiri Kosinac1d171a2008-01-30 13:30:40 +0100954 current->mm->brk = current->mm->start_brk =
955 arch_randomize_brk(current->mm);
Jiri Kosina4471a672011-04-14 15:22:09 -0700956#ifdef CONFIG_COMPAT_BRK
957 current->brk_randomized = 1;
958#endif
959 }
Jiri Kosinac1d171a2008-01-30 13:30:40 +0100960#endif
961
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 if (current->personality & MMAP_PAGE_ZERO) {
963 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
964 and some applications "depend" upon this behavior.
965 Since we do not have the power to recompile these, we
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700966 emulate the SVr4 behavior. Sigh. */
Linus Torvalds6be5ceb2012-04-20 17:13:58 -0700967 error = vm_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 MAP_FIXED | MAP_PRIVATE, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969 }
970
971#ifdef ELF_PLAT_INIT
972 /*
973 * The ABI may specify that certain registers be set up in special
974 * ways (on i386 %edx is the address of a DT_FINI function, for
975 * example. In addition, it may also specify (eg, PowerPC64 ELF)
976 * that the e_entry field is the address of the function descriptor
977 * for the startup routine, rather than the address of the startup
978 * routine itself. This macro performs whatever initialization to
979 * the regs structure is required as well as any relocations to the
980 * function descriptor entries when executing dynamically links apps.
981 */
982 ELF_PLAT_INIT(regs, reloc_func_desc);
983#endif
984
985 start_thread(regs, elf_entry, bprm->p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 retval = 0;
987out:
988 kfree(loc);
989out_ret:
990 return retval;
991
992 /* error cleanup */
993out_free_dentry:
994 allow_write_access(interpreter);
995 if (interpreter)
996 fput(interpreter);
997out_free_interp:
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800998 kfree(elf_interpreter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999out_free_ph:
1000 kfree(elf_phdata);
1001 goto out;
1002}
1003
1004/* This is really simpleminded and specialized - we are loading an
1005 a.out library that is given an ELF header. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006static int load_elf_library(struct file *file)
1007{
1008 struct elf_phdr *elf_phdata;
1009 struct elf_phdr *eppnt;
1010 unsigned long elf_bss, bss, len;
1011 int retval, error, i, j;
1012 struct elfhdr elf_ex;
1013
1014 error = -ENOEXEC;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001015 retval = kernel_read(file, 0, (char *)&elf_ex, sizeof(elf_ex));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 if (retval != sizeof(elf_ex))
1017 goto out;
1018
1019 if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1020 goto out;
1021
1022 /* First of all, some simple consistency checks */
1023 if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001024 !elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 goto out;
1026
1027 /* Now read in all of the header information */
1028
1029 j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1030 /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1031
1032 error = -ENOMEM;
1033 elf_phdata = kmalloc(j, GFP_KERNEL);
1034 if (!elf_phdata)
1035 goto out;
1036
1037 eppnt = elf_phdata;
1038 error = -ENOEXEC;
1039 retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);
1040 if (retval != j)
1041 goto out_free_ph;
1042
1043 for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1044 if ((eppnt + i)->p_type == PT_LOAD)
1045 j++;
1046 if (j != 1)
1047 goto out_free_ph;
1048
1049 while (eppnt->p_type != PT_LOAD)
1050 eppnt++;
1051
1052 /* Now use mmap to map the library into memory. */
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001053 error = vm_mmap(file,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 ELF_PAGESTART(eppnt->p_vaddr),
1055 (eppnt->p_filesz +
1056 ELF_PAGEOFFSET(eppnt->p_vaddr)),
1057 PROT_READ | PROT_WRITE | PROT_EXEC,
1058 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
1059 (eppnt->p_offset -
1060 ELF_PAGEOFFSET(eppnt->p_vaddr)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 if (error != ELF_PAGESTART(eppnt->p_vaddr))
1062 goto out_free_ph;
1063
1064 elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1065 if (padzero(elf_bss)) {
1066 error = -EFAULT;
1067 goto out_free_ph;
1068 }
1069
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001070 len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr +
1071 ELF_MIN_ALIGN - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 bss = eppnt->p_memsz + eppnt->p_vaddr;
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -07001073 if (bss > len)
1074 vm_brk(len, bss - len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 error = 0;
1076
1077out_free_ph:
1078 kfree(elf_phdata);
1079out:
1080 return error;
1081}
1082
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08001083#ifdef CONFIG_ELF_CORE
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084/*
1085 * ELF core dumper
1086 *
1087 * Modelled on fs/exec.c:aout_core_dump()
1088 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1089 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090
1091/*
Jason Baron909af762012-03-23 15:02:51 -07001092 * The purpose of always_dump_vma() is to make sure that special kernel mappings
1093 * that are useful for post-mortem analysis are included in every core dump.
1094 * In that way we ensure that the core dump is fully interpretable later
1095 * without matching up the same kernel and hardware config to see what PC values
1096 * meant. These special mappings include - vDSO, vsyscall, and other
1097 * architecture specific mappings
1098 */
1099static bool always_dump_vma(struct vm_area_struct *vma)
1100{
1101 /* Any vsyscall mappings? */
1102 if (vma == get_gate_vma(vma->vm_mm))
1103 return true;
1104 /*
1105 * arch_vma_name() returns non-NULL for special architecture mappings,
1106 * such as vDSO sections.
1107 */
1108 if (arch_vma_name(vma))
1109 return true;
1110
1111 return false;
1112}
1113
1114/*
Roland McGrath82df3972007-10-16 23:27:02 -07001115 * Decide what to dump of a segment, part, all or none.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 */
Roland McGrath82df3972007-10-16 23:27:02 -07001117static unsigned long vma_dump_size(struct vm_area_struct *vma,
1118 unsigned long mm_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119{
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001120#define FILTER(type) (mm_flags & (1UL << MMF_DUMP_##type))
1121
Jason Baron909af762012-03-23 15:02:51 -07001122 /* always dump the vdso and vsyscall sections */
1123 if (always_dump_vma(vma))
Roland McGrath82df3972007-10-16 23:27:02 -07001124 goto whole;
Roland McGrathe5b97dd2007-01-26 00:56:48 -08001125
Konstantin Khlebnikov0103bd12012-10-08 16:28:59 -07001126 if (vma->vm_flags & VM_DONTDUMP)
Jason Baronaccb61f2012-03-23 15:02:51 -07001127 return 0;
1128
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001129 /* Hugetlb memory check */
1130 if (vma->vm_flags & VM_HUGETLB) {
1131 if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))
1132 goto whole;
1133 if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))
1134 goto whole;
1135 }
1136
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 /* Do not dump I/O mapped devices or special mappings */
Konstantin Khlebnikov314e51b2012-10-08 16:29:02 -07001138 if (vma->vm_flags & VM_IO)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 return 0;
1140
Kawai, Hidehiroa1b59e82007-07-19 01:48:29 -07001141 /* By default, dump shared memory if mapped from an anonymous file. */
1142 if (vma->vm_flags & VM_SHARED) {
Roland McGrath82df3972007-10-16 23:27:02 -07001143 if (vma->vm_file->f_path.dentry->d_inode->i_nlink == 0 ?
1144 FILTER(ANON_SHARED) : FILTER(MAPPED_SHARED))
1145 goto whole;
1146 return 0;
Kawai, Hidehiroa1b59e82007-07-19 01:48:29 -07001147 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148
Roland McGrath82df3972007-10-16 23:27:02 -07001149 /* Dump segments that have been written to. */
1150 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1151 goto whole;
1152 if (vma->vm_file == NULL)
1153 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154
Roland McGrath82df3972007-10-16 23:27:02 -07001155 if (FILTER(MAPPED_PRIVATE))
1156 goto whole;
1157
1158 /*
1159 * If this looks like the beginning of a DSO or executable mapping,
1160 * check for an ELF header. If we find one, dump the first page to
1161 * aid in determining what was mapped here.
1162 */
Roland McGrath92dc07b2009-02-06 17:34:07 -08001163 if (FILTER(ELF_HEADERS) &&
1164 vma->vm_pgoff == 0 && (vma->vm_flags & VM_READ)) {
Roland McGrath82df3972007-10-16 23:27:02 -07001165 u32 __user *header = (u32 __user *) vma->vm_start;
1166 u32 word;
Roland McGrath92dc07b2009-02-06 17:34:07 -08001167 mm_segment_t fs = get_fs();
Roland McGrath82df3972007-10-16 23:27:02 -07001168 /*
1169 * Doing it this way gets the constant folded by GCC.
1170 */
1171 union {
1172 u32 cmp;
1173 char elfmag[SELFMAG];
1174 } magic;
1175 BUILD_BUG_ON(SELFMAG != sizeof word);
1176 magic.elfmag[EI_MAG0] = ELFMAG0;
1177 magic.elfmag[EI_MAG1] = ELFMAG1;
1178 magic.elfmag[EI_MAG2] = ELFMAG2;
1179 magic.elfmag[EI_MAG3] = ELFMAG3;
Roland McGrath92dc07b2009-02-06 17:34:07 -08001180 /*
1181 * Switch to the user "segment" for get_user(),
1182 * then put back what elf_core_dump() had in place.
1183 */
1184 set_fs(USER_DS);
1185 if (unlikely(get_user(word, header)))
1186 word = 0;
1187 set_fs(fs);
1188 if (word == magic.cmp)
Roland McGrath82df3972007-10-16 23:27:02 -07001189 return PAGE_SIZE;
1190 }
1191
1192#undef FILTER
1193
1194 return 0;
1195
1196whole:
1197 return vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198}
1199
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200/* An ELF note in memory */
1201struct memelfnote
1202{
1203 const char *name;
1204 int type;
1205 unsigned int datasz;
1206 void *data;
1207};
1208
1209static int notesize(struct memelfnote *en)
1210{
1211 int sz;
1212
1213 sz = sizeof(struct elf_note);
1214 sz += roundup(strlen(en->name) + 1, 4);
1215 sz += roundup(en->datasz, 4);
1216
1217 return sz;
1218}
1219
Andi Kleend025c9d2006-09-30 23:29:28 -07001220#define DUMP_WRITE(addr, nr, foffset) \
1221 do { if (!dump_write(file, (addr), (nr))) return 0; *foffset += (nr); } while(0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222
Andi Kleend025c9d2006-09-30 23:29:28 -07001223static int alignfile(struct file *file, loff_t *foffset)
1224{
Petr Vandroveca7a0d862006-10-13 18:42:07 +02001225 static const char buf[4] = { 0, };
Andi Kleend025c9d2006-09-30 23:29:28 -07001226 DUMP_WRITE(buf, roundup(*foffset, 4) - *foffset, foffset);
1227 return 1;
1228}
1229
1230static int writenote(struct memelfnote *men, struct file *file,
1231 loff_t *foffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232{
1233 struct elf_note en;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 en.n_namesz = strlen(men->name) + 1;
1235 en.n_descsz = men->datasz;
1236 en.n_type = men->type;
1237
Andi Kleend025c9d2006-09-30 23:29:28 -07001238 DUMP_WRITE(&en, sizeof(en), foffset);
1239 DUMP_WRITE(men->name, en.n_namesz, foffset);
1240 if (!alignfile(file, foffset))
1241 return 0;
1242 DUMP_WRITE(men->data, men->datasz, foffset);
1243 if (!alignfile(file, foffset))
1244 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245
1246 return 1;
1247}
1248#undef DUMP_WRITE
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249
Roland McGrath3aba4812008-01-30 13:31:44 +01001250static void fill_elf_header(struct elfhdr *elf, int segs,
1251 u16 machine, u32 flags, u8 osabi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252{
Cyrill Gorcunov6970c8e2008-04-29 01:01:18 -07001253 memset(elf, 0, sizeof(*elf));
1254
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 memcpy(elf->e_ident, ELFMAG, SELFMAG);
1256 elf->e_ident[EI_CLASS] = ELF_CLASS;
1257 elf->e_ident[EI_DATA] = ELF_DATA;
1258 elf->e_ident[EI_VERSION] = EV_CURRENT;
1259 elf->e_ident[EI_OSABI] = ELF_OSABI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
1261 elf->e_type = ET_CORE;
Roland McGrath3aba4812008-01-30 13:31:44 +01001262 elf->e_machine = machine;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 elf->e_version = EV_CURRENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 elf->e_phoff = sizeof(struct elfhdr);
Roland McGrath3aba4812008-01-30 13:31:44 +01001265 elf->e_flags = flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 elf->e_ehsize = sizeof(struct elfhdr);
1267 elf->e_phentsize = sizeof(struct elf_phdr);
1268 elf->e_phnum = segs;
Cyrill Gorcunov6970c8e2008-04-29 01:01:18 -07001269
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 return;
1271}
1272
Andrew Morton8d6b5eee2006-09-25 23:32:04 -07001273static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274{
1275 phdr->p_type = PT_NOTE;
1276 phdr->p_offset = offset;
1277 phdr->p_vaddr = 0;
1278 phdr->p_paddr = 0;
1279 phdr->p_filesz = sz;
1280 phdr->p_memsz = 0;
1281 phdr->p_flags = 0;
1282 phdr->p_align = 0;
1283 return;
1284}
1285
1286static void fill_note(struct memelfnote *note, const char *name, int type,
1287 unsigned int sz, void *data)
1288{
1289 note->name = name;
1290 note->type = type;
1291 note->datasz = sz;
1292 note->data = data;
1293 return;
1294}
1295
1296/*
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001297 * fill up all the fields in prstatus from the given task struct, except
1298 * registers which need to be filled up separately.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 */
1300static void fill_prstatus(struct elf_prstatus *prstatus,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001301 struct task_struct *p, long signr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302{
1303 prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1304 prstatus->pr_sigpend = p->pending.signal.sig[0];
1305 prstatus->pr_sighold = p->blocked.sig[0];
Oleg Nesterov3b34fc52009-06-17 16:27:38 -07001306 rcu_read_lock();
1307 prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1308 rcu_read_unlock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001309 prstatus->pr_pid = task_pid_vnr(p);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001310 prstatus->pr_pgrp = task_pgrp_vnr(p);
1311 prstatus->pr_sid = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 if (thread_group_leader(p)) {
Frank Mayharf06febc2008-09-12 09:54:39 -07001313 struct task_cputime cputime;
1314
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 /*
Frank Mayharf06febc2008-09-12 09:54:39 -07001316 * This is the record for the group leader. It shows the
1317 * group-wide total, not its individual thread total.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 */
Frank Mayharf06febc2008-09-12 09:54:39 -07001319 thread_group_cputime(p, &cputime);
1320 cputime_to_timeval(cputime.utime, &prstatus->pr_utime);
1321 cputime_to_timeval(cputime.stime, &prstatus->pr_stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 } else {
1323 cputime_to_timeval(p->utime, &prstatus->pr_utime);
1324 cputime_to_timeval(p->stime, &prstatus->pr_stime);
1325 }
1326 cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
1327 cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
1328}
1329
1330static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1331 struct mm_struct *mm)
1332{
David Howellsc69e8d92008-11-14 10:39:19 +11001333 const struct cred *cred;
Greg Kroah-Hartmana84a5052005-05-11 00:10:44 -07001334 unsigned int i, len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335
1336 /* first copy the parameters from user space */
1337 memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1338
1339 len = mm->arg_end - mm->arg_start;
1340 if (len >= ELF_PRARGSZ)
1341 len = ELF_PRARGSZ-1;
1342 if (copy_from_user(&psinfo->pr_psargs,
1343 (const char __user *)mm->arg_start, len))
1344 return -EFAULT;
1345 for(i = 0; i < len; i++)
1346 if (psinfo->pr_psargs[i] == 0)
1347 psinfo->pr_psargs[i] = ' ';
1348 psinfo->pr_psargs[len] = 0;
1349
Oleg Nesterov3b34fc52009-06-17 16:27:38 -07001350 rcu_read_lock();
1351 psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1352 rcu_read_unlock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001353 psinfo->pr_pid = task_pid_vnr(p);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001354 psinfo->pr_pgrp = task_pgrp_vnr(p);
1355 psinfo->pr_sid = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356
1357 i = p->state ? ffz(~p->state) + 1 : 0;
1358 psinfo->pr_state = i;
Carsten Otte55148542006-03-25 03:08:22 -08001359 psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1361 psinfo->pr_nice = task_nice(p);
1362 psinfo->pr_flag = p->flags;
David Howellsc69e8d92008-11-14 10:39:19 +11001363 rcu_read_lock();
1364 cred = __task_cred(p);
Eric W. Biedermanebc887b2012-02-07 18:36:10 -08001365 SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
1366 SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
David Howellsc69e8d92008-11-14 10:39:19 +11001367 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1369
1370 return 0;
1371}
1372
Roland McGrath3aba4812008-01-30 13:31:44 +01001373static void fill_auxv_note(struct memelfnote *note, struct mm_struct *mm)
1374{
1375 elf_addr_t *auxv = (elf_addr_t *) mm->saved_auxv;
1376 int i = 0;
1377 do
1378 i += 2;
1379 while (auxv[i - 2] != AT_NULL);
1380 fill_note(note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);
1381}
1382
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001383static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,
1384 siginfo_t *siginfo)
1385{
1386 mm_segment_t old_fs = get_fs();
1387 set_fs(KERNEL_DS);
1388 copy_siginfo_to_user((user_siginfo_t __user *) csigdata, siginfo);
1389 set_fs(old_fs);
1390 fill_note(note, "CORE", NT_SIGINFO, sizeof(*csigdata), csigdata);
1391}
1392
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001393#define MAX_FILE_NOTE_SIZE (4*1024*1024)
1394/*
1395 * Format of NT_FILE note:
1396 *
1397 * long count -- how many files are mapped
1398 * long page_size -- units for file_ofs
1399 * array of [COUNT] elements of
1400 * long start
1401 * long end
1402 * long file_ofs
1403 * followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1404 */
1405static void fill_files_note(struct memelfnote *note)
1406{
1407 struct vm_area_struct *vma;
1408 unsigned count, size, names_ofs, remaining, n;
1409 user_long_t *data;
1410 user_long_t *start_end_ofs;
1411 char *name_base, *name_curpos;
1412
1413 /* *Estimated* file count and total data size needed */
1414 count = current->mm->map_count;
1415 size = count * 64;
1416
1417 names_ofs = (2 + 3 * count) * sizeof(data[0]);
1418 alloc:
1419 if (size >= MAX_FILE_NOTE_SIZE) /* paranoia check */
1420 goto err;
1421 size = round_up(size, PAGE_SIZE);
1422 data = vmalloc(size);
1423 if (!data)
1424 goto err;
1425
1426 start_end_ofs = data + 2;
1427 name_base = name_curpos = ((char *)data) + names_ofs;
1428 remaining = size - names_ofs;
1429 count = 0;
1430 for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1431 struct file *file;
1432 const char *filename;
1433
1434 file = vma->vm_file;
1435 if (!file)
1436 continue;
1437 filename = d_path(&file->f_path, name_curpos, remaining);
1438 if (IS_ERR(filename)) {
1439 if (PTR_ERR(filename) == -ENAMETOOLONG) {
1440 vfree(data);
1441 size = size * 5 / 4;
1442 goto alloc;
1443 }
1444 continue;
1445 }
1446
1447 /* d_path() fills at the end, move name down */
1448 /* n = strlen(filename) + 1: */
1449 n = (name_curpos + remaining) - filename;
1450 remaining = filename - name_curpos;
1451 memmove(name_curpos, filename, n);
1452 name_curpos += n;
1453
1454 *start_end_ofs++ = vma->vm_start;
1455 *start_end_ofs++ = vma->vm_end;
1456 *start_end_ofs++ = vma->vm_pgoff;
1457 count++;
1458 }
1459
1460 /* Now we know exact count of files, can store it */
1461 data[0] = count;
1462 data[1] = PAGE_SIZE;
1463 /*
1464 * Count usually is less than current->mm->map_count,
1465 * we need to move filenames down.
1466 */
1467 n = current->mm->map_count - count;
1468 if (n != 0) {
1469 unsigned shift_bytes = n * 3 * sizeof(data[0]);
1470 memmove(name_base - shift_bytes, name_base,
1471 name_curpos - name_base);
1472 name_curpos -= shift_bytes;
1473 }
1474
1475 size = name_curpos - (char *)data;
1476 fill_note(note, "CORE", NT_FILE, size, data);
1477 err: ;
1478}
1479
Roland McGrath4206d3a2008-01-30 13:31:45 +01001480#ifdef CORE_DUMP_USE_REGSET
1481#include <linux/regset.h>
1482
1483struct elf_thread_core_info {
1484 struct elf_thread_core_info *next;
1485 struct task_struct *task;
1486 struct elf_prstatus prstatus;
1487 struct memelfnote notes[0];
1488};
1489
1490struct elf_note_info {
1491 struct elf_thread_core_info *thread;
1492 struct memelfnote psinfo;
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001493 struct memelfnote signote;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001494 struct memelfnote auxv;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001495 struct memelfnote files;
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001496 user_siginfo_t csigdata;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001497 size_t size;
1498 int thread_notes;
1499};
1500
Roland McGrathd31472b2008-03-04 14:28:30 -08001501/*
1502 * When a regset has a writeback hook, we call it on each thread before
1503 * dumping user memory. On register window machines, this makes sure the
1504 * user memory backing the register data is up to date before we read it.
1505 */
1506static void do_thread_regset_writeback(struct task_struct *task,
1507 const struct user_regset *regset)
1508{
1509 if (regset->writeback)
1510 regset->writeback(task, regset, 1);
1511}
1512
H. J. Lu0953f65d2012-02-14 13:34:52 -08001513#ifndef PR_REG_SIZE
1514#define PR_REG_SIZE(S) sizeof(S)
1515#endif
1516
1517#ifndef PRSTATUS_SIZE
1518#define PRSTATUS_SIZE(S) sizeof(S)
1519#endif
1520
1521#ifndef PR_REG_PTR
1522#define PR_REG_PTR(S) (&((S)->pr_reg))
1523#endif
1524
1525#ifndef SET_PR_FPVALID
1526#define SET_PR_FPVALID(S, V) ((S)->pr_fpvalid = (V))
1527#endif
1528
Roland McGrath4206d3a2008-01-30 13:31:45 +01001529static int fill_thread_core_info(struct elf_thread_core_info *t,
1530 const struct user_regset_view *view,
1531 long signr, size_t *total)
1532{
1533 unsigned int i;
1534
1535 /*
1536 * NT_PRSTATUS is the one special case, because the regset data
1537 * goes into the pr_reg field inside the note contents, rather
1538 * than being the whole note contents. We fill the reset in here.
1539 * We assume that regset 0 is NT_PRSTATUS.
1540 */
1541 fill_prstatus(&t->prstatus, t->task, signr);
1542 (void) view->regsets[0].get(t->task, &view->regsets[0],
H. J. Lu0953f65d2012-02-14 13:34:52 -08001543 0, PR_REG_SIZE(t->prstatus.pr_reg),
1544 PR_REG_PTR(&t->prstatus), NULL);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001545
1546 fill_note(&t->notes[0], "CORE", NT_PRSTATUS,
H. J. Lu0953f65d2012-02-14 13:34:52 -08001547 PRSTATUS_SIZE(t->prstatus), &t->prstatus);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001548 *total += notesize(&t->notes[0]);
1549
Roland McGrathd31472b2008-03-04 14:28:30 -08001550 do_thread_regset_writeback(t->task, &view->regsets[0]);
1551
Roland McGrath4206d3a2008-01-30 13:31:45 +01001552 /*
1553 * Each other regset might generate a note too. For each regset
1554 * that has no core_note_type or is inactive, we leave t->notes[i]
1555 * all zero and we'll know to skip writing it later.
1556 */
1557 for (i = 1; i < view->n; ++i) {
1558 const struct user_regset *regset = &view->regsets[i];
Roland McGrathd31472b2008-03-04 14:28:30 -08001559 do_thread_regset_writeback(t->task, regset);
H. Peter Anvinc8e25252012-03-02 10:43:48 -08001560 if (regset->core_note_type && regset->get &&
Roland McGrath4206d3a2008-01-30 13:31:45 +01001561 (!regset->active || regset->active(t->task, regset))) {
1562 int ret;
1563 size_t size = regset->n * regset->size;
1564 void *data = kmalloc(size, GFP_KERNEL);
1565 if (unlikely(!data))
1566 return 0;
1567 ret = regset->get(t->task, regset,
1568 0, size, data, NULL);
1569 if (unlikely(ret))
1570 kfree(data);
1571 else {
1572 if (regset->core_note_type != NT_PRFPREG)
1573 fill_note(&t->notes[i], "LINUX",
1574 regset->core_note_type,
1575 size, data);
1576 else {
H. J. Lu0953f65d2012-02-14 13:34:52 -08001577 SET_PR_FPVALID(&t->prstatus, 1);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001578 fill_note(&t->notes[i], "CORE",
1579 NT_PRFPREG, size, data);
1580 }
1581 *total += notesize(&t->notes[i]);
1582 }
1583 }
1584 }
1585
1586 return 1;
1587}
1588
1589static int fill_note_info(struct elfhdr *elf, int phdrs,
1590 struct elf_note_info *info,
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001591 siginfo_t *siginfo, struct pt_regs *regs)
Roland McGrath4206d3a2008-01-30 13:31:45 +01001592{
1593 struct task_struct *dump_task = current;
1594 const struct user_regset_view *view = task_user_regset_view(dump_task);
1595 struct elf_thread_core_info *t;
1596 struct elf_prpsinfo *psinfo;
Oleg Nesterov83914442008-07-25 01:47:45 -07001597 struct core_thread *ct;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001598 unsigned int i;
1599
1600 info->size = 0;
1601 info->thread = NULL;
1602
1603 psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
Alan Cox6899e922012-12-17 16:02:09 -08001604 if (psinfo == NULL) {
1605 info->psinfo.data = NULL; /* So we don't free this wrongly */
Roland McGrath4206d3a2008-01-30 13:31:45 +01001606 return 0;
Alan Cox6899e922012-12-17 16:02:09 -08001607 }
Roland McGrath4206d3a2008-01-30 13:31:45 +01001608
Amerigo Wange2dbe122009-07-01 01:06:26 -04001609 fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1610
Roland McGrath4206d3a2008-01-30 13:31:45 +01001611 /*
1612 * Figure out how many notes we're going to need for each thread.
1613 */
1614 info->thread_notes = 0;
1615 for (i = 0; i < view->n; ++i)
1616 if (view->regsets[i].core_note_type != 0)
1617 ++info->thread_notes;
1618
1619 /*
1620 * Sanity check. We rely on regset 0 being in NT_PRSTATUS,
1621 * since it is our one special case.
1622 */
1623 if (unlikely(info->thread_notes == 0) ||
1624 unlikely(view->regsets[0].core_note_type != NT_PRSTATUS)) {
1625 WARN_ON(1);
1626 return 0;
1627 }
1628
1629 /*
1630 * Initialize the ELF file header.
1631 */
1632 fill_elf_header(elf, phdrs,
1633 view->e_machine, view->e_flags, view->ei_osabi);
1634
1635 /*
1636 * Allocate a structure for each thread.
1637 */
Oleg Nesterov83914442008-07-25 01:47:45 -07001638 for (ct = &dump_task->mm->core_state->dumper; ct; ct = ct->next) {
1639 t = kzalloc(offsetof(struct elf_thread_core_info,
1640 notes[info->thread_notes]),
1641 GFP_KERNEL);
1642 if (unlikely(!t))
1643 return 0;
Oleg Nesterov24d52882008-07-25 01:47:40 -07001644
Oleg Nesterov83914442008-07-25 01:47:45 -07001645 t->task = ct->task;
1646 if (ct->task == dump_task || !info->thread) {
1647 t->next = info->thread;
1648 info->thread = t;
1649 } else {
1650 /*
1651 * Make sure to keep the original task at
1652 * the head of the list.
1653 */
1654 t->next = info->thread->next;
1655 info->thread->next = t;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001656 }
Oleg Nesterov83914442008-07-25 01:47:45 -07001657 }
Roland McGrath4206d3a2008-01-30 13:31:45 +01001658
1659 /*
1660 * Now fill in each thread's information.
1661 */
1662 for (t = info->thread; t != NULL; t = t->next)
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001663 if (!fill_thread_core_info(t, view, siginfo->si_signo, &info->size))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001664 return 0;
1665
1666 /*
1667 * Fill in the two process-wide notes.
1668 */
1669 fill_psinfo(psinfo, dump_task->group_leader, dump_task->mm);
1670 info->size += notesize(&info->psinfo);
1671
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001672 fill_siginfo_note(&info->signote, &info->csigdata, siginfo);
1673 info->size += notesize(&info->signote);
1674
Roland McGrath4206d3a2008-01-30 13:31:45 +01001675 fill_auxv_note(&info->auxv, current->mm);
1676 info->size += notesize(&info->auxv);
1677
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001678 fill_files_note(&info->files);
1679 info->size += notesize(&info->files);
1680
Roland McGrath4206d3a2008-01-30 13:31:45 +01001681 return 1;
1682}
1683
1684static size_t get_note_info_size(struct elf_note_info *info)
1685{
1686 return info->size;
1687}
1688
1689/*
1690 * Write all the notes for each thread. When writing the first thread, the
1691 * process-wide notes are interleaved after the first thread-specific note.
1692 */
1693static int write_note_info(struct elf_note_info *info,
1694 struct file *file, loff_t *foffset)
1695{
1696 bool first = 1;
1697 struct elf_thread_core_info *t = info->thread;
1698
1699 do {
1700 int i;
1701
1702 if (!writenote(&t->notes[0], file, foffset))
1703 return 0;
1704
1705 if (first && !writenote(&info->psinfo, file, foffset))
1706 return 0;
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001707 if (first && !writenote(&info->signote, file, foffset))
1708 return 0;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001709 if (first && !writenote(&info->auxv, file, foffset))
1710 return 0;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001711 if (first && !writenote(&info->files, file, foffset))
1712 return 0;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001713
1714 for (i = 1; i < info->thread_notes; ++i)
1715 if (t->notes[i].data &&
1716 !writenote(&t->notes[i], file, foffset))
1717 return 0;
1718
1719 first = 0;
1720 t = t->next;
1721 } while (t);
1722
1723 return 1;
1724}
1725
1726static void free_note_info(struct elf_note_info *info)
1727{
1728 struct elf_thread_core_info *threads = info->thread;
1729 while (threads) {
1730 unsigned int i;
1731 struct elf_thread_core_info *t = threads;
1732 threads = t->next;
1733 WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);
1734 for (i = 1; i < info->thread_notes; ++i)
1735 kfree(t->notes[i].data);
1736 kfree(t);
1737 }
1738 kfree(info->psinfo.data);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001739 vfree(info->files.data);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001740}
1741
1742#else
1743
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744/* Here is the structure in which status of each thread is captured. */
1745struct elf_thread_status
1746{
1747 struct list_head list;
1748 struct elf_prstatus prstatus; /* NT_PRSTATUS */
1749 elf_fpregset_t fpu; /* NT_PRFPREG */
1750 struct task_struct *thread;
1751#ifdef ELF_CORE_COPY_XFPREGS
Mark Nelson5b20cd82007-10-16 23:25:39 -07001752 elf_fpxregset_t xfpu; /* ELF_CORE_XFPREG_TYPE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753#endif
1754 struct memelfnote notes[3];
1755 int num_notes;
1756};
1757
1758/*
1759 * In order to add the specific thread information for the elf file format,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001760 * we need to keep a linked list of every threads pr_status and then create
1761 * a single section for them in the final core file.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 */
1763static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1764{
1765 int sz = 0;
1766 struct task_struct *p = t->thread;
1767 t->num_notes = 0;
1768
1769 fill_prstatus(&t->prstatus, p, signr);
1770 elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1771
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001772 fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1773 &(t->prstatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 t->num_notes++;
1775 sz += notesize(&t->notes[0]);
1776
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001777 if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1778 &t->fpu))) {
1779 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1780 &(t->fpu));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 t->num_notes++;
1782 sz += notesize(&t->notes[1]);
1783 }
1784
1785#ifdef ELF_CORE_COPY_XFPREGS
1786 if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
Mark Nelson5b20cd82007-10-16 23:25:39 -07001787 fill_note(&t->notes[2], "LINUX", ELF_CORE_XFPREG_TYPE,
1788 sizeof(t->xfpu), &t->xfpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 t->num_notes++;
1790 sz += notesize(&t->notes[2]);
1791 }
1792#endif
1793 return sz;
1794}
1795
Roland McGrath3aba4812008-01-30 13:31:44 +01001796struct elf_note_info {
1797 struct memelfnote *notes;
1798 struct elf_prstatus *prstatus; /* NT_PRSTATUS */
1799 struct elf_prpsinfo *psinfo; /* NT_PRPSINFO */
1800 struct list_head thread_list;
1801 elf_fpregset_t *fpu;
1802#ifdef ELF_CORE_COPY_XFPREGS
1803 elf_fpxregset_t *xfpu;
1804#endif
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001805 user_siginfo_t csigdata;
Roland McGrath3aba4812008-01-30 13:31:44 +01001806 int thread_status_size;
1807 int numnote;
1808};
1809
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001810static int elf_note_info_init(struct elf_note_info *info)
Roland McGrath3aba4812008-01-30 13:31:44 +01001811{
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001812 memset(info, 0, sizeof(*info));
Roland McGrath3aba4812008-01-30 13:31:44 +01001813 INIT_LIST_HEAD(&info->thread_list);
1814
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001815 /* Allocate space for ELF notes */
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001816 info->notes = kmalloc(8 * sizeof(struct memelfnote), GFP_KERNEL);
Roland McGrath3aba4812008-01-30 13:31:44 +01001817 if (!info->notes)
1818 return 0;
1819 info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL);
1820 if (!info->psinfo)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001821 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001822 info->prstatus = kmalloc(sizeof(*info->prstatus), GFP_KERNEL);
1823 if (!info->prstatus)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001824 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001825 info->fpu = kmalloc(sizeof(*info->fpu), GFP_KERNEL);
1826 if (!info->fpu)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001827 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001828#ifdef ELF_CORE_COPY_XFPREGS
1829 info->xfpu = kmalloc(sizeof(*info->xfpu), GFP_KERNEL);
1830 if (!info->xfpu)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001831 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001832#endif
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001833 return 1;
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001834}
Roland McGrath3aba4812008-01-30 13:31:44 +01001835
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001836static int fill_note_info(struct elfhdr *elf, int phdrs,
1837 struct elf_note_info *info,
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001838 siginfo_t *siginfo, struct pt_regs *regs)
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001839{
1840 struct list_head *t;
1841
1842 if (!elf_note_info_init(info))
1843 return 0;
1844
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001845 if (siginfo->si_signo) {
Oleg Nesterov83914442008-07-25 01:47:45 -07001846 struct core_thread *ct;
WANG Cong4220b7f2008-04-29 01:01:18 -07001847 struct elf_thread_status *ets;
Oleg Nesterov24d52882008-07-25 01:47:40 -07001848
Oleg Nesterov83914442008-07-25 01:47:45 -07001849 for (ct = current->mm->core_state->dumper.next;
1850 ct; ct = ct->next) {
1851 ets = kzalloc(sizeof(*ets), GFP_KERNEL);
1852 if (!ets)
1853 return 0;
1854
1855 ets->thread = ct->task;
1856 list_add(&ets->list, &info->thread_list);
1857 }
1858
Roland McGrath3aba4812008-01-30 13:31:44 +01001859 list_for_each(t, &info->thread_list) {
Roland McGrath3aba4812008-01-30 13:31:44 +01001860 int sz;
1861
WANG Cong4220b7f2008-04-29 01:01:18 -07001862 ets = list_entry(t, struct elf_thread_status, list);
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001863 sz = elf_dump_thread_status(siginfo->si_signo, ets);
Roland McGrath3aba4812008-01-30 13:31:44 +01001864 info->thread_status_size += sz;
1865 }
1866 }
1867 /* now collect the dump for the current */
1868 memset(info->prstatus, 0, sizeof(*info->prstatus));
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001869 fill_prstatus(info->prstatus, current, siginfo->si_signo);
Roland McGrath3aba4812008-01-30 13:31:44 +01001870 elf_core_copy_regs(&info->prstatus->pr_reg, regs);
1871
1872 /* Set up header */
1873 fill_elf_header(elf, phdrs, ELF_ARCH, ELF_CORE_EFLAGS, ELF_OSABI);
1874
1875 /*
1876 * Set up the notes in similar form to SVR4 core dumps made
1877 * with info from their /proc.
1878 */
1879
1880 fill_note(info->notes + 0, "CORE", NT_PRSTATUS,
1881 sizeof(*info->prstatus), info->prstatus);
1882 fill_psinfo(info->psinfo, current->group_leader, current->mm);
1883 fill_note(info->notes + 1, "CORE", NT_PRPSINFO,
1884 sizeof(*info->psinfo), info->psinfo);
1885
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001886 fill_siginfo_note(info->notes + 2, &info->csigdata, siginfo);
1887 fill_auxv_note(info->notes + 3, current->mm);
1888 fill_files_note(info->notes + 4);
Roland McGrath3aba4812008-01-30 13:31:44 +01001889
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001890 info->numnote = 5;
Roland McGrath3aba4812008-01-30 13:31:44 +01001891
1892 /* Try to dump the FPU. */
1893 info->prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs,
1894 info->fpu);
1895 if (info->prstatus->pr_fpvalid)
1896 fill_note(info->notes + info->numnote++,
1897 "CORE", NT_PRFPREG, sizeof(*info->fpu), info->fpu);
1898#ifdef ELF_CORE_COPY_XFPREGS
1899 if (elf_core_copy_task_xfpregs(current, info->xfpu))
1900 fill_note(info->notes + info->numnote++,
1901 "LINUX", ELF_CORE_XFPREG_TYPE,
1902 sizeof(*info->xfpu), info->xfpu);
1903#endif
1904
1905 return 1;
Roland McGrath3aba4812008-01-30 13:31:44 +01001906}
1907
1908static size_t get_note_info_size(struct elf_note_info *info)
1909{
1910 int sz = 0;
1911 int i;
1912
1913 for (i = 0; i < info->numnote; i++)
1914 sz += notesize(info->notes + i);
1915
1916 sz += info->thread_status_size;
1917
1918 return sz;
1919}
1920
1921static int write_note_info(struct elf_note_info *info,
1922 struct file *file, loff_t *foffset)
1923{
1924 int i;
1925 struct list_head *t;
1926
1927 for (i = 0; i < info->numnote; i++)
1928 if (!writenote(info->notes + i, file, foffset))
1929 return 0;
1930
1931 /* write out the thread status notes section */
1932 list_for_each(t, &info->thread_list) {
1933 struct elf_thread_status *tmp =
1934 list_entry(t, struct elf_thread_status, list);
1935
1936 for (i = 0; i < tmp->num_notes; i++)
1937 if (!writenote(&tmp->notes[i], file, foffset))
1938 return 0;
1939 }
1940
1941 return 1;
1942}
1943
1944static void free_note_info(struct elf_note_info *info)
1945{
1946 while (!list_empty(&info->thread_list)) {
1947 struct list_head *tmp = info->thread_list.next;
1948 list_del(tmp);
1949 kfree(list_entry(tmp, struct elf_thread_status, list));
1950 }
1951
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001952 /* Free data allocated by fill_files_note(): */
1953 vfree(info->notes[4].data);
1954
Roland McGrath3aba4812008-01-30 13:31:44 +01001955 kfree(info->prstatus);
1956 kfree(info->psinfo);
1957 kfree(info->notes);
1958 kfree(info->fpu);
1959#ifdef ELF_CORE_COPY_XFPREGS
1960 kfree(info->xfpu);
1961#endif
1962}
1963
Roland McGrath4206d3a2008-01-30 13:31:45 +01001964#endif
1965
Roland McGrathf47aef52007-01-26 00:56:49 -08001966static struct vm_area_struct *first_vma(struct task_struct *tsk,
1967 struct vm_area_struct *gate_vma)
1968{
1969 struct vm_area_struct *ret = tsk->mm->mmap;
1970
1971 if (ret)
1972 return ret;
1973 return gate_vma;
1974}
1975/*
1976 * Helper function for iterating across a vma list. It ensures that the caller
1977 * will visit `gate_vma' prior to terminating the search.
1978 */
1979static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
1980 struct vm_area_struct *gate_vma)
1981{
1982 struct vm_area_struct *ret;
1983
1984 ret = this_vma->vm_next;
1985 if (ret)
1986 return ret;
1987 if (this_vma == gate_vma)
1988 return NULL;
1989 return gate_vma;
1990}
1991
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08001992static void fill_extnum_info(struct elfhdr *elf, struct elf_shdr *shdr4extnum,
1993 elf_addr_t e_shoff, int segs)
1994{
1995 elf->e_shoff = e_shoff;
1996 elf->e_shentsize = sizeof(*shdr4extnum);
1997 elf->e_shnum = 1;
1998 elf->e_shstrndx = SHN_UNDEF;
1999
2000 memset(shdr4extnum, 0, sizeof(*shdr4extnum));
2001
2002 shdr4extnum->sh_type = SHT_NULL;
2003 shdr4extnum->sh_size = elf->e_shnum;
2004 shdr4extnum->sh_link = elf->e_shstrndx;
2005 shdr4extnum->sh_info = segs;
2006}
2007
2008static size_t elf_core_vma_data_size(struct vm_area_struct *gate_vma,
2009 unsigned long mm_flags)
2010{
2011 struct vm_area_struct *vma;
2012 size_t size = 0;
2013
2014 for (vma = first_vma(current, gate_vma); vma != NULL;
2015 vma = next_vma(vma, gate_vma))
2016 size += vma_dump_size(vma, mm_flags);
2017 return size;
2018}
2019
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020/*
2021 * Actual dumper
2022 *
2023 * This is a two-pass process; first we find the offsets of the bits,
2024 * and then they are actually written out. If we run out of core limit
2025 * we just truncate.
2026 */
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002027static int elf_core_dump(struct coredump_params *cprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029 int has_dumped = 0;
2030 mm_segment_t fs;
2031 int segs;
2032 size_t size = 0;
Roland McGrathf47aef52007-01-26 00:56:49 -08002033 struct vm_area_struct *vma, *gate_vma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034 struct elfhdr *elf = NULL;
Andi Kleend025c9d2006-09-30 23:29:28 -07002035 loff_t offset = 0, dataoff, foffset;
Roland McGrath3aba4812008-01-30 13:31:44 +01002036 struct elf_note_info info;
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002037 struct elf_phdr *phdr4note = NULL;
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002038 struct elf_shdr *shdr4extnum = NULL;
2039 Elf_Half e_phnum;
2040 elf_addr_t e_shoff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041
2042 /*
2043 * We no longer stop all VM operations.
2044 *
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002045 * This is because those proceses that could possibly change map_count
2046 * or the mmap / vma pages are now blocked in do_exit on current
2047 * finishing this core dump.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 *
2049 * Only ptrace can touch these memory addresses, but it doesn't change
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002050 * the map_count or the pages allocated. So no possibility of crashing
Linus Torvalds1da177e2005-04-16 15:20:36 -07002051 * exists while dumping the mm->vm_next areas to the core file.
2052 */
2053
2054 /* alloc memory for large data structures: too large to be on stack */
2055 elf = kmalloc(sizeof(*elf), GFP_KERNEL);
2056 if (!elf)
WANG Cong5f719552008-05-06 12:45:35 +08002057 goto out;
KAMEZAWA Hiroyuki341c87b2009-06-30 11:41:23 -07002058 /*
2059 * The number of segs are recored into ELF header as 16bit value.
2060 * Please check DEFAULT_MAX_MAP_COUNT definition when you modify here.
2061 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 segs = current->mm->map_count;
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002063 segs += elf_core_extra_phdrs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064
Stephen Wilson31db58b2011-03-13 15:49:15 -04002065 gate_vma = get_gate_vma(current->mm);
Roland McGrathf47aef52007-01-26 00:56:49 -08002066 if (gate_vma != NULL)
2067 segs++;
2068
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002069 /* for notes section */
2070 segs++;
2071
2072 /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
2073 * this, kernel supports extended numbering. Have a look at
2074 * include/linux/elf.h for further information. */
2075 e_phnum = segs > PN_XNUM ? PN_XNUM : segs;
2076
Roland McGrath3aba4812008-01-30 13:31:44 +01002077 /*
2078 * Collect all the non-memory information about the process for the
2079 * notes. This also sets up the file header.
2080 */
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07002081 if (!fill_note_info(elf, e_phnum, &info, cprm->siginfo, cprm->regs))
Roland McGrath3aba4812008-01-30 13:31:44 +01002082 goto cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083
2084 has_dumped = 1;
2085 current->flags |= PF_DUMPCORE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086
2087 fs = get_fs();
2088 set_fs(KERNEL_DS);
2089
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090 offset += sizeof(*elf); /* Elf header */
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002091 offset += segs * sizeof(struct elf_phdr); /* Program headers */
Petr Vandroveca7a0d862006-10-13 18:42:07 +02002092 foffset = offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093
2094 /* Write notes phdr entry */
2095 {
Roland McGrath3aba4812008-01-30 13:31:44 +01002096 size_t sz = get_note_info_size(&info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097
Michael Ellermane5501492007-09-19 14:38:12 +10002098 sz += elf_coredump_extra_notes_size();
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002099
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002100 phdr4note = kmalloc(sizeof(*phdr4note), GFP_KERNEL);
2101 if (!phdr4note)
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -08002102 goto end_coredump;
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002103
2104 fill_elf_note_phdr(phdr4note, sz, offset);
2105 offset += sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 }
2107
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108 dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
2109
Masami Hiramatsu30736a42010-03-05 13:44:12 -08002110 offset += elf_core_vma_data_size(gate_vma, cprm->mm_flags);
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002111 offset += elf_core_extra_data_size();
2112 e_shoff = offset;
2113
2114 if (e_phnum == PN_XNUM) {
2115 shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);
2116 if (!shdr4extnum)
2117 goto end_coredump;
2118 fill_extnum_info(elf, shdr4extnum, e_shoff, segs);
2119 }
2120
2121 offset = dataoff;
2122
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002123 size += sizeof(*elf);
2124 if (size > cprm->limit || !dump_write(cprm->file, elf, sizeof(*elf)))
2125 goto end_coredump;
2126
2127 size += sizeof(*phdr4note);
2128 if (size > cprm->limit
2129 || !dump_write(cprm->file, phdr4note, sizeof(*phdr4note)))
2130 goto end_coredump;
2131
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 /* Write program headers for segments dump */
Roland McGrathf47aef52007-01-26 00:56:49 -08002133 for (vma = first_vma(current, gate_vma); vma != NULL;
2134 vma = next_vma(vma, gate_vma)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135 struct elf_phdr phdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136
2137 phdr.p_type = PT_LOAD;
2138 phdr.p_offset = offset;
2139 phdr.p_vaddr = vma->vm_start;
2140 phdr.p_paddr = 0;
Masami Hiramatsu30736a42010-03-05 13:44:12 -08002141 phdr.p_filesz = vma_dump_size(vma, cprm->mm_flags);
Roland McGrath82df3972007-10-16 23:27:02 -07002142 phdr.p_memsz = vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143 offset += phdr.p_filesz;
2144 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002145 if (vma->vm_flags & VM_WRITE)
2146 phdr.p_flags |= PF_W;
2147 if (vma->vm_flags & VM_EXEC)
2148 phdr.p_flags |= PF_X;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 phdr.p_align = ELF_EXEC_PAGESIZE;
2150
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -08002151 size += sizeof(phdr);
2152 if (size > cprm->limit
2153 || !dump_write(cprm->file, &phdr, sizeof(phdr)))
2154 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155 }
2156
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002157 if (!elf_core_write_extra_phdrs(cprm->file, offset, &size, cprm->limit))
2158 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159
2160 /* write out the notes section */
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002161 if (!write_note_info(&info, cprm->file, &foffset))
Roland McGrath3aba4812008-01-30 13:31:44 +01002162 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002164 if (elf_coredump_extra_notes_write(cprm->file, &foffset))
Michael Ellermane5501492007-09-19 14:38:12 +10002165 goto end_coredump;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002166
Andi Kleend025c9d2006-09-30 23:29:28 -07002167 /* Align to page */
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002168 if (!dump_seek(cprm->file, dataoff - foffset))
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002169 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170
Roland McGrathf47aef52007-01-26 00:56:49 -08002171 for (vma = first_vma(current, gate_vma); vma != NULL;
2172 vma = next_vma(vma, gate_vma)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173 unsigned long addr;
Roland McGrath82df3972007-10-16 23:27:02 -07002174 unsigned long end;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175
Masami Hiramatsu30736a42010-03-05 13:44:12 -08002176 end = vma->vm_start + vma_dump_size(vma, cprm->mm_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177
Roland McGrath82df3972007-10-16 23:27:02 -07002178 for (addr = vma->vm_start; addr < end; addr += PAGE_SIZE) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002179 struct page *page;
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002180 int stop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002182 page = get_dump_page(addr);
2183 if (page) {
2184 void *kaddr = kmap(page);
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002185 stop = ((size += PAGE_SIZE) > cprm->limit) ||
2186 !dump_write(cprm->file, kaddr,
2187 PAGE_SIZE);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002188 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 page_cache_release(page);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002190 } else
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002191 stop = !dump_seek(cprm->file, PAGE_SIZE);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002192 if (stop)
2193 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194 }
2195 }
2196
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002197 if (!elf_core_write_extra_data(cprm->file, &size, cprm->limit))
2198 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002200 if (e_phnum == PN_XNUM) {
2201 size += sizeof(*shdr4extnum);
2202 if (size > cprm->limit
2203 || !dump_write(cprm->file, shdr4extnum,
2204 sizeof(*shdr4extnum)))
2205 goto end_coredump;
2206 }
2207
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208end_coredump:
2209 set_fs(fs);
2210
2211cleanup:
Roland McGrath3aba4812008-01-30 13:31:44 +01002212 free_note_info(&info);
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002213 kfree(shdr4extnum);
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002214 kfree(phdr4note);
WANG Cong5f719552008-05-06 12:45:35 +08002215 kfree(elf);
2216out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 return has_dumped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218}
2219
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08002220#endif /* CONFIG_ELF_CORE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221
2222static int __init init_elf_binfmt(void)
2223{
Al Viro8fc3dc52012-03-17 03:05:16 -04002224 register_binfmt(&elf_format);
2225 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226}
2227
2228static void __exit exit_elf_binfmt(void)
2229{
2230 /* Remove the COFF and ELF loaders. */
2231 unregister_binfmt(&elf_format);
2232}
2233
2234core_initcall(init_elf_binfmt);
2235module_exit(exit_elf_binfmt);
2236MODULE_LICENSE("GPL");