blob: 52a6c5042586d52d3fe9b8f308a9e81ce973f70e [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>
30#include <linux/security.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/random.h>
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070032#include <linux/elf.h>
Alexey Dobriyan7e80d0d2007-05-08 00:28:59 -070033#include <linux/utsname.h>
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -080034#include <linux/coredump.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <asm/uaccess.h>
36#include <asm/param.h>
37#include <asm/page.h>
David Howells96f951e2012-03-28 18:30:03 +010038#include <asm/exec.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070040static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs);
41static int load_elf_library(struct file *);
Andrew Mortonbb1ad822008-01-30 13:31:07 +010042static unsigned long elf_map(struct file *, unsigned long, struct elf_phdr *,
43 int, int, unsigned long);
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Linus Torvalds1da177e2005-04-16 15:20:36 -070045/*
46 * If we don't support core dumping, then supply a NULL so we
47 * don't even try.
48 */
Christoph Hellwig698ba7b2009-12-15 16:47:37 -080049#ifdef CONFIG_ELF_CORE
Masami Hiramatsuf6151df2009-12-17 15:27:16 -080050static int elf_core_dump(struct coredump_params *cprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#else
52#define elf_core_dump NULL
53#endif
54
55#if ELF_EXEC_PAGESIZE > PAGE_SIZE
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070056#define ELF_MIN_ALIGN ELF_EXEC_PAGESIZE
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#else
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070058#define ELF_MIN_ALIGN PAGE_SIZE
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#endif
60
61#ifndef ELF_CORE_EFLAGS
62#define ELF_CORE_EFLAGS 0
63#endif
64
65#define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
66#define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
67#define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
68
69static struct linux_binfmt elf_format = {
Mikael Petterssonf670d0e2011-01-12 17:00:02 -080070 .module = THIS_MODULE,
71 .load_binary = load_elf_binary,
72 .load_shlib = load_elf_library,
73 .core_dump = elf_core_dump,
74 .min_coredump = ELF_EXEC_PAGESIZE,
Linus Torvalds1da177e2005-04-16 15:20:36 -070075};
76
Andrew Mortond4e3cc32007-07-21 04:37:32 -070077#define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79static int set_brk(unsigned long start, unsigned long end)
80{
81 start = ELF_PAGEALIGN(start);
82 end = ELF_PAGEALIGN(end);
83 if (end > start) {
84 unsigned long addr;
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -070085 addr = vm_brk(start, end - start);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 if (BAD_ADDR(addr))
87 return addr;
88 }
89 current->mm->start_brk = current->mm->brk = end;
90 return 0;
91}
92
Linus Torvalds1da177e2005-04-16 15:20:36 -070093/* We need to explicitly zero any fractional pages
94 after the data section (i.e. bss). This would
95 contain the junk from the file that should not
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070096 be in memory
97 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070098static int padzero(unsigned long elf_bss)
99{
100 unsigned long nbyte;
101
102 nbyte = ELF_PAGEOFFSET(elf_bss);
103 if (nbyte) {
104 nbyte = ELF_MIN_ALIGN - nbyte;
105 if (clear_user((void __user *) elf_bss, nbyte))
106 return -EFAULT;
107 }
108 return 0;
109}
110
Ohad Ben-Cohen09c6dd32008-02-03 18:05:15 +0200111/* Let's use some macros to make this stack manipulation a little clearer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112#ifdef CONFIG_STACK_GROWSUP
113#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))
114#define STACK_ROUND(sp, items) \
115 ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700116#define STACK_ALLOC(sp, len) ({ \
117 elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; \
118 old_sp; })
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119#else
120#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))
121#define STACK_ROUND(sp, items) \
122 (((unsigned long) (sp - items)) &~ 15UL)
123#define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })
124#endif
125
Nathan Lynch483fad12008-07-22 04:48:46 +1000126#ifndef ELF_BASE_PLATFORM
127/*
128 * AT_BASE_PLATFORM indicates the "real" hardware/microarchitecture.
129 * If the arch defines ELF_BASE_PLATFORM (in asm/elf.h), the value
130 * will be copied to the user stack in the same manner as AT_PLATFORM.
131 */
132#define ELF_BASE_PLATFORM NULL
133#endif
134
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135static int
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700136create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
Andi Kleend20894a2008-02-08 04:21:54 -0800137 unsigned long load_addr, unsigned long interp_load_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138{
139 unsigned long p = bprm->p;
140 int argc = bprm->argc;
141 int envc = bprm->envc;
142 elf_addr_t __user *argv;
143 elf_addr_t __user *envp;
144 elf_addr_t __user *sp;
145 elf_addr_t __user *u_platform;
Nathan Lynch483fad12008-07-22 04:48:46 +1000146 elf_addr_t __user *u_base_platform;
Kees Cookf06295b2009-01-07 18:08:52 -0800147 elf_addr_t __user *u_rand_bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 const char *k_platform = ELF_PLATFORM;
Nathan Lynch483fad12008-07-22 04:48:46 +1000149 const char *k_base_platform = ELF_BASE_PLATFORM;
Kees Cookf06295b2009-01-07 18:08:52 -0800150 unsigned char k_rand_bytes[16];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 int items;
152 elf_addr_t *elf_info;
153 int ei_index = 0;
David Howells86a264a2008-11-14 10:39:18 +1100154 const struct cred *cred = current_cred();
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700155 struct vm_area_struct *vma;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
157 /*
Franck Bui-Huud68c9d62007-10-16 23:30:24 -0700158 * In some cases (e.g. Hyper-Threading), we want to avoid L1
159 * evictions by the processes running on the same package. One
160 * thing we can do is to shuffle the initial stack for them.
161 */
162
163 p = arch_align_stack(p);
164
165 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 * If this architecture has a platform capability string, copy it
167 * to userspace. In some cases (Sparc), this info is impossible
168 * for userspace to get any other way, in others (i386) it is
169 * merely difficult.
170 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 u_platform = NULL;
172 if (k_platform) {
173 size_t len = strlen(k_platform) + 1;
174
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
176 if (__copy_to_user(u_platform, k_platform, len))
177 return -EFAULT;
178 }
179
Nathan Lynch483fad12008-07-22 04:48:46 +1000180 /*
181 * If this architecture has a "base" platform capability
182 * string, copy it to userspace.
183 */
184 u_base_platform = NULL;
185 if (k_base_platform) {
186 size_t len = strlen(k_base_platform) + 1;
187
188 u_base_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
189 if (__copy_to_user(u_base_platform, k_base_platform, len))
190 return -EFAULT;
191 }
192
Kees Cookf06295b2009-01-07 18:08:52 -0800193 /*
194 * Generate 16 random bytes for userspace PRNG seeding.
195 */
196 get_random_bytes(k_rand_bytes, sizeof(k_rand_bytes));
197 u_rand_bytes = (elf_addr_t __user *)
198 STACK_ALLOC(p, sizeof(k_rand_bytes));
199 if (__copy_to_user(u_rand_bytes, k_rand_bytes, sizeof(k_rand_bytes)))
200 return -EFAULT;
201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 /* Create the ELF interpreter info */
Jesper Juhl785d5572006-06-23 02:05:35 -0700203 elf_info = (elf_addr_t *)current->mm->saved_auxv;
Olaf Hering4f9a58d2007-10-16 23:30:12 -0700204 /* update AT_VECTOR_SIZE_BASE if the number of NEW_AUX_ENT() changes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205#define NEW_AUX_ENT(id, val) \
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700206 do { \
Jesper Juhl785d5572006-06-23 02:05:35 -0700207 elf_info[ei_index++] = id; \
208 elf_info[ei_index++] = val; \
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700209 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
211#ifdef ARCH_DLINFO
212 /*
213 * ARCH_DLINFO must come first so PPC can do its special alignment of
214 * AUXV.
Olaf Hering4f9a58d2007-10-16 23:30:12 -0700215 * update AT_VECTOR_SIZE_ARCH if the number of NEW_AUX_ENT() in
216 * ARCH_DLINFO changes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 */
218 ARCH_DLINFO;
219#endif
220 NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);
221 NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
222 NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
223 NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700224 NEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);
226 NEW_AUX_ENT(AT_BASE, interp_load_addr);
227 NEW_AUX_ENT(AT_FLAGS, 0);
228 NEW_AUX_ENT(AT_ENTRY, exec->e_entry);
David Howells86a264a2008-11-14 10:39:18 +1100229 NEW_AUX_ENT(AT_UID, cred->uid);
230 NEW_AUX_ENT(AT_EUID, cred->euid);
231 NEW_AUX_ENT(AT_GID, cred->gid);
232 NEW_AUX_ENT(AT_EGID, cred->egid);
Jesper Juhl785d5572006-06-23 02:05:35 -0700233 NEW_AUX_ENT(AT_SECURE, security_bprm_secureexec(bprm));
Kees Cookf06295b2009-01-07 18:08:52 -0800234 NEW_AUX_ENT(AT_RANDOM, (elf_addr_t)(unsigned long)u_rand_bytes);
John Reiser65191082008-07-21 14:21:32 -0700235 NEW_AUX_ENT(AT_EXECFN, bprm->exec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 if (k_platform) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700237 NEW_AUX_ENT(AT_PLATFORM,
Jesper Juhl785d5572006-06-23 02:05:35 -0700238 (elf_addr_t)(unsigned long)u_platform);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 }
Nathan Lynch483fad12008-07-22 04:48:46 +1000240 if (k_base_platform) {
241 NEW_AUX_ENT(AT_BASE_PLATFORM,
242 (elf_addr_t)(unsigned long)u_base_platform);
243 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
Jesper Juhl785d5572006-06-23 02:05:35 -0700245 NEW_AUX_ENT(AT_EXECFD, bprm->interp_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 }
247#undef NEW_AUX_ENT
248 /* AT_NULL is zero; clear the rest too */
249 memset(&elf_info[ei_index], 0,
250 sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);
251
252 /* And advance past the AT_NULL entry. */
253 ei_index += 2;
254
255 sp = STACK_ADD(p, ei_index);
256
Andi Kleend20894a2008-02-08 04:21:54 -0800257 items = (argc + 1) + (envc + 1) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 bprm->p = STACK_ROUND(sp, items);
259
260 /* Point sp at the lowest address on the stack */
261#ifdef CONFIG_STACK_GROWSUP
262 sp = (elf_addr_t __user *)bprm->p - items - ei_index;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700263 bprm->exec = (unsigned long)sp; /* XXX: PARISC HACK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264#else
265 sp = (elf_addr_t __user *)bprm->p;
266#endif
267
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700268
269 /*
270 * Grow the stack manually; some architectures have a limit on how
271 * far ahead a user-space access may be in order to grow the stack.
272 */
273 vma = find_extend_vma(current->mm, bprm->p);
274 if (!vma)
275 return -EFAULT;
276
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 /* Now, let's put argc (and argv, envp if appropriate) on the stack */
278 if (__put_user(argc, sp++))
279 return -EFAULT;
Andi Kleend20894a2008-02-08 04:21:54 -0800280 argv = sp;
281 envp = argv + argc + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
283 /* Populate argv and envp */
Greg Kroah-Hartmana84a5052005-05-11 00:10:44 -0700284 p = current->mm->arg_end = current->mm->arg_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 while (argc-- > 0) {
286 size_t len;
Heiko Carstens841d5fb2006-12-06 20:36:35 -0800287 if (__put_user((elf_addr_t)p, argv++))
288 return -EFAULT;
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700289 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
290 if (!len || len > MAX_ARG_STRLEN)
WANG Cong23c49712008-05-08 21:52:33 +0800291 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 p += len;
293 }
294 if (__put_user(0, argv))
295 return -EFAULT;
296 current->mm->arg_end = current->mm->env_start = p;
297 while (envc-- > 0) {
298 size_t len;
Heiko Carstens841d5fb2006-12-06 20:36:35 -0800299 if (__put_user((elf_addr_t)p, envp++))
300 return -EFAULT;
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700301 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
302 if (!len || len > MAX_ARG_STRLEN)
WANG Cong23c49712008-05-08 21:52:33 +0800303 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 p += len;
305 }
306 if (__put_user(0, envp))
307 return -EFAULT;
308 current->mm->env_end = p;
309
310 /* Put the elf_info on the stack in the right place. */
311 sp = (elf_addr_t __user *)envp + 1;
312 if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))
313 return -EFAULT;
314 return 0;
315}
316
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317static unsigned long elf_map(struct file *filep, unsigned long addr,
Jiri Kosinacc503c12008-01-30 13:31:07 +0100318 struct elf_phdr *eppnt, int prot, int type,
319 unsigned long total_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320{
321 unsigned long map_addr;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100322 unsigned long size = eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr);
323 unsigned long off = eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr);
324 addr = ELF_PAGESTART(addr);
325 size = ELF_PAGEALIGN(size);
Jan Kratochvil60bfba72007-07-15 23:40:06 -0700326
Andrew Mortond4e3cc32007-07-21 04:37:32 -0700327 /* mmap() will return -EINVAL if given a zero size, but a
328 * segment with zero filesize is perfectly valid */
Jiri Kosinacc503c12008-01-30 13:31:07 +0100329 if (!size)
330 return addr;
331
332 down_write(&current->mm->mmap_sem);
333 /*
334 * total_size is the size of the ELF (interpreter) image.
335 * The _first_ mmap needs to know the full size, otherwise
336 * randomization might put this image into an overlapping
337 * position with the ELF binary image. (since size < total_size)
338 * So we first map the 'big' image - and unmap the remainder at
339 * the end. (which unmap is needed for ELF images with holes.)
340 */
341 if (total_size) {
342 total_size = ELF_PAGEALIGN(total_size);
343 map_addr = do_mmap(filep, addr, total_size, prot, type, off);
344 if (!BAD_ADDR(map_addr))
345 do_munmap(current->mm, map_addr+size, total_size-size);
346 } else
347 map_addr = do_mmap(filep, addr, size, prot, type, off);
348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 up_write(&current->mm->mmap_sem);
350 return(map_addr);
351}
352
Jiri Kosinacc503c12008-01-30 13:31:07 +0100353static unsigned long total_mapping_size(struct elf_phdr *cmds, int nr)
354{
355 int i, first_idx = -1, last_idx = -1;
356
357 for (i = 0; i < nr; i++) {
358 if (cmds[i].p_type == PT_LOAD) {
359 last_idx = i;
360 if (first_idx == -1)
361 first_idx = i;
362 }
363 }
364 if (first_idx == -1)
365 return 0;
366
367 return cmds[last_idx].p_vaddr + cmds[last_idx].p_memsz -
368 ELF_PAGESTART(cmds[first_idx].p_vaddr);
369}
370
371
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372/* This is much more generalized than the library routine read function,
373 so we keep this separate. Technically the library read function
374 is only provided so that we can read a.out libraries that have
375 an ELF header */
376
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700377static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
Jiri Kosinacc503c12008-01-30 13:31:07 +0100378 struct file *interpreter, unsigned long *interp_map_addr,
379 unsigned long no_base)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380{
381 struct elf_phdr *elf_phdata;
382 struct elf_phdr *eppnt;
383 unsigned long load_addr = 0;
384 int load_addr_set = 0;
385 unsigned long last_bss = 0, elf_bss = 0;
386 unsigned long error = ~0UL;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100387 unsigned long total_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 int retval, i, size;
389
390 /* First of all, some simple consistency checks */
391 if (interp_elf_ex->e_type != ET_EXEC &&
392 interp_elf_ex->e_type != ET_DYN)
393 goto out;
394 if (!elf_check_arch(interp_elf_ex))
395 goto out;
396 if (!interpreter->f_op || !interpreter->f_op->mmap)
397 goto out;
398
399 /*
400 * If the size of this structure has changed, then punt, since
401 * we will be doing the wrong thing.
402 */
403 if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr))
404 goto out;
405 if (interp_elf_ex->e_phnum < 1 ||
406 interp_elf_ex->e_phnum > 65536U / sizeof(struct elf_phdr))
407 goto out;
408
409 /* Now read in all of the header information */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 size = sizeof(struct elf_phdr) * interp_elf_ex->e_phnum;
411 if (size > ELF_MIN_ALIGN)
412 goto out;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700413 elf_phdata = kmalloc(size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 if (!elf_phdata)
415 goto out;
416
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700417 retval = kernel_read(interpreter, interp_elf_ex->e_phoff,
Mikael Petterssonf670d0e2011-01-12 17:00:02 -0800418 (char *)elf_phdata, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 error = -EIO;
420 if (retval != size) {
421 if (retval < 0)
422 error = retval;
423 goto out_close;
424 }
425
Jiri Kosinacc503c12008-01-30 13:31:07 +0100426 total_size = total_mapping_size(elf_phdata, interp_elf_ex->e_phnum);
427 if (!total_size) {
428 error = -EINVAL;
429 goto out_close;
430 }
431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 eppnt = elf_phdata;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700433 for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
434 if (eppnt->p_type == PT_LOAD) {
435 int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
436 int elf_prot = 0;
437 unsigned long vaddr = 0;
438 unsigned long k, map_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700440 if (eppnt->p_flags & PF_R)
441 elf_prot = PROT_READ;
442 if (eppnt->p_flags & PF_W)
443 elf_prot |= PROT_WRITE;
444 if (eppnt->p_flags & PF_X)
445 elf_prot |= PROT_EXEC;
446 vaddr = eppnt->p_vaddr;
447 if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
448 elf_type |= MAP_FIXED;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100449 else if (no_base && interp_elf_ex->e_type == ET_DYN)
450 load_addr = -vaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700452 map_addr = elf_map(interpreter, load_addr + vaddr,
Andrew Mortonbb1ad822008-01-30 13:31:07 +0100453 eppnt, elf_prot, elf_type, total_size);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100454 total_size = 0;
455 if (!*interp_map_addr)
456 *interp_map_addr = map_addr;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700457 error = map_addr;
458 if (BAD_ADDR(map_addr))
459 goto out_close;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700461 if (!load_addr_set &&
462 interp_elf_ex->e_type == ET_DYN) {
463 load_addr = map_addr - ELF_PAGESTART(vaddr);
464 load_addr_set = 1;
465 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700467 /*
468 * Check to see if the section's size will overflow the
469 * allowed task size. Note that p_filesz must always be
470 * <= p_memsize so it's only necessary to check p_memsz.
471 */
472 k = load_addr + eppnt->p_vaddr;
Chuck Ebbertce510592006-07-03 00:24:14 -0700473 if (BAD_ADDR(k) ||
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700474 eppnt->p_filesz > eppnt->p_memsz ||
475 eppnt->p_memsz > TASK_SIZE ||
476 TASK_SIZE - eppnt->p_memsz < k) {
477 error = -ENOMEM;
478 goto out_close;
479 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700481 /*
482 * Find the end of the file mapping for this phdr, and
483 * keep track of the largest address we see for this.
484 */
485 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
486 if (k > elf_bss)
487 elf_bss = k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700489 /*
490 * Do the same thing for the memory mapping - between
491 * elf_bss and last_bss is the bss section.
492 */
493 k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
494 if (k > last_bss)
495 last_bss = k;
496 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 }
498
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 if (last_bss > elf_bss) {
Roland McGrath752015d2009-09-08 19:49:40 -0700500 /*
501 * Now fill out the bss section. First pad the last page up
502 * to the page boundary, and then perform a mmap to make sure
503 * that there are zero-mapped pages up to and including the
504 * last bss page.
505 */
506 if (padzero(elf_bss)) {
507 error = -EFAULT;
508 goto out_close;
509 }
510
511 /* What we have mapped so far */
512 elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1);
513
514 /* Map the last of the bss segment */
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -0700515 error = vm_brk(elf_bss, last_bss - elf_bss);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 if (BAD_ADDR(error))
517 goto out_close;
518 }
519
Jiri Kosinacc503c12008-01-30 13:31:07 +0100520 error = load_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521
522out_close:
523 kfree(elf_phdata);
524out:
525 return error;
526}
527
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528/*
529 * These are the functions used to load ELF style executables and shared
530 * libraries. There is no binary dependent code anywhere else.
531 */
532
533#define INTERPRETER_NONE 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534#define INTERPRETER_ELF 2
535
Andi Kleen913bd902006-03-25 16:29:09 +0100536#ifndef STACK_RND_MASK
James Bottomleyd1cabd62007-03-16 13:38:35 -0800537#define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12)) /* 8MB of VA */
Andi Kleen913bd902006-03-25 16:29:09 +0100538#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
540static unsigned long randomize_stack_top(unsigned long stack_top)
541{
Teow Wan Yee87c589c2016-07-27 16:47:28 +0800542 unsigned long random_variable = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
Andi Kleenc16b63e2006-09-26 10:52:28 +0200544 if ((current->flags & PF_RANDOMIZE) &&
545 !(current->personality & ADDR_NO_RANDOMIZE)) {
Teow Wan Yee87c589c2016-07-27 16:47:28 +0800546 random_variable = (unsigned long) get_random_int();
547 random_variable &= STACK_RND_MASK;
Andi Kleen913bd902006-03-25 16:29:09 +0100548 random_variable <<= PAGE_SHIFT;
549 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550#ifdef CONFIG_STACK_GROWSUP
Andi Kleen913bd902006-03-25 16:29:09 +0100551 return PAGE_ALIGN(stack_top) + random_variable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552#else
Andi Kleen913bd902006-03-25 16:29:09 +0100553 return PAGE_ALIGN(stack_top) - random_variable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554#endif
555}
556
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700557static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558{
559 struct file *interpreter = NULL; /* to shut gcc up */
560 unsigned long load_addr = 0, load_bias = 0;
561 int load_addr_set = 0;
562 char * elf_interpreter = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 unsigned long error;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700564 struct elf_phdr *elf_ppnt, *elf_phdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 unsigned long elf_bss, elf_brk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 int retval, i;
567 unsigned int size;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100568 unsigned long elf_entry;
569 unsigned long interp_load_addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 unsigned long start_code, end_code, start_data, end_data;
David Daney1a530a62011-03-22 16:34:48 -0700571 unsigned long reloc_func_desc __maybe_unused = 0;
David Rientjes8de61e62006-12-06 20:40:16 -0800572 int executable_stack = EXSTACK_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 unsigned long def_flags = 0;
574 struct {
575 struct elfhdr elf_ex;
576 struct elfhdr interp_elf_ex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 } *loc;
578
579 loc = kmalloc(sizeof(*loc), GFP_KERNEL);
580 if (!loc) {
581 retval = -ENOMEM;
582 goto out_ret;
583 }
584
585 /* Get the exec-header */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700586 loc->elf_ex = *((struct elfhdr *)bprm->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
588 retval = -ENOEXEC;
589 /* First of all, some simple consistency checks */
590 if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
591 goto out;
592
593 if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
594 goto out;
595 if (!elf_check_arch(&loc->elf_ex))
596 goto out;
Mikael Petterssonf670d0e2011-01-12 17:00:02 -0800597 if (!bprm->file->f_op || !bprm->file->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 goto out;
599
600 /* Now read in all of the header information */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 if (loc->elf_ex.e_phentsize != sizeof(struct elf_phdr))
602 goto out;
603 if (loc->elf_ex.e_phnum < 1 ||
604 loc->elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))
605 goto out;
606 size = loc->elf_ex.e_phnum * sizeof(struct elf_phdr);
607 retval = -ENOMEM;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700608 elf_phdata = kmalloc(size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 if (!elf_phdata)
610 goto out;
611
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700612 retval = kernel_read(bprm->file, loc->elf_ex.e_phoff,
613 (char *)elf_phdata, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 if (retval != size) {
615 if (retval >= 0)
616 retval = -EIO;
617 goto out_free_ph;
618 }
619
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 elf_ppnt = elf_phdata;
621 elf_bss = 0;
622 elf_brk = 0;
623
624 start_code = ~0UL;
625 end_code = 0;
626 start_data = 0;
627 end_data = 0;
628
629 for (i = 0; i < loc->elf_ex.e_phnum; i++) {
630 if (elf_ppnt->p_type == PT_INTERP) {
631 /* This is the program interpreter used for
632 * shared libraries - for now assume that this
633 * is an a.out format binary
634 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 retval = -ENOEXEC;
636 if (elf_ppnt->p_filesz > PATH_MAX ||
637 elf_ppnt->p_filesz < 2)
Al Viroe7b9b552009-03-29 16:31:16 -0400638 goto out_free_ph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
640 retval = -ENOMEM;
Jesper Juhl792db3a2006-01-09 20:54:45 -0800641 elf_interpreter = kmalloc(elf_ppnt->p_filesz,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700642 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 if (!elf_interpreter)
Al Viroe7b9b552009-03-29 16:31:16 -0400644 goto out_free_ph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
646 retval = kernel_read(bprm->file, elf_ppnt->p_offset,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700647 elf_interpreter,
648 elf_ppnt->p_filesz);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 if (retval != elf_ppnt->p_filesz) {
650 if (retval >= 0)
651 retval = -EIO;
652 goto out_free_interp;
653 }
654 /* make sure path is NULL terminated */
655 retval = -ENOEXEC;
656 if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
657 goto out_free_interp;
658
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 interpreter = open_exec(elf_interpreter);
660 retval = PTR_ERR(interpreter);
661 if (IS_ERR(interpreter))
662 goto out_free_interp;
Alexey Dobriyan1fb84492007-01-26 00:57:16 -0800663
664 /*
665 * If the binary is not readable then enforce
666 * mm->dumpable = 0 regardless of the interpreter's
667 * permissions.
668 */
Al Viro1b5d7832011-06-19 12:49:47 -0400669 would_dump(bprm, interpreter);
Alexey Dobriyan1fb84492007-01-26 00:57:16 -0800670
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700671 retval = kernel_read(interpreter, 0, bprm->buf,
672 BINPRM_BUF_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 if (retval != BINPRM_BUF_SIZE) {
674 if (retval >= 0)
675 retval = -EIO;
676 goto out_free_dentry;
677 }
678
679 /* Get the exec headers */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700680 loc->interp_elf_ex = *((struct elfhdr *)bprm->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 break;
682 }
683 elf_ppnt++;
684 }
685
686 elf_ppnt = elf_phdata;
687 for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
688 if (elf_ppnt->p_type == PT_GNU_STACK) {
689 if (elf_ppnt->p_flags & PF_X)
690 executable_stack = EXSTACK_ENABLE_X;
691 else
692 executable_stack = EXSTACK_DISABLE_X;
693 break;
694 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
696 /* Some simple consistency checks for the interpreter */
697 if (elf_interpreter) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 retval = -ELIBBAD;
Andi Kleend20894a2008-02-08 04:21:54 -0800699 /* Not an ELF interpreter */
700 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 /* Verify the interpreter has a valid arch */
Andi Kleend20894a2008-02-08 04:21:54 -0800703 if (!elf_check_arch(&loc->interp_elf_ex))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 }
706
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 /* Flush all traces of the currently running executable */
708 retval = flush_old_exec(bprm);
709 if (retval)
710 goto out_free_dentry;
711
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 /* OK, This is the point of no return */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 current->mm->def_flags = def_flags;
714
715 /* Do this immediately, since STACK_TOP as used in setup_arg_pages
716 may depend on the personality. */
Martin Schwidefsky0b592682008-10-16 15:39:57 +0200717 SET_PERSONALITY(loc->elf_ex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 if (elf_read_implies_exec(loc->elf_ex, executable_stack))
719 current->personality |= READ_IMPLIES_EXEC;
720
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700721 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 current->flags |= PF_RANDOMIZE;
Linus Torvalds221af7f2010-01-28 22:14:42 -0800723
724 setup_new_exec(bprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725
726 /* Do this so that we can load the interpreter, if need be. We will
727 change some of these later */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 current->mm->free_area_cache = current->mm->mmap_base;
Wolfgang Wander1363c3c2005-06-21 17:14:49 -0700729 current->mm->cached_hole_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
731 executable_stack);
732 if (retval < 0) {
733 send_sig(SIGKILL, current, 0);
734 goto out_free_dentry;
735 }
736
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 current->mm->start_stack = bprm->p;
738
André Goddard Rosaaf901ca2009-11-14 13:09:05 -0200739 /* Now we do a little grungy work by mmapping the ELF image into
Jiri Kosinacc503c12008-01-30 13:31:07 +0100740 the correct location in memory. */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700741 for(i = 0, elf_ppnt = elf_phdata;
742 i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 int elf_prot = 0, elf_flags;
744 unsigned long k, vaddr;
745
746 if (elf_ppnt->p_type != PT_LOAD)
747 continue;
748
749 if (unlikely (elf_brk > elf_bss)) {
750 unsigned long nbyte;
751
752 /* There was a PT_LOAD segment with p_memsz > p_filesz
753 before this one. Map anonymous pages, if needed,
754 and clear the area. */
Mikael Petterssonf670d0e2011-01-12 17:00:02 -0800755 retval = set_brk(elf_bss + load_bias,
756 elf_brk + load_bias);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 if (retval) {
758 send_sig(SIGKILL, current, 0);
759 goto out_free_dentry;
760 }
761 nbyte = ELF_PAGEOFFSET(elf_bss);
762 if (nbyte) {
763 nbyte = ELF_MIN_ALIGN - nbyte;
764 if (nbyte > elf_brk - elf_bss)
765 nbyte = elf_brk - elf_bss;
766 if (clear_user((void __user *)elf_bss +
767 load_bias, nbyte)) {
768 /*
769 * This bss-zeroing can fail if the ELF
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700770 * file specifies odd protections. So
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 * we don't check the return value
772 */
773 }
774 }
775 }
776
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700777 if (elf_ppnt->p_flags & PF_R)
778 elf_prot |= PROT_READ;
779 if (elf_ppnt->p_flags & PF_W)
780 elf_prot |= PROT_WRITE;
781 if (elf_ppnt->p_flags & PF_X)
782 elf_prot |= PROT_EXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700784 elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
786 vaddr = elf_ppnt->p_vaddr;
787 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
788 elf_flags |= MAP_FIXED;
789 } else if (loc->elf_ex.e_type == ET_DYN) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700790 /* Try and get dynamic programs out of the way of the
791 * default mmap base, as well as whatever program they
792 * might try to exec. This is because the brk will
793 * follow the loader, and is not movable. */
David Daneye39f5602012-01-10 15:10:21 -0800794#ifdef CONFIG_ARCH_BINFMT_ELF_RANDOMIZE_PIE
Jiri Kosinaa3defbe2011-11-02 13:37:41 -0700795 /* Memory randomization might have been switched off
796 * in runtime via sysctl.
797 * If that is the case, retain the original non-zero
798 * load_bias value in order to establish proper
799 * non-randomized mappings.
800 */
801 if (current->flags & PF_RANDOMIZE)
802 load_bias = 0;
803 else
804 load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100805#else
Linus Torvalds90cb28e2007-01-06 13:28:21 -0800806 load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100807#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 }
809
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700810 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
Andrew Mortonbb1ad822008-01-30 13:31:07 +0100811 elf_prot, elf_flags, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 if (BAD_ADDR(error)) {
813 send_sig(SIGKILL, current, 0);
Alexey Kuznetsovb140f252007-05-08 00:31:57 -0700814 retval = IS_ERR((void *)error) ?
815 PTR_ERR((void*)error) : -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 goto out_free_dentry;
817 }
818
819 if (!load_addr_set) {
820 load_addr_set = 1;
821 load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
822 if (loc->elf_ex.e_type == ET_DYN) {
823 load_bias += error -
824 ELF_PAGESTART(load_bias + vaddr);
825 load_addr += load_bias;
826 reloc_func_desc = load_bias;
827 }
828 }
829 k = elf_ppnt->p_vaddr;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700830 if (k < start_code)
831 start_code = k;
832 if (start_data < k)
833 start_data = k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
835 /*
836 * Check to see if the section's size will overflow the
837 * allowed task size. Note that p_filesz must always be
838 * <= p_memsz so it is only necessary to check p_memsz.
839 */
Chuck Ebbertce510592006-07-03 00:24:14 -0700840 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 elf_ppnt->p_memsz > TASK_SIZE ||
842 TASK_SIZE - elf_ppnt->p_memsz < k) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700843 /* set_brk can never work. Avoid overflows. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 send_sig(SIGKILL, current, 0);
Alexey Kuznetsovb140f252007-05-08 00:31:57 -0700845 retval = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 goto out_free_dentry;
847 }
848
849 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
850
851 if (k > elf_bss)
852 elf_bss = k;
853 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
854 end_code = k;
855 if (end_data < k)
856 end_data = k;
857 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
858 if (k > elf_brk)
859 elf_brk = k;
860 }
861
862 loc->elf_ex.e_entry += load_bias;
863 elf_bss += load_bias;
864 elf_brk += load_bias;
865 start_code += load_bias;
866 end_code += load_bias;
867 start_data += load_bias;
868 end_data += load_bias;
869
870 /* Calling set_brk effectively mmaps the pages that we need
871 * for the bss and break sections. We must do this before
872 * mapping in the interpreter, to make sure it doesn't wind
873 * up getting placed where the bss needs to go.
874 */
875 retval = set_brk(elf_bss, elf_brk);
876 if (retval) {
877 send_sig(SIGKILL, current, 0);
878 goto out_free_dentry;
879 }
akpm@osdl.org6de50512005-10-11 08:29:08 -0700880 if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 send_sig(SIGSEGV, current, 0);
882 retval = -EFAULT; /* Nobody gets to see this, but.. */
883 goto out_free_dentry;
884 }
885
886 if (elf_interpreter) {
Andi Kleend20894a2008-02-08 04:21:54 -0800887 unsigned long uninitialized_var(interp_map_addr);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100888
Andi Kleend20894a2008-02-08 04:21:54 -0800889 elf_entry = load_elf_interp(&loc->interp_elf_ex,
890 interpreter,
891 &interp_map_addr,
892 load_bias);
893 if (!IS_ERR((void *)elf_entry)) {
894 /*
895 * load_elf_interp() returns relocation
896 * adjustment
897 */
898 interp_load_addr = elf_entry;
899 elf_entry += loc->interp_elf_ex.e_entry;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100900 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 if (BAD_ADDR(elf_entry)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 force_sig(SIGSEGV, current);
Chuck Ebbertce510592006-07-03 00:24:14 -0700903 retval = IS_ERR((void *)elf_entry) ?
904 (int)elf_entry : -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 goto out_free_dentry;
906 }
907 reloc_func_desc = interp_load_addr;
908
909 allow_write_access(interpreter);
910 fput(interpreter);
911 kfree(elf_interpreter);
912 } else {
913 elf_entry = loc->elf_ex.e_entry;
Suresh Siddha5342fba2006-02-26 04:18:28 +0100914 if (BAD_ADDR(elf_entry)) {
Chuck Ebbertce510592006-07-03 00:24:14 -0700915 force_sig(SIGSEGV, current);
916 retval = -EINVAL;
Suresh Siddha5342fba2006-02-26 04:18:28 +0100917 goto out_free_dentry;
918 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 }
920
921 kfree(elf_phdata);
922
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 set_binfmt(&elf_format);
924
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -0700925#ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
Martin Schwidefskyfc5243d2008-12-25 13:38:35 +0100926 retval = arch_setup_additional_pages(bprm, !!elf_interpreter);
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -0700927 if (retval < 0) {
928 send_sig(SIGKILL, current, 0);
Roland McGrath18c8baf2005-04-28 15:17:19 -0700929 goto out;
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -0700930 }
931#endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
932
David Howellsa6f76f22008-11-14 10:39:24 +1100933 install_exec_creds(bprm);
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700934 retval = create_elf_tables(bprm, &loc->elf_ex,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700935 load_addr, interp_load_addr);
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700936 if (retval < 0) {
937 send_sig(SIGKILL, current, 0);
938 goto out;
939 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 /* N.B. passed_fileno might not be initialized? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 current->mm->end_code = end_code;
942 current->mm->start_code = start_code;
943 current->mm->start_data = start_data;
944 current->mm->end_data = end_data;
945 current->mm->start_stack = bprm->p;
946
Jiri Kosinac1d171a2008-01-30 13:30:40 +0100947#ifdef arch_randomize_brk
Jiri Kosina4471a672011-04-14 15:22:09 -0700948 if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
Jiri Kosinac1d171a2008-01-30 13:30:40 +0100949 current->mm->brk = current->mm->start_brk =
950 arch_randomize_brk(current->mm);
Jiri Kosina4471a672011-04-14 15:22:09 -0700951#ifdef CONFIG_COMPAT_BRK
952 current->brk_randomized = 1;
953#endif
954 }
Jiri Kosinac1d171a2008-01-30 13:30:40 +0100955#endif
956
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 if (current->personality & MMAP_PAGE_ZERO) {
958 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
959 and some applications "depend" upon this behavior.
960 Since we do not have the power to recompile these, we
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700961 emulate the SVr4 behavior. Sigh. */
Linus Torvalds6be5ceb2012-04-20 17:13:58 -0700962 error = vm_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 MAP_FIXED | MAP_PRIVATE, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 }
965
966#ifdef ELF_PLAT_INIT
967 /*
968 * The ABI may specify that certain registers be set up in special
969 * ways (on i386 %edx is the address of a DT_FINI function, for
970 * example. In addition, it may also specify (eg, PowerPC64 ELF)
971 * that the e_entry field is the address of the function descriptor
972 * for the startup routine, rather than the address of the startup
973 * routine itself. This macro performs whatever initialization to
974 * the regs structure is required as well as any relocations to the
975 * function descriptor entries when executing dynamically links apps.
976 */
977 ELF_PLAT_INIT(regs, reloc_func_desc);
978#endif
979
980 start_thread(regs, elf_entry, bprm->p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 retval = 0;
982out:
983 kfree(loc);
984out_ret:
985 return retval;
986
987 /* error cleanup */
988out_free_dentry:
989 allow_write_access(interpreter);
990 if (interpreter)
991 fput(interpreter);
992out_free_interp:
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800993 kfree(elf_interpreter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994out_free_ph:
995 kfree(elf_phdata);
996 goto out;
997}
998
999/* This is really simpleminded and specialized - we are loading an
1000 a.out library that is given an ELF header. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001static int load_elf_library(struct file *file)
1002{
1003 struct elf_phdr *elf_phdata;
1004 struct elf_phdr *eppnt;
1005 unsigned long elf_bss, bss, len;
1006 int retval, error, i, j;
1007 struct elfhdr elf_ex;
1008
1009 error = -ENOEXEC;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001010 retval = kernel_read(file, 0, (char *)&elf_ex, sizeof(elf_ex));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 if (retval != sizeof(elf_ex))
1012 goto out;
1013
1014 if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1015 goto out;
1016
1017 /* First of all, some simple consistency checks */
1018 if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001019 !elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 goto out;
1021
1022 /* Now read in all of the header information */
1023
1024 j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1025 /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1026
1027 error = -ENOMEM;
1028 elf_phdata = kmalloc(j, GFP_KERNEL);
1029 if (!elf_phdata)
1030 goto out;
1031
1032 eppnt = elf_phdata;
1033 error = -ENOEXEC;
1034 retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);
1035 if (retval != j)
1036 goto out_free_ph;
1037
1038 for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1039 if ((eppnt + i)->p_type == PT_LOAD)
1040 j++;
1041 if (j != 1)
1042 goto out_free_ph;
1043
1044 while (eppnt->p_type != PT_LOAD)
1045 eppnt++;
1046
1047 /* Now use mmap to map the library into memory. */
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001048 error = vm_mmap(file,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 ELF_PAGESTART(eppnt->p_vaddr),
1050 (eppnt->p_filesz +
1051 ELF_PAGEOFFSET(eppnt->p_vaddr)),
1052 PROT_READ | PROT_WRITE | PROT_EXEC,
1053 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
1054 (eppnt->p_offset -
1055 ELF_PAGEOFFSET(eppnt->p_vaddr)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 if (error != ELF_PAGESTART(eppnt->p_vaddr))
1057 goto out_free_ph;
1058
1059 elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1060 if (padzero(elf_bss)) {
1061 error = -EFAULT;
1062 goto out_free_ph;
1063 }
1064
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001065 len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr +
1066 ELF_MIN_ALIGN - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 bss = eppnt->p_memsz + eppnt->p_vaddr;
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -07001068 if (bss > len)
1069 vm_brk(len, bss - len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 error = 0;
1071
1072out_free_ph:
1073 kfree(elf_phdata);
1074out:
1075 return error;
1076}
1077
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08001078#ifdef CONFIG_ELF_CORE
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079/*
1080 * ELF core dumper
1081 *
1082 * Modelled on fs/exec.c:aout_core_dump()
1083 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1084 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085
1086/*
Jason Baron909af762012-03-23 15:02:51 -07001087 * The purpose of always_dump_vma() is to make sure that special kernel mappings
1088 * that are useful for post-mortem analysis are included in every core dump.
1089 * In that way we ensure that the core dump is fully interpretable later
1090 * without matching up the same kernel and hardware config to see what PC values
1091 * meant. These special mappings include - vDSO, vsyscall, and other
1092 * architecture specific mappings
1093 */
1094static bool always_dump_vma(struct vm_area_struct *vma)
1095{
1096 /* Any vsyscall mappings? */
1097 if (vma == get_gate_vma(vma->vm_mm))
1098 return true;
1099 /*
1100 * arch_vma_name() returns non-NULL for special architecture mappings,
1101 * such as vDSO sections.
1102 */
1103 if (arch_vma_name(vma))
1104 return true;
1105
1106 return false;
1107}
1108
1109/*
Roland McGrath82df3972007-10-16 23:27:02 -07001110 * Decide what to dump of a segment, part, all or none.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 */
Roland McGrath82df3972007-10-16 23:27:02 -07001112static unsigned long vma_dump_size(struct vm_area_struct *vma,
1113 unsigned long mm_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114{
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001115#define FILTER(type) (mm_flags & (1UL << MMF_DUMP_##type))
1116
Jason Baron909af762012-03-23 15:02:51 -07001117 /* always dump the vdso and vsyscall sections */
1118 if (always_dump_vma(vma))
Roland McGrath82df3972007-10-16 23:27:02 -07001119 goto whole;
Roland McGrathe5b97dd2007-01-26 00:56:48 -08001120
Jason Baronaccb61f2012-03-23 15:02:51 -07001121 if (vma->vm_flags & VM_NODUMP)
1122 return 0;
1123
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001124 /* Hugetlb memory check */
1125 if (vma->vm_flags & VM_HUGETLB) {
1126 if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))
1127 goto whole;
1128 if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))
1129 goto whole;
1130 }
1131
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 /* Do not dump I/O mapped devices or special mappings */
1133 if (vma->vm_flags & (VM_IO | VM_RESERVED))
1134 return 0;
1135
Kawai, Hidehiroa1b59e82007-07-19 01:48:29 -07001136 /* By default, dump shared memory if mapped from an anonymous file. */
1137 if (vma->vm_flags & VM_SHARED) {
Roland McGrath82df3972007-10-16 23:27:02 -07001138 if (vma->vm_file->f_path.dentry->d_inode->i_nlink == 0 ?
1139 FILTER(ANON_SHARED) : FILTER(MAPPED_SHARED))
1140 goto whole;
1141 return 0;
Kawai, Hidehiroa1b59e82007-07-19 01:48:29 -07001142 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143
Roland McGrath82df3972007-10-16 23:27:02 -07001144 /* Dump segments that have been written to. */
1145 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1146 goto whole;
1147 if (vma->vm_file == NULL)
1148 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149
Roland McGrath82df3972007-10-16 23:27:02 -07001150 if (FILTER(MAPPED_PRIVATE))
1151 goto whole;
1152
1153 /*
1154 * If this looks like the beginning of a DSO or executable mapping,
1155 * check for an ELF header. If we find one, dump the first page to
1156 * aid in determining what was mapped here.
1157 */
Roland McGrath92dc07b2009-02-06 17:34:07 -08001158 if (FILTER(ELF_HEADERS) &&
1159 vma->vm_pgoff == 0 && (vma->vm_flags & VM_READ)) {
Roland McGrath82df3972007-10-16 23:27:02 -07001160 u32 __user *header = (u32 __user *) vma->vm_start;
1161 u32 word;
Roland McGrath92dc07b2009-02-06 17:34:07 -08001162 mm_segment_t fs = get_fs();
Roland McGrath82df3972007-10-16 23:27:02 -07001163 /*
1164 * Doing it this way gets the constant folded by GCC.
1165 */
1166 union {
1167 u32 cmp;
1168 char elfmag[SELFMAG];
1169 } magic;
1170 BUILD_BUG_ON(SELFMAG != sizeof word);
1171 magic.elfmag[EI_MAG0] = ELFMAG0;
1172 magic.elfmag[EI_MAG1] = ELFMAG1;
1173 magic.elfmag[EI_MAG2] = ELFMAG2;
1174 magic.elfmag[EI_MAG3] = ELFMAG3;
Roland McGrath92dc07b2009-02-06 17:34:07 -08001175 /*
1176 * Switch to the user "segment" for get_user(),
1177 * then put back what elf_core_dump() had in place.
1178 */
1179 set_fs(USER_DS);
1180 if (unlikely(get_user(word, header)))
1181 word = 0;
1182 set_fs(fs);
1183 if (word == magic.cmp)
Roland McGrath82df3972007-10-16 23:27:02 -07001184 return PAGE_SIZE;
1185 }
1186
1187#undef FILTER
1188
1189 return 0;
1190
1191whole:
1192 return vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193}
1194
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195/* An ELF note in memory */
1196struct memelfnote
1197{
1198 const char *name;
1199 int type;
1200 unsigned int datasz;
1201 void *data;
1202};
1203
1204static int notesize(struct memelfnote *en)
1205{
1206 int sz;
1207
1208 sz = sizeof(struct elf_note);
1209 sz += roundup(strlen(en->name) + 1, 4);
1210 sz += roundup(en->datasz, 4);
1211
1212 return sz;
1213}
1214
Andi Kleend025c9d2006-09-30 23:29:28 -07001215#define DUMP_WRITE(addr, nr, foffset) \
1216 do { if (!dump_write(file, (addr), (nr))) return 0; *foffset += (nr); } while(0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217
Andi Kleend025c9d2006-09-30 23:29:28 -07001218static int alignfile(struct file *file, loff_t *foffset)
1219{
Petr Vandroveca7a0d862006-10-13 18:42:07 +02001220 static const char buf[4] = { 0, };
Andi Kleend025c9d2006-09-30 23:29:28 -07001221 DUMP_WRITE(buf, roundup(*foffset, 4) - *foffset, foffset);
1222 return 1;
1223}
1224
1225static int writenote(struct memelfnote *men, struct file *file,
1226 loff_t *foffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227{
1228 struct elf_note en;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 en.n_namesz = strlen(men->name) + 1;
1230 en.n_descsz = men->datasz;
1231 en.n_type = men->type;
1232
Andi Kleend025c9d2006-09-30 23:29:28 -07001233 DUMP_WRITE(&en, sizeof(en), foffset);
1234 DUMP_WRITE(men->name, en.n_namesz, foffset);
1235 if (!alignfile(file, foffset))
1236 return 0;
1237 DUMP_WRITE(men->data, men->datasz, foffset);
1238 if (!alignfile(file, foffset))
1239 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240
1241 return 1;
1242}
1243#undef DUMP_WRITE
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244
Roland McGrath3aba4812008-01-30 13:31:44 +01001245static void fill_elf_header(struct elfhdr *elf, int segs,
1246 u16 machine, u32 flags, u8 osabi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247{
Cyrill Gorcunov6970c8e2008-04-29 01:01:18 -07001248 memset(elf, 0, sizeof(*elf));
1249
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 memcpy(elf->e_ident, ELFMAG, SELFMAG);
1251 elf->e_ident[EI_CLASS] = ELF_CLASS;
1252 elf->e_ident[EI_DATA] = ELF_DATA;
1253 elf->e_ident[EI_VERSION] = EV_CURRENT;
1254 elf->e_ident[EI_OSABI] = ELF_OSABI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255
1256 elf->e_type = ET_CORE;
Roland McGrath3aba4812008-01-30 13:31:44 +01001257 elf->e_machine = machine;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 elf->e_version = EV_CURRENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 elf->e_phoff = sizeof(struct elfhdr);
Roland McGrath3aba4812008-01-30 13:31:44 +01001260 elf->e_flags = flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 elf->e_ehsize = sizeof(struct elfhdr);
1262 elf->e_phentsize = sizeof(struct elf_phdr);
1263 elf->e_phnum = segs;
Cyrill Gorcunov6970c8e2008-04-29 01:01:18 -07001264
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 return;
1266}
1267
Andrew Morton8d6b5eee2006-09-25 23:32:04 -07001268static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269{
1270 phdr->p_type = PT_NOTE;
1271 phdr->p_offset = offset;
1272 phdr->p_vaddr = 0;
1273 phdr->p_paddr = 0;
1274 phdr->p_filesz = sz;
1275 phdr->p_memsz = 0;
1276 phdr->p_flags = 0;
1277 phdr->p_align = 0;
1278 return;
1279}
1280
1281static void fill_note(struct memelfnote *note, const char *name, int type,
1282 unsigned int sz, void *data)
1283{
1284 note->name = name;
1285 note->type = type;
1286 note->datasz = sz;
1287 note->data = data;
1288 return;
1289}
1290
1291/*
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001292 * fill up all the fields in prstatus from the given task struct, except
1293 * registers which need to be filled up separately.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 */
1295static void fill_prstatus(struct elf_prstatus *prstatus,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001296 struct task_struct *p, long signr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297{
1298 prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1299 prstatus->pr_sigpend = p->pending.signal.sig[0];
1300 prstatus->pr_sighold = p->blocked.sig[0];
Oleg Nesterov3b34fc52009-06-17 16:27:38 -07001301 rcu_read_lock();
1302 prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1303 rcu_read_unlock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001304 prstatus->pr_pid = task_pid_vnr(p);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001305 prstatus->pr_pgrp = task_pgrp_vnr(p);
1306 prstatus->pr_sid = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 if (thread_group_leader(p)) {
Frank Mayharf06febc2008-09-12 09:54:39 -07001308 struct task_cputime cputime;
1309
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 /*
Frank Mayharf06febc2008-09-12 09:54:39 -07001311 * This is the record for the group leader. It shows the
1312 * group-wide total, not its individual thread total.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 */
Frank Mayharf06febc2008-09-12 09:54:39 -07001314 thread_group_cputime(p, &cputime);
1315 cputime_to_timeval(cputime.utime, &prstatus->pr_utime);
1316 cputime_to_timeval(cputime.stime, &prstatus->pr_stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 } else {
1318 cputime_to_timeval(p->utime, &prstatus->pr_utime);
1319 cputime_to_timeval(p->stime, &prstatus->pr_stime);
1320 }
1321 cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
1322 cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
1323}
1324
1325static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1326 struct mm_struct *mm)
1327{
David Howellsc69e8d92008-11-14 10:39:19 +11001328 const struct cred *cred;
Greg Kroah-Hartmana84a5052005-05-11 00:10:44 -07001329 unsigned int i, len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330
1331 /* first copy the parameters from user space */
1332 memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1333
1334 len = mm->arg_end - mm->arg_start;
1335 if (len >= ELF_PRARGSZ)
1336 len = ELF_PRARGSZ-1;
1337 if (copy_from_user(&psinfo->pr_psargs,
1338 (const char __user *)mm->arg_start, len))
1339 return -EFAULT;
1340 for(i = 0; i < len; i++)
1341 if (psinfo->pr_psargs[i] == 0)
1342 psinfo->pr_psargs[i] = ' ';
1343 psinfo->pr_psargs[len] = 0;
1344
Oleg Nesterov3b34fc52009-06-17 16:27:38 -07001345 rcu_read_lock();
1346 psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1347 rcu_read_unlock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001348 psinfo->pr_pid = task_pid_vnr(p);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001349 psinfo->pr_pgrp = task_pgrp_vnr(p);
1350 psinfo->pr_sid = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351
1352 i = p->state ? ffz(~p->state) + 1 : 0;
1353 psinfo->pr_state = i;
Carsten Otte55148542006-03-25 03:08:22 -08001354 psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1356 psinfo->pr_nice = task_nice(p);
1357 psinfo->pr_flag = p->flags;
David Howellsc69e8d92008-11-14 10:39:19 +11001358 rcu_read_lock();
1359 cred = __task_cred(p);
1360 SET_UID(psinfo->pr_uid, cred->uid);
1361 SET_GID(psinfo->pr_gid, cred->gid);
1362 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1364
1365 return 0;
1366}
1367
Roland McGrath3aba4812008-01-30 13:31:44 +01001368static void fill_auxv_note(struct memelfnote *note, struct mm_struct *mm)
1369{
1370 elf_addr_t *auxv = (elf_addr_t *) mm->saved_auxv;
1371 int i = 0;
1372 do
1373 i += 2;
1374 while (auxv[i - 2] != AT_NULL);
1375 fill_note(note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);
1376}
1377
Roland McGrath4206d3a2008-01-30 13:31:45 +01001378#ifdef CORE_DUMP_USE_REGSET
1379#include <linux/regset.h>
1380
1381struct elf_thread_core_info {
1382 struct elf_thread_core_info *next;
1383 struct task_struct *task;
1384 struct elf_prstatus prstatus;
1385 struct memelfnote notes[0];
1386};
1387
1388struct elf_note_info {
1389 struct elf_thread_core_info *thread;
1390 struct memelfnote psinfo;
1391 struct memelfnote auxv;
1392 size_t size;
1393 int thread_notes;
1394};
1395
Roland McGrathd31472b2008-03-04 14:28:30 -08001396/*
1397 * When a regset has a writeback hook, we call it on each thread before
1398 * dumping user memory. On register window machines, this makes sure the
1399 * user memory backing the register data is up to date before we read it.
1400 */
1401static void do_thread_regset_writeback(struct task_struct *task,
1402 const struct user_regset *regset)
1403{
1404 if (regset->writeback)
1405 regset->writeback(task, regset, 1);
1406}
1407
H. J. Lu0953f652012-02-14 13:34:52 -08001408#ifndef PR_REG_SIZE
1409#define PR_REG_SIZE(S) sizeof(S)
1410#endif
1411
1412#ifndef PRSTATUS_SIZE
1413#define PRSTATUS_SIZE(S) sizeof(S)
1414#endif
1415
1416#ifndef PR_REG_PTR
1417#define PR_REG_PTR(S) (&((S)->pr_reg))
1418#endif
1419
1420#ifndef SET_PR_FPVALID
1421#define SET_PR_FPVALID(S, V) ((S)->pr_fpvalid = (V))
1422#endif
1423
Roland McGrath4206d3a2008-01-30 13:31:45 +01001424static int fill_thread_core_info(struct elf_thread_core_info *t,
1425 const struct user_regset_view *view,
1426 long signr, size_t *total)
1427{
1428 unsigned int i;
1429
1430 /*
1431 * NT_PRSTATUS is the one special case, because the regset data
1432 * goes into the pr_reg field inside the note contents, rather
1433 * than being the whole note contents. We fill the reset in here.
1434 * We assume that regset 0 is NT_PRSTATUS.
1435 */
1436 fill_prstatus(&t->prstatus, t->task, signr);
1437 (void) view->regsets[0].get(t->task, &view->regsets[0],
H. J. Lu0953f652012-02-14 13:34:52 -08001438 0, PR_REG_SIZE(t->prstatus.pr_reg),
1439 PR_REG_PTR(&t->prstatus), NULL);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001440
1441 fill_note(&t->notes[0], "CORE", NT_PRSTATUS,
H. J. Lu0953f652012-02-14 13:34:52 -08001442 PRSTATUS_SIZE(t->prstatus), &t->prstatus);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001443 *total += notesize(&t->notes[0]);
1444
Roland McGrathd31472b2008-03-04 14:28:30 -08001445 do_thread_regset_writeback(t->task, &view->regsets[0]);
1446
Roland McGrath4206d3a2008-01-30 13:31:45 +01001447 /*
1448 * Each other regset might generate a note too. For each regset
1449 * that has no core_note_type or is inactive, we leave t->notes[i]
1450 * all zero and we'll know to skip writing it later.
1451 */
1452 for (i = 1; i < view->n; ++i) {
1453 const struct user_regset *regset = &view->regsets[i];
Roland McGrathd31472b2008-03-04 14:28:30 -08001454 do_thread_regset_writeback(t->task, regset);
H. Peter Anvinc8e25252012-03-02 10:43:48 -08001455 if (regset->core_note_type && regset->get &&
Roland McGrath4206d3a2008-01-30 13:31:45 +01001456 (!regset->active || regset->active(t->task, regset))) {
1457 int ret;
1458 size_t size = regset->n * regset->size;
1459 void *data = kmalloc(size, GFP_KERNEL);
1460 if (unlikely(!data))
1461 return 0;
1462 ret = regset->get(t->task, regset,
1463 0, size, data, NULL);
1464 if (unlikely(ret))
1465 kfree(data);
1466 else {
1467 if (regset->core_note_type != NT_PRFPREG)
1468 fill_note(&t->notes[i], "LINUX",
1469 regset->core_note_type,
1470 size, data);
1471 else {
H. J. Lu0953f652012-02-14 13:34:52 -08001472 SET_PR_FPVALID(&t->prstatus, 1);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001473 fill_note(&t->notes[i], "CORE",
1474 NT_PRFPREG, size, data);
1475 }
1476 *total += notesize(&t->notes[i]);
1477 }
1478 }
1479 }
1480
1481 return 1;
1482}
1483
1484static int fill_note_info(struct elfhdr *elf, int phdrs,
1485 struct elf_note_info *info,
1486 long signr, struct pt_regs *regs)
1487{
1488 struct task_struct *dump_task = current;
1489 const struct user_regset_view *view = task_user_regset_view(dump_task);
1490 struct elf_thread_core_info *t;
1491 struct elf_prpsinfo *psinfo;
Oleg Nesterov83914442008-07-25 01:47:45 -07001492 struct core_thread *ct;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001493 unsigned int i;
1494
1495 info->size = 0;
1496 info->thread = NULL;
1497
1498 psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001499 if (psinfo == NULL)
1500 return 0;
1501
Amerigo Wange2dbe122009-07-01 01:06:26 -04001502 fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1503
Roland McGrath4206d3a2008-01-30 13:31:45 +01001504 /*
1505 * Figure out how many notes we're going to need for each thread.
1506 */
1507 info->thread_notes = 0;
1508 for (i = 0; i < view->n; ++i)
1509 if (view->regsets[i].core_note_type != 0)
1510 ++info->thread_notes;
1511
1512 /*
1513 * Sanity check. We rely on regset 0 being in NT_PRSTATUS,
1514 * since it is our one special case.
1515 */
1516 if (unlikely(info->thread_notes == 0) ||
1517 unlikely(view->regsets[0].core_note_type != NT_PRSTATUS)) {
1518 WARN_ON(1);
1519 return 0;
1520 }
1521
1522 /*
1523 * Initialize the ELF file header.
1524 */
1525 fill_elf_header(elf, phdrs,
1526 view->e_machine, view->e_flags, view->ei_osabi);
1527
1528 /*
1529 * Allocate a structure for each thread.
1530 */
Oleg Nesterov83914442008-07-25 01:47:45 -07001531 for (ct = &dump_task->mm->core_state->dumper; ct; ct = ct->next) {
1532 t = kzalloc(offsetof(struct elf_thread_core_info,
1533 notes[info->thread_notes]),
1534 GFP_KERNEL);
1535 if (unlikely(!t))
1536 return 0;
Oleg Nesterov24d52882008-07-25 01:47:40 -07001537
Oleg Nesterov83914442008-07-25 01:47:45 -07001538 t->task = ct->task;
1539 if (ct->task == dump_task || !info->thread) {
1540 t->next = info->thread;
1541 info->thread = t;
1542 } else {
1543 /*
1544 * Make sure to keep the original task at
1545 * the head of the list.
1546 */
1547 t->next = info->thread->next;
1548 info->thread->next = t;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001549 }
Oleg Nesterov83914442008-07-25 01:47:45 -07001550 }
Roland McGrath4206d3a2008-01-30 13:31:45 +01001551
1552 /*
1553 * Now fill in each thread's information.
1554 */
1555 for (t = info->thread; t != NULL; t = t->next)
1556 if (!fill_thread_core_info(t, view, signr, &info->size))
1557 return 0;
1558
1559 /*
1560 * Fill in the two process-wide notes.
1561 */
1562 fill_psinfo(psinfo, dump_task->group_leader, dump_task->mm);
1563 info->size += notesize(&info->psinfo);
1564
1565 fill_auxv_note(&info->auxv, current->mm);
1566 info->size += notesize(&info->auxv);
1567
1568 return 1;
1569}
1570
1571static size_t get_note_info_size(struct elf_note_info *info)
1572{
1573 return info->size;
1574}
1575
1576/*
1577 * Write all the notes for each thread. When writing the first thread, the
1578 * process-wide notes are interleaved after the first thread-specific note.
1579 */
1580static int write_note_info(struct elf_note_info *info,
1581 struct file *file, loff_t *foffset)
1582{
1583 bool first = 1;
1584 struct elf_thread_core_info *t = info->thread;
1585
1586 do {
1587 int i;
1588
1589 if (!writenote(&t->notes[0], file, foffset))
1590 return 0;
1591
1592 if (first && !writenote(&info->psinfo, file, foffset))
1593 return 0;
1594 if (first && !writenote(&info->auxv, file, foffset))
1595 return 0;
1596
1597 for (i = 1; i < info->thread_notes; ++i)
1598 if (t->notes[i].data &&
1599 !writenote(&t->notes[i], file, foffset))
1600 return 0;
1601
1602 first = 0;
1603 t = t->next;
1604 } while (t);
1605
1606 return 1;
1607}
1608
1609static void free_note_info(struct elf_note_info *info)
1610{
1611 struct elf_thread_core_info *threads = info->thread;
1612 while (threads) {
1613 unsigned int i;
1614 struct elf_thread_core_info *t = threads;
1615 threads = t->next;
1616 WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);
1617 for (i = 1; i < info->thread_notes; ++i)
1618 kfree(t->notes[i].data);
1619 kfree(t);
1620 }
1621 kfree(info->psinfo.data);
1622}
1623
1624#else
1625
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626/* Here is the structure in which status of each thread is captured. */
1627struct elf_thread_status
1628{
1629 struct list_head list;
1630 struct elf_prstatus prstatus; /* NT_PRSTATUS */
1631 elf_fpregset_t fpu; /* NT_PRFPREG */
1632 struct task_struct *thread;
1633#ifdef ELF_CORE_COPY_XFPREGS
Mark Nelson5b20cd82007-10-16 23:25:39 -07001634 elf_fpxregset_t xfpu; /* ELF_CORE_XFPREG_TYPE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635#endif
1636 struct memelfnote notes[3];
1637 int num_notes;
1638};
1639
1640/*
1641 * In order to add the specific thread information for the elf file format,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001642 * we need to keep a linked list of every threads pr_status and then create
1643 * a single section for them in the final core file.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 */
1645static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1646{
1647 int sz = 0;
1648 struct task_struct *p = t->thread;
1649 t->num_notes = 0;
1650
1651 fill_prstatus(&t->prstatus, p, signr);
1652 elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1653
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001654 fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1655 &(t->prstatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 t->num_notes++;
1657 sz += notesize(&t->notes[0]);
1658
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001659 if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1660 &t->fpu))) {
1661 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1662 &(t->fpu));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 t->num_notes++;
1664 sz += notesize(&t->notes[1]);
1665 }
1666
1667#ifdef ELF_CORE_COPY_XFPREGS
1668 if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
Mark Nelson5b20cd82007-10-16 23:25:39 -07001669 fill_note(&t->notes[2], "LINUX", ELF_CORE_XFPREG_TYPE,
1670 sizeof(t->xfpu), &t->xfpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 t->num_notes++;
1672 sz += notesize(&t->notes[2]);
1673 }
1674#endif
1675 return sz;
1676}
1677
Roland McGrath3aba4812008-01-30 13:31:44 +01001678struct elf_note_info {
1679 struct memelfnote *notes;
1680 struct elf_prstatus *prstatus; /* NT_PRSTATUS */
1681 struct elf_prpsinfo *psinfo; /* NT_PRPSINFO */
1682 struct list_head thread_list;
1683 elf_fpregset_t *fpu;
1684#ifdef ELF_CORE_COPY_XFPREGS
1685 elf_fpxregset_t *xfpu;
1686#endif
1687 int thread_status_size;
1688 int numnote;
1689};
1690
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001691static int elf_note_info_init(struct elf_note_info *info)
Roland McGrath3aba4812008-01-30 13:31:44 +01001692{
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001693 memset(info, 0, sizeof(*info));
Roland McGrath3aba4812008-01-30 13:31:44 +01001694 INIT_LIST_HEAD(&info->thread_list);
1695
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001696 /* Allocate space for six ELF notes */
1697 info->notes = kmalloc(6 * sizeof(struct memelfnote), GFP_KERNEL);
Roland McGrath3aba4812008-01-30 13:31:44 +01001698 if (!info->notes)
1699 return 0;
1700 info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL);
1701 if (!info->psinfo)
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001702 goto notes_free;
Roland McGrath3aba4812008-01-30 13:31:44 +01001703 info->prstatus = kmalloc(sizeof(*info->prstatus), GFP_KERNEL);
1704 if (!info->prstatus)
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001705 goto psinfo_free;
Roland McGrath3aba4812008-01-30 13:31:44 +01001706 info->fpu = kmalloc(sizeof(*info->fpu), GFP_KERNEL);
1707 if (!info->fpu)
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001708 goto prstatus_free;
Roland McGrath3aba4812008-01-30 13:31:44 +01001709#ifdef ELF_CORE_COPY_XFPREGS
1710 info->xfpu = kmalloc(sizeof(*info->xfpu), GFP_KERNEL);
1711 if (!info->xfpu)
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001712 goto fpu_free;
Roland McGrath3aba4812008-01-30 13:31:44 +01001713#endif
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001714 return 1;
1715#ifdef ELF_CORE_COPY_XFPREGS
1716 fpu_free:
1717 kfree(info->fpu);
1718#endif
1719 prstatus_free:
1720 kfree(info->prstatus);
1721 psinfo_free:
1722 kfree(info->psinfo);
1723 notes_free:
1724 kfree(info->notes);
1725 return 0;
1726}
Roland McGrath3aba4812008-01-30 13:31:44 +01001727
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001728static int fill_note_info(struct elfhdr *elf, int phdrs,
1729 struct elf_note_info *info,
1730 long signr, struct pt_regs *regs)
1731{
1732 struct list_head *t;
1733
1734 if (!elf_note_info_init(info))
1735 return 0;
1736
Roland McGrath3aba4812008-01-30 13:31:44 +01001737 if (signr) {
Oleg Nesterov83914442008-07-25 01:47:45 -07001738 struct core_thread *ct;
WANG Cong4220b7f2008-04-29 01:01:18 -07001739 struct elf_thread_status *ets;
Oleg Nesterov24d52882008-07-25 01:47:40 -07001740
Oleg Nesterov83914442008-07-25 01:47:45 -07001741 for (ct = current->mm->core_state->dumper.next;
1742 ct; ct = ct->next) {
1743 ets = kzalloc(sizeof(*ets), GFP_KERNEL);
1744 if (!ets)
1745 return 0;
1746
1747 ets->thread = ct->task;
1748 list_add(&ets->list, &info->thread_list);
1749 }
1750
Roland McGrath3aba4812008-01-30 13:31:44 +01001751 list_for_each(t, &info->thread_list) {
Roland McGrath3aba4812008-01-30 13:31:44 +01001752 int sz;
1753
WANG Cong4220b7f2008-04-29 01:01:18 -07001754 ets = list_entry(t, struct elf_thread_status, list);
1755 sz = elf_dump_thread_status(signr, ets);
Roland McGrath3aba4812008-01-30 13:31:44 +01001756 info->thread_status_size += sz;
1757 }
1758 }
1759 /* now collect the dump for the current */
1760 memset(info->prstatus, 0, sizeof(*info->prstatus));
1761 fill_prstatus(info->prstatus, current, signr);
1762 elf_core_copy_regs(&info->prstatus->pr_reg, regs);
1763
1764 /* Set up header */
1765 fill_elf_header(elf, phdrs, ELF_ARCH, ELF_CORE_EFLAGS, ELF_OSABI);
1766
1767 /*
1768 * Set up the notes in similar form to SVR4 core dumps made
1769 * with info from their /proc.
1770 */
1771
1772 fill_note(info->notes + 0, "CORE", NT_PRSTATUS,
1773 sizeof(*info->prstatus), info->prstatus);
1774 fill_psinfo(info->psinfo, current->group_leader, current->mm);
1775 fill_note(info->notes + 1, "CORE", NT_PRPSINFO,
1776 sizeof(*info->psinfo), info->psinfo);
1777
1778 info->numnote = 2;
1779
1780 fill_auxv_note(&info->notes[info->numnote++], current->mm);
1781
1782 /* Try to dump the FPU. */
1783 info->prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs,
1784 info->fpu);
1785 if (info->prstatus->pr_fpvalid)
1786 fill_note(info->notes + info->numnote++,
1787 "CORE", NT_PRFPREG, sizeof(*info->fpu), info->fpu);
1788#ifdef ELF_CORE_COPY_XFPREGS
1789 if (elf_core_copy_task_xfpregs(current, info->xfpu))
1790 fill_note(info->notes + info->numnote++,
1791 "LINUX", ELF_CORE_XFPREG_TYPE,
1792 sizeof(*info->xfpu), info->xfpu);
1793#endif
1794
1795 return 1;
Roland McGrath3aba4812008-01-30 13:31:44 +01001796}
1797
1798static size_t get_note_info_size(struct elf_note_info *info)
1799{
1800 int sz = 0;
1801 int i;
1802
1803 for (i = 0; i < info->numnote; i++)
1804 sz += notesize(info->notes + i);
1805
1806 sz += info->thread_status_size;
1807
1808 return sz;
1809}
1810
1811static int write_note_info(struct elf_note_info *info,
1812 struct file *file, loff_t *foffset)
1813{
1814 int i;
1815 struct list_head *t;
1816
1817 for (i = 0; i < info->numnote; i++)
1818 if (!writenote(info->notes + i, file, foffset))
1819 return 0;
1820
1821 /* write out the thread status notes section */
1822 list_for_each(t, &info->thread_list) {
1823 struct elf_thread_status *tmp =
1824 list_entry(t, struct elf_thread_status, list);
1825
1826 for (i = 0; i < tmp->num_notes; i++)
1827 if (!writenote(&tmp->notes[i], file, foffset))
1828 return 0;
1829 }
1830
1831 return 1;
1832}
1833
1834static void free_note_info(struct elf_note_info *info)
1835{
1836 while (!list_empty(&info->thread_list)) {
1837 struct list_head *tmp = info->thread_list.next;
1838 list_del(tmp);
1839 kfree(list_entry(tmp, struct elf_thread_status, list));
1840 }
1841
1842 kfree(info->prstatus);
1843 kfree(info->psinfo);
1844 kfree(info->notes);
1845 kfree(info->fpu);
1846#ifdef ELF_CORE_COPY_XFPREGS
1847 kfree(info->xfpu);
1848#endif
1849}
1850
Roland McGrath4206d3a2008-01-30 13:31:45 +01001851#endif
1852
Roland McGrathf47aef52007-01-26 00:56:49 -08001853static struct vm_area_struct *first_vma(struct task_struct *tsk,
1854 struct vm_area_struct *gate_vma)
1855{
1856 struct vm_area_struct *ret = tsk->mm->mmap;
1857
1858 if (ret)
1859 return ret;
1860 return gate_vma;
1861}
1862/*
1863 * Helper function for iterating across a vma list. It ensures that the caller
1864 * will visit `gate_vma' prior to terminating the search.
1865 */
1866static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
1867 struct vm_area_struct *gate_vma)
1868{
1869 struct vm_area_struct *ret;
1870
1871 ret = this_vma->vm_next;
1872 if (ret)
1873 return ret;
1874 if (this_vma == gate_vma)
1875 return NULL;
1876 return gate_vma;
1877}
1878
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08001879static void fill_extnum_info(struct elfhdr *elf, struct elf_shdr *shdr4extnum,
1880 elf_addr_t e_shoff, int segs)
1881{
1882 elf->e_shoff = e_shoff;
1883 elf->e_shentsize = sizeof(*shdr4extnum);
1884 elf->e_shnum = 1;
1885 elf->e_shstrndx = SHN_UNDEF;
1886
1887 memset(shdr4extnum, 0, sizeof(*shdr4extnum));
1888
1889 shdr4extnum->sh_type = SHT_NULL;
1890 shdr4extnum->sh_size = elf->e_shnum;
1891 shdr4extnum->sh_link = elf->e_shstrndx;
1892 shdr4extnum->sh_info = segs;
1893}
1894
1895static size_t elf_core_vma_data_size(struct vm_area_struct *gate_vma,
1896 unsigned long mm_flags)
1897{
1898 struct vm_area_struct *vma;
1899 size_t size = 0;
1900
1901 for (vma = first_vma(current, gate_vma); vma != NULL;
1902 vma = next_vma(vma, gate_vma))
1903 size += vma_dump_size(vma, mm_flags);
1904 return size;
1905}
1906
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907/*
1908 * Actual dumper
1909 *
1910 * This is a two-pass process; first we find the offsets of the bits,
1911 * and then they are actually written out. If we run out of core limit
1912 * we just truncate.
1913 */
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08001914static int elf_core_dump(struct coredump_params *cprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 int has_dumped = 0;
1917 mm_segment_t fs;
1918 int segs;
1919 size_t size = 0;
Roland McGrathf47aef52007-01-26 00:56:49 -08001920 struct vm_area_struct *vma, *gate_vma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 struct elfhdr *elf = NULL;
Andi Kleend025c9d2006-09-30 23:29:28 -07001922 loff_t offset = 0, dataoff, foffset;
Roland McGrath3aba4812008-01-30 13:31:44 +01001923 struct elf_note_info info;
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08001924 struct elf_phdr *phdr4note = NULL;
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08001925 struct elf_shdr *shdr4extnum = NULL;
1926 Elf_Half e_phnum;
1927 elf_addr_t e_shoff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928
1929 /*
1930 * We no longer stop all VM operations.
1931 *
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001932 * This is because those proceses that could possibly change map_count
1933 * or the mmap / vma pages are now blocked in do_exit on current
1934 * finishing this core dump.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 *
1936 * Only ptrace can touch these memory addresses, but it doesn't change
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001937 * the map_count or the pages allocated. So no possibility of crashing
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 * exists while dumping the mm->vm_next areas to the core file.
1939 */
1940
1941 /* alloc memory for large data structures: too large to be on stack */
1942 elf = kmalloc(sizeof(*elf), GFP_KERNEL);
1943 if (!elf)
WANG Cong5f719552008-05-06 12:45:35 +08001944 goto out;
KAMEZAWA Hiroyuki341c87b2009-06-30 11:41:23 -07001945 /*
1946 * The number of segs are recored into ELF header as 16bit value.
1947 * Please check DEFAULT_MAX_MAP_COUNT definition when you modify here.
1948 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 segs = current->mm->map_count;
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08001950 segs += elf_core_extra_phdrs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951
Stephen Wilson31db58b2011-03-13 15:49:15 -04001952 gate_vma = get_gate_vma(current->mm);
Roland McGrathf47aef52007-01-26 00:56:49 -08001953 if (gate_vma != NULL)
1954 segs++;
1955
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08001956 /* for notes section */
1957 segs++;
1958
1959 /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
1960 * this, kernel supports extended numbering. Have a look at
1961 * include/linux/elf.h for further information. */
1962 e_phnum = segs > PN_XNUM ? PN_XNUM : segs;
1963
Roland McGrath3aba4812008-01-30 13:31:44 +01001964 /*
1965 * Collect all the non-memory information about the process for the
1966 * notes. This also sets up the file header.
1967 */
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08001968 if (!fill_note_info(elf, e_phnum, &info, cprm->signr, cprm->regs))
Roland McGrath3aba4812008-01-30 13:31:44 +01001969 goto cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970
1971 has_dumped = 1;
1972 current->flags |= PF_DUMPCORE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973
1974 fs = get_fs();
1975 set_fs(KERNEL_DS);
1976
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977 offset += sizeof(*elf); /* Elf header */
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08001978 offset += segs * sizeof(struct elf_phdr); /* Program headers */
Petr Vandroveca7a0d862006-10-13 18:42:07 +02001979 foffset = offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980
1981 /* Write notes phdr entry */
1982 {
Roland McGrath3aba4812008-01-30 13:31:44 +01001983 size_t sz = get_note_info_size(&info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984
Michael Ellermane5501492007-09-19 14:38:12 +10001985 sz += elf_coredump_extra_notes_size();
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001986
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08001987 phdr4note = kmalloc(sizeof(*phdr4note), GFP_KERNEL);
1988 if (!phdr4note)
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -08001989 goto end_coredump;
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08001990
1991 fill_elf_note_phdr(phdr4note, sz, offset);
1992 offset += sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 }
1994
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
1996
Masami Hiramatsu30736a42010-03-05 13:44:12 -08001997 offset += elf_core_vma_data_size(gate_vma, cprm->mm_flags);
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08001998 offset += elf_core_extra_data_size();
1999 e_shoff = offset;
2000
2001 if (e_phnum == PN_XNUM) {
2002 shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);
2003 if (!shdr4extnum)
2004 goto end_coredump;
2005 fill_extnum_info(elf, shdr4extnum, e_shoff, segs);
2006 }
2007
2008 offset = dataoff;
2009
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002010 size += sizeof(*elf);
2011 if (size > cprm->limit || !dump_write(cprm->file, elf, sizeof(*elf)))
2012 goto end_coredump;
2013
2014 size += sizeof(*phdr4note);
2015 if (size > cprm->limit
2016 || !dump_write(cprm->file, phdr4note, sizeof(*phdr4note)))
2017 goto end_coredump;
2018
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 /* Write program headers for segments dump */
Roland McGrathf47aef52007-01-26 00:56:49 -08002020 for (vma = first_vma(current, gate_vma); vma != NULL;
2021 vma = next_vma(vma, gate_vma)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 struct elf_phdr phdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023
2024 phdr.p_type = PT_LOAD;
2025 phdr.p_offset = offset;
2026 phdr.p_vaddr = vma->vm_start;
2027 phdr.p_paddr = 0;
Masami Hiramatsu30736a42010-03-05 13:44:12 -08002028 phdr.p_filesz = vma_dump_size(vma, cprm->mm_flags);
Roland McGrath82df3972007-10-16 23:27:02 -07002029 phdr.p_memsz = vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 offset += phdr.p_filesz;
2031 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002032 if (vma->vm_flags & VM_WRITE)
2033 phdr.p_flags |= PF_W;
2034 if (vma->vm_flags & VM_EXEC)
2035 phdr.p_flags |= PF_X;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 phdr.p_align = ELF_EXEC_PAGESIZE;
2037
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -08002038 size += sizeof(phdr);
2039 if (size > cprm->limit
2040 || !dump_write(cprm->file, &phdr, sizeof(phdr)))
2041 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 }
2043
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002044 if (!elf_core_write_extra_phdrs(cprm->file, offset, &size, cprm->limit))
2045 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046
2047 /* write out the notes section */
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002048 if (!write_note_info(&info, cprm->file, &foffset))
Roland McGrath3aba4812008-01-30 13:31:44 +01002049 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002051 if (elf_coredump_extra_notes_write(cprm->file, &foffset))
Michael Ellermane5501492007-09-19 14:38:12 +10002052 goto end_coredump;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002053
Andi Kleend025c9d2006-09-30 23:29:28 -07002054 /* Align to page */
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002055 if (!dump_seek(cprm->file, dataoff - foffset))
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002056 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057
Roland McGrathf47aef52007-01-26 00:56:49 -08002058 for (vma = first_vma(current, gate_vma); vma != NULL;
2059 vma = next_vma(vma, gate_vma)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 unsigned long addr;
Roland McGrath82df3972007-10-16 23:27:02 -07002061 unsigned long end;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062
Masami Hiramatsu30736a42010-03-05 13:44:12 -08002063 end = vma->vm_start + vma_dump_size(vma, cprm->mm_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064
Roland McGrath82df3972007-10-16 23:27:02 -07002065 for (addr = vma->vm_start; addr < end; addr += PAGE_SIZE) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002066 struct page *page;
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002067 int stop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002069 page = get_dump_page(addr);
2070 if (page) {
2071 void *kaddr = kmap(page);
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002072 stop = ((size += PAGE_SIZE) > cprm->limit) ||
2073 !dump_write(cprm->file, kaddr,
2074 PAGE_SIZE);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002075 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 page_cache_release(page);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002077 } else
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002078 stop = !dump_seek(cprm->file, PAGE_SIZE);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002079 if (stop)
2080 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 }
2082 }
2083
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002084 if (!elf_core_write_extra_data(cprm->file, &size, cprm->limit))
2085 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002087 if (e_phnum == PN_XNUM) {
2088 size += sizeof(*shdr4extnum);
2089 if (size > cprm->limit
2090 || !dump_write(cprm->file, shdr4extnum,
2091 sizeof(*shdr4extnum)))
2092 goto end_coredump;
2093 }
2094
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095end_coredump:
2096 set_fs(fs);
2097
2098cleanup:
Roland McGrath3aba4812008-01-30 13:31:44 +01002099 free_note_info(&info);
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002100 kfree(shdr4extnum);
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002101 kfree(phdr4note);
WANG Cong5f719552008-05-06 12:45:35 +08002102 kfree(elf);
2103out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 return has_dumped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105}
2106
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08002107#endif /* CONFIG_ELF_CORE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108
2109static int __init init_elf_binfmt(void)
2110{
Al Viro8fc3dc52012-03-17 03:05:16 -04002111 register_binfmt(&elf_format);
2112 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113}
2114
2115static void __exit exit_elf_binfmt(void)
2116{
2117 /* Remove the COFF and ELF loaders. */
2118 unregister_binfmt(&elf_format);
2119}
2120
2121core_initcall(init_elf_binfmt);
2122module_exit(exit_elf_binfmt);
2123MODULE_LICENSE("GPL");