blob: a333cd982d3395a16913d4480dda7f9c1ded0686 [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>
Frederic Weisbecker6fac4822012-11-13 14:20:55 +010036#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <asm/uaccess.h>
38#include <asm/param.h>
39#include <asm/page.h>
40
Denys Vlasenko2aa362c2012-10-04 17:15:36 -070041#ifndef user_long_t
42#define user_long_t long
43#endif
Denys Vlasenko49ae4d42012-10-04 17:15:35 -070044#ifndef user_siginfo_t
45#define user_siginfo_t siginfo_t
46#endif
47
Al Viro71613c32012-10-20 22:00:48 -040048static int load_elf_binary(struct linux_binprm *bprm);
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
Josh Triplett69369a72014-04-03 14:48:27 -070052#ifdef CONFIG_USELIB
53static int load_elf_library(struct file *);
54#else
55#define load_elf_library NULL
56#endif
57
Linus Torvalds1da177e2005-04-16 15:20:36 -070058/*
59 * If we don't support core dumping, then supply a NULL so we
60 * don't even try.
61 */
Christoph Hellwig698ba7b2009-12-15 16:47:37 -080062#ifdef CONFIG_ELF_CORE
Masami Hiramatsuf6151df2009-12-17 15:27:16 -080063static int elf_core_dump(struct coredump_params *cprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#else
65#define elf_core_dump NULL
66#endif
67
68#if ELF_EXEC_PAGESIZE > PAGE_SIZE
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070069#define ELF_MIN_ALIGN ELF_EXEC_PAGESIZE
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#else
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070071#define ELF_MIN_ALIGN PAGE_SIZE
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#endif
73
74#ifndef ELF_CORE_EFLAGS
75#define ELF_CORE_EFLAGS 0
76#endif
77
78#define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
79#define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
80#define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
81
82static struct linux_binfmt elf_format = {
Mikael Petterssonf670d0e2011-01-12 17:00:02 -080083 .module = THIS_MODULE,
84 .load_binary = load_elf_binary,
85 .load_shlib = load_elf_library,
86 .core_dump = elf_core_dump,
87 .min_coredump = ELF_EXEC_PAGESIZE,
Linus Torvalds1da177e2005-04-16 15:20:36 -070088};
89
Andrew Mortond4e3cc32007-07-21 04:37:32 -070090#define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
92static int set_brk(unsigned long start, unsigned long end)
93{
94 start = ELF_PAGEALIGN(start);
95 end = ELF_PAGEALIGN(end);
96 if (end > start) {
97 unsigned long addr;
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -070098 addr = vm_brk(start, end - start);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 if (BAD_ADDR(addr))
100 return addr;
101 }
102 current->mm->start_brk = current->mm->brk = end;
103 return 0;
104}
105
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106/* We need to explicitly zero any fractional pages
107 after the data section (i.e. bss). This would
108 contain the junk from the file that should not
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700109 be in memory
110 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111static int padzero(unsigned long elf_bss)
112{
113 unsigned long nbyte;
114
115 nbyte = ELF_PAGEOFFSET(elf_bss);
116 if (nbyte) {
117 nbyte = ELF_MIN_ALIGN - nbyte;
118 if (clear_user((void __user *) elf_bss, nbyte))
119 return -EFAULT;
120 }
121 return 0;
122}
123
Ohad Ben-Cohen09c6dd32008-02-03 18:05:15 +0200124/* Let's use some macros to make this stack manipulation a little clearer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125#ifdef CONFIG_STACK_GROWSUP
126#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))
127#define STACK_ROUND(sp, items) \
128 ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700129#define STACK_ALLOC(sp, len) ({ \
130 elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; \
131 old_sp; })
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132#else
133#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))
134#define STACK_ROUND(sp, items) \
135 (((unsigned long) (sp - items)) &~ 15UL)
136#define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })
137#endif
138
Nathan Lynch483fad12008-07-22 04:48:46 +1000139#ifndef ELF_BASE_PLATFORM
140/*
141 * AT_BASE_PLATFORM indicates the "real" hardware/microarchitecture.
142 * If the arch defines ELF_BASE_PLATFORM (in asm/elf.h), the value
143 * will be copied to the user stack in the same manner as AT_PLATFORM.
144 */
145#define ELF_BASE_PLATFORM NULL
146#endif
147
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148static int
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700149create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
Andi Kleend20894a2008-02-08 04:21:54 -0800150 unsigned long load_addr, unsigned long interp_load_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
152 unsigned long p = bprm->p;
153 int argc = bprm->argc;
154 int envc = bprm->envc;
155 elf_addr_t __user *argv;
156 elf_addr_t __user *envp;
157 elf_addr_t __user *sp;
158 elf_addr_t __user *u_platform;
Nathan Lynch483fad12008-07-22 04:48:46 +1000159 elf_addr_t __user *u_base_platform;
Kees Cookf06295b2009-01-07 18:08:52 -0800160 elf_addr_t __user *u_rand_bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 const char *k_platform = ELF_PLATFORM;
Nathan Lynch483fad12008-07-22 04:48:46 +1000162 const char *k_base_platform = ELF_BASE_PLATFORM;
Kees Cookf06295b2009-01-07 18:08:52 -0800163 unsigned char k_rand_bytes[16];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 int items;
165 elf_addr_t *elf_info;
166 int ei_index = 0;
David Howells86a264a2008-11-14 10:39:18 +1100167 const struct cred *cred = current_cred();
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700168 struct vm_area_struct *vma;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
170 /*
Franck Bui-Huud68c9d62007-10-16 23:30:24 -0700171 * In some cases (e.g. Hyper-Threading), we want to avoid L1
172 * evictions by the processes running on the same package. One
173 * thing we can do is to shuffle the initial stack for them.
174 */
175
176 p = arch_align_stack(p);
177
178 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 * If this architecture has a platform capability string, copy it
180 * to userspace. In some cases (Sparc), this info is impossible
181 * for userspace to get any other way, in others (i386) it is
182 * merely difficult.
183 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 u_platform = NULL;
185 if (k_platform) {
186 size_t len = strlen(k_platform) + 1;
187
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
189 if (__copy_to_user(u_platform, k_platform, len))
190 return -EFAULT;
191 }
192
Nathan Lynch483fad12008-07-22 04:48:46 +1000193 /*
194 * If this architecture has a "base" platform capability
195 * string, copy it to userspace.
196 */
197 u_base_platform = NULL;
198 if (k_base_platform) {
199 size_t len = strlen(k_base_platform) + 1;
200
201 u_base_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
202 if (__copy_to_user(u_base_platform, k_base_platform, len))
203 return -EFAULT;
204 }
205
Kees Cookf06295b2009-01-07 18:08:52 -0800206 /*
207 * Generate 16 random bytes for userspace PRNG seeding.
208 */
209 get_random_bytes(k_rand_bytes, sizeof(k_rand_bytes));
210 u_rand_bytes = (elf_addr_t __user *)
211 STACK_ALLOC(p, sizeof(k_rand_bytes));
212 if (__copy_to_user(u_rand_bytes, k_rand_bytes, sizeof(k_rand_bytes)))
213 return -EFAULT;
214
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 /* Create the ELF interpreter info */
Jesper Juhl785d5572006-06-23 02:05:35 -0700216 elf_info = (elf_addr_t *)current->mm->saved_auxv;
Olaf Hering4f9a58d2007-10-16 23:30:12 -0700217 /* update AT_VECTOR_SIZE_BASE if the number of NEW_AUX_ENT() changes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218#define NEW_AUX_ENT(id, val) \
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700219 do { \
Jesper Juhl785d5572006-06-23 02:05:35 -0700220 elf_info[ei_index++] = id; \
221 elf_info[ei_index++] = val; \
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700222 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
224#ifdef ARCH_DLINFO
225 /*
226 * ARCH_DLINFO must come first so PPC can do its special alignment of
227 * AUXV.
Olaf Hering4f9a58d2007-10-16 23:30:12 -0700228 * update AT_VECTOR_SIZE_ARCH if the number of NEW_AUX_ENT() in
229 * ARCH_DLINFO changes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 */
231 ARCH_DLINFO;
232#endif
233 NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);
234 NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
235 NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
236 NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700237 NEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);
239 NEW_AUX_ENT(AT_BASE, interp_load_addr);
240 NEW_AUX_ENT(AT_FLAGS, 0);
241 NEW_AUX_ENT(AT_ENTRY, exec->e_entry);
Eric W. Biedermanebc887b2012-02-07 18:36:10 -0800242 NEW_AUX_ENT(AT_UID, from_kuid_munged(cred->user_ns, cred->uid));
243 NEW_AUX_ENT(AT_EUID, from_kuid_munged(cred->user_ns, cred->euid));
244 NEW_AUX_ENT(AT_GID, from_kgid_munged(cred->user_ns, cred->gid));
245 NEW_AUX_ENT(AT_EGID, from_kgid_munged(cred->user_ns, cred->egid));
Jesper Juhl785d5572006-06-23 02:05:35 -0700246 NEW_AUX_ENT(AT_SECURE, security_bprm_secureexec(bprm));
Kees Cookf06295b2009-01-07 18:08:52 -0800247 NEW_AUX_ENT(AT_RANDOM, (elf_addr_t)(unsigned long)u_rand_bytes);
Michael Neuling21713642013-04-17 17:33:11 +0000248#ifdef ELF_HWCAP2
249 NEW_AUX_ENT(AT_HWCAP2, ELF_HWCAP2);
250#endif
John Reiser65191082008-07-21 14:21:32 -0700251 NEW_AUX_ENT(AT_EXECFN, bprm->exec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 if (k_platform) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700253 NEW_AUX_ENT(AT_PLATFORM,
Jesper Juhl785d5572006-06-23 02:05:35 -0700254 (elf_addr_t)(unsigned long)u_platform);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 }
Nathan Lynch483fad12008-07-22 04:48:46 +1000256 if (k_base_platform) {
257 NEW_AUX_ENT(AT_BASE_PLATFORM,
258 (elf_addr_t)(unsigned long)u_base_platform);
259 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
Jesper Juhl785d5572006-06-23 02:05:35 -0700261 NEW_AUX_ENT(AT_EXECFD, bprm->interp_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 }
263#undef NEW_AUX_ENT
264 /* AT_NULL is zero; clear the rest too */
265 memset(&elf_info[ei_index], 0,
266 sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);
267
268 /* And advance past the AT_NULL entry. */
269 ei_index += 2;
270
271 sp = STACK_ADD(p, ei_index);
272
Andi Kleend20894a2008-02-08 04:21:54 -0800273 items = (argc + 1) + (envc + 1) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 bprm->p = STACK_ROUND(sp, items);
275
276 /* Point sp at the lowest address on the stack */
277#ifdef CONFIG_STACK_GROWSUP
278 sp = (elf_addr_t __user *)bprm->p - items - ei_index;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700279 bprm->exec = (unsigned long)sp; /* XXX: PARISC HACK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280#else
281 sp = (elf_addr_t __user *)bprm->p;
282#endif
283
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700284
285 /*
286 * Grow the stack manually; some architectures have a limit on how
287 * far ahead a user-space access may be in order to grow the stack.
288 */
289 vma = find_extend_vma(current->mm, bprm->p);
290 if (!vma)
291 return -EFAULT;
292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 /* Now, let's put argc (and argv, envp if appropriate) on the stack */
294 if (__put_user(argc, sp++))
295 return -EFAULT;
Andi Kleend20894a2008-02-08 04:21:54 -0800296 argv = sp;
297 envp = argv + argc + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
299 /* Populate argv and envp */
Greg Kroah-Hartmana84a5052005-05-11 00:10:44 -0700300 p = current->mm->arg_end = current->mm->arg_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 while (argc-- > 0) {
302 size_t len;
Heiko Carstens841d5fb2006-12-06 20:36:35 -0800303 if (__put_user((elf_addr_t)p, argv++))
304 return -EFAULT;
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700305 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
306 if (!len || len > MAX_ARG_STRLEN)
WANG Cong23c49712008-05-08 21:52:33 +0800307 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 p += len;
309 }
310 if (__put_user(0, argv))
311 return -EFAULT;
312 current->mm->arg_end = current->mm->env_start = p;
313 while (envc-- > 0) {
314 size_t len;
Heiko Carstens841d5fb2006-12-06 20:36:35 -0800315 if (__put_user((elf_addr_t)p, envp++))
316 return -EFAULT;
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700317 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
318 if (!len || len > MAX_ARG_STRLEN)
WANG Cong23c49712008-05-08 21:52:33 +0800319 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 p += len;
321 }
322 if (__put_user(0, envp))
323 return -EFAULT;
324 current->mm->env_end = p;
325
326 /* Put the elf_info on the stack in the right place. */
327 sp = (elf_addr_t __user *)envp + 1;
328 if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))
329 return -EFAULT;
330 return 0;
331}
332
James Hoganc07380b2011-05-09 10:58:40 +0100333#ifndef elf_map
334
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335static unsigned long elf_map(struct file *filep, unsigned long addr,
Jiri Kosinacc503c12008-01-30 13:31:07 +0100336 struct elf_phdr *eppnt, int prot, int type,
337 unsigned long total_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338{
339 unsigned long map_addr;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100340 unsigned long size = eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr);
341 unsigned long off = eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr);
342 addr = ELF_PAGESTART(addr);
343 size = ELF_PAGEALIGN(size);
Jan Kratochvil60bfba72007-07-15 23:40:06 -0700344
Andrew Mortond4e3cc32007-07-21 04:37:32 -0700345 /* mmap() will return -EINVAL if given a zero size, but a
346 * segment with zero filesize is perfectly valid */
Jiri Kosinacc503c12008-01-30 13:31:07 +0100347 if (!size)
348 return addr;
349
Jiri Kosinacc503c12008-01-30 13:31:07 +0100350 /*
351 * total_size is the size of the ELF (interpreter) image.
352 * The _first_ mmap needs to know the full size, otherwise
353 * randomization might put this image into an overlapping
354 * position with the ELF binary image. (since size < total_size)
355 * So we first map the 'big' image - and unmap the remainder at
356 * the end. (which unmap is needed for ELF images with holes.)
357 */
358 if (total_size) {
359 total_size = ELF_PAGEALIGN(total_size);
Al Viro5a5e4c22012-05-30 01:49:38 -0400360 map_addr = vm_mmap(filep, addr, total_size, prot, type, off);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100361 if (!BAD_ADDR(map_addr))
Al Viro5a5e4c22012-05-30 01:49:38 -0400362 vm_munmap(map_addr+size, total_size-size);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100363 } else
Al Viro5a5e4c22012-05-30 01:49:38 -0400364 map_addr = vm_mmap(filep, addr, size, prot, type, off);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 return(map_addr);
367}
368
James Hoganc07380b2011-05-09 10:58:40 +0100369#endif /* !elf_map */
370
Jiri Kosinacc503c12008-01-30 13:31:07 +0100371static unsigned long total_mapping_size(struct elf_phdr *cmds, int nr)
372{
373 int i, first_idx = -1, last_idx = -1;
374
375 for (i = 0; i < nr; i++) {
376 if (cmds[i].p_type == PT_LOAD) {
377 last_idx = i;
378 if (first_idx == -1)
379 first_idx = i;
380 }
381 }
382 if (first_idx == -1)
383 return 0;
384
385 return cmds[last_idx].p_vaddr + cmds[last_idx].p_memsz -
386 ELF_PAGESTART(cmds[first_idx].p_vaddr);
387}
388
Paul Burton6a8d3892014-09-11 08:30:14 +0100389/**
390 * load_elf_phdrs() - load ELF program headers
391 * @elf_ex: ELF header of the binary whose program headers should be loaded
392 * @elf_file: the opened ELF binary file
393 *
394 * Loads ELF program headers from the binary file elf_file, which has the ELF
395 * header pointed to by elf_ex, into a newly allocated array. The caller is
396 * responsible for freeing the allocated data. Returns an ERR_PTR upon failure.
397 */
398static struct elf_phdr *load_elf_phdrs(struct elfhdr *elf_ex,
399 struct file *elf_file)
400{
401 struct elf_phdr *elf_phdata = NULL;
402 int retval, size, err = -1;
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 (elf_ex->e_phentsize != sizeof(struct elf_phdr))
409 goto out;
410
411 /* Sanity check the number of program headers... */
412 if (elf_ex->e_phnum < 1 ||
413 elf_ex->e_phnum > 65536U / sizeof(struct elf_phdr))
414 goto out;
415
416 /* ...and their total size. */
417 size = sizeof(struct elf_phdr) * elf_ex->e_phnum;
418 if (size > ELF_MIN_ALIGN)
419 goto out;
420
421 elf_phdata = kmalloc(size, GFP_KERNEL);
422 if (!elf_phdata)
423 goto out;
424
425 /* Read in the program headers */
426 retval = kernel_read(elf_file, elf_ex->e_phoff,
427 (char *)elf_phdata, size);
428 if (retval != size) {
429 err = (retval < 0) ? retval : -EIO;
430 goto out;
431 }
432
433 /* Success! */
434 err = 0;
435out:
436 if (err) {
437 kfree(elf_phdata);
438 elf_phdata = NULL;
439 }
440 return elf_phdata;
441}
Jiri Kosinacc503c12008-01-30 13:31:07 +0100442
Paul Burton774c1052014-09-11 08:30:16 +0100443#ifndef CONFIG_ARCH_BINFMT_ELF_STATE
444
445/**
446 * struct arch_elf_state - arch-specific ELF loading state
447 *
448 * This structure is used to preserve architecture specific data during
449 * the loading of an ELF file, throughout the checking of architecture
450 * specific ELF headers & through to the point where the ELF load is
451 * known to be proceeding (ie. SET_PERSONALITY).
452 *
453 * This implementation is a dummy for architectures which require no
454 * specific state.
455 */
456struct arch_elf_state {
457};
458
459#define INIT_ARCH_ELF_STATE {}
460
461/**
462 * arch_elf_pt_proc() - check a PT_LOPROC..PT_HIPROC ELF program header
463 * @ehdr: The main ELF header
464 * @phdr: The program header to check
465 * @elf: The open ELF file
466 * @is_interp: True if the phdr is from the interpreter of the ELF being
467 * loaded, else false.
468 * @state: Architecture-specific state preserved throughout the process
469 * of loading the ELF.
470 *
471 * Inspects the program header phdr to validate its correctness and/or
472 * suitability for the system. Called once per ELF program header in the
473 * range PT_LOPROC to PT_HIPROC, for both the ELF being loaded and its
474 * interpreter.
475 *
476 * Return: Zero to proceed with the ELF load, non-zero to fail the ELF load
477 * with that return code.
478 */
479static inline int arch_elf_pt_proc(struct elfhdr *ehdr,
480 struct elf_phdr *phdr,
481 struct file *elf, bool is_interp,
482 struct arch_elf_state *state)
483{
484 /* Dummy implementation, always proceed */
485 return 0;
486}
487
488/**
489 * arch_check_elf() - check a PT_LOPROC..PT_HIPROC ELF program header
490 * @ehdr: The main ELF header
491 * @has_interp: True if the ELF has an interpreter, else false.
492 * @state: Architecture-specific state preserved throughout the process
493 * of loading the ELF.
494 *
495 * Provides a final opportunity for architecture code to reject the loading
496 * of the ELF & cause an exec syscall to return an error. This is called after
497 * all program headers to be checked by arch_elf_pt_proc have been.
498 *
499 * Return: Zero to proceed with the ELF load, non-zero to fail the ELF load
500 * with that return code.
501 */
502static inline int arch_check_elf(struct elfhdr *ehdr, bool has_interp,
503 struct arch_elf_state *state)
504{
505 /* Dummy implementation, always proceed */
506 return 0;
507}
508
509#endif /* !CONFIG_ARCH_BINFMT_ELF_STATE */
510
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511/* This is much more generalized than the library routine read function,
512 so we keep this separate. Technically the library read function
513 is only provided so that we can read a.out libraries that have
514 an ELF header */
515
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700516static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
Jiri Kosinacc503c12008-01-30 13:31:07 +0100517 struct file *interpreter, unsigned long *interp_map_addr,
Paul Burtona9d9ef12014-09-11 08:30:15 +0100518 unsigned long no_base, struct elf_phdr *interp_elf_phdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 struct elf_phdr *eppnt;
521 unsigned long load_addr = 0;
522 int load_addr_set = 0;
523 unsigned long last_bss = 0, elf_bss = 0;
524 unsigned long error = ~0UL;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100525 unsigned long total_size;
Paul Burton6a8d3892014-09-11 08:30:14 +0100526 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
528 /* First of all, some simple consistency checks */
529 if (interp_elf_ex->e_type != ET_EXEC &&
530 interp_elf_ex->e_type != ET_DYN)
531 goto out;
532 if (!elf_check_arch(interp_elf_ex))
533 goto out;
Al Viro72c2d532013-09-22 16:27:52 -0400534 if (!interpreter->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 goto out;
536
Paul Burtona9d9ef12014-09-11 08:30:15 +0100537 total_size = total_mapping_size(interp_elf_phdata,
538 interp_elf_ex->e_phnum);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100539 if (!total_size) {
540 error = -EINVAL;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100541 goto out;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100542 }
543
Paul Burtona9d9ef12014-09-11 08:30:15 +0100544 eppnt = interp_elf_phdata;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700545 for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
546 if (eppnt->p_type == PT_LOAD) {
547 int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
548 int elf_prot = 0;
549 unsigned long vaddr = 0;
550 unsigned long k, map_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700552 if (eppnt->p_flags & PF_R)
553 elf_prot = PROT_READ;
554 if (eppnt->p_flags & PF_W)
555 elf_prot |= PROT_WRITE;
556 if (eppnt->p_flags & PF_X)
557 elf_prot |= PROT_EXEC;
558 vaddr = eppnt->p_vaddr;
559 if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
560 elf_type |= MAP_FIXED;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100561 else if (no_base && interp_elf_ex->e_type == ET_DYN)
562 load_addr = -vaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700564 map_addr = elf_map(interpreter, load_addr + vaddr,
Andrew Mortonbb1ad822008-01-30 13:31:07 +0100565 eppnt, elf_prot, elf_type, total_size);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100566 total_size = 0;
567 if (!*interp_map_addr)
568 *interp_map_addr = map_addr;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700569 error = map_addr;
570 if (BAD_ADDR(map_addr))
Paul Burtona9d9ef12014-09-11 08:30:15 +0100571 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700573 if (!load_addr_set &&
574 interp_elf_ex->e_type == ET_DYN) {
575 load_addr = map_addr - ELF_PAGESTART(vaddr);
576 load_addr_set = 1;
577 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700579 /*
580 * Check to see if the section's size will overflow the
581 * allowed task size. Note that p_filesz must always be
582 * <= p_memsize so it's only necessary to check p_memsz.
583 */
584 k = load_addr + eppnt->p_vaddr;
Chuck Ebbertce510592006-07-03 00:24:14 -0700585 if (BAD_ADDR(k) ||
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700586 eppnt->p_filesz > eppnt->p_memsz ||
587 eppnt->p_memsz > TASK_SIZE ||
588 TASK_SIZE - eppnt->p_memsz < k) {
589 error = -ENOMEM;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100590 goto out;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700591 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700593 /*
594 * Find the end of the file mapping for this phdr, and
595 * keep track of the largest address we see for this.
596 */
597 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
598 if (k > elf_bss)
599 elf_bss = k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700601 /*
602 * Do the same thing for the memory mapping - between
603 * elf_bss and last_bss is the bss section.
604 */
605 k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
606 if (k > last_bss)
607 last_bss = k;
608 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 }
610
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 if (last_bss > elf_bss) {
Roland McGrath752015d2009-09-08 19:49:40 -0700612 /*
613 * Now fill out the bss section. First pad the last page up
614 * to the page boundary, and then perform a mmap to make sure
615 * that there are zero-mapped pages up to and including the
616 * last bss page.
617 */
618 if (padzero(elf_bss)) {
619 error = -EFAULT;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100620 goto out;
Roland McGrath752015d2009-09-08 19:49:40 -0700621 }
622
623 /* What we have mapped so far */
624 elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1);
625
626 /* Map the last of the bss segment */
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -0700627 error = vm_brk(elf_bss, last_bss - elf_bss);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 if (BAD_ADDR(error))
Paul Burtona9d9ef12014-09-11 08:30:15 +0100629 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 }
631
Jiri Kosinacc503c12008-01-30 13:31:07 +0100632 error = load_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633out:
634 return error;
635}
636
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637/*
638 * These are the functions used to load ELF style executables and shared
639 * libraries. There is no binary dependent code anywhere else.
640 */
641
Andi Kleen913bd902006-03-25 16:29:09 +0100642#ifndef STACK_RND_MASK
James Bottomleyd1cabd62007-03-16 13:38:35 -0800643#define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12)) /* 8MB of VA */
Andi Kleen913bd902006-03-25 16:29:09 +0100644#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
646static unsigned long randomize_stack_top(unsigned long stack_top)
647{
648 unsigned int random_variable = 0;
649
Andi Kleenc16b63e02006-09-26 10:52:28 +0200650 if ((current->flags & PF_RANDOMIZE) &&
651 !(current->personality & ADDR_NO_RANDOMIZE)) {
Andi Kleen913bd902006-03-25 16:29:09 +0100652 random_variable = get_random_int() & STACK_RND_MASK;
653 random_variable <<= PAGE_SHIFT;
654 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655#ifdef CONFIG_STACK_GROWSUP
Andi Kleen913bd902006-03-25 16:29:09 +0100656 return PAGE_ALIGN(stack_top) + random_variable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657#else
Andi Kleen913bd902006-03-25 16:29:09 +0100658 return PAGE_ALIGN(stack_top) - random_variable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659#endif
660}
661
Al Viro71613c32012-10-20 22:00:48 -0400662static int load_elf_binary(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663{
664 struct file *interpreter = NULL; /* to shut gcc up */
665 unsigned long load_addr = 0, load_bias = 0;
666 int load_addr_set = 0;
667 char * elf_interpreter = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 unsigned long error;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100669 struct elf_phdr *elf_ppnt, *elf_phdata, *interp_elf_phdata = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 unsigned long elf_bss, elf_brk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 int retval, i;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100672 unsigned long elf_entry;
673 unsigned long interp_load_addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 unsigned long start_code, end_code, start_data, end_data;
David Daney1a530a62011-03-22 16:34:48 -0700675 unsigned long reloc_func_desc __maybe_unused = 0;
David Rientjes8de61e62006-12-06 20:40:16 -0800676 int executable_stack = EXSTACK_DEFAULT;
Al Viro71613c32012-10-20 22:00:48 -0400677 struct pt_regs *regs = current_pt_regs();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 struct {
679 struct elfhdr elf_ex;
680 struct elfhdr interp_elf_ex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 } *loc;
Paul Burton774c1052014-09-11 08:30:16 +0100682 struct arch_elf_state arch_state = INIT_ARCH_ELF_STATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683
684 loc = kmalloc(sizeof(*loc), GFP_KERNEL);
685 if (!loc) {
686 retval = -ENOMEM;
687 goto out_ret;
688 }
689
690 /* Get the exec-header */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700691 loc->elf_ex = *((struct elfhdr *)bprm->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692
693 retval = -ENOEXEC;
694 /* First of all, some simple consistency checks */
695 if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
696 goto out;
697
698 if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
699 goto out;
700 if (!elf_check_arch(&loc->elf_ex))
701 goto out;
Al Viro72c2d532013-09-22 16:27:52 -0400702 if (!bprm->file->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 goto out;
704
Paul Burton6a8d3892014-09-11 08:30:14 +0100705 elf_phdata = load_elf_phdrs(&loc->elf_ex, bprm->file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 if (!elf_phdata)
707 goto out;
708
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 elf_ppnt = elf_phdata;
710 elf_bss = 0;
711 elf_brk = 0;
712
713 start_code = ~0UL;
714 end_code = 0;
715 start_data = 0;
716 end_data = 0;
717
718 for (i = 0; i < loc->elf_ex.e_phnum; i++) {
719 if (elf_ppnt->p_type == PT_INTERP) {
720 /* This is the program interpreter used for
721 * shared libraries - for now assume that this
722 * is an a.out format binary
723 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 retval = -ENOEXEC;
725 if (elf_ppnt->p_filesz > PATH_MAX ||
726 elf_ppnt->p_filesz < 2)
Al Viroe7b9b552009-03-29 16:31:16 -0400727 goto out_free_ph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
729 retval = -ENOMEM;
Jesper Juhl792db3a2006-01-09 20:54:45 -0800730 elf_interpreter = kmalloc(elf_ppnt->p_filesz,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700731 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 if (!elf_interpreter)
Al Viroe7b9b552009-03-29 16:31:16 -0400733 goto out_free_ph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
735 retval = kernel_read(bprm->file, elf_ppnt->p_offset,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700736 elf_interpreter,
737 elf_ppnt->p_filesz);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 if (retval != elf_ppnt->p_filesz) {
739 if (retval >= 0)
740 retval = -EIO;
741 goto out_free_interp;
742 }
743 /* make sure path is NULL terminated */
744 retval = -ENOEXEC;
745 if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
746 goto out_free_interp;
747
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 interpreter = open_exec(elf_interpreter);
749 retval = PTR_ERR(interpreter);
750 if (IS_ERR(interpreter))
751 goto out_free_interp;
Alexey Dobriyan1fb84492007-01-26 00:57:16 -0800752
753 /*
754 * If the binary is not readable then enforce
755 * mm->dumpable = 0 regardless of the interpreter's
756 * permissions.
757 */
Al Viro1b5d7832011-06-19 12:49:47 -0400758 would_dump(bprm, interpreter);
Alexey Dobriyan1fb84492007-01-26 00:57:16 -0800759
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700760 retval = kernel_read(interpreter, 0, bprm->buf,
761 BINPRM_BUF_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 if (retval != BINPRM_BUF_SIZE) {
763 if (retval >= 0)
764 retval = -EIO;
765 goto out_free_dentry;
766 }
767
768 /* Get the exec headers */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700769 loc->interp_elf_ex = *((struct elfhdr *)bprm->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 break;
771 }
772 elf_ppnt++;
773 }
774
775 elf_ppnt = elf_phdata;
776 for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
Paul Burton774c1052014-09-11 08:30:16 +0100777 switch (elf_ppnt->p_type) {
778 case PT_GNU_STACK:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 if (elf_ppnt->p_flags & PF_X)
780 executable_stack = EXSTACK_ENABLE_X;
781 else
782 executable_stack = EXSTACK_DISABLE_X;
783 break;
Paul Burton774c1052014-09-11 08:30:16 +0100784
785 case PT_LOPROC ... PT_HIPROC:
786 retval = arch_elf_pt_proc(&loc->elf_ex, elf_ppnt,
787 bprm->file, false,
788 &arch_state);
789 if (retval)
790 goto out_free_dentry;
791 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
794 /* Some simple consistency checks for the interpreter */
795 if (elf_interpreter) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 retval = -ELIBBAD;
Andi Kleend20894a2008-02-08 04:21:54 -0800797 /* Not an ELF interpreter */
798 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 /* Verify the interpreter has a valid arch */
Andi Kleend20894a2008-02-08 04:21:54 -0800801 if (!elf_check_arch(&loc->interp_elf_ex))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 goto out_free_dentry;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100803
804 /* Load the interpreter program headers */
805 interp_elf_phdata = load_elf_phdrs(&loc->interp_elf_ex,
806 interpreter);
807 if (!interp_elf_phdata)
808 goto out_free_dentry;
Paul Burton774c1052014-09-11 08:30:16 +0100809
810 /* Pass PT_LOPROC..PT_HIPROC headers to arch code */
811 elf_ppnt = interp_elf_phdata;
812 for (i = 0; i < loc->interp_elf_ex.e_phnum; i++, elf_ppnt++)
813 switch (elf_ppnt->p_type) {
814 case PT_LOPROC ... PT_HIPROC:
815 retval = arch_elf_pt_proc(&loc->interp_elf_ex,
816 elf_ppnt, interpreter,
817 true, &arch_state);
818 if (retval)
819 goto out_free_dentry;
820 break;
821 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 }
823
Paul Burton774c1052014-09-11 08:30:16 +0100824 /*
825 * Allow arch code to reject the ELF at this point, whilst it's
826 * still possible to return an error to the code that invoked
827 * the exec syscall.
828 */
829 retval = arch_check_elf(&loc->elf_ex, !!interpreter, &arch_state);
830 if (retval)
831 goto out_free_dentry;
832
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 /* Flush all traces of the currently running executable */
834 retval = flush_old_exec(bprm);
835 if (retval)
836 goto out_free_dentry;
837
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 /* Do this immediately, since STACK_TOP as used in setup_arg_pages
839 may depend on the personality. */
Paul Burton774c1052014-09-11 08:30:16 +0100840 SET_PERSONALITY2(loc->elf_ex, &arch_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 if (elf_read_implies_exec(loc->elf_ex, executable_stack))
842 current->personality |= READ_IMPLIES_EXEC;
843
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700844 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 current->flags |= PF_RANDOMIZE;
Linus Torvalds221af7f2010-01-28 22:14:42 -0800846
847 setup_new_exec(bprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848
849 /* Do this so that we can load the interpreter, if need be. We will
850 change some of these later */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
852 executable_stack);
Al Viro19d860a2014-05-04 20:11:36 -0400853 if (retval < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 current->mm->start_stack = bprm->p;
857
André Goddard Rosaaf901ca2009-11-14 13:09:05 -0200858 /* Now we do a little grungy work by mmapping the ELF image into
Jiri Kosinacc503c12008-01-30 13:31:07 +0100859 the correct location in memory. */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700860 for(i = 0, elf_ppnt = elf_phdata;
861 i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 int elf_prot = 0, elf_flags;
863 unsigned long k, vaddr;
864
865 if (elf_ppnt->p_type != PT_LOAD)
866 continue;
867
868 if (unlikely (elf_brk > elf_bss)) {
869 unsigned long nbyte;
870
871 /* There was a PT_LOAD segment with p_memsz > p_filesz
872 before this one. Map anonymous pages, if needed,
873 and clear the area. */
Mikael Petterssonf670d0e2011-01-12 17:00:02 -0800874 retval = set_brk(elf_bss + load_bias,
875 elf_brk + load_bias);
Al Viro19d860a2014-05-04 20:11:36 -0400876 if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 nbyte = ELF_PAGEOFFSET(elf_bss);
879 if (nbyte) {
880 nbyte = ELF_MIN_ALIGN - nbyte;
881 if (nbyte > elf_brk - elf_bss)
882 nbyte = elf_brk - elf_bss;
883 if (clear_user((void __user *)elf_bss +
884 load_bias, nbyte)) {
885 /*
886 * This bss-zeroing can fail if the ELF
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700887 * file specifies odd protections. So
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 * we don't check the return value
889 */
890 }
891 }
892 }
893
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700894 if (elf_ppnt->p_flags & PF_R)
895 elf_prot |= PROT_READ;
896 if (elf_ppnt->p_flags & PF_W)
897 elf_prot |= PROT_WRITE;
898 if (elf_ppnt->p_flags & PF_X)
899 elf_prot |= PROT_EXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700901 elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902
903 vaddr = elf_ppnt->p_vaddr;
904 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
905 elf_flags |= MAP_FIXED;
906 } else if (loc->elf_ex.e_type == ET_DYN) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700907 /* Try and get dynamic programs out of the way of the
908 * default mmap base, as well as whatever program they
909 * might try to exec. This is because the brk will
910 * follow the loader, and is not movable. */
David Daneye39f5602012-01-10 15:10:21 -0800911#ifdef CONFIG_ARCH_BINFMT_ELF_RANDOMIZE_PIE
Jiri Kosinaa3defbe2011-11-02 13:37:41 -0700912 /* Memory randomization might have been switched off
Jiri Kosinac1d025e2013-04-30 15:27:45 -0700913 * in runtime via sysctl or explicit setting of
914 * personality flags.
Jiri Kosinaa3defbe2011-11-02 13:37:41 -0700915 * If that is the case, retain the original non-zero
916 * load_bias value in order to establish proper
917 * non-randomized mappings.
918 */
919 if (current->flags & PF_RANDOMIZE)
920 load_bias = 0;
921 else
922 load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100923#else
Linus Torvalds90cb28e2007-01-06 13:28:21 -0800924 load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100925#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 }
927
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700928 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
Andrew Mortonbb1ad822008-01-30 13:31:07 +0100929 elf_prot, elf_flags, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 if (BAD_ADDR(error)) {
Alexey Kuznetsovb140f2512007-05-08 00:31:57 -0700931 retval = IS_ERR((void *)error) ?
932 PTR_ERR((void*)error) : -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 goto out_free_dentry;
934 }
935
936 if (!load_addr_set) {
937 load_addr_set = 1;
938 load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
939 if (loc->elf_ex.e_type == ET_DYN) {
940 load_bias += error -
941 ELF_PAGESTART(load_bias + vaddr);
942 load_addr += load_bias;
943 reloc_func_desc = load_bias;
944 }
945 }
946 k = elf_ppnt->p_vaddr;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700947 if (k < start_code)
948 start_code = k;
949 if (start_data < k)
950 start_data = k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951
952 /*
953 * Check to see if the section's size will overflow the
954 * allowed task size. Note that p_filesz must always be
955 * <= p_memsz so it is only necessary to check p_memsz.
956 */
Chuck Ebbertce510592006-07-03 00:24:14 -0700957 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 elf_ppnt->p_memsz > TASK_SIZE ||
959 TASK_SIZE - elf_ppnt->p_memsz < k) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700960 /* set_brk can never work. Avoid overflows. */
Alexey Kuznetsovb140f2512007-05-08 00:31:57 -0700961 retval = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 goto out_free_dentry;
963 }
964
965 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
966
967 if (k > elf_bss)
968 elf_bss = k;
969 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
970 end_code = k;
971 if (end_data < k)
972 end_data = k;
973 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
974 if (k > elf_brk)
975 elf_brk = k;
976 }
977
978 loc->elf_ex.e_entry += load_bias;
979 elf_bss += load_bias;
980 elf_brk += load_bias;
981 start_code += load_bias;
982 end_code += load_bias;
983 start_data += load_bias;
984 end_data += load_bias;
985
986 /* Calling set_brk effectively mmaps the pages that we need
987 * for the bss and break sections. We must do this before
988 * mapping in the interpreter, to make sure it doesn't wind
989 * up getting placed where the bss needs to go.
990 */
991 retval = set_brk(elf_bss, elf_brk);
Al Viro19d860a2014-05-04 20:11:36 -0400992 if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 goto out_free_dentry;
akpm@osdl.org6de50512005-10-11 08:29:08 -0700994 if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 retval = -EFAULT; /* Nobody gets to see this, but.. */
996 goto out_free_dentry;
997 }
998
999 if (elf_interpreter) {
Alan Cox6eec4822012-10-04 17:13:42 -07001000 unsigned long interp_map_addr = 0;
Jiri Kosinacc503c12008-01-30 13:31:07 +01001001
Andi Kleend20894a2008-02-08 04:21:54 -08001002 elf_entry = load_elf_interp(&loc->interp_elf_ex,
1003 interpreter,
1004 &interp_map_addr,
Paul Burtona9d9ef12014-09-11 08:30:15 +01001005 load_bias, interp_elf_phdata);
Andi Kleend20894a2008-02-08 04:21:54 -08001006 if (!IS_ERR((void *)elf_entry)) {
1007 /*
1008 * load_elf_interp() returns relocation
1009 * adjustment
1010 */
1011 interp_load_addr = elf_entry;
1012 elf_entry += loc->interp_elf_ex.e_entry;
Jiri Kosinacc503c12008-01-30 13:31:07 +01001013 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 if (BAD_ADDR(elf_entry)) {
Chuck Ebbertce510592006-07-03 00:24:14 -07001015 retval = IS_ERR((void *)elf_entry) ?
1016 (int)elf_entry : -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 goto out_free_dentry;
1018 }
1019 reloc_func_desc = interp_load_addr;
1020
1021 allow_write_access(interpreter);
1022 fput(interpreter);
1023 kfree(elf_interpreter);
1024 } else {
1025 elf_entry = loc->elf_ex.e_entry;
Suresh Siddha5342fba2006-02-26 04:18:28 +01001026 if (BAD_ADDR(elf_entry)) {
Chuck Ebbertce510592006-07-03 00:24:14 -07001027 retval = -EINVAL;
Suresh Siddha5342fba2006-02-26 04:18:28 +01001028 goto out_free_dentry;
1029 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 }
1031
Paul Burton774c1052014-09-11 08:30:16 +01001032 kfree(interp_elf_phdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 kfree(elf_phdata);
1034
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 set_binfmt(&elf_format);
1036
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -07001037#ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
Martin Schwidefskyfc5243d2008-12-25 13:38:35 +01001038 retval = arch_setup_additional_pages(bprm, !!elf_interpreter);
Al Viro19d860a2014-05-04 20:11:36 -04001039 if (retval < 0)
Roland McGrath18c8baf2005-04-28 15:17:19 -07001040 goto out;
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -07001041#endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
1042
David Howellsa6f76f22008-11-14 10:39:24 +11001043 install_exec_creds(bprm);
Ollie Wildb6a2fea2007-07-19 01:48:16 -07001044 retval = create_elf_tables(bprm, &loc->elf_ex,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001045 load_addr, interp_load_addr);
Al Viro19d860a2014-05-04 20:11:36 -04001046 if (retval < 0)
Ollie Wildb6a2fea2007-07-19 01:48:16 -07001047 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 /* N.B. passed_fileno might not be initialized? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 current->mm->end_code = end_code;
1050 current->mm->start_code = start_code;
1051 current->mm->start_data = start_data;
1052 current->mm->end_data = end_data;
1053 current->mm->start_stack = bprm->p;
1054
Jiri Kosinac1d171a2008-01-30 13:30:40 +01001055#ifdef arch_randomize_brk
Jiri Kosina4471a672011-04-14 15:22:09 -07001056 if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
Jiri Kosinac1d171a2008-01-30 13:30:40 +01001057 current->mm->brk = current->mm->start_brk =
1058 arch_randomize_brk(current->mm);
Jiri Kosina4471a672011-04-14 15:22:09 -07001059#ifdef CONFIG_COMPAT_BRK
1060 current->brk_randomized = 1;
1061#endif
1062 }
Jiri Kosinac1d171a2008-01-30 13:30:40 +01001063#endif
1064
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 if (current->personality & MMAP_PAGE_ZERO) {
1066 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1067 and some applications "depend" upon this behavior.
1068 Since we do not have the power to recompile these, we
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001069 emulate the SVr4 behavior. Sigh. */
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001070 error = vm_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 MAP_FIXED | MAP_PRIVATE, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 }
1073
1074#ifdef ELF_PLAT_INIT
1075 /*
1076 * The ABI may specify that certain registers be set up in special
1077 * ways (on i386 %edx is the address of a DT_FINI function, for
1078 * example. In addition, it may also specify (eg, PowerPC64 ELF)
1079 * that the e_entry field is the address of the function descriptor
1080 * for the startup routine, rather than the address of the startup
1081 * routine itself. This macro performs whatever initialization to
1082 * the regs structure is required as well as any relocations to the
1083 * function descriptor entries when executing dynamically links apps.
1084 */
1085 ELF_PLAT_INIT(regs, reloc_func_desc);
1086#endif
1087
1088 start_thread(regs, elf_entry, bprm->p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 retval = 0;
1090out:
1091 kfree(loc);
1092out_ret:
1093 return retval;
1094
1095 /* error cleanup */
1096out_free_dentry:
Paul Burtona9d9ef12014-09-11 08:30:15 +01001097 kfree(interp_elf_phdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 allow_write_access(interpreter);
1099 if (interpreter)
1100 fput(interpreter);
1101out_free_interp:
Jesper Juhlf99d49a2005-11-07 01:01:34 -08001102 kfree(elf_interpreter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103out_free_ph:
1104 kfree(elf_phdata);
1105 goto out;
1106}
1107
Josh Triplett69369a72014-04-03 14:48:27 -07001108#ifdef CONFIG_USELIB
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109/* This is really simpleminded and specialized - we are loading an
1110 a.out library that is given an ELF header. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111static int load_elf_library(struct file *file)
1112{
1113 struct elf_phdr *elf_phdata;
1114 struct elf_phdr *eppnt;
1115 unsigned long elf_bss, bss, len;
1116 int retval, error, i, j;
1117 struct elfhdr elf_ex;
1118
1119 error = -ENOEXEC;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001120 retval = kernel_read(file, 0, (char *)&elf_ex, sizeof(elf_ex));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 if (retval != sizeof(elf_ex))
1122 goto out;
1123
1124 if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1125 goto out;
1126
1127 /* First of all, some simple consistency checks */
1128 if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
Al Viro72c2d532013-09-22 16:27:52 -04001129 !elf_check_arch(&elf_ex) || !file->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 goto out;
1131
1132 /* Now read in all of the header information */
1133
1134 j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1135 /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1136
1137 error = -ENOMEM;
1138 elf_phdata = kmalloc(j, GFP_KERNEL);
1139 if (!elf_phdata)
1140 goto out;
1141
1142 eppnt = elf_phdata;
1143 error = -ENOEXEC;
1144 retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);
1145 if (retval != j)
1146 goto out_free_ph;
1147
1148 for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1149 if ((eppnt + i)->p_type == PT_LOAD)
1150 j++;
1151 if (j != 1)
1152 goto out_free_ph;
1153
1154 while (eppnt->p_type != PT_LOAD)
1155 eppnt++;
1156
1157 /* Now use mmap to map the library into memory. */
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001158 error = vm_mmap(file,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 ELF_PAGESTART(eppnt->p_vaddr),
1160 (eppnt->p_filesz +
1161 ELF_PAGEOFFSET(eppnt->p_vaddr)),
1162 PROT_READ | PROT_WRITE | PROT_EXEC,
1163 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
1164 (eppnt->p_offset -
1165 ELF_PAGEOFFSET(eppnt->p_vaddr)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 if (error != ELF_PAGESTART(eppnt->p_vaddr))
1167 goto out_free_ph;
1168
1169 elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1170 if (padzero(elf_bss)) {
1171 error = -EFAULT;
1172 goto out_free_ph;
1173 }
1174
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001175 len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr +
1176 ELF_MIN_ALIGN - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 bss = eppnt->p_memsz + eppnt->p_vaddr;
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -07001178 if (bss > len)
1179 vm_brk(len, bss - len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 error = 0;
1181
1182out_free_ph:
1183 kfree(elf_phdata);
1184out:
1185 return error;
1186}
Josh Triplett69369a72014-04-03 14:48:27 -07001187#endif /* #ifdef CONFIG_USELIB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08001189#ifdef CONFIG_ELF_CORE
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190/*
1191 * ELF core dumper
1192 *
1193 * Modelled on fs/exec.c:aout_core_dump()
1194 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1195 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196
1197/*
Jason Baron909af762012-03-23 15:02:51 -07001198 * The purpose of always_dump_vma() is to make sure that special kernel mappings
1199 * that are useful for post-mortem analysis are included in every core dump.
1200 * In that way we ensure that the core dump is fully interpretable later
1201 * without matching up the same kernel and hardware config to see what PC values
1202 * meant. These special mappings include - vDSO, vsyscall, and other
1203 * architecture specific mappings
1204 */
1205static bool always_dump_vma(struct vm_area_struct *vma)
1206{
1207 /* Any vsyscall mappings? */
1208 if (vma == get_gate_vma(vma->vm_mm))
1209 return true;
Andy Lutomirski78d683e2014-05-19 15:58:32 -07001210
1211 /*
1212 * Assume that all vmas with a .name op should always be dumped.
1213 * If this changes, a new vm_ops field can easily be added.
1214 */
1215 if (vma->vm_ops && vma->vm_ops->name && vma->vm_ops->name(vma))
1216 return true;
1217
Jason Baron909af762012-03-23 15:02:51 -07001218 /*
1219 * arch_vma_name() returns non-NULL for special architecture mappings,
1220 * such as vDSO sections.
1221 */
1222 if (arch_vma_name(vma))
1223 return true;
1224
1225 return false;
1226}
1227
1228/*
Roland McGrath82df3972007-10-16 23:27:02 -07001229 * Decide what to dump of a segment, part, all or none.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 */
Roland McGrath82df3972007-10-16 23:27:02 -07001231static unsigned long vma_dump_size(struct vm_area_struct *vma,
1232 unsigned long mm_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233{
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001234#define FILTER(type) (mm_flags & (1UL << MMF_DUMP_##type))
1235
Jason Baron909af762012-03-23 15:02:51 -07001236 /* always dump the vdso and vsyscall sections */
1237 if (always_dump_vma(vma))
Roland McGrath82df3972007-10-16 23:27:02 -07001238 goto whole;
Roland McGrathe5b97dd2007-01-26 00:56:48 -08001239
Konstantin Khlebnikov0103bd12012-10-08 16:28:59 -07001240 if (vma->vm_flags & VM_DONTDUMP)
Jason Baronaccb61f2012-03-23 15:02:51 -07001241 return 0;
1242
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001243 /* Hugetlb memory check */
1244 if (vma->vm_flags & VM_HUGETLB) {
1245 if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))
1246 goto whole;
1247 if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))
1248 goto whole;
Naoya Horiguchi23d9e482013-04-17 15:58:28 -07001249 return 0;
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001250 }
1251
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 /* Do not dump I/O mapped devices or special mappings */
Konstantin Khlebnikov314e51b2012-10-08 16:29:02 -07001253 if (vma->vm_flags & VM_IO)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 return 0;
1255
Kawai, Hidehiroa1b59e82007-07-19 01:48:29 -07001256 /* By default, dump shared memory if mapped from an anonymous file. */
1257 if (vma->vm_flags & VM_SHARED) {
Al Viro496ad9a2013-01-23 17:07:38 -05001258 if (file_inode(vma->vm_file)->i_nlink == 0 ?
Roland McGrath82df3972007-10-16 23:27:02 -07001259 FILTER(ANON_SHARED) : FILTER(MAPPED_SHARED))
1260 goto whole;
1261 return 0;
Kawai, Hidehiroa1b59e82007-07-19 01:48:29 -07001262 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263
Roland McGrath82df3972007-10-16 23:27:02 -07001264 /* Dump segments that have been written to. */
1265 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1266 goto whole;
1267 if (vma->vm_file == NULL)
1268 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269
Roland McGrath82df3972007-10-16 23:27:02 -07001270 if (FILTER(MAPPED_PRIVATE))
1271 goto whole;
1272
1273 /*
1274 * If this looks like the beginning of a DSO or executable mapping,
1275 * check for an ELF header. If we find one, dump the first page to
1276 * aid in determining what was mapped here.
1277 */
Roland McGrath92dc07b2009-02-06 17:34:07 -08001278 if (FILTER(ELF_HEADERS) &&
1279 vma->vm_pgoff == 0 && (vma->vm_flags & VM_READ)) {
Roland McGrath82df3972007-10-16 23:27:02 -07001280 u32 __user *header = (u32 __user *) vma->vm_start;
1281 u32 word;
Roland McGrath92dc07b2009-02-06 17:34:07 -08001282 mm_segment_t fs = get_fs();
Roland McGrath82df3972007-10-16 23:27:02 -07001283 /*
1284 * Doing it this way gets the constant folded by GCC.
1285 */
1286 union {
1287 u32 cmp;
1288 char elfmag[SELFMAG];
1289 } magic;
1290 BUILD_BUG_ON(SELFMAG != sizeof word);
1291 magic.elfmag[EI_MAG0] = ELFMAG0;
1292 magic.elfmag[EI_MAG1] = ELFMAG1;
1293 magic.elfmag[EI_MAG2] = ELFMAG2;
1294 magic.elfmag[EI_MAG3] = ELFMAG3;
Roland McGrath92dc07b2009-02-06 17:34:07 -08001295 /*
1296 * Switch to the user "segment" for get_user(),
1297 * then put back what elf_core_dump() had in place.
1298 */
1299 set_fs(USER_DS);
1300 if (unlikely(get_user(word, header)))
1301 word = 0;
1302 set_fs(fs);
1303 if (word == magic.cmp)
Roland McGrath82df3972007-10-16 23:27:02 -07001304 return PAGE_SIZE;
1305 }
1306
1307#undef FILTER
1308
1309 return 0;
1310
1311whole:
1312 return vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313}
1314
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315/* An ELF note in memory */
1316struct memelfnote
1317{
1318 const char *name;
1319 int type;
1320 unsigned int datasz;
1321 void *data;
1322};
1323
1324static int notesize(struct memelfnote *en)
1325{
1326 int sz;
1327
1328 sz = sizeof(struct elf_note);
1329 sz += roundup(strlen(en->name) + 1, 4);
1330 sz += roundup(en->datasz, 4);
1331
1332 return sz;
1333}
1334
Al Viroecc8c772013-10-05 15:32:35 -04001335static int writenote(struct memelfnote *men, struct coredump_params *cprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336{
1337 struct elf_note en;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 en.n_namesz = strlen(men->name) + 1;
1339 en.n_descsz = men->datasz;
1340 en.n_type = men->type;
1341
Al Viroecc8c772013-10-05 15:32:35 -04001342 return dump_emit(cprm, &en, sizeof(en)) &&
Al Viro22a8cb82013-10-08 11:05:01 -04001343 dump_emit(cprm, men->name, en.n_namesz) && dump_align(cprm, 4) &&
1344 dump_emit(cprm, men->data, men->datasz) && dump_align(cprm, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
Roland McGrath3aba4812008-01-30 13:31:44 +01001347static void fill_elf_header(struct elfhdr *elf, int segs,
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08001348 u16 machine, u32 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349{
Cyrill Gorcunov6970c8e2008-04-29 01:01:18 -07001350 memset(elf, 0, sizeof(*elf));
1351
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 memcpy(elf->e_ident, ELFMAG, SELFMAG);
1353 elf->e_ident[EI_CLASS] = ELF_CLASS;
1354 elf->e_ident[EI_DATA] = ELF_DATA;
1355 elf->e_ident[EI_VERSION] = EV_CURRENT;
1356 elf->e_ident[EI_OSABI] = ELF_OSABI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357
1358 elf->e_type = ET_CORE;
Roland McGrath3aba4812008-01-30 13:31:44 +01001359 elf->e_machine = machine;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360 elf->e_version = EV_CURRENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 elf->e_phoff = sizeof(struct elfhdr);
Roland McGrath3aba4812008-01-30 13:31:44 +01001362 elf->e_flags = flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 elf->e_ehsize = sizeof(struct elfhdr);
1364 elf->e_phentsize = sizeof(struct elf_phdr);
1365 elf->e_phnum = segs;
Cyrill Gorcunov6970c8e2008-04-29 01:01:18 -07001366
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 return;
1368}
1369
Andrew Morton8d6b5eee2006-09-25 23:32:04 -07001370static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371{
1372 phdr->p_type = PT_NOTE;
1373 phdr->p_offset = offset;
1374 phdr->p_vaddr = 0;
1375 phdr->p_paddr = 0;
1376 phdr->p_filesz = sz;
1377 phdr->p_memsz = 0;
1378 phdr->p_flags = 0;
1379 phdr->p_align = 0;
1380 return;
1381}
1382
1383static void fill_note(struct memelfnote *note, const char *name, int type,
1384 unsigned int sz, void *data)
1385{
1386 note->name = name;
1387 note->type = type;
1388 note->datasz = sz;
1389 note->data = data;
1390 return;
1391}
1392
1393/*
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001394 * fill up all the fields in prstatus from the given task struct, except
1395 * registers which need to be filled up separately.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396 */
1397static void fill_prstatus(struct elf_prstatus *prstatus,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001398 struct task_struct *p, long signr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399{
1400 prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1401 prstatus->pr_sigpend = p->pending.signal.sig[0];
1402 prstatus->pr_sighold = p->blocked.sig[0];
Oleg Nesterov3b34fc52009-06-17 16:27:38 -07001403 rcu_read_lock();
1404 prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1405 rcu_read_unlock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001406 prstatus->pr_pid = task_pid_vnr(p);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001407 prstatus->pr_pgrp = task_pgrp_vnr(p);
1408 prstatus->pr_sid = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 if (thread_group_leader(p)) {
Frank Mayharf06febc2008-09-12 09:54:39 -07001410 struct task_cputime cputime;
1411
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 /*
Frank Mayharf06febc2008-09-12 09:54:39 -07001413 * This is the record for the group leader. It shows the
1414 * group-wide total, not its individual thread total.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 */
Frank Mayharf06febc2008-09-12 09:54:39 -07001416 thread_group_cputime(p, &cputime);
1417 cputime_to_timeval(cputime.utime, &prstatus->pr_utime);
1418 cputime_to_timeval(cputime.stime, &prstatus->pr_stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 } else {
Frederic Weisbecker6fac4822012-11-13 14:20:55 +01001420 cputime_t utime, stime;
1421
1422 task_cputime(p, &utime, &stime);
1423 cputime_to_timeval(utime, &prstatus->pr_utime);
1424 cputime_to_timeval(stime, &prstatus->pr_stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 }
1426 cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
1427 cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
1428}
1429
1430static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1431 struct mm_struct *mm)
1432{
David Howellsc69e8d92008-11-14 10:39:19 +11001433 const struct cred *cred;
Greg Kroah-Hartmana84a5052005-05-11 00:10:44 -07001434 unsigned int i, len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435
1436 /* first copy the parameters from user space */
1437 memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1438
1439 len = mm->arg_end - mm->arg_start;
1440 if (len >= ELF_PRARGSZ)
1441 len = ELF_PRARGSZ-1;
1442 if (copy_from_user(&psinfo->pr_psargs,
1443 (const char __user *)mm->arg_start, len))
1444 return -EFAULT;
1445 for(i = 0; i < len; i++)
1446 if (psinfo->pr_psargs[i] == 0)
1447 psinfo->pr_psargs[i] = ' ';
1448 psinfo->pr_psargs[len] = 0;
1449
Oleg Nesterov3b34fc52009-06-17 16:27:38 -07001450 rcu_read_lock();
1451 psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1452 rcu_read_unlock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001453 psinfo->pr_pid = task_pid_vnr(p);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001454 psinfo->pr_pgrp = task_pgrp_vnr(p);
1455 psinfo->pr_sid = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456
1457 i = p->state ? ffz(~p->state) + 1 : 0;
1458 psinfo->pr_state = i;
Carsten Otte55148542006-03-25 03:08:22 -08001459 psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1461 psinfo->pr_nice = task_nice(p);
1462 psinfo->pr_flag = p->flags;
David Howellsc69e8d92008-11-14 10:39:19 +11001463 rcu_read_lock();
1464 cred = __task_cred(p);
Eric W. Biedermanebc887b2012-02-07 18:36:10 -08001465 SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
1466 SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
David Howellsc69e8d92008-11-14 10:39:19 +11001467 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1469
1470 return 0;
1471}
1472
Roland McGrath3aba4812008-01-30 13:31:44 +01001473static void fill_auxv_note(struct memelfnote *note, struct mm_struct *mm)
1474{
1475 elf_addr_t *auxv = (elf_addr_t *) mm->saved_auxv;
1476 int i = 0;
1477 do
1478 i += 2;
1479 while (auxv[i - 2] != AT_NULL);
1480 fill_note(note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);
1481}
1482
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001483static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,
Al Viroce395962013-10-13 17:23:53 -04001484 const siginfo_t *siginfo)
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001485{
1486 mm_segment_t old_fs = get_fs();
1487 set_fs(KERNEL_DS);
1488 copy_siginfo_to_user((user_siginfo_t __user *) csigdata, siginfo);
1489 set_fs(old_fs);
1490 fill_note(note, "CORE", NT_SIGINFO, sizeof(*csigdata), csigdata);
1491}
1492
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001493#define MAX_FILE_NOTE_SIZE (4*1024*1024)
1494/*
1495 * Format of NT_FILE note:
1496 *
1497 * long count -- how many files are mapped
1498 * long page_size -- units for file_ofs
1499 * array of [COUNT] elements of
1500 * long start
1501 * long end
1502 * long file_ofs
1503 * followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1504 */
Dan Aloni72023652013-09-30 13:45:02 -07001505static int fill_files_note(struct memelfnote *note)
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001506{
1507 struct vm_area_struct *vma;
1508 unsigned count, size, names_ofs, remaining, n;
1509 user_long_t *data;
1510 user_long_t *start_end_ofs;
1511 char *name_base, *name_curpos;
1512
1513 /* *Estimated* file count and total data size needed */
1514 count = current->mm->map_count;
1515 size = count * 64;
1516
1517 names_ofs = (2 + 3 * count) * sizeof(data[0]);
1518 alloc:
1519 if (size >= MAX_FILE_NOTE_SIZE) /* paranoia check */
Dan Aloni72023652013-09-30 13:45:02 -07001520 return -EINVAL;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001521 size = round_up(size, PAGE_SIZE);
1522 data = vmalloc(size);
1523 if (!data)
Dan Aloni72023652013-09-30 13:45:02 -07001524 return -ENOMEM;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001525
1526 start_end_ofs = data + 2;
1527 name_base = name_curpos = ((char *)data) + names_ofs;
1528 remaining = size - names_ofs;
1529 count = 0;
1530 for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1531 struct file *file;
1532 const char *filename;
1533
1534 file = vma->vm_file;
1535 if (!file)
1536 continue;
1537 filename = d_path(&file->f_path, name_curpos, remaining);
1538 if (IS_ERR(filename)) {
1539 if (PTR_ERR(filename) == -ENAMETOOLONG) {
1540 vfree(data);
1541 size = size * 5 / 4;
1542 goto alloc;
1543 }
1544 continue;
1545 }
1546
1547 /* d_path() fills at the end, move name down */
1548 /* n = strlen(filename) + 1: */
1549 n = (name_curpos + remaining) - filename;
1550 remaining = filename - name_curpos;
1551 memmove(name_curpos, filename, n);
1552 name_curpos += n;
1553
1554 *start_end_ofs++ = vma->vm_start;
1555 *start_end_ofs++ = vma->vm_end;
1556 *start_end_ofs++ = vma->vm_pgoff;
1557 count++;
1558 }
1559
1560 /* Now we know exact count of files, can store it */
1561 data[0] = count;
1562 data[1] = PAGE_SIZE;
1563 /*
1564 * Count usually is less than current->mm->map_count,
1565 * we need to move filenames down.
1566 */
1567 n = current->mm->map_count - count;
1568 if (n != 0) {
1569 unsigned shift_bytes = n * 3 * sizeof(data[0]);
1570 memmove(name_base - shift_bytes, name_base,
1571 name_curpos - name_base);
1572 name_curpos -= shift_bytes;
1573 }
1574
1575 size = name_curpos - (char *)data;
1576 fill_note(note, "CORE", NT_FILE, size, data);
Dan Aloni72023652013-09-30 13:45:02 -07001577 return 0;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001578}
1579
Roland McGrath4206d3a2008-01-30 13:31:45 +01001580#ifdef CORE_DUMP_USE_REGSET
1581#include <linux/regset.h>
1582
1583struct elf_thread_core_info {
1584 struct elf_thread_core_info *next;
1585 struct task_struct *task;
1586 struct elf_prstatus prstatus;
1587 struct memelfnote notes[0];
1588};
1589
1590struct elf_note_info {
1591 struct elf_thread_core_info *thread;
1592 struct memelfnote psinfo;
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001593 struct memelfnote signote;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001594 struct memelfnote auxv;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001595 struct memelfnote files;
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001596 user_siginfo_t csigdata;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001597 size_t size;
1598 int thread_notes;
1599};
1600
Roland McGrathd31472b2008-03-04 14:28:30 -08001601/*
1602 * When a regset has a writeback hook, we call it on each thread before
1603 * dumping user memory. On register window machines, this makes sure the
1604 * user memory backing the register data is up to date before we read it.
1605 */
1606static void do_thread_regset_writeback(struct task_struct *task,
1607 const struct user_regset *regset)
1608{
1609 if (regset->writeback)
1610 regset->writeback(task, regset, 1);
1611}
1612
H. J. Lu0953f65d2012-02-14 13:34:52 -08001613#ifndef PR_REG_SIZE
1614#define PR_REG_SIZE(S) sizeof(S)
1615#endif
1616
1617#ifndef PRSTATUS_SIZE
1618#define PRSTATUS_SIZE(S) sizeof(S)
1619#endif
1620
1621#ifndef PR_REG_PTR
1622#define PR_REG_PTR(S) (&((S)->pr_reg))
1623#endif
1624
1625#ifndef SET_PR_FPVALID
1626#define SET_PR_FPVALID(S, V) ((S)->pr_fpvalid = (V))
1627#endif
1628
Roland McGrath4206d3a2008-01-30 13:31:45 +01001629static int fill_thread_core_info(struct elf_thread_core_info *t,
1630 const struct user_regset_view *view,
1631 long signr, size_t *total)
1632{
1633 unsigned int i;
1634
1635 /*
1636 * NT_PRSTATUS is the one special case, because the regset data
1637 * goes into the pr_reg field inside the note contents, rather
1638 * than being the whole note contents. We fill the reset in here.
1639 * We assume that regset 0 is NT_PRSTATUS.
1640 */
1641 fill_prstatus(&t->prstatus, t->task, signr);
1642 (void) view->regsets[0].get(t->task, &view->regsets[0],
H. J. Lu0953f65d2012-02-14 13:34:52 -08001643 0, PR_REG_SIZE(t->prstatus.pr_reg),
1644 PR_REG_PTR(&t->prstatus), NULL);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001645
1646 fill_note(&t->notes[0], "CORE", NT_PRSTATUS,
H. J. Lu0953f65d2012-02-14 13:34:52 -08001647 PRSTATUS_SIZE(t->prstatus), &t->prstatus);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001648 *total += notesize(&t->notes[0]);
1649
Roland McGrathd31472b2008-03-04 14:28:30 -08001650 do_thread_regset_writeback(t->task, &view->regsets[0]);
1651
Roland McGrath4206d3a2008-01-30 13:31:45 +01001652 /*
1653 * Each other regset might generate a note too. For each regset
1654 * that has no core_note_type or is inactive, we leave t->notes[i]
1655 * all zero and we'll know to skip writing it later.
1656 */
1657 for (i = 1; i < view->n; ++i) {
1658 const struct user_regset *regset = &view->regsets[i];
Roland McGrathd31472b2008-03-04 14:28:30 -08001659 do_thread_regset_writeback(t->task, regset);
H. Peter Anvinc8e25252012-03-02 10:43:48 -08001660 if (regset->core_note_type && regset->get &&
Roland McGrath4206d3a2008-01-30 13:31:45 +01001661 (!regset->active || regset->active(t->task, regset))) {
1662 int ret;
1663 size_t size = regset->n * regset->size;
1664 void *data = kmalloc(size, GFP_KERNEL);
1665 if (unlikely(!data))
1666 return 0;
1667 ret = regset->get(t->task, regset,
1668 0, size, data, NULL);
1669 if (unlikely(ret))
1670 kfree(data);
1671 else {
1672 if (regset->core_note_type != NT_PRFPREG)
1673 fill_note(&t->notes[i], "LINUX",
1674 regset->core_note_type,
1675 size, data);
1676 else {
H. J. Lu0953f65d2012-02-14 13:34:52 -08001677 SET_PR_FPVALID(&t->prstatus, 1);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001678 fill_note(&t->notes[i], "CORE",
1679 NT_PRFPREG, size, data);
1680 }
1681 *total += notesize(&t->notes[i]);
1682 }
1683 }
1684 }
1685
1686 return 1;
1687}
1688
1689static int fill_note_info(struct elfhdr *elf, int phdrs,
1690 struct elf_note_info *info,
Al Viroec579412013-10-13 17:57:29 -04001691 const siginfo_t *siginfo, struct pt_regs *regs)
Roland McGrath4206d3a2008-01-30 13:31:45 +01001692{
1693 struct task_struct *dump_task = current;
1694 const struct user_regset_view *view = task_user_regset_view(dump_task);
1695 struct elf_thread_core_info *t;
1696 struct elf_prpsinfo *psinfo;
Oleg Nesterov83914442008-07-25 01:47:45 -07001697 struct core_thread *ct;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001698 unsigned int i;
1699
1700 info->size = 0;
1701 info->thread = NULL;
1702
1703 psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
Alan Cox6899e922012-12-17 16:02:09 -08001704 if (psinfo == NULL) {
1705 info->psinfo.data = NULL; /* So we don't free this wrongly */
Roland McGrath4206d3a2008-01-30 13:31:45 +01001706 return 0;
Alan Cox6899e922012-12-17 16:02:09 -08001707 }
Roland McGrath4206d3a2008-01-30 13:31:45 +01001708
Amerigo Wange2dbe122009-07-01 01:06:26 -04001709 fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1710
Roland McGrath4206d3a2008-01-30 13:31:45 +01001711 /*
1712 * Figure out how many notes we're going to need for each thread.
1713 */
1714 info->thread_notes = 0;
1715 for (i = 0; i < view->n; ++i)
1716 if (view->regsets[i].core_note_type != 0)
1717 ++info->thread_notes;
1718
1719 /*
1720 * Sanity check. We rely on regset 0 being in NT_PRSTATUS,
1721 * since it is our one special case.
1722 */
1723 if (unlikely(info->thread_notes == 0) ||
1724 unlikely(view->regsets[0].core_note_type != NT_PRSTATUS)) {
1725 WARN_ON(1);
1726 return 0;
1727 }
1728
1729 /*
1730 * Initialize the ELF file header.
1731 */
1732 fill_elf_header(elf, phdrs,
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08001733 view->e_machine, view->e_flags);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001734
1735 /*
1736 * Allocate a structure for each thread.
1737 */
Oleg Nesterov83914442008-07-25 01:47:45 -07001738 for (ct = &dump_task->mm->core_state->dumper; ct; ct = ct->next) {
1739 t = kzalloc(offsetof(struct elf_thread_core_info,
1740 notes[info->thread_notes]),
1741 GFP_KERNEL);
1742 if (unlikely(!t))
1743 return 0;
Oleg Nesterov24d52882008-07-25 01:47:40 -07001744
Oleg Nesterov83914442008-07-25 01:47:45 -07001745 t->task = ct->task;
1746 if (ct->task == dump_task || !info->thread) {
1747 t->next = info->thread;
1748 info->thread = t;
1749 } else {
1750 /*
1751 * Make sure to keep the original task at
1752 * the head of the list.
1753 */
1754 t->next = info->thread->next;
1755 info->thread->next = t;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001756 }
Oleg Nesterov83914442008-07-25 01:47:45 -07001757 }
Roland McGrath4206d3a2008-01-30 13:31:45 +01001758
1759 /*
1760 * Now fill in each thread's information.
1761 */
1762 for (t = info->thread; t != NULL; t = t->next)
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001763 if (!fill_thread_core_info(t, view, siginfo->si_signo, &info->size))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001764 return 0;
1765
1766 /*
1767 * Fill in the two process-wide notes.
1768 */
1769 fill_psinfo(psinfo, dump_task->group_leader, dump_task->mm);
1770 info->size += notesize(&info->psinfo);
1771
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001772 fill_siginfo_note(&info->signote, &info->csigdata, siginfo);
1773 info->size += notesize(&info->signote);
1774
Roland McGrath4206d3a2008-01-30 13:31:45 +01001775 fill_auxv_note(&info->auxv, current->mm);
1776 info->size += notesize(&info->auxv);
1777
Dan Aloni72023652013-09-30 13:45:02 -07001778 if (fill_files_note(&info->files) == 0)
1779 info->size += notesize(&info->files);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001780
Roland McGrath4206d3a2008-01-30 13:31:45 +01001781 return 1;
1782}
1783
1784static size_t get_note_info_size(struct elf_note_info *info)
1785{
1786 return info->size;
1787}
1788
1789/*
1790 * Write all the notes for each thread. When writing the first thread, the
1791 * process-wide notes are interleaved after the first thread-specific note.
1792 */
1793static int write_note_info(struct elf_note_info *info,
Al Viroecc8c772013-10-05 15:32:35 -04001794 struct coredump_params *cprm)
Roland McGrath4206d3a2008-01-30 13:31:45 +01001795{
Fabian Frederickb219e252014-06-04 16:12:14 -07001796 bool first = true;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001797 struct elf_thread_core_info *t = info->thread;
1798
1799 do {
1800 int i;
1801
Al Viroecc8c772013-10-05 15:32:35 -04001802 if (!writenote(&t->notes[0], cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001803 return 0;
1804
Al Viroecc8c772013-10-05 15:32:35 -04001805 if (first && !writenote(&info->psinfo, cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001806 return 0;
Al Viroecc8c772013-10-05 15:32:35 -04001807 if (first && !writenote(&info->signote, cprm))
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001808 return 0;
Al Viroecc8c772013-10-05 15:32:35 -04001809 if (first && !writenote(&info->auxv, cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001810 return 0;
Dan Aloni72023652013-09-30 13:45:02 -07001811 if (first && info->files.data &&
Al Viroecc8c772013-10-05 15:32:35 -04001812 !writenote(&info->files, cprm))
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001813 return 0;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001814
1815 for (i = 1; i < info->thread_notes; ++i)
1816 if (t->notes[i].data &&
Al Viroecc8c772013-10-05 15:32:35 -04001817 !writenote(&t->notes[i], cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001818 return 0;
1819
Fabian Frederickb219e252014-06-04 16:12:14 -07001820 first = false;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001821 t = t->next;
1822 } while (t);
1823
1824 return 1;
1825}
1826
1827static void free_note_info(struct elf_note_info *info)
1828{
1829 struct elf_thread_core_info *threads = info->thread;
1830 while (threads) {
1831 unsigned int i;
1832 struct elf_thread_core_info *t = threads;
1833 threads = t->next;
1834 WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);
1835 for (i = 1; i < info->thread_notes; ++i)
1836 kfree(t->notes[i].data);
1837 kfree(t);
1838 }
1839 kfree(info->psinfo.data);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001840 vfree(info->files.data);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001841}
1842
1843#else
1844
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845/* Here is the structure in which status of each thread is captured. */
1846struct elf_thread_status
1847{
1848 struct list_head list;
1849 struct elf_prstatus prstatus; /* NT_PRSTATUS */
1850 elf_fpregset_t fpu; /* NT_PRFPREG */
1851 struct task_struct *thread;
1852#ifdef ELF_CORE_COPY_XFPREGS
Mark Nelson5b20cd82007-10-16 23:25:39 -07001853 elf_fpxregset_t xfpu; /* ELF_CORE_XFPREG_TYPE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854#endif
1855 struct memelfnote notes[3];
1856 int num_notes;
1857};
1858
1859/*
1860 * In order to add the specific thread information for the elf file format,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001861 * we need to keep a linked list of every threads pr_status and then create
1862 * a single section for them in the final core file.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 */
1864static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1865{
1866 int sz = 0;
1867 struct task_struct *p = t->thread;
1868 t->num_notes = 0;
1869
1870 fill_prstatus(&t->prstatus, p, signr);
1871 elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1872
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001873 fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1874 &(t->prstatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 t->num_notes++;
1876 sz += notesize(&t->notes[0]);
1877
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001878 if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1879 &t->fpu))) {
1880 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1881 &(t->fpu));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 t->num_notes++;
1883 sz += notesize(&t->notes[1]);
1884 }
1885
1886#ifdef ELF_CORE_COPY_XFPREGS
1887 if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
Mark Nelson5b20cd82007-10-16 23:25:39 -07001888 fill_note(&t->notes[2], "LINUX", ELF_CORE_XFPREG_TYPE,
1889 sizeof(t->xfpu), &t->xfpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 t->num_notes++;
1891 sz += notesize(&t->notes[2]);
1892 }
1893#endif
1894 return sz;
1895}
1896
Roland McGrath3aba4812008-01-30 13:31:44 +01001897struct elf_note_info {
1898 struct memelfnote *notes;
Dan Aloni72023652013-09-30 13:45:02 -07001899 struct memelfnote *notes_files;
Roland McGrath3aba4812008-01-30 13:31:44 +01001900 struct elf_prstatus *prstatus; /* NT_PRSTATUS */
1901 struct elf_prpsinfo *psinfo; /* NT_PRPSINFO */
1902 struct list_head thread_list;
1903 elf_fpregset_t *fpu;
1904#ifdef ELF_CORE_COPY_XFPREGS
1905 elf_fpxregset_t *xfpu;
1906#endif
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001907 user_siginfo_t csigdata;
Roland McGrath3aba4812008-01-30 13:31:44 +01001908 int thread_status_size;
1909 int numnote;
1910};
1911
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001912static int elf_note_info_init(struct elf_note_info *info)
Roland McGrath3aba4812008-01-30 13:31:44 +01001913{
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001914 memset(info, 0, sizeof(*info));
Roland McGrath3aba4812008-01-30 13:31:44 +01001915 INIT_LIST_HEAD(&info->thread_list);
1916
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001917 /* Allocate space for ELF notes */
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001918 info->notes = kmalloc(8 * sizeof(struct memelfnote), GFP_KERNEL);
Roland McGrath3aba4812008-01-30 13:31:44 +01001919 if (!info->notes)
1920 return 0;
1921 info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL);
1922 if (!info->psinfo)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001923 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001924 info->prstatus = kmalloc(sizeof(*info->prstatus), GFP_KERNEL);
1925 if (!info->prstatus)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001926 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001927 info->fpu = kmalloc(sizeof(*info->fpu), GFP_KERNEL);
1928 if (!info->fpu)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001929 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001930#ifdef ELF_CORE_COPY_XFPREGS
1931 info->xfpu = kmalloc(sizeof(*info->xfpu), GFP_KERNEL);
1932 if (!info->xfpu)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001933 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001934#endif
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001935 return 1;
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001936}
Roland McGrath3aba4812008-01-30 13:31:44 +01001937
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001938static int fill_note_info(struct elfhdr *elf, int phdrs,
1939 struct elf_note_info *info,
Al Viroec579412013-10-13 17:57:29 -04001940 const siginfo_t *siginfo, struct pt_regs *regs)
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001941{
1942 struct list_head *t;
Al Viroafabada2013-10-14 07:39:56 -04001943 struct core_thread *ct;
1944 struct elf_thread_status *ets;
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001945
1946 if (!elf_note_info_init(info))
1947 return 0;
1948
Al Viroafabada2013-10-14 07:39:56 -04001949 for (ct = current->mm->core_state->dumper.next;
1950 ct; ct = ct->next) {
1951 ets = kzalloc(sizeof(*ets), GFP_KERNEL);
1952 if (!ets)
1953 return 0;
Oleg Nesterov24d52882008-07-25 01:47:40 -07001954
Al Viroafabada2013-10-14 07:39:56 -04001955 ets->thread = ct->task;
1956 list_add(&ets->list, &info->thread_list);
1957 }
Oleg Nesterov83914442008-07-25 01:47:45 -07001958
Al Viroafabada2013-10-14 07:39:56 -04001959 list_for_each(t, &info->thread_list) {
1960 int sz;
Oleg Nesterov83914442008-07-25 01:47:45 -07001961
Al Viroafabada2013-10-14 07:39:56 -04001962 ets = list_entry(t, struct elf_thread_status, list);
1963 sz = elf_dump_thread_status(siginfo->si_signo, ets);
1964 info->thread_status_size += sz;
Roland McGrath3aba4812008-01-30 13:31:44 +01001965 }
1966 /* now collect the dump for the current */
1967 memset(info->prstatus, 0, sizeof(*info->prstatus));
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001968 fill_prstatus(info->prstatus, current, siginfo->si_signo);
Roland McGrath3aba4812008-01-30 13:31:44 +01001969 elf_core_copy_regs(&info->prstatus->pr_reg, regs);
1970
1971 /* Set up header */
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08001972 fill_elf_header(elf, phdrs, ELF_ARCH, ELF_CORE_EFLAGS);
Roland McGrath3aba4812008-01-30 13:31:44 +01001973
1974 /*
1975 * Set up the notes in similar form to SVR4 core dumps made
1976 * with info from their /proc.
1977 */
1978
1979 fill_note(info->notes + 0, "CORE", NT_PRSTATUS,
1980 sizeof(*info->prstatus), info->prstatus);
1981 fill_psinfo(info->psinfo, current->group_leader, current->mm);
1982 fill_note(info->notes + 1, "CORE", NT_PRPSINFO,
1983 sizeof(*info->psinfo), info->psinfo);
1984
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001985 fill_siginfo_note(info->notes + 2, &info->csigdata, siginfo);
1986 fill_auxv_note(info->notes + 3, current->mm);
Dan Aloni72023652013-09-30 13:45:02 -07001987 info->numnote = 4;
Roland McGrath3aba4812008-01-30 13:31:44 +01001988
Dan Aloni72023652013-09-30 13:45:02 -07001989 if (fill_files_note(info->notes + info->numnote) == 0) {
1990 info->notes_files = info->notes + info->numnote;
1991 info->numnote++;
1992 }
Roland McGrath3aba4812008-01-30 13:31:44 +01001993
1994 /* Try to dump the FPU. */
1995 info->prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs,
1996 info->fpu);
1997 if (info->prstatus->pr_fpvalid)
1998 fill_note(info->notes + info->numnote++,
1999 "CORE", NT_PRFPREG, sizeof(*info->fpu), info->fpu);
2000#ifdef ELF_CORE_COPY_XFPREGS
2001 if (elf_core_copy_task_xfpregs(current, info->xfpu))
2002 fill_note(info->notes + info->numnote++,
2003 "LINUX", ELF_CORE_XFPREG_TYPE,
2004 sizeof(*info->xfpu), info->xfpu);
2005#endif
2006
2007 return 1;
Roland McGrath3aba4812008-01-30 13:31:44 +01002008}
2009
2010static size_t get_note_info_size(struct elf_note_info *info)
2011{
2012 int sz = 0;
2013 int i;
2014
2015 for (i = 0; i < info->numnote; i++)
2016 sz += notesize(info->notes + i);
2017
2018 sz += info->thread_status_size;
2019
2020 return sz;
2021}
2022
2023static int write_note_info(struct elf_note_info *info,
Al Viroecc8c772013-10-05 15:32:35 -04002024 struct coredump_params *cprm)
Roland McGrath3aba4812008-01-30 13:31:44 +01002025{
2026 int i;
2027 struct list_head *t;
2028
2029 for (i = 0; i < info->numnote; i++)
Al Viroecc8c772013-10-05 15:32:35 -04002030 if (!writenote(info->notes + i, cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002031 return 0;
2032
2033 /* write out the thread status notes section */
2034 list_for_each(t, &info->thread_list) {
2035 struct elf_thread_status *tmp =
2036 list_entry(t, struct elf_thread_status, list);
2037
2038 for (i = 0; i < tmp->num_notes; i++)
Al Viroecc8c772013-10-05 15:32:35 -04002039 if (!writenote(&tmp->notes[i], cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002040 return 0;
2041 }
2042
2043 return 1;
2044}
2045
2046static void free_note_info(struct elf_note_info *info)
2047{
2048 while (!list_empty(&info->thread_list)) {
2049 struct list_head *tmp = info->thread_list.next;
2050 list_del(tmp);
2051 kfree(list_entry(tmp, struct elf_thread_status, list));
2052 }
2053
Dan Aloni72023652013-09-30 13:45:02 -07002054 /* Free data possibly allocated by fill_files_note(): */
2055 if (info->notes_files)
2056 vfree(info->notes_files->data);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07002057
Roland McGrath3aba4812008-01-30 13:31:44 +01002058 kfree(info->prstatus);
2059 kfree(info->psinfo);
2060 kfree(info->notes);
2061 kfree(info->fpu);
2062#ifdef ELF_CORE_COPY_XFPREGS
2063 kfree(info->xfpu);
2064#endif
2065}
2066
Roland McGrath4206d3a2008-01-30 13:31:45 +01002067#endif
2068
Roland McGrathf47aef52007-01-26 00:56:49 -08002069static struct vm_area_struct *first_vma(struct task_struct *tsk,
2070 struct vm_area_struct *gate_vma)
2071{
2072 struct vm_area_struct *ret = tsk->mm->mmap;
2073
2074 if (ret)
2075 return ret;
2076 return gate_vma;
2077}
2078/*
2079 * Helper function for iterating across a vma list. It ensures that the caller
2080 * will visit `gate_vma' prior to terminating the search.
2081 */
2082static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
2083 struct vm_area_struct *gate_vma)
2084{
2085 struct vm_area_struct *ret;
2086
2087 ret = this_vma->vm_next;
2088 if (ret)
2089 return ret;
2090 if (this_vma == gate_vma)
2091 return NULL;
2092 return gate_vma;
2093}
2094
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002095static void fill_extnum_info(struct elfhdr *elf, struct elf_shdr *shdr4extnum,
2096 elf_addr_t e_shoff, int segs)
2097{
2098 elf->e_shoff = e_shoff;
2099 elf->e_shentsize = sizeof(*shdr4extnum);
2100 elf->e_shnum = 1;
2101 elf->e_shstrndx = SHN_UNDEF;
2102
2103 memset(shdr4extnum, 0, sizeof(*shdr4extnum));
2104
2105 shdr4extnum->sh_type = SHT_NULL;
2106 shdr4extnum->sh_size = elf->e_shnum;
2107 shdr4extnum->sh_link = elf->e_shstrndx;
2108 shdr4extnum->sh_info = segs;
2109}
2110
2111static size_t elf_core_vma_data_size(struct vm_area_struct *gate_vma,
2112 unsigned long mm_flags)
2113{
2114 struct vm_area_struct *vma;
2115 size_t size = 0;
2116
2117 for (vma = first_vma(current, gate_vma); vma != NULL;
2118 vma = next_vma(vma, gate_vma))
2119 size += vma_dump_size(vma, mm_flags);
2120 return size;
2121}
2122
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123/*
2124 * Actual dumper
2125 *
2126 * This is a two-pass process; first we find the offsets of the bits,
2127 * and then they are actually written out. If we run out of core limit
2128 * we just truncate.
2129 */
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002130static int elf_core_dump(struct coredump_params *cprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 int has_dumped = 0;
2133 mm_segment_t fs;
2134 int segs;
Roland McGrathf47aef52007-01-26 00:56:49 -08002135 struct vm_area_struct *vma, *gate_vma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136 struct elfhdr *elf = NULL;
Al Virocdc3d562013-10-05 22:24:29 -04002137 loff_t offset = 0, dataoff;
Dan Aloni72023652013-09-30 13:45:02 -07002138 struct elf_note_info info = { };
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002139 struct elf_phdr *phdr4note = NULL;
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002140 struct elf_shdr *shdr4extnum = NULL;
2141 Elf_Half e_phnum;
2142 elf_addr_t e_shoff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143
2144 /*
2145 * We no longer stop all VM operations.
2146 *
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002147 * This is because those proceses that could possibly change map_count
2148 * or the mmap / vma pages are now blocked in do_exit on current
2149 * finishing this core dump.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150 *
2151 * Only ptrace can touch these memory addresses, but it doesn't change
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002152 * the map_count or the pages allocated. So no possibility of crashing
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 * exists while dumping the mm->vm_next areas to the core file.
2154 */
2155
2156 /* alloc memory for large data structures: too large to be on stack */
2157 elf = kmalloc(sizeof(*elf), GFP_KERNEL);
2158 if (!elf)
WANG Cong5f719552008-05-06 12:45:35 +08002159 goto out;
KAMEZAWA Hiroyuki341c87b2009-06-30 11:41:23 -07002160 /*
2161 * The number of segs are recored into ELF header as 16bit value.
2162 * Please check DEFAULT_MAX_MAP_COUNT definition when you modify here.
2163 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 segs = current->mm->map_count;
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002165 segs += elf_core_extra_phdrs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166
Stephen Wilson31db58b2011-03-13 15:49:15 -04002167 gate_vma = get_gate_vma(current->mm);
Roland McGrathf47aef52007-01-26 00:56:49 -08002168 if (gate_vma != NULL)
2169 segs++;
2170
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002171 /* for notes section */
2172 segs++;
2173
2174 /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
2175 * this, kernel supports extended numbering. Have a look at
2176 * include/linux/elf.h for further information. */
2177 e_phnum = segs > PN_XNUM ? PN_XNUM : segs;
2178
Roland McGrath3aba4812008-01-30 13:31:44 +01002179 /*
2180 * Collect all the non-memory information about the process for the
2181 * notes. This also sets up the file header.
2182 */
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07002183 if (!fill_note_info(elf, e_phnum, &info, cprm->siginfo, cprm->regs))
Roland McGrath3aba4812008-01-30 13:31:44 +01002184 goto cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185
2186 has_dumped = 1;
Oleg Nesterov079148b2013-04-30 15:28:16 -07002187
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188 fs = get_fs();
2189 set_fs(KERNEL_DS);
2190
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191 offset += sizeof(*elf); /* Elf header */
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002192 offset += segs * sizeof(struct elf_phdr); /* Program headers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193
2194 /* Write notes phdr entry */
2195 {
Roland McGrath3aba4812008-01-30 13:31:44 +01002196 size_t sz = get_note_info_size(&info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197
Michael Ellermane5501492007-09-19 14:38:12 +10002198 sz += elf_coredump_extra_notes_size();
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002199
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002200 phdr4note = kmalloc(sizeof(*phdr4note), GFP_KERNEL);
2201 if (!phdr4note)
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -08002202 goto end_coredump;
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002203
2204 fill_elf_note_phdr(phdr4note, sz, offset);
2205 offset += sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206 }
2207
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
2209
Masami Hiramatsu30736a42010-03-05 13:44:12 -08002210 offset += elf_core_vma_data_size(gate_vma, cprm->mm_flags);
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002211 offset += elf_core_extra_data_size();
2212 e_shoff = offset;
2213
2214 if (e_phnum == PN_XNUM) {
2215 shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);
2216 if (!shdr4extnum)
2217 goto end_coredump;
2218 fill_extnum_info(elf, shdr4extnum, e_shoff, segs);
2219 }
2220
2221 offset = dataoff;
2222
Al Viroecc8c772013-10-05 15:32:35 -04002223 if (!dump_emit(cprm, elf, sizeof(*elf)))
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002224 goto end_coredump;
2225
Al Viroecc8c772013-10-05 15:32:35 -04002226 if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note)))
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002227 goto end_coredump;
2228
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229 /* Write program headers for segments dump */
Roland McGrathf47aef52007-01-26 00:56:49 -08002230 for (vma = first_vma(current, gate_vma); vma != NULL;
2231 vma = next_vma(vma, gate_vma)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232 struct elf_phdr phdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233
2234 phdr.p_type = PT_LOAD;
2235 phdr.p_offset = offset;
2236 phdr.p_vaddr = vma->vm_start;
2237 phdr.p_paddr = 0;
Masami Hiramatsu30736a42010-03-05 13:44:12 -08002238 phdr.p_filesz = vma_dump_size(vma, cprm->mm_flags);
Roland McGrath82df3972007-10-16 23:27:02 -07002239 phdr.p_memsz = vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240 offset += phdr.p_filesz;
2241 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002242 if (vma->vm_flags & VM_WRITE)
2243 phdr.p_flags |= PF_W;
2244 if (vma->vm_flags & VM_EXEC)
2245 phdr.p_flags |= PF_X;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246 phdr.p_align = ELF_EXEC_PAGESIZE;
2247
Al Viroecc8c772013-10-05 15:32:35 -04002248 if (!dump_emit(cprm, &phdr, sizeof(phdr)))
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -08002249 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 }
2251
Al Viro506f21c2013-10-05 17:22:57 -04002252 if (!elf_core_write_extra_phdrs(cprm, offset))
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002253 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254
2255 /* write out the notes section */
Al Viroecc8c772013-10-05 15:32:35 -04002256 if (!write_note_info(&info, cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002257 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258
Al Virocdc3d562013-10-05 22:24:29 -04002259 if (elf_coredump_extra_notes_write(cprm))
Michael Ellermane5501492007-09-19 14:38:12 +10002260 goto end_coredump;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002261
Andi Kleend025c9d2006-09-30 23:29:28 -07002262 /* Align to page */
Al Viro9b56d542013-10-08 09:26:08 -04002263 if (!dump_skip(cprm, dataoff - cprm->written))
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002264 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265
Roland McGrathf47aef52007-01-26 00:56:49 -08002266 for (vma = first_vma(current, gate_vma); vma != NULL;
2267 vma = next_vma(vma, gate_vma)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268 unsigned long addr;
Roland McGrath82df3972007-10-16 23:27:02 -07002269 unsigned long end;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270
Masami Hiramatsu30736a42010-03-05 13:44:12 -08002271 end = vma->vm_start + vma_dump_size(vma, cprm->mm_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272
Roland McGrath82df3972007-10-16 23:27:02 -07002273 for (addr = vma->vm_start; addr < end; addr += PAGE_SIZE) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002274 struct page *page;
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002275 int stop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002277 page = get_dump_page(addr);
2278 if (page) {
2279 void *kaddr = kmap(page);
Al Viro13046ec2013-10-05 18:08:47 -04002280 stop = !dump_emit(cprm, kaddr, PAGE_SIZE);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002281 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 page_cache_release(page);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002283 } else
Al Viro9b56d542013-10-08 09:26:08 -04002284 stop = !dump_skip(cprm, PAGE_SIZE);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002285 if (stop)
2286 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287 }
2288 }
2289
Al Viroaa3e7ea2013-10-05 17:50:15 -04002290 if (!elf_core_write_extra_data(cprm))
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002291 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002293 if (e_phnum == PN_XNUM) {
Al Viro13046ec2013-10-05 18:08:47 -04002294 if (!dump_emit(cprm, shdr4extnum, sizeof(*shdr4extnum)))
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002295 goto end_coredump;
2296 }
2297
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298end_coredump:
2299 set_fs(fs);
2300
2301cleanup:
Roland McGrath3aba4812008-01-30 13:31:44 +01002302 free_note_info(&info);
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002303 kfree(shdr4extnum);
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002304 kfree(phdr4note);
WANG Cong5f719552008-05-06 12:45:35 +08002305 kfree(elf);
2306out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307 return has_dumped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308}
2309
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08002310#endif /* CONFIG_ELF_CORE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311
2312static int __init init_elf_binfmt(void)
2313{
Al Viro8fc3dc52012-03-17 03:05:16 -04002314 register_binfmt(&elf_format);
2315 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316}
2317
2318static void __exit exit_elf_binfmt(void)
2319{
2320 /* Remove the COFF and ELF loaders. */
2321 unregister_binfmt(&elf_format);
2322}
2323
2324core_initcall(init_elf_binfmt);
2325module_exit(exit_elf_binfmt);
2326MODULE_LICENSE("GPL");