blob: cd46e415883090747d8238c2a2fbaa9b101dbc5e [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>
Kees Cookd1fd8362015-04-14 15:48:07 -070034#include <linux/elf-randomize.h>
Alexey Dobriyan7e80d0d2007-05-08 00:28:59 -070035#include <linux/utsname.h>
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -080036#include <linux/coredump.h>
Frederic Weisbecker6fac4822012-11-13 14:20:55 +010037#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <asm/uaccess.h>
39#include <asm/param.h>
40#include <asm/page.h>
41
Denys Vlasenko2aa362c2012-10-04 17:15:36 -070042#ifndef user_long_t
43#define user_long_t long
44#endif
Denys Vlasenko49ae4d42012-10-04 17:15:35 -070045#ifndef user_siginfo_t
46#define user_siginfo_t siginfo_t
47#endif
48
Al Viro71613c32012-10-20 22:00:48 -040049static int load_elf_binary(struct linux_binprm *bprm);
Andrew Mortonbb1ad822008-01-30 13:31:07 +010050static unsigned long elf_map(struct file *, unsigned long, struct elf_phdr *,
51 int, int, unsigned long);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
Josh Triplett69369a72014-04-03 14:48:27 -070053#ifdef CONFIG_USELIB
54static int load_elf_library(struct file *);
55#else
56#define load_elf_library NULL
57#endif
58
Linus Torvalds1da177e2005-04-16 15:20:36 -070059/*
60 * If we don't support core dumping, then supply a NULL so we
61 * don't even try.
62 */
Christoph Hellwig698ba7b2009-12-15 16:47:37 -080063#ifdef CONFIG_ELF_CORE
Masami Hiramatsuf6151df2009-12-17 15:27:16 -080064static int elf_core_dump(struct coredump_params *cprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065#else
66#define elf_core_dump NULL
67#endif
68
69#if ELF_EXEC_PAGESIZE > PAGE_SIZE
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070070#define ELF_MIN_ALIGN ELF_EXEC_PAGESIZE
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#else
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070072#define ELF_MIN_ALIGN PAGE_SIZE
Linus Torvalds1da177e2005-04-16 15:20:36 -070073#endif
74
75#ifndef ELF_CORE_EFLAGS
76#define ELF_CORE_EFLAGS 0
77#endif
78
79#define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
80#define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
81#define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
82
83static struct linux_binfmt elf_format = {
Mikael Petterssonf670d0e2011-01-12 17:00:02 -080084 .module = THIS_MODULE,
85 .load_binary = load_elf_binary,
86 .load_shlib = load_elf_library,
87 .core_dump = elf_core_dump,
88 .min_coredump = ELF_EXEC_PAGESIZE,
Linus Torvalds1da177e2005-04-16 15:20:36 -070089};
90
Andrew Mortond4e3cc32007-07-21 04:37:32 -070091#define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
93static int set_brk(unsigned long start, unsigned long end)
94{
95 start = ELF_PAGEALIGN(start);
96 end = ELF_PAGEALIGN(end);
97 if (end > start) {
98 unsigned long addr;
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -070099 addr = vm_brk(start, end - start);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 if (BAD_ADDR(addr))
101 return addr;
102 }
103 current->mm->start_brk = current->mm->brk = end;
104 return 0;
105}
106
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107/* We need to explicitly zero any fractional pages
108 after the data section (i.e. bss). This would
109 contain the junk from the file that should not
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700110 be in memory
111 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112static int padzero(unsigned long elf_bss)
113{
114 unsigned long nbyte;
115
116 nbyte = ELF_PAGEOFFSET(elf_bss);
117 if (nbyte) {
118 nbyte = ELF_MIN_ALIGN - nbyte;
119 if (clear_user((void __user *) elf_bss, nbyte))
120 return -EFAULT;
121 }
122 return 0;
123}
124
Ohad Ben-Cohen09c6dd32008-02-03 18:05:15 +0200125/* Let's use some macros to make this stack manipulation a little clearer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126#ifdef CONFIG_STACK_GROWSUP
127#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))
128#define STACK_ROUND(sp, items) \
129 ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700130#define STACK_ALLOC(sp, len) ({ \
131 elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; \
132 old_sp; })
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133#else
134#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))
135#define STACK_ROUND(sp, items) \
136 (((unsigned long) (sp - items)) &~ 15UL)
137#define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })
138#endif
139
Nathan Lynch483fad12008-07-22 04:48:46 +1000140#ifndef ELF_BASE_PLATFORM
141/*
142 * AT_BASE_PLATFORM indicates the "real" hardware/microarchitecture.
143 * If the arch defines ELF_BASE_PLATFORM (in asm/elf.h), the value
144 * will be copied to the user stack in the same manner as AT_PLATFORM.
145 */
146#define ELF_BASE_PLATFORM NULL
147#endif
148
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149static int
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700150create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
Andi Kleend20894a2008-02-08 04:21:54 -0800151 unsigned long load_addr, unsigned long interp_load_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152{
153 unsigned long p = bprm->p;
154 int argc = bprm->argc;
155 int envc = bprm->envc;
156 elf_addr_t __user *argv;
157 elf_addr_t __user *envp;
158 elf_addr_t __user *sp;
159 elf_addr_t __user *u_platform;
Nathan Lynch483fad12008-07-22 04:48:46 +1000160 elf_addr_t __user *u_base_platform;
Kees Cookf06295b2009-01-07 18:08:52 -0800161 elf_addr_t __user *u_rand_bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 const char *k_platform = ELF_PLATFORM;
Nathan Lynch483fad12008-07-22 04:48:46 +1000163 const char *k_base_platform = ELF_BASE_PLATFORM;
Kees Cookf06295b2009-01-07 18:08:52 -0800164 unsigned char k_rand_bytes[16];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 int items;
166 elf_addr_t *elf_info;
167 int ei_index = 0;
David Howells86a264a2008-11-14 10:39:18 +1100168 const struct cred *cred = current_cred();
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700169 struct vm_area_struct *vma;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
171 /*
Franck Bui-Huud68c9d62007-10-16 23:30:24 -0700172 * In some cases (e.g. Hyper-Threading), we want to avoid L1
173 * evictions by the processes running on the same package. One
174 * thing we can do is to shuffle the initial stack for them.
175 */
176
177 p = arch_align_stack(p);
178
179 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 * If this architecture has a platform capability string, copy it
181 * to userspace. In some cases (Sparc), this info is impossible
182 * for userspace to get any other way, in others (i386) it is
183 * merely difficult.
184 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 u_platform = NULL;
186 if (k_platform) {
187 size_t len = strlen(k_platform) + 1;
188
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
190 if (__copy_to_user(u_platform, k_platform, len))
191 return -EFAULT;
192 }
193
Nathan Lynch483fad12008-07-22 04:48:46 +1000194 /*
195 * If this architecture has a "base" platform capability
196 * string, copy it to userspace.
197 */
198 u_base_platform = NULL;
199 if (k_base_platform) {
200 size_t len = strlen(k_base_platform) + 1;
201
202 u_base_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
203 if (__copy_to_user(u_base_platform, k_base_platform, len))
204 return -EFAULT;
205 }
206
Kees Cookf06295b2009-01-07 18:08:52 -0800207 /*
208 * Generate 16 random bytes for userspace PRNG seeding.
209 */
210 get_random_bytes(k_rand_bytes, sizeof(k_rand_bytes));
211 u_rand_bytes = (elf_addr_t __user *)
212 STACK_ALLOC(p, sizeof(k_rand_bytes));
213 if (__copy_to_user(u_rand_bytes, k_rand_bytes, sizeof(k_rand_bytes)))
214 return -EFAULT;
215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 /* Create the ELF interpreter info */
Jesper Juhl785d5572006-06-23 02:05:35 -0700217 elf_info = (elf_addr_t *)current->mm->saved_auxv;
Olaf Hering4f9a58d2007-10-16 23:30:12 -0700218 /* update AT_VECTOR_SIZE_BASE if the number of NEW_AUX_ENT() changes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219#define NEW_AUX_ENT(id, val) \
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700220 do { \
Jesper Juhl785d5572006-06-23 02:05:35 -0700221 elf_info[ei_index++] = id; \
222 elf_info[ei_index++] = val; \
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700223 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
225#ifdef ARCH_DLINFO
226 /*
227 * ARCH_DLINFO must come first so PPC can do its special alignment of
228 * AUXV.
Olaf Hering4f9a58d2007-10-16 23:30:12 -0700229 * update AT_VECTOR_SIZE_ARCH if the number of NEW_AUX_ENT() in
230 * ARCH_DLINFO changes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 */
232 ARCH_DLINFO;
233#endif
234 NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);
235 NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
236 NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
237 NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700238 NEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);
240 NEW_AUX_ENT(AT_BASE, interp_load_addr);
241 NEW_AUX_ENT(AT_FLAGS, 0);
242 NEW_AUX_ENT(AT_ENTRY, exec->e_entry);
Eric W. Biedermanebc887b2012-02-07 18:36:10 -0800243 NEW_AUX_ENT(AT_UID, from_kuid_munged(cred->user_ns, cred->uid));
244 NEW_AUX_ENT(AT_EUID, from_kuid_munged(cred->user_ns, cred->euid));
245 NEW_AUX_ENT(AT_GID, from_kgid_munged(cred->user_ns, cred->gid));
246 NEW_AUX_ENT(AT_EGID, from_kgid_munged(cred->user_ns, cred->egid));
Jesper Juhl785d5572006-06-23 02:05:35 -0700247 NEW_AUX_ENT(AT_SECURE, security_bprm_secureexec(bprm));
Kees Cookf06295b2009-01-07 18:08:52 -0800248 NEW_AUX_ENT(AT_RANDOM, (elf_addr_t)(unsigned long)u_rand_bytes);
Michael Neuling21713642013-04-17 17:33:11 +0000249#ifdef ELF_HWCAP2
250 NEW_AUX_ENT(AT_HWCAP2, ELF_HWCAP2);
251#endif
John Reiser65191082008-07-21 14:21:32 -0700252 NEW_AUX_ENT(AT_EXECFN, bprm->exec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 if (k_platform) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700254 NEW_AUX_ENT(AT_PLATFORM,
Jesper Juhl785d5572006-06-23 02:05:35 -0700255 (elf_addr_t)(unsigned long)u_platform);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 }
Nathan Lynch483fad12008-07-22 04:48:46 +1000257 if (k_base_platform) {
258 NEW_AUX_ENT(AT_BASE_PLATFORM,
259 (elf_addr_t)(unsigned long)u_base_platform);
260 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
Jesper Juhl785d5572006-06-23 02:05:35 -0700262 NEW_AUX_ENT(AT_EXECFD, bprm->interp_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 }
264#undef NEW_AUX_ENT
265 /* AT_NULL is zero; clear the rest too */
266 memset(&elf_info[ei_index], 0,
267 sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);
268
269 /* And advance past the AT_NULL entry. */
270 ei_index += 2;
271
272 sp = STACK_ADD(p, ei_index);
273
Andi Kleend20894a2008-02-08 04:21:54 -0800274 items = (argc + 1) + (envc + 1) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 bprm->p = STACK_ROUND(sp, items);
276
277 /* Point sp at the lowest address on the stack */
278#ifdef CONFIG_STACK_GROWSUP
279 sp = (elf_addr_t __user *)bprm->p - items - ei_index;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700280 bprm->exec = (unsigned long)sp; /* XXX: PARISC HACK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281#else
282 sp = (elf_addr_t __user *)bprm->p;
283#endif
284
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700285
286 /*
287 * Grow the stack manually; some architectures have a limit on how
288 * far ahead a user-space access may be in order to grow the stack.
289 */
290 vma = find_extend_vma(current->mm, bprm->p);
291 if (!vma)
292 return -EFAULT;
293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 /* Now, let's put argc (and argv, envp if appropriate) on the stack */
295 if (__put_user(argc, sp++))
296 return -EFAULT;
Andi Kleend20894a2008-02-08 04:21:54 -0800297 argv = sp;
298 envp = argv + argc + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
300 /* Populate argv and envp */
Greg Kroah-Hartmana84a5052005-05-11 00:10:44 -0700301 p = current->mm->arg_end = current->mm->arg_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 while (argc-- > 0) {
303 size_t len;
Heiko Carstens841d5fb2006-12-06 20:36:35 -0800304 if (__put_user((elf_addr_t)p, argv++))
305 return -EFAULT;
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700306 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
307 if (!len || len > MAX_ARG_STRLEN)
WANG Cong23c49712008-05-08 21:52:33 +0800308 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 p += len;
310 }
311 if (__put_user(0, argv))
312 return -EFAULT;
313 current->mm->arg_end = current->mm->env_start = p;
314 while (envc-- > 0) {
315 size_t len;
Heiko Carstens841d5fb2006-12-06 20:36:35 -0800316 if (__put_user((elf_addr_t)p, envp++))
317 return -EFAULT;
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700318 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
319 if (!len || len > MAX_ARG_STRLEN)
WANG Cong23c49712008-05-08 21:52:33 +0800320 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 p += len;
322 }
323 if (__put_user(0, envp))
324 return -EFAULT;
325 current->mm->env_end = p;
326
327 /* Put the elf_info on the stack in the right place. */
328 sp = (elf_addr_t __user *)envp + 1;
329 if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))
330 return -EFAULT;
331 return 0;
332}
333
James Hoganc07380b2011-05-09 10:58:40 +0100334#ifndef elf_map
335
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336static unsigned long elf_map(struct file *filep, unsigned long addr,
Jiri Kosinacc503c12008-01-30 13:31:07 +0100337 struct elf_phdr *eppnt, int prot, int type,
338 unsigned long total_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
340 unsigned long map_addr;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100341 unsigned long size = eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr);
342 unsigned long off = eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr);
343 addr = ELF_PAGESTART(addr);
344 size = ELF_PAGEALIGN(size);
Jan Kratochvil60bfba72007-07-15 23:40:06 -0700345
Andrew Mortond4e3cc32007-07-21 04:37:32 -0700346 /* mmap() will return -EINVAL if given a zero size, but a
347 * segment with zero filesize is perfectly valid */
Jiri Kosinacc503c12008-01-30 13:31:07 +0100348 if (!size)
349 return addr;
350
Jiri Kosinacc503c12008-01-30 13:31:07 +0100351 /*
352 * total_size is the size of the ELF (interpreter) image.
353 * The _first_ mmap needs to know the full size, otherwise
354 * randomization might put this image into an overlapping
355 * position with the ELF binary image. (since size < total_size)
356 * So we first map the 'big' image - and unmap the remainder at
357 * the end. (which unmap is needed for ELF images with holes.)
358 */
359 if (total_size) {
360 total_size = ELF_PAGEALIGN(total_size);
Al Viro5a5e4c22012-05-30 01:49:38 -0400361 map_addr = vm_mmap(filep, addr, total_size, prot, type, off);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100362 if (!BAD_ADDR(map_addr))
Al Viro5a5e4c22012-05-30 01:49:38 -0400363 vm_munmap(map_addr+size, total_size-size);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100364 } else
Al Viro5a5e4c22012-05-30 01:49:38 -0400365 map_addr = vm_mmap(filep, addr, size, prot, type, off);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100366
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 return(map_addr);
368}
369
James Hoganc07380b2011-05-09 10:58:40 +0100370#endif /* !elf_map */
371
Jiri Kosinacc503c12008-01-30 13:31:07 +0100372static unsigned long total_mapping_size(struct elf_phdr *cmds, int nr)
373{
374 int i, first_idx = -1, last_idx = -1;
375
376 for (i = 0; i < nr; i++) {
377 if (cmds[i].p_type == PT_LOAD) {
378 last_idx = i;
379 if (first_idx == -1)
380 first_idx = i;
381 }
382 }
383 if (first_idx == -1)
384 return 0;
385
386 return cmds[last_idx].p_vaddr + cmds[last_idx].p_memsz -
387 ELF_PAGESTART(cmds[first_idx].p_vaddr);
388}
389
Paul Burton6a8d3892014-09-11 08:30:14 +0100390/**
391 * load_elf_phdrs() - load ELF program headers
392 * @elf_ex: ELF header of the binary whose program headers should be loaded
393 * @elf_file: the opened ELF binary file
394 *
395 * Loads ELF program headers from the binary file elf_file, which has the ELF
396 * header pointed to by elf_ex, into a newly allocated array. The caller is
397 * responsible for freeing the allocated data. Returns an ERR_PTR upon failure.
398 */
399static struct elf_phdr *load_elf_phdrs(struct elfhdr *elf_ex,
400 struct file *elf_file)
401{
402 struct elf_phdr *elf_phdata = NULL;
403 int retval, size, err = -1;
404
405 /*
406 * If the size of this structure has changed, then punt, since
407 * we will be doing the wrong thing.
408 */
409 if (elf_ex->e_phentsize != sizeof(struct elf_phdr))
410 goto out;
411
412 /* Sanity check the number of program headers... */
413 if (elf_ex->e_phnum < 1 ||
414 elf_ex->e_phnum > 65536U / sizeof(struct elf_phdr))
415 goto out;
416
417 /* ...and their total size. */
418 size = sizeof(struct elf_phdr) * elf_ex->e_phnum;
419 if (size > ELF_MIN_ALIGN)
420 goto out;
421
422 elf_phdata = kmalloc(size, GFP_KERNEL);
423 if (!elf_phdata)
424 goto out;
425
426 /* Read in the program headers */
427 retval = kernel_read(elf_file, elf_ex->e_phoff,
428 (char *)elf_phdata, size);
429 if (retval != size) {
430 err = (retval < 0) ? retval : -EIO;
431 goto out;
432 }
433
434 /* Success! */
435 err = 0;
436out:
437 if (err) {
438 kfree(elf_phdata);
439 elf_phdata = NULL;
440 }
441 return elf_phdata;
442}
Jiri Kosinacc503c12008-01-30 13:31:07 +0100443
Paul Burton774c1052014-09-11 08:30:16 +0100444#ifndef CONFIG_ARCH_BINFMT_ELF_STATE
445
446/**
447 * struct arch_elf_state - arch-specific ELF loading state
448 *
449 * This structure is used to preserve architecture specific data during
450 * the loading of an ELF file, throughout the checking of architecture
451 * specific ELF headers & through to the point where the ELF load is
452 * known to be proceeding (ie. SET_PERSONALITY).
453 *
454 * This implementation is a dummy for architectures which require no
455 * specific state.
456 */
457struct arch_elf_state {
458};
459
460#define INIT_ARCH_ELF_STATE {}
461
462/**
463 * arch_elf_pt_proc() - check a PT_LOPROC..PT_HIPROC ELF program header
464 * @ehdr: The main ELF header
465 * @phdr: The program header to check
466 * @elf: The open ELF file
467 * @is_interp: True if the phdr is from the interpreter of the ELF being
468 * loaded, else false.
469 * @state: Architecture-specific state preserved throughout the process
470 * of loading the ELF.
471 *
472 * Inspects the program header phdr to validate its correctness and/or
473 * suitability for the system. Called once per ELF program header in the
474 * range PT_LOPROC to PT_HIPROC, for both the ELF being loaded and its
475 * interpreter.
476 *
477 * Return: Zero to proceed with the ELF load, non-zero to fail the ELF load
478 * with that return code.
479 */
480static inline int arch_elf_pt_proc(struct elfhdr *ehdr,
481 struct elf_phdr *phdr,
482 struct file *elf, bool is_interp,
483 struct arch_elf_state *state)
484{
485 /* Dummy implementation, always proceed */
486 return 0;
487}
488
489/**
490 * arch_check_elf() - check a PT_LOPROC..PT_HIPROC ELF program header
491 * @ehdr: The main ELF header
492 * @has_interp: True if the ELF has an interpreter, else false.
493 * @state: Architecture-specific state preserved throughout the process
494 * of loading the ELF.
495 *
496 * Provides a final opportunity for architecture code to reject the loading
497 * of the ELF & cause an exec syscall to return an error. This is called after
498 * all program headers to be checked by arch_elf_pt_proc have been.
499 *
500 * Return: Zero to proceed with the ELF load, non-zero to fail the ELF load
501 * with that return code.
502 */
503static inline int arch_check_elf(struct elfhdr *ehdr, bool has_interp,
504 struct arch_elf_state *state)
505{
506 /* Dummy implementation, always proceed */
507 return 0;
508}
509
510#endif /* !CONFIG_ARCH_BINFMT_ELF_STATE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511
512/* This is much more generalized than the library routine read function,
513 so we keep this separate. Technically the library read function
514 is only provided so that we can read a.out libraries that have
515 an ELF header */
516
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700517static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
Jiri Kosinacc503c12008-01-30 13:31:07 +0100518 struct file *interpreter, unsigned long *interp_map_addr,
Paul Burtona9d9ef12014-09-11 08:30:15 +0100519 unsigned long no_base, struct elf_phdr *interp_elf_phdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 struct elf_phdr *eppnt;
522 unsigned long load_addr = 0;
523 int load_addr_set = 0;
524 unsigned long last_bss = 0, elf_bss = 0;
525 unsigned long error = ~0UL;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100526 unsigned long total_size;
Paul Burton6a8d3892014-09-11 08:30:14 +0100527 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
529 /* First of all, some simple consistency checks */
530 if (interp_elf_ex->e_type != ET_EXEC &&
531 interp_elf_ex->e_type != ET_DYN)
532 goto out;
533 if (!elf_check_arch(interp_elf_ex))
534 goto out;
Al Viro72c2d532013-09-22 16:27:52 -0400535 if (!interpreter->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 goto out;
537
Paul Burtona9d9ef12014-09-11 08:30:15 +0100538 total_size = total_mapping_size(interp_elf_phdata,
539 interp_elf_ex->e_phnum);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100540 if (!total_size) {
541 error = -EINVAL;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100542 goto out;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100543 }
544
Paul Burtona9d9ef12014-09-11 08:30:15 +0100545 eppnt = interp_elf_phdata;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700546 for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
547 if (eppnt->p_type == PT_LOAD) {
548 int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
549 int elf_prot = 0;
550 unsigned long vaddr = 0;
551 unsigned long k, map_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700553 if (eppnt->p_flags & PF_R)
554 elf_prot = PROT_READ;
555 if (eppnt->p_flags & PF_W)
556 elf_prot |= PROT_WRITE;
557 if (eppnt->p_flags & PF_X)
558 elf_prot |= PROT_EXEC;
559 vaddr = eppnt->p_vaddr;
560 if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
561 elf_type |= MAP_FIXED;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100562 else if (no_base && interp_elf_ex->e_type == ET_DYN)
563 load_addr = -vaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700565 map_addr = elf_map(interpreter, load_addr + vaddr,
Andrew Mortonbb1ad822008-01-30 13:31:07 +0100566 eppnt, elf_prot, elf_type, total_size);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100567 total_size = 0;
568 if (!*interp_map_addr)
569 *interp_map_addr = map_addr;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700570 error = map_addr;
571 if (BAD_ADDR(map_addr))
Paul Burtona9d9ef12014-09-11 08:30:15 +0100572 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700574 if (!load_addr_set &&
575 interp_elf_ex->e_type == ET_DYN) {
576 load_addr = map_addr - ELF_PAGESTART(vaddr);
577 load_addr_set = 1;
578 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700580 /*
581 * Check to see if the section's size will overflow the
582 * allowed task size. Note that p_filesz must always be
583 * <= p_memsize so it's only necessary to check p_memsz.
584 */
585 k = load_addr + eppnt->p_vaddr;
Chuck Ebbertce510592006-07-03 00:24:14 -0700586 if (BAD_ADDR(k) ||
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700587 eppnt->p_filesz > eppnt->p_memsz ||
588 eppnt->p_memsz > TASK_SIZE ||
589 TASK_SIZE - eppnt->p_memsz < k) {
590 error = -ENOMEM;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100591 goto out;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700592 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700594 /*
595 * Find the end of the file mapping for this phdr, and
596 * keep track of the largest address we see for this.
597 */
598 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
599 if (k > elf_bss)
600 elf_bss = k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700602 /*
603 * Do the same thing for the memory mapping - between
604 * elf_bss and last_bss is the bss section.
605 */
606 k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
607 if (k > last_bss)
608 last_bss = k;
609 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 }
611
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 if (last_bss > elf_bss) {
Roland McGrath752015d2009-09-08 19:49:40 -0700613 /*
614 * Now fill out the bss section. First pad the last page up
615 * to the page boundary, and then perform a mmap to make sure
616 * that there are zero-mapped pages up to and including the
617 * last bss page.
618 */
619 if (padzero(elf_bss)) {
620 error = -EFAULT;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100621 goto out;
Roland McGrath752015d2009-09-08 19:49:40 -0700622 }
623
624 /* What we have mapped so far */
625 elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1);
626
627 /* Map the last of the bss segment */
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -0700628 error = vm_brk(elf_bss, last_bss - elf_bss);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 if (BAD_ADDR(error))
Paul Burtona9d9ef12014-09-11 08:30:15 +0100630 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 }
632
Jiri Kosinacc503c12008-01-30 13:31:07 +0100633 error = load_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634out:
635 return error;
636}
637
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638/*
639 * These are the functions used to load ELF style executables and shared
640 * libraries. There is no binary dependent code anywhere else.
641 */
642
Andi Kleen913bd902006-03-25 16:29:09 +0100643#ifndef STACK_RND_MASK
James Bottomleyd1cabd62007-03-16 13:38:35 -0800644#define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12)) /* 8MB of VA */
Andi Kleen913bd902006-03-25 16:29:09 +0100645#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
647static unsigned long randomize_stack_top(unsigned long stack_top)
648{
Hector Marco-Gisbert4e7c22d2015-02-14 09:33:50 -0800649 unsigned long random_variable = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
Andi Kleenc16b63e02006-09-26 10:52:28 +0200651 if ((current->flags & PF_RANDOMIZE) &&
652 !(current->personality & ADDR_NO_RANDOMIZE)) {
Hector Marco-Gisbert4e7c22d2015-02-14 09:33:50 -0800653 random_variable = (unsigned long) get_random_int();
654 random_variable &= STACK_RND_MASK;
Andi Kleen913bd902006-03-25 16:29:09 +0100655 random_variable <<= PAGE_SHIFT;
656 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657#ifdef CONFIG_STACK_GROWSUP
Andi Kleen913bd902006-03-25 16:29:09 +0100658 return PAGE_ALIGN(stack_top) + random_variable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659#else
Andi Kleen913bd902006-03-25 16:29:09 +0100660 return PAGE_ALIGN(stack_top) - random_variable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661#endif
662}
663
Al Viro71613c32012-10-20 22:00:48 -0400664static int load_elf_binary(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665{
666 struct file *interpreter = NULL; /* to shut gcc up */
667 unsigned long load_addr = 0, load_bias = 0;
668 int load_addr_set = 0;
669 char * elf_interpreter = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 unsigned long error;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100671 struct elf_phdr *elf_ppnt, *elf_phdata, *interp_elf_phdata = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 unsigned long elf_bss, elf_brk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 int retval, i;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100674 unsigned long elf_entry;
675 unsigned long interp_load_addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 unsigned long start_code, end_code, start_data, end_data;
David Daney1a530a62011-03-22 16:34:48 -0700677 unsigned long reloc_func_desc __maybe_unused = 0;
David Rientjes8de61e62006-12-06 20:40:16 -0800678 int executable_stack = EXSTACK_DEFAULT;
Al Viro71613c32012-10-20 22:00:48 -0400679 struct pt_regs *regs = current_pt_regs();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 struct {
681 struct elfhdr elf_ex;
682 struct elfhdr interp_elf_ex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 } *loc;
Paul Burton774c1052014-09-11 08:30:16 +0100684 struct arch_elf_state arch_state = INIT_ARCH_ELF_STATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
686 loc = kmalloc(sizeof(*loc), GFP_KERNEL);
687 if (!loc) {
688 retval = -ENOMEM;
689 goto out_ret;
690 }
691
692 /* Get the exec-header */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700693 loc->elf_ex = *((struct elfhdr *)bprm->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
695 retval = -ENOEXEC;
696 /* First of all, some simple consistency checks */
697 if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
698 goto out;
699
700 if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
701 goto out;
702 if (!elf_check_arch(&loc->elf_ex))
703 goto out;
Al Viro72c2d532013-09-22 16:27:52 -0400704 if (!bprm->file->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 goto out;
706
Paul Burton6a8d3892014-09-11 08:30:14 +0100707 elf_phdata = load_elf_phdrs(&loc->elf_ex, bprm->file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 if (!elf_phdata)
709 goto out;
710
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 elf_ppnt = elf_phdata;
712 elf_bss = 0;
713 elf_brk = 0;
714
715 start_code = ~0UL;
716 end_code = 0;
717 start_data = 0;
718 end_data = 0;
719
720 for (i = 0; i < loc->elf_ex.e_phnum; i++) {
721 if (elf_ppnt->p_type == PT_INTERP) {
722 /* This is the program interpreter used for
723 * shared libraries - for now assume that this
724 * is an a.out format binary
725 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 retval = -ENOEXEC;
727 if (elf_ppnt->p_filesz > PATH_MAX ||
728 elf_ppnt->p_filesz < 2)
Al Viroe7b9b552009-03-29 16:31:16 -0400729 goto out_free_ph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730
731 retval = -ENOMEM;
Jesper Juhl792db3a2006-01-09 20:54:45 -0800732 elf_interpreter = kmalloc(elf_ppnt->p_filesz,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700733 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 if (!elf_interpreter)
Al Viroe7b9b552009-03-29 16:31:16 -0400735 goto out_free_ph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
737 retval = kernel_read(bprm->file, elf_ppnt->p_offset,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700738 elf_interpreter,
739 elf_ppnt->p_filesz);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 if (retval != elf_ppnt->p_filesz) {
741 if (retval >= 0)
742 retval = -EIO;
743 goto out_free_interp;
744 }
745 /* make sure path is NULL terminated */
746 retval = -ENOEXEC;
747 if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
748 goto out_free_interp;
749
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 interpreter = open_exec(elf_interpreter);
751 retval = PTR_ERR(interpreter);
752 if (IS_ERR(interpreter))
753 goto out_free_interp;
Alexey Dobriyan1fb84492007-01-26 00:57:16 -0800754
755 /*
756 * If the binary is not readable then enforce
757 * mm->dumpable = 0 regardless of the interpreter's
758 * permissions.
759 */
Al Viro1b5d7832011-06-19 12:49:47 -0400760 would_dump(bprm, interpreter);
Alexey Dobriyan1fb84492007-01-26 00:57:16 -0800761
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700762 retval = kernel_read(interpreter, 0, bprm->buf,
763 BINPRM_BUF_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 if (retval != BINPRM_BUF_SIZE) {
765 if (retval >= 0)
766 retval = -EIO;
767 goto out_free_dentry;
768 }
769
770 /* Get the exec headers */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700771 loc->interp_elf_ex = *((struct elfhdr *)bprm->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 break;
773 }
774 elf_ppnt++;
775 }
776
777 elf_ppnt = elf_phdata;
778 for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
Paul Burton774c1052014-09-11 08:30:16 +0100779 switch (elf_ppnt->p_type) {
780 case PT_GNU_STACK:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 if (elf_ppnt->p_flags & PF_X)
782 executable_stack = EXSTACK_ENABLE_X;
783 else
784 executable_stack = EXSTACK_DISABLE_X;
785 break;
Paul Burton774c1052014-09-11 08:30:16 +0100786
787 case PT_LOPROC ... PT_HIPROC:
788 retval = arch_elf_pt_proc(&loc->elf_ex, elf_ppnt,
789 bprm->file, false,
790 &arch_state);
791 if (retval)
792 goto out_free_dentry;
793 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
796 /* Some simple consistency checks for the interpreter */
797 if (elf_interpreter) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 retval = -ELIBBAD;
Andi Kleend20894a2008-02-08 04:21:54 -0800799 /* Not an ELF interpreter */
800 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 /* Verify the interpreter has a valid arch */
Andi Kleend20894a2008-02-08 04:21:54 -0800803 if (!elf_check_arch(&loc->interp_elf_ex))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 goto out_free_dentry;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100805
806 /* Load the interpreter program headers */
807 interp_elf_phdata = load_elf_phdrs(&loc->interp_elf_ex,
808 interpreter);
809 if (!interp_elf_phdata)
810 goto out_free_dentry;
Paul Burton774c1052014-09-11 08:30:16 +0100811
812 /* Pass PT_LOPROC..PT_HIPROC headers to arch code */
813 elf_ppnt = interp_elf_phdata;
814 for (i = 0; i < loc->interp_elf_ex.e_phnum; i++, elf_ppnt++)
815 switch (elf_ppnt->p_type) {
816 case PT_LOPROC ... PT_HIPROC:
817 retval = arch_elf_pt_proc(&loc->interp_elf_ex,
818 elf_ppnt, interpreter,
819 true, &arch_state);
820 if (retval)
821 goto out_free_dentry;
822 break;
823 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 }
825
Paul Burton774c1052014-09-11 08:30:16 +0100826 /*
827 * Allow arch code to reject the ELF at this point, whilst it's
828 * still possible to return an error to the code that invoked
829 * the exec syscall.
830 */
831 retval = arch_check_elf(&loc->elf_ex, !!interpreter, &arch_state);
832 if (retval)
833 goto out_free_dentry;
834
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 /* Flush all traces of the currently running executable */
836 retval = flush_old_exec(bprm);
837 if (retval)
838 goto out_free_dentry;
839
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 /* Do this immediately, since STACK_TOP as used in setup_arg_pages
841 may depend on the personality. */
Paul Burton774c1052014-09-11 08:30:16 +0100842 SET_PERSONALITY2(loc->elf_ex, &arch_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 if (elf_read_implies_exec(loc->elf_ex, executable_stack))
844 current->personality |= READ_IMPLIES_EXEC;
845
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700846 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 current->flags |= PF_RANDOMIZE;
Linus Torvalds221af7f2010-01-28 22:14:42 -0800848
849 setup_new_exec(bprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850
851 /* Do this so that we can load the interpreter, if need be. We will
852 change some of these later */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
854 executable_stack);
Al Viro19d860a2014-05-04 20:11:36 -0400855 if (retval < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 current->mm->start_stack = bprm->p;
859
André Goddard Rosaaf901ca2009-11-14 13:09:05 -0200860 /* Now we do a little grungy work by mmapping the ELF image into
Jiri Kosinacc503c12008-01-30 13:31:07 +0100861 the correct location in memory. */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700862 for(i = 0, elf_ppnt = elf_phdata;
863 i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 int elf_prot = 0, elf_flags;
865 unsigned long k, vaddr;
Michael Davidsona87938b2015-04-14 15:47:38 -0700866 unsigned long total_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
868 if (elf_ppnt->p_type != PT_LOAD)
869 continue;
870
871 if (unlikely (elf_brk > elf_bss)) {
872 unsigned long nbyte;
873
874 /* There was a PT_LOAD segment with p_memsz > p_filesz
875 before this one. Map anonymous pages, if needed,
876 and clear the area. */
Mikael Petterssonf670d0e2011-01-12 17:00:02 -0800877 retval = set_brk(elf_bss + load_bias,
878 elf_brk + load_bias);
Al Viro19d860a2014-05-04 20:11:36 -0400879 if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 nbyte = ELF_PAGEOFFSET(elf_bss);
882 if (nbyte) {
883 nbyte = ELF_MIN_ALIGN - nbyte;
884 if (nbyte > elf_brk - elf_bss)
885 nbyte = elf_brk - elf_bss;
886 if (clear_user((void __user *)elf_bss +
887 load_bias, nbyte)) {
888 /*
889 * This bss-zeroing can fail if the ELF
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700890 * file specifies odd protections. So
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 * we don't check the return value
892 */
893 }
894 }
895 }
896
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700897 if (elf_ppnt->p_flags & PF_R)
898 elf_prot |= PROT_READ;
899 if (elf_ppnt->p_flags & PF_W)
900 elf_prot |= PROT_WRITE;
901 if (elf_ppnt->p_flags & PF_X)
902 elf_prot |= PROT_EXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700904 elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905
906 vaddr = elf_ppnt->p_vaddr;
907 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
908 elf_flags |= MAP_FIXED;
909 } else if (loc->elf_ex.e_type == ET_DYN) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700910 /* Try and get dynamic programs out of the way of the
911 * default mmap base, as well as whatever program they
912 * might try to exec. This is because the brk will
913 * follow the loader, and is not movable. */
Kees Cookd1fd8362015-04-14 15:48:07 -0700914 load_bias = ELF_ET_DYN_BASE - vaddr;
Jiri Kosinaa3defbe2011-11-02 13:37:41 -0700915 if (current->flags & PF_RANDOMIZE)
Kees Cookd1fd8362015-04-14 15:48:07 -0700916 load_bias += arch_mmap_rnd();
917 load_bias = ELF_PAGESTART(load_bias);
Michael Davidsona87938b2015-04-14 15:47:38 -0700918 total_size = total_mapping_size(elf_phdata,
919 loc->elf_ex.e_phnum);
920 if (!total_size) {
Andrew Morton2b1d3ae2015-05-28 15:44:24 -0700921 retval = -EINVAL;
Michael Davidsona87938b2015-04-14 15:47:38 -0700922 goto out_free_dentry;
923 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 }
925
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700926 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
Michael Davidsona87938b2015-04-14 15:47:38 -0700927 elf_prot, elf_flags, total_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 if (BAD_ADDR(error)) {
Alexey Kuznetsovb140f2512007-05-08 00:31:57 -0700929 retval = IS_ERR((void *)error) ?
930 PTR_ERR((void*)error) : -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 goto out_free_dentry;
932 }
933
934 if (!load_addr_set) {
935 load_addr_set = 1;
936 load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
937 if (loc->elf_ex.e_type == ET_DYN) {
938 load_bias += error -
939 ELF_PAGESTART(load_bias + vaddr);
940 load_addr += load_bias;
941 reloc_func_desc = load_bias;
942 }
943 }
944 k = elf_ppnt->p_vaddr;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700945 if (k < start_code)
946 start_code = k;
947 if (start_data < k)
948 start_data = k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949
950 /*
951 * Check to see if the section's size will overflow the
952 * allowed task size. Note that p_filesz must always be
953 * <= p_memsz so it is only necessary to check p_memsz.
954 */
Chuck Ebbertce510592006-07-03 00:24:14 -0700955 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 elf_ppnt->p_memsz > TASK_SIZE ||
957 TASK_SIZE - elf_ppnt->p_memsz < k) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700958 /* set_brk can never work. Avoid overflows. */
Alexey Kuznetsovb140f2512007-05-08 00:31:57 -0700959 retval = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 goto out_free_dentry;
961 }
962
963 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
964
965 if (k > elf_bss)
966 elf_bss = k;
967 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
968 end_code = k;
969 if (end_data < k)
970 end_data = k;
971 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
972 if (k > elf_brk)
973 elf_brk = k;
974 }
975
976 loc->elf_ex.e_entry += load_bias;
977 elf_bss += load_bias;
978 elf_brk += load_bias;
979 start_code += load_bias;
980 end_code += load_bias;
981 start_data += load_bias;
982 end_data += load_bias;
983
984 /* Calling set_brk effectively mmaps the pages that we need
985 * for the bss and break sections. We must do this before
986 * mapping in the interpreter, to make sure it doesn't wind
987 * up getting placed where the bss needs to go.
988 */
989 retval = set_brk(elf_bss, elf_brk);
Al Viro19d860a2014-05-04 20:11:36 -0400990 if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 goto out_free_dentry;
akpm@osdl.org6de50512005-10-11 08:29:08 -0700992 if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 retval = -EFAULT; /* Nobody gets to see this, but.. */
994 goto out_free_dentry;
995 }
996
997 if (elf_interpreter) {
Alan Cox6eec4822012-10-04 17:13:42 -0700998 unsigned long interp_map_addr = 0;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100999
Andi Kleend20894a2008-02-08 04:21:54 -08001000 elf_entry = load_elf_interp(&loc->interp_elf_ex,
1001 interpreter,
1002 &interp_map_addr,
Paul Burtona9d9ef12014-09-11 08:30:15 +01001003 load_bias, interp_elf_phdata);
Andi Kleend20894a2008-02-08 04:21:54 -08001004 if (!IS_ERR((void *)elf_entry)) {
1005 /*
1006 * load_elf_interp() returns relocation
1007 * adjustment
1008 */
1009 interp_load_addr = elf_entry;
1010 elf_entry += loc->interp_elf_ex.e_entry;
Jiri Kosinacc503c12008-01-30 13:31:07 +01001011 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 if (BAD_ADDR(elf_entry)) {
Chuck Ebbertce510592006-07-03 00:24:14 -07001013 retval = IS_ERR((void *)elf_entry) ?
1014 (int)elf_entry : -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 goto out_free_dentry;
1016 }
1017 reloc_func_desc = interp_load_addr;
1018
1019 allow_write_access(interpreter);
1020 fput(interpreter);
1021 kfree(elf_interpreter);
1022 } else {
1023 elf_entry = loc->elf_ex.e_entry;
Suresh Siddha5342fba2006-02-26 04:18:28 +01001024 if (BAD_ADDR(elf_entry)) {
Chuck Ebbertce510592006-07-03 00:24:14 -07001025 retval = -EINVAL;
Suresh Siddha5342fba2006-02-26 04:18:28 +01001026 goto out_free_dentry;
1027 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 }
1029
Paul Burton774c1052014-09-11 08:30:16 +01001030 kfree(interp_elf_phdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 kfree(elf_phdata);
1032
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 set_binfmt(&elf_format);
1034
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -07001035#ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
Martin Schwidefskyfc5243d2008-12-25 13:38:35 +01001036 retval = arch_setup_additional_pages(bprm, !!elf_interpreter);
Al Viro19d860a2014-05-04 20:11:36 -04001037 if (retval < 0)
Roland McGrath18c8baf2005-04-28 15:17:19 -07001038 goto out;
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -07001039#endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
1040
David Howellsa6f76f22008-11-14 10:39:24 +11001041 install_exec_creds(bprm);
Ollie Wildb6a2fea2007-07-19 01:48:16 -07001042 retval = create_elf_tables(bprm, &loc->elf_ex,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001043 load_addr, interp_load_addr);
Al Viro19d860a2014-05-04 20:11:36 -04001044 if (retval < 0)
Ollie Wildb6a2fea2007-07-19 01:48:16 -07001045 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 /* N.B. passed_fileno might not be initialized? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047 current->mm->end_code = end_code;
1048 current->mm->start_code = start_code;
1049 current->mm->start_data = start_data;
1050 current->mm->end_data = end_data;
1051 current->mm->start_stack = bprm->p;
1052
Jiri Kosina4471a672011-04-14 15:22:09 -07001053 if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
Jiri Kosinac1d171a2008-01-30 13:30:40 +01001054 current->mm->brk = current->mm->start_brk =
1055 arch_randomize_brk(current->mm);
Kees Cook204db6e2015-04-14 15:48:12 -07001056#ifdef compat_brk_randomized
Jiri Kosina4471a672011-04-14 15:22:09 -07001057 current->brk_randomized = 1;
1058#endif
1059 }
Jiri Kosinac1d171a2008-01-30 13:30:40 +01001060
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 if (current->personality & MMAP_PAGE_ZERO) {
1062 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1063 and some applications "depend" upon this behavior.
1064 Since we do not have the power to recompile these, we
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001065 emulate the SVr4 behavior. Sigh. */
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001066 error = vm_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 MAP_FIXED | MAP_PRIVATE, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 }
1069
1070#ifdef ELF_PLAT_INIT
1071 /*
1072 * The ABI may specify that certain registers be set up in special
1073 * ways (on i386 %edx is the address of a DT_FINI function, for
1074 * example. In addition, it may also specify (eg, PowerPC64 ELF)
1075 * that the e_entry field is the address of the function descriptor
1076 * for the startup routine, rather than the address of the startup
1077 * routine itself. This macro performs whatever initialization to
1078 * the regs structure is required as well as any relocations to the
1079 * function descriptor entries when executing dynamically links apps.
1080 */
1081 ELF_PLAT_INIT(regs, reloc_func_desc);
1082#endif
1083
1084 start_thread(regs, elf_entry, bprm->p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 retval = 0;
1086out:
1087 kfree(loc);
1088out_ret:
1089 return retval;
1090
1091 /* error cleanup */
1092out_free_dentry:
Paul Burtona9d9ef12014-09-11 08:30:15 +01001093 kfree(interp_elf_phdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 allow_write_access(interpreter);
1095 if (interpreter)
1096 fput(interpreter);
1097out_free_interp:
Jesper Juhlf99d49a2005-11-07 01:01:34 -08001098 kfree(elf_interpreter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099out_free_ph:
1100 kfree(elf_phdata);
1101 goto out;
1102}
1103
Josh Triplett69369a72014-04-03 14:48:27 -07001104#ifdef CONFIG_USELIB
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105/* This is really simpleminded and specialized - we are loading an
1106 a.out library that is given an ELF header. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107static int load_elf_library(struct file *file)
1108{
1109 struct elf_phdr *elf_phdata;
1110 struct elf_phdr *eppnt;
1111 unsigned long elf_bss, bss, len;
1112 int retval, error, i, j;
1113 struct elfhdr elf_ex;
1114
1115 error = -ENOEXEC;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001116 retval = kernel_read(file, 0, (char *)&elf_ex, sizeof(elf_ex));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 if (retval != sizeof(elf_ex))
1118 goto out;
1119
1120 if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1121 goto out;
1122
1123 /* First of all, some simple consistency checks */
1124 if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
Al Viro72c2d532013-09-22 16:27:52 -04001125 !elf_check_arch(&elf_ex) || !file->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 goto out;
1127
1128 /* Now read in all of the header information */
1129
1130 j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1131 /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1132
1133 error = -ENOMEM;
1134 elf_phdata = kmalloc(j, GFP_KERNEL);
1135 if (!elf_phdata)
1136 goto out;
1137
1138 eppnt = elf_phdata;
1139 error = -ENOEXEC;
1140 retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);
1141 if (retval != j)
1142 goto out_free_ph;
1143
1144 for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1145 if ((eppnt + i)->p_type == PT_LOAD)
1146 j++;
1147 if (j != 1)
1148 goto out_free_ph;
1149
1150 while (eppnt->p_type != PT_LOAD)
1151 eppnt++;
1152
1153 /* Now use mmap to map the library into memory. */
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001154 error = vm_mmap(file,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 ELF_PAGESTART(eppnt->p_vaddr),
1156 (eppnt->p_filesz +
1157 ELF_PAGEOFFSET(eppnt->p_vaddr)),
1158 PROT_READ | PROT_WRITE | PROT_EXEC,
1159 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
1160 (eppnt->p_offset -
1161 ELF_PAGEOFFSET(eppnt->p_vaddr)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 if (error != ELF_PAGESTART(eppnt->p_vaddr))
1163 goto out_free_ph;
1164
1165 elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1166 if (padzero(elf_bss)) {
1167 error = -EFAULT;
1168 goto out_free_ph;
1169 }
1170
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001171 len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr +
1172 ELF_MIN_ALIGN - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 bss = eppnt->p_memsz + eppnt->p_vaddr;
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -07001174 if (bss > len)
1175 vm_brk(len, bss - len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 error = 0;
1177
1178out_free_ph:
1179 kfree(elf_phdata);
1180out:
1181 return error;
1182}
Josh Triplett69369a72014-04-03 14:48:27 -07001183#endif /* #ifdef CONFIG_USELIB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08001185#ifdef CONFIG_ELF_CORE
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186/*
1187 * ELF core dumper
1188 *
1189 * Modelled on fs/exec.c:aout_core_dump()
1190 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1191 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
1193/*
Jason Baron909af762012-03-23 15:02:51 -07001194 * The purpose of always_dump_vma() is to make sure that special kernel mappings
1195 * that are useful for post-mortem analysis are included in every core dump.
1196 * In that way we ensure that the core dump is fully interpretable later
1197 * without matching up the same kernel and hardware config to see what PC values
1198 * meant. These special mappings include - vDSO, vsyscall, and other
1199 * architecture specific mappings
1200 */
1201static bool always_dump_vma(struct vm_area_struct *vma)
1202{
1203 /* Any vsyscall mappings? */
1204 if (vma == get_gate_vma(vma->vm_mm))
1205 return true;
Andy Lutomirski78d683e2014-05-19 15:58:32 -07001206
1207 /*
1208 * Assume that all vmas with a .name op should always be dumped.
1209 * If this changes, a new vm_ops field can easily be added.
1210 */
1211 if (vma->vm_ops && vma->vm_ops->name && vma->vm_ops->name(vma))
1212 return true;
1213
Jason Baron909af762012-03-23 15:02:51 -07001214 /*
1215 * arch_vma_name() returns non-NULL for special architecture mappings,
1216 * such as vDSO sections.
1217 */
1218 if (arch_vma_name(vma))
1219 return true;
1220
1221 return false;
1222}
1223
1224/*
Roland McGrath82df3972007-10-16 23:27:02 -07001225 * Decide what to dump of a segment, part, all or none.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 */
Roland McGrath82df3972007-10-16 23:27:02 -07001227static unsigned long vma_dump_size(struct vm_area_struct *vma,
1228 unsigned long mm_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229{
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001230#define FILTER(type) (mm_flags & (1UL << MMF_DUMP_##type))
1231
Jason Baron909af762012-03-23 15:02:51 -07001232 /* always dump the vdso and vsyscall sections */
1233 if (always_dump_vma(vma))
Roland McGrath82df3972007-10-16 23:27:02 -07001234 goto whole;
Roland McGrathe5b97dd2007-01-26 00:56:48 -08001235
Konstantin Khlebnikov0103bd12012-10-08 16:28:59 -07001236 if (vma->vm_flags & VM_DONTDUMP)
Jason Baronaccb61f2012-03-23 15:02:51 -07001237 return 0;
1238
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001239 /* Hugetlb memory check */
1240 if (vma->vm_flags & VM_HUGETLB) {
1241 if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))
1242 goto whole;
1243 if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))
1244 goto whole;
Naoya Horiguchi23d9e482013-04-17 15:58:28 -07001245 return 0;
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001246 }
1247
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 /* Do not dump I/O mapped devices or special mappings */
Konstantin Khlebnikov314e51b2012-10-08 16:29:02 -07001249 if (vma->vm_flags & VM_IO)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 return 0;
1251
Kawai, Hidehiroa1b59e82007-07-19 01:48:29 -07001252 /* By default, dump shared memory if mapped from an anonymous file. */
1253 if (vma->vm_flags & VM_SHARED) {
Al Viro496ad9a2013-01-23 17:07:38 -05001254 if (file_inode(vma->vm_file)->i_nlink == 0 ?
Roland McGrath82df3972007-10-16 23:27:02 -07001255 FILTER(ANON_SHARED) : FILTER(MAPPED_SHARED))
1256 goto whole;
1257 return 0;
Kawai, Hidehiroa1b59e82007-07-19 01:48:29 -07001258 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259
Roland McGrath82df3972007-10-16 23:27:02 -07001260 /* Dump segments that have been written to. */
1261 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1262 goto whole;
1263 if (vma->vm_file == NULL)
1264 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265
Roland McGrath82df3972007-10-16 23:27:02 -07001266 if (FILTER(MAPPED_PRIVATE))
1267 goto whole;
1268
1269 /*
1270 * If this looks like the beginning of a DSO or executable mapping,
1271 * check for an ELF header. If we find one, dump the first page to
1272 * aid in determining what was mapped here.
1273 */
Roland McGrath92dc07b2009-02-06 17:34:07 -08001274 if (FILTER(ELF_HEADERS) &&
1275 vma->vm_pgoff == 0 && (vma->vm_flags & VM_READ)) {
Roland McGrath82df3972007-10-16 23:27:02 -07001276 u32 __user *header = (u32 __user *) vma->vm_start;
1277 u32 word;
Roland McGrath92dc07b2009-02-06 17:34:07 -08001278 mm_segment_t fs = get_fs();
Roland McGrath82df3972007-10-16 23:27:02 -07001279 /*
1280 * Doing it this way gets the constant folded by GCC.
1281 */
1282 union {
1283 u32 cmp;
1284 char elfmag[SELFMAG];
1285 } magic;
1286 BUILD_BUG_ON(SELFMAG != sizeof word);
1287 magic.elfmag[EI_MAG0] = ELFMAG0;
1288 magic.elfmag[EI_MAG1] = ELFMAG1;
1289 magic.elfmag[EI_MAG2] = ELFMAG2;
1290 magic.elfmag[EI_MAG3] = ELFMAG3;
Roland McGrath92dc07b2009-02-06 17:34:07 -08001291 /*
1292 * Switch to the user "segment" for get_user(),
1293 * then put back what elf_core_dump() had in place.
1294 */
1295 set_fs(USER_DS);
1296 if (unlikely(get_user(word, header)))
1297 word = 0;
1298 set_fs(fs);
1299 if (word == magic.cmp)
Roland McGrath82df3972007-10-16 23:27:02 -07001300 return PAGE_SIZE;
1301 }
1302
1303#undef FILTER
1304
1305 return 0;
1306
1307whole:
1308 return vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309}
1310
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311/* An ELF note in memory */
1312struct memelfnote
1313{
1314 const char *name;
1315 int type;
1316 unsigned int datasz;
1317 void *data;
1318};
1319
1320static int notesize(struct memelfnote *en)
1321{
1322 int sz;
1323
1324 sz = sizeof(struct elf_note);
1325 sz += roundup(strlen(en->name) + 1, 4);
1326 sz += roundup(en->datasz, 4);
1327
1328 return sz;
1329}
1330
Al Viroecc8c772013-10-05 15:32:35 -04001331static int writenote(struct memelfnote *men, struct coredump_params *cprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332{
1333 struct elf_note en;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 en.n_namesz = strlen(men->name) + 1;
1335 en.n_descsz = men->datasz;
1336 en.n_type = men->type;
1337
Al Viroecc8c772013-10-05 15:32:35 -04001338 return dump_emit(cprm, &en, sizeof(en)) &&
Al Viro22a8cb82013-10-08 11:05:01 -04001339 dump_emit(cprm, men->name, en.n_namesz) && dump_align(cprm, 4) &&
1340 dump_emit(cprm, men->data, men->datasz) && dump_align(cprm, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342
Roland McGrath3aba4812008-01-30 13:31:44 +01001343static void fill_elf_header(struct elfhdr *elf, int segs,
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08001344 u16 machine, u32 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345{
Cyrill Gorcunov6970c8e2008-04-29 01:01:18 -07001346 memset(elf, 0, sizeof(*elf));
1347
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 memcpy(elf->e_ident, ELFMAG, SELFMAG);
1349 elf->e_ident[EI_CLASS] = ELF_CLASS;
1350 elf->e_ident[EI_DATA] = ELF_DATA;
1351 elf->e_ident[EI_VERSION] = EV_CURRENT;
1352 elf->e_ident[EI_OSABI] = ELF_OSABI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353
1354 elf->e_type = ET_CORE;
Roland McGrath3aba4812008-01-30 13:31:44 +01001355 elf->e_machine = machine;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 elf->e_version = EV_CURRENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 elf->e_phoff = sizeof(struct elfhdr);
Roland McGrath3aba4812008-01-30 13:31:44 +01001358 elf->e_flags = flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 elf->e_ehsize = sizeof(struct elfhdr);
1360 elf->e_phentsize = sizeof(struct elf_phdr);
1361 elf->e_phnum = segs;
Cyrill Gorcunov6970c8e2008-04-29 01:01:18 -07001362
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 return;
1364}
1365
Andrew Morton8d6b5eee2006-09-25 23:32:04 -07001366static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367{
1368 phdr->p_type = PT_NOTE;
1369 phdr->p_offset = offset;
1370 phdr->p_vaddr = 0;
1371 phdr->p_paddr = 0;
1372 phdr->p_filesz = sz;
1373 phdr->p_memsz = 0;
1374 phdr->p_flags = 0;
1375 phdr->p_align = 0;
1376 return;
1377}
1378
1379static void fill_note(struct memelfnote *note, const char *name, int type,
1380 unsigned int sz, void *data)
1381{
1382 note->name = name;
1383 note->type = type;
1384 note->datasz = sz;
1385 note->data = data;
1386 return;
1387}
1388
1389/*
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001390 * fill up all the fields in prstatus from the given task struct, except
1391 * registers which need to be filled up separately.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 */
1393static void fill_prstatus(struct elf_prstatus *prstatus,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001394 struct task_struct *p, long signr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395{
1396 prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1397 prstatus->pr_sigpend = p->pending.signal.sig[0];
1398 prstatus->pr_sighold = p->blocked.sig[0];
Oleg Nesterov3b34fc52009-06-17 16:27:38 -07001399 rcu_read_lock();
1400 prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1401 rcu_read_unlock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001402 prstatus->pr_pid = task_pid_vnr(p);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001403 prstatus->pr_pgrp = task_pgrp_vnr(p);
1404 prstatus->pr_sid = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 if (thread_group_leader(p)) {
Frank Mayharf06febc2008-09-12 09:54:39 -07001406 struct task_cputime cputime;
1407
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 /*
Frank Mayharf06febc2008-09-12 09:54:39 -07001409 * This is the record for the group leader. It shows the
1410 * group-wide total, not its individual thread total.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 */
Frank Mayharf06febc2008-09-12 09:54:39 -07001412 thread_group_cputime(p, &cputime);
1413 cputime_to_timeval(cputime.utime, &prstatus->pr_utime);
1414 cputime_to_timeval(cputime.stime, &prstatus->pr_stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 } else {
Frederic Weisbecker6fac4822012-11-13 14:20:55 +01001416 cputime_t utime, stime;
1417
1418 task_cputime(p, &utime, &stime);
1419 cputime_to_timeval(utime, &prstatus->pr_utime);
1420 cputime_to_timeval(stime, &prstatus->pr_stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 }
1422 cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
1423 cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
1424}
1425
1426static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1427 struct mm_struct *mm)
1428{
David Howellsc69e8d92008-11-14 10:39:19 +11001429 const struct cred *cred;
Greg Kroah-Hartmana84a5052005-05-11 00:10:44 -07001430 unsigned int i, len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431
1432 /* first copy the parameters from user space */
1433 memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1434
1435 len = mm->arg_end - mm->arg_start;
1436 if (len >= ELF_PRARGSZ)
1437 len = ELF_PRARGSZ-1;
1438 if (copy_from_user(&psinfo->pr_psargs,
1439 (const char __user *)mm->arg_start, len))
1440 return -EFAULT;
1441 for(i = 0; i < len; i++)
1442 if (psinfo->pr_psargs[i] == 0)
1443 psinfo->pr_psargs[i] = ' ';
1444 psinfo->pr_psargs[len] = 0;
1445
Oleg Nesterov3b34fc52009-06-17 16:27:38 -07001446 rcu_read_lock();
1447 psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1448 rcu_read_unlock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001449 psinfo->pr_pid = task_pid_vnr(p);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001450 psinfo->pr_pgrp = task_pgrp_vnr(p);
1451 psinfo->pr_sid = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452
1453 i = p->state ? ffz(~p->state) + 1 : 0;
1454 psinfo->pr_state = i;
Carsten Otte55148542006-03-25 03:08:22 -08001455 psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1457 psinfo->pr_nice = task_nice(p);
1458 psinfo->pr_flag = p->flags;
David Howellsc69e8d92008-11-14 10:39:19 +11001459 rcu_read_lock();
1460 cred = __task_cred(p);
Eric W. Biedermanebc887b2012-02-07 18:36:10 -08001461 SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
1462 SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
David Howellsc69e8d92008-11-14 10:39:19 +11001463 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1465
1466 return 0;
1467}
1468
Roland McGrath3aba4812008-01-30 13:31:44 +01001469static void fill_auxv_note(struct memelfnote *note, struct mm_struct *mm)
1470{
1471 elf_addr_t *auxv = (elf_addr_t *) mm->saved_auxv;
1472 int i = 0;
1473 do
1474 i += 2;
1475 while (auxv[i - 2] != AT_NULL);
1476 fill_note(note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);
1477}
1478
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001479static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,
Al Viroce395962013-10-13 17:23:53 -04001480 const siginfo_t *siginfo)
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001481{
1482 mm_segment_t old_fs = get_fs();
1483 set_fs(KERNEL_DS);
1484 copy_siginfo_to_user((user_siginfo_t __user *) csigdata, siginfo);
1485 set_fs(old_fs);
1486 fill_note(note, "CORE", NT_SIGINFO, sizeof(*csigdata), csigdata);
1487}
1488
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001489#define MAX_FILE_NOTE_SIZE (4*1024*1024)
1490/*
1491 * Format of NT_FILE note:
1492 *
1493 * long count -- how many files are mapped
1494 * long page_size -- units for file_ofs
1495 * array of [COUNT] elements of
1496 * long start
1497 * long end
1498 * long file_ofs
1499 * followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1500 */
Dan Aloni72023652013-09-30 13:45:02 -07001501static int fill_files_note(struct memelfnote *note)
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001502{
1503 struct vm_area_struct *vma;
1504 unsigned count, size, names_ofs, remaining, n;
1505 user_long_t *data;
1506 user_long_t *start_end_ofs;
1507 char *name_base, *name_curpos;
1508
1509 /* *Estimated* file count and total data size needed */
1510 count = current->mm->map_count;
1511 size = count * 64;
1512
1513 names_ofs = (2 + 3 * count) * sizeof(data[0]);
1514 alloc:
1515 if (size >= MAX_FILE_NOTE_SIZE) /* paranoia check */
Dan Aloni72023652013-09-30 13:45:02 -07001516 return -EINVAL;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001517 size = round_up(size, PAGE_SIZE);
1518 data = vmalloc(size);
1519 if (!data)
Dan Aloni72023652013-09-30 13:45:02 -07001520 return -ENOMEM;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001521
1522 start_end_ofs = data + 2;
1523 name_base = name_curpos = ((char *)data) + names_ofs;
1524 remaining = size - names_ofs;
1525 count = 0;
1526 for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1527 struct file *file;
1528 const char *filename;
1529
1530 file = vma->vm_file;
1531 if (!file)
1532 continue;
1533 filename = d_path(&file->f_path, name_curpos, remaining);
1534 if (IS_ERR(filename)) {
1535 if (PTR_ERR(filename) == -ENAMETOOLONG) {
1536 vfree(data);
1537 size = size * 5 / 4;
1538 goto alloc;
1539 }
1540 continue;
1541 }
1542
1543 /* d_path() fills at the end, move name down */
1544 /* n = strlen(filename) + 1: */
1545 n = (name_curpos + remaining) - filename;
1546 remaining = filename - name_curpos;
1547 memmove(name_curpos, filename, n);
1548 name_curpos += n;
1549
1550 *start_end_ofs++ = vma->vm_start;
1551 *start_end_ofs++ = vma->vm_end;
1552 *start_end_ofs++ = vma->vm_pgoff;
1553 count++;
1554 }
1555
1556 /* Now we know exact count of files, can store it */
1557 data[0] = count;
1558 data[1] = PAGE_SIZE;
1559 /*
1560 * Count usually is less than current->mm->map_count,
1561 * we need to move filenames down.
1562 */
1563 n = current->mm->map_count - count;
1564 if (n != 0) {
1565 unsigned shift_bytes = n * 3 * sizeof(data[0]);
1566 memmove(name_base - shift_bytes, name_base,
1567 name_curpos - name_base);
1568 name_curpos -= shift_bytes;
1569 }
1570
1571 size = name_curpos - (char *)data;
1572 fill_note(note, "CORE", NT_FILE, size, data);
Dan Aloni72023652013-09-30 13:45:02 -07001573 return 0;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001574}
1575
Roland McGrath4206d3a2008-01-30 13:31:45 +01001576#ifdef CORE_DUMP_USE_REGSET
1577#include <linux/regset.h>
1578
1579struct elf_thread_core_info {
1580 struct elf_thread_core_info *next;
1581 struct task_struct *task;
1582 struct elf_prstatus prstatus;
1583 struct memelfnote notes[0];
1584};
1585
1586struct elf_note_info {
1587 struct elf_thread_core_info *thread;
1588 struct memelfnote psinfo;
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001589 struct memelfnote signote;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001590 struct memelfnote auxv;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001591 struct memelfnote files;
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001592 user_siginfo_t csigdata;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001593 size_t size;
1594 int thread_notes;
1595};
1596
Roland McGrathd31472b2008-03-04 14:28:30 -08001597/*
1598 * When a regset has a writeback hook, we call it on each thread before
1599 * dumping user memory. On register window machines, this makes sure the
1600 * user memory backing the register data is up to date before we read it.
1601 */
1602static void do_thread_regset_writeback(struct task_struct *task,
1603 const struct user_regset *regset)
1604{
1605 if (regset->writeback)
1606 regset->writeback(task, regset, 1);
1607}
1608
H. J. Lu0953f65d2012-02-14 13:34:52 -08001609#ifndef PR_REG_SIZE
1610#define PR_REG_SIZE(S) sizeof(S)
1611#endif
1612
1613#ifndef PRSTATUS_SIZE
1614#define PRSTATUS_SIZE(S) sizeof(S)
1615#endif
1616
1617#ifndef PR_REG_PTR
1618#define PR_REG_PTR(S) (&((S)->pr_reg))
1619#endif
1620
1621#ifndef SET_PR_FPVALID
1622#define SET_PR_FPVALID(S, V) ((S)->pr_fpvalid = (V))
1623#endif
1624
Roland McGrath4206d3a2008-01-30 13:31:45 +01001625static int fill_thread_core_info(struct elf_thread_core_info *t,
1626 const struct user_regset_view *view,
1627 long signr, size_t *total)
1628{
1629 unsigned int i;
1630
1631 /*
1632 * NT_PRSTATUS is the one special case, because the regset data
1633 * goes into the pr_reg field inside the note contents, rather
1634 * than being the whole note contents. We fill the reset in here.
1635 * We assume that regset 0 is NT_PRSTATUS.
1636 */
1637 fill_prstatus(&t->prstatus, t->task, signr);
1638 (void) view->regsets[0].get(t->task, &view->regsets[0],
H. J. Lu0953f65d2012-02-14 13:34:52 -08001639 0, PR_REG_SIZE(t->prstatus.pr_reg),
1640 PR_REG_PTR(&t->prstatus), NULL);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001641
1642 fill_note(&t->notes[0], "CORE", NT_PRSTATUS,
H. J. Lu0953f65d2012-02-14 13:34:52 -08001643 PRSTATUS_SIZE(t->prstatus), &t->prstatus);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001644 *total += notesize(&t->notes[0]);
1645
Roland McGrathd31472b2008-03-04 14:28:30 -08001646 do_thread_regset_writeback(t->task, &view->regsets[0]);
1647
Roland McGrath4206d3a2008-01-30 13:31:45 +01001648 /*
1649 * Each other regset might generate a note too. For each regset
1650 * that has no core_note_type or is inactive, we leave t->notes[i]
1651 * all zero and we'll know to skip writing it later.
1652 */
1653 for (i = 1; i < view->n; ++i) {
1654 const struct user_regset *regset = &view->regsets[i];
Roland McGrathd31472b2008-03-04 14:28:30 -08001655 do_thread_regset_writeback(t->task, regset);
H. Peter Anvinc8e25252012-03-02 10:43:48 -08001656 if (regset->core_note_type && regset->get &&
Roland McGrath4206d3a2008-01-30 13:31:45 +01001657 (!regset->active || regset->active(t->task, regset))) {
1658 int ret;
1659 size_t size = regset->n * regset->size;
1660 void *data = kmalloc(size, GFP_KERNEL);
1661 if (unlikely(!data))
1662 return 0;
1663 ret = regset->get(t->task, regset,
1664 0, size, data, NULL);
1665 if (unlikely(ret))
1666 kfree(data);
1667 else {
1668 if (regset->core_note_type != NT_PRFPREG)
1669 fill_note(&t->notes[i], "LINUX",
1670 regset->core_note_type,
1671 size, data);
1672 else {
H. J. Lu0953f65d2012-02-14 13:34:52 -08001673 SET_PR_FPVALID(&t->prstatus, 1);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001674 fill_note(&t->notes[i], "CORE",
1675 NT_PRFPREG, size, data);
1676 }
1677 *total += notesize(&t->notes[i]);
1678 }
1679 }
1680 }
1681
1682 return 1;
1683}
1684
1685static int fill_note_info(struct elfhdr *elf, int phdrs,
1686 struct elf_note_info *info,
Al Viroec579412013-10-13 17:57:29 -04001687 const siginfo_t *siginfo, struct pt_regs *regs)
Roland McGrath4206d3a2008-01-30 13:31:45 +01001688{
1689 struct task_struct *dump_task = current;
1690 const struct user_regset_view *view = task_user_regset_view(dump_task);
1691 struct elf_thread_core_info *t;
1692 struct elf_prpsinfo *psinfo;
Oleg Nesterov83914442008-07-25 01:47:45 -07001693 struct core_thread *ct;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001694 unsigned int i;
1695
1696 info->size = 0;
1697 info->thread = NULL;
1698
1699 psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
Alan Cox6899e922012-12-17 16:02:09 -08001700 if (psinfo == NULL) {
1701 info->psinfo.data = NULL; /* So we don't free this wrongly */
Roland McGrath4206d3a2008-01-30 13:31:45 +01001702 return 0;
Alan Cox6899e922012-12-17 16:02:09 -08001703 }
Roland McGrath4206d3a2008-01-30 13:31:45 +01001704
Amerigo Wange2dbe122009-07-01 01:06:26 -04001705 fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1706
Roland McGrath4206d3a2008-01-30 13:31:45 +01001707 /*
1708 * Figure out how many notes we're going to need for each thread.
1709 */
1710 info->thread_notes = 0;
1711 for (i = 0; i < view->n; ++i)
1712 if (view->regsets[i].core_note_type != 0)
1713 ++info->thread_notes;
1714
1715 /*
1716 * Sanity check. We rely on regset 0 being in NT_PRSTATUS,
1717 * since it is our one special case.
1718 */
1719 if (unlikely(info->thread_notes == 0) ||
1720 unlikely(view->regsets[0].core_note_type != NT_PRSTATUS)) {
1721 WARN_ON(1);
1722 return 0;
1723 }
1724
1725 /*
1726 * Initialize the ELF file header.
1727 */
1728 fill_elf_header(elf, phdrs,
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08001729 view->e_machine, view->e_flags);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001730
1731 /*
1732 * Allocate a structure for each thread.
1733 */
Oleg Nesterov83914442008-07-25 01:47:45 -07001734 for (ct = &dump_task->mm->core_state->dumper; ct; ct = ct->next) {
1735 t = kzalloc(offsetof(struct elf_thread_core_info,
1736 notes[info->thread_notes]),
1737 GFP_KERNEL);
1738 if (unlikely(!t))
1739 return 0;
Oleg Nesterov24d52882008-07-25 01:47:40 -07001740
Oleg Nesterov83914442008-07-25 01:47:45 -07001741 t->task = ct->task;
1742 if (ct->task == dump_task || !info->thread) {
1743 t->next = info->thread;
1744 info->thread = t;
1745 } else {
1746 /*
1747 * Make sure to keep the original task at
1748 * the head of the list.
1749 */
1750 t->next = info->thread->next;
1751 info->thread->next = t;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001752 }
Oleg Nesterov83914442008-07-25 01:47:45 -07001753 }
Roland McGrath4206d3a2008-01-30 13:31:45 +01001754
1755 /*
1756 * Now fill in each thread's information.
1757 */
1758 for (t = info->thread; t != NULL; t = t->next)
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001759 if (!fill_thread_core_info(t, view, siginfo->si_signo, &info->size))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001760 return 0;
1761
1762 /*
1763 * Fill in the two process-wide notes.
1764 */
1765 fill_psinfo(psinfo, dump_task->group_leader, dump_task->mm);
1766 info->size += notesize(&info->psinfo);
1767
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001768 fill_siginfo_note(&info->signote, &info->csigdata, siginfo);
1769 info->size += notesize(&info->signote);
1770
Roland McGrath4206d3a2008-01-30 13:31:45 +01001771 fill_auxv_note(&info->auxv, current->mm);
1772 info->size += notesize(&info->auxv);
1773
Dan Aloni72023652013-09-30 13:45:02 -07001774 if (fill_files_note(&info->files) == 0)
1775 info->size += notesize(&info->files);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001776
Roland McGrath4206d3a2008-01-30 13:31:45 +01001777 return 1;
1778}
1779
1780static size_t get_note_info_size(struct elf_note_info *info)
1781{
1782 return info->size;
1783}
1784
1785/*
1786 * Write all the notes for each thread. When writing the first thread, the
1787 * process-wide notes are interleaved after the first thread-specific note.
1788 */
1789static int write_note_info(struct elf_note_info *info,
Al Viroecc8c772013-10-05 15:32:35 -04001790 struct coredump_params *cprm)
Roland McGrath4206d3a2008-01-30 13:31:45 +01001791{
Fabian Frederickb219e252014-06-04 16:12:14 -07001792 bool first = true;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001793 struct elf_thread_core_info *t = info->thread;
1794
1795 do {
1796 int i;
1797
Al Viroecc8c772013-10-05 15:32:35 -04001798 if (!writenote(&t->notes[0], cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001799 return 0;
1800
Al Viroecc8c772013-10-05 15:32:35 -04001801 if (first && !writenote(&info->psinfo, cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001802 return 0;
Al Viroecc8c772013-10-05 15:32:35 -04001803 if (first && !writenote(&info->signote, cprm))
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001804 return 0;
Al Viroecc8c772013-10-05 15:32:35 -04001805 if (first && !writenote(&info->auxv, cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001806 return 0;
Dan Aloni72023652013-09-30 13:45:02 -07001807 if (first && info->files.data &&
Al Viroecc8c772013-10-05 15:32:35 -04001808 !writenote(&info->files, cprm))
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001809 return 0;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001810
1811 for (i = 1; i < info->thread_notes; ++i)
1812 if (t->notes[i].data &&
Al Viroecc8c772013-10-05 15:32:35 -04001813 !writenote(&t->notes[i], cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001814 return 0;
1815
Fabian Frederickb219e252014-06-04 16:12:14 -07001816 first = false;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001817 t = t->next;
1818 } while (t);
1819
1820 return 1;
1821}
1822
1823static void free_note_info(struct elf_note_info *info)
1824{
1825 struct elf_thread_core_info *threads = info->thread;
1826 while (threads) {
1827 unsigned int i;
1828 struct elf_thread_core_info *t = threads;
1829 threads = t->next;
1830 WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);
1831 for (i = 1; i < info->thread_notes; ++i)
1832 kfree(t->notes[i].data);
1833 kfree(t);
1834 }
1835 kfree(info->psinfo.data);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001836 vfree(info->files.data);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001837}
1838
1839#else
1840
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841/* Here is the structure in which status of each thread is captured. */
1842struct elf_thread_status
1843{
1844 struct list_head list;
1845 struct elf_prstatus prstatus; /* NT_PRSTATUS */
1846 elf_fpregset_t fpu; /* NT_PRFPREG */
1847 struct task_struct *thread;
1848#ifdef ELF_CORE_COPY_XFPREGS
Mark Nelson5b20cd82007-10-16 23:25:39 -07001849 elf_fpxregset_t xfpu; /* ELF_CORE_XFPREG_TYPE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850#endif
1851 struct memelfnote notes[3];
1852 int num_notes;
1853};
1854
1855/*
1856 * In order to add the specific thread information for the elf file format,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001857 * we need to keep a linked list of every threads pr_status and then create
1858 * a single section for them in the final core file.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 */
1860static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1861{
1862 int sz = 0;
1863 struct task_struct *p = t->thread;
1864 t->num_notes = 0;
1865
1866 fill_prstatus(&t->prstatus, p, signr);
1867 elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1868
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001869 fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1870 &(t->prstatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 t->num_notes++;
1872 sz += notesize(&t->notes[0]);
1873
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001874 if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1875 &t->fpu))) {
1876 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1877 &(t->fpu));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 t->num_notes++;
1879 sz += notesize(&t->notes[1]);
1880 }
1881
1882#ifdef ELF_CORE_COPY_XFPREGS
1883 if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
Mark Nelson5b20cd82007-10-16 23:25:39 -07001884 fill_note(&t->notes[2], "LINUX", ELF_CORE_XFPREG_TYPE,
1885 sizeof(t->xfpu), &t->xfpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886 t->num_notes++;
1887 sz += notesize(&t->notes[2]);
1888 }
1889#endif
1890 return sz;
1891}
1892
Roland McGrath3aba4812008-01-30 13:31:44 +01001893struct elf_note_info {
1894 struct memelfnote *notes;
Dan Aloni72023652013-09-30 13:45:02 -07001895 struct memelfnote *notes_files;
Roland McGrath3aba4812008-01-30 13:31:44 +01001896 struct elf_prstatus *prstatus; /* NT_PRSTATUS */
1897 struct elf_prpsinfo *psinfo; /* NT_PRPSINFO */
1898 struct list_head thread_list;
1899 elf_fpregset_t *fpu;
1900#ifdef ELF_CORE_COPY_XFPREGS
1901 elf_fpxregset_t *xfpu;
1902#endif
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001903 user_siginfo_t csigdata;
Roland McGrath3aba4812008-01-30 13:31:44 +01001904 int thread_status_size;
1905 int numnote;
1906};
1907
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001908static int elf_note_info_init(struct elf_note_info *info)
Roland McGrath3aba4812008-01-30 13:31:44 +01001909{
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001910 memset(info, 0, sizeof(*info));
Roland McGrath3aba4812008-01-30 13:31:44 +01001911 INIT_LIST_HEAD(&info->thread_list);
1912
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001913 /* Allocate space for ELF notes */
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001914 info->notes = kmalloc(8 * sizeof(struct memelfnote), GFP_KERNEL);
Roland McGrath3aba4812008-01-30 13:31:44 +01001915 if (!info->notes)
1916 return 0;
1917 info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL);
1918 if (!info->psinfo)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001919 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001920 info->prstatus = kmalloc(sizeof(*info->prstatus), GFP_KERNEL);
1921 if (!info->prstatus)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001922 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001923 info->fpu = kmalloc(sizeof(*info->fpu), GFP_KERNEL);
1924 if (!info->fpu)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001925 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001926#ifdef ELF_CORE_COPY_XFPREGS
1927 info->xfpu = kmalloc(sizeof(*info->xfpu), GFP_KERNEL);
1928 if (!info->xfpu)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001929 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001930#endif
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001931 return 1;
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001932}
Roland McGrath3aba4812008-01-30 13:31:44 +01001933
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001934static int fill_note_info(struct elfhdr *elf, int phdrs,
1935 struct elf_note_info *info,
Al Viroec579412013-10-13 17:57:29 -04001936 const siginfo_t *siginfo, struct pt_regs *regs)
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001937{
1938 struct list_head *t;
Al Viroafabada2013-10-14 07:39:56 -04001939 struct core_thread *ct;
1940 struct elf_thread_status *ets;
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001941
1942 if (!elf_note_info_init(info))
1943 return 0;
1944
Al Viroafabada2013-10-14 07:39:56 -04001945 for (ct = current->mm->core_state->dumper.next;
1946 ct; ct = ct->next) {
1947 ets = kzalloc(sizeof(*ets), GFP_KERNEL);
1948 if (!ets)
1949 return 0;
Oleg Nesterov24d52882008-07-25 01:47:40 -07001950
Al Viroafabada2013-10-14 07:39:56 -04001951 ets->thread = ct->task;
1952 list_add(&ets->list, &info->thread_list);
1953 }
Oleg Nesterov83914442008-07-25 01:47:45 -07001954
Al Viroafabada2013-10-14 07:39:56 -04001955 list_for_each(t, &info->thread_list) {
1956 int sz;
Oleg Nesterov83914442008-07-25 01:47:45 -07001957
Al Viroafabada2013-10-14 07:39:56 -04001958 ets = list_entry(t, struct elf_thread_status, list);
1959 sz = elf_dump_thread_status(siginfo->si_signo, ets);
1960 info->thread_status_size += sz;
Roland McGrath3aba4812008-01-30 13:31:44 +01001961 }
1962 /* now collect the dump for the current */
1963 memset(info->prstatus, 0, sizeof(*info->prstatus));
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001964 fill_prstatus(info->prstatus, current, siginfo->si_signo);
Roland McGrath3aba4812008-01-30 13:31:44 +01001965 elf_core_copy_regs(&info->prstatus->pr_reg, regs);
1966
1967 /* Set up header */
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08001968 fill_elf_header(elf, phdrs, ELF_ARCH, ELF_CORE_EFLAGS);
Roland McGrath3aba4812008-01-30 13:31:44 +01001969
1970 /*
1971 * Set up the notes in similar form to SVR4 core dumps made
1972 * with info from their /proc.
1973 */
1974
1975 fill_note(info->notes + 0, "CORE", NT_PRSTATUS,
1976 sizeof(*info->prstatus), info->prstatus);
1977 fill_psinfo(info->psinfo, current->group_leader, current->mm);
1978 fill_note(info->notes + 1, "CORE", NT_PRPSINFO,
1979 sizeof(*info->psinfo), info->psinfo);
1980
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001981 fill_siginfo_note(info->notes + 2, &info->csigdata, siginfo);
1982 fill_auxv_note(info->notes + 3, current->mm);
Dan Aloni72023652013-09-30 13:45:02 -07001983 info->numnote = 4;
Roland McGrath3aba4812008-01-30 13:31:44 +01001984
Dan Aloni72023652013-09-30 13:45:02 -07001985 if (fill_files_note(info->notes + info->numnote) == 0) {
1986 info->notes_files = info->notes + info->numnote;
1987 info->numnote++;
1988 }
Roland McGrath3aba4812008-01-30 13:31:44 +01001989
1990 /* Try to dump the FPU. */
1991 info->prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs,
1992 info->fpu);
1993 if (info->prstatus->pr_fpvalid)
1994 fill_note(info->notes + info->numnote++,
1995 "CORE", NT_PRFPREG, sizeof(*info->fpu), info->fpu);
1996#ifdef ELF_CORE_COPY_XFPREGS
1997 if (elf_core_copy_task_xfpregs(current, info->xfpu))
1998 fill_note(info->notes + info->numnote++,
1999 "LINUX", ELF_CORE_XFPREG_TYPE,
2000 sizeof(*info->xfpu), info->xfpu);
2001#endif
2002
2003 return 1;
Roland McGrath3aba4812008-01-30 13:31:44 +01002004}
2005
2006static size_t get_note_info_size(struct elf_note_info *info)
2007{
2008 int sz = 0;
2009 int i;
2010
2011 for (i = 0; i < info->numnote; i++)
2012 sz += notesize(info->notes + i);
2013
2014 sz += info->thread_status_size;
2015
2016 return sz;
2017}
2018
2019static int write_note_info(struct elf_note_info *info,
Al Viroecc8c772013-10-05 15:32:35 -04002020 struct coredump_params *cprm)
Roland McGrath3aba4812008-01-30 13:31:44 +01002021{
2022 int i;
2023 struct list_head *t;
2024
2025 for (i = 0; i < info->numnote; i++)
Al Viroecc8c772013-10-05 15:32:35 -04002026 if (!writenote(info->notes + i, cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002027 return 0;
2028
2029 /* write out the thread status notes section */
2030 list_for_each(t, &info->thread_list) {
2031 struct elf_thread_status *tmp =
2032 list_entry(t, struct elf_thread_status, list);
2033
2034 for (i = 0; i < tmp->num_notes; i++)
Al Viroecc8c772013-10-05 15:32:35 -04002035 if (!writenote(&tmp->notes[i], cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002036 return 0;
2037 }
2038
2039 return 1;
2040}
2041
2042static void free_note_info(struct elf_note_info *info)
2043{
2044 while (!list_empty(&info->thread_list)) {
2045 struct list_head *tmp = info->thread_list.next;
2046 list_del(tmp);
2047 kfree(list_entry(tmp, struct elf_thread_status, list));
2048 }
2049
Dan Aloni72023652013-09-30 13:45:02 -07002050 /* Free data possibly allocated by fill_files_note(): */
2051 if (info->notes_files)
2052 vfree(info->notes_files->data);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07002053
Roland McGrath3aba4812008-01-30 13:31:44 +01002054 kfree(info->prstatus);
2055 kfree(info->psinfo);
2056 kfree(info->notes);
2057 kfree(info->fpu);
2058#ifdef ELF_CORE_COPY_XFPREGS
2059 kfree(info->xfpu);
2060#endif
2061}
2062
Roland McGrath4206d3a2008-01-30 13:31:45 +01002063#endif
2064
Roland McGrathf47aef52007-01-26 00:56:49 -08002065static struct vm_area_struct *first_vma(struct task_struct *tsk,
2066 struct vm_area_struct *gate_vma)
2067{
2068 struct vm_area_struct *ret = tsk->mm->mmap;
2069
2070 if (ret)
2071 return ret;
2072 return gate_vma;
2073}
2074/*
2075 * Helper function for iterating across a vma list. It ensures that the caller
2076 * will visit `gate_vma' prior to terminating the search.
2077 */
2078static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
2079 struct vm_area_struct *gate_vma)
2080{
2081 struct vm_area_struct *ret;
2082
2083 ret = this_vma->vm_next;
2084 if (ret)
2085 return ret;
2086 if (this_vma == gate_vma)
2087 return NULL;
2088 return gate_vma;
2089}
2090
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002091static void fill_extnum_info(struct elfhdr *elf, struct elf_shdr *shdr4extnum,
2092 elf_addr_t e_shoff, int segs)
2093{
2094 elf->e_shoff = e_shoff;
2095 elf->e_shentsize = sizeof(*shdr4extnum);
2096 elf->e_shnum = 1;
2097 elf->e_shstrndx = SHN_UNDEF;
2098
2099 memset(shdr4extnum, 0, sizeof(*shdr4extnum));
2100
2101 shdr4extnum->sh_type = SHT_NULL;
2102 shdr4extnum->sh_size = elf->e_shnum;
2103 shdr4extnum->sh_link = elf->e_shstrndx;
2104 shdr4extnum->sh_info = segs;
2105}
2106
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107/*
2108 * Actual dumper
2109 *
2110 * This is a two-pass process; first we find the offsets of the bits,
2111 * and then they are actually written out. If we run out of core limit
2112 * we just truncate.
2113 */
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002114static int elf_core_dump(struct coredump_params *cprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 int has_dumped = 0;
2117 mm_segment_t fs;
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002118 int segs, i;
2119 size_t vma_data_size = 0;
Roland McGrathf47aef52007-01-26 00:56:49 -08002120 struct vm_area_struct *vma, *gate_vma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121 struct elfhdr *elf = NULL;
Al Virocdc3d562013-10-05 22:24:29 -04002122 loff_t offset = 0, dataoff;
Dan Aloni72023652013-09-30 13:45:02 -07002123 struct elf_note_info info = { };
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002124 struct elf_phdr *phdr4note = NULL;
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002125 struct elf_shdr *shdr4extnum = NULL;
2126 Elf_Half e_phnum;
2127 elf_addr_t e_shoff;
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002128 elf_addr_t *vma_filesz = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129
2130 /*
2131 * We no longer stop all VM operations.
2132 *
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002133 * This is because those proceses that could possibly change map_count
2134 * or the mmap / vma pages are now blocked in do_exit on current
2135 * finishing this core dump.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136 *
2137 * Only ptrace can touch these memory addresses, but it doesn't change
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002138 * the map_count or the pages allocated. So no possibility of crashing
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139 * exists while dumping the mm->vm_next areas to the core file.
2140 */
2141
2142 /* alloc memory for large data structures: too large to be on stack */
2143 elf = kmalloc(sizeof(*elf), GFP_KERNEL);
2144 if (!elf)
WANG Cong5f719552008-05-06 12:45:35 +08002145 goto out;
KAMEZAWA Hiroyuki341c87b2009-06-30 11:41:23 -07002146 /*
2147 * The number of segs are recored into ELF header as 16bit value.
2148 * Please check DEFAULT_MAX_MAP_COUNT definition when you modify here.
2149 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150 segs = current->mm->map_count;
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002151 segs += elf_core_extra_phdrs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152
Stephen Wilson31db58b2011-03-13 15:49:15 -04002153 gate_vma = get_gate_vma(current->mm);
Roland McGrathf47aef52007-01-26 00:56:49 -08002154 if (gate_vma != NULL)
2155 segs++;
2156
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002157 /* for notes section */
2158 segs++;
2159
2160 /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
2161 * this, kernel supports extended numbering. Have a look at
2162 * include/linux/elf.h for further information. */
2163 e_phnum = segs > PN_XNUM ? PN_XNUM : segs;
2164
Roland McGrath3aba4812008-01-30 13:31:44 +01002165 /*
2166 * Collect all the non-memory information about the process for the
2167 * notes. This also sets up the file header.
2168 */
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07002169 if (!fill_note_info(elf, e_phnum, &info, cprm->siginfo, cprm->regs))
Roland McGrath3aba4812008-01-30 13:31:44 +01002170 goto cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171
2172 has_dumped = 1;
Oleg Nesterov079148b2013-04-30 15:28:16 -07002173
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 fs = get_fs();
2175 set_fs(KERNEL_DS);
2176
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 offset += sizeof(*elf); /* Elf header */
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002178 offset += segs * sizeof(struct elf_phdr); /* Program headers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179
2180 /* Write notes phdr entry */
2181 {
Roland McGrath3aba4812008-01-30 13:31:44 +01002182 size_t sz = get_note_info_size(&info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183
Michael Ellermane5501492007-09-19 14:38:12 +10002184 sz += elf_coredump_extra_notes_size();
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002185
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002186 phdr4note = kmalloc(sizeof(*phdr4note), GFP_KERNEL);
2187 if (!phdr4note)
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -08002188 goto end_coredump;
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002189
2190 fill_elf_note_phdr(phdr4note, sz, offset);
2191 offset += sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 }
2193
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194 dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
2195
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002196 vma_filesz = kmalloc_array(segs - 1, sizeof(*vma_filesz), GFP_KERNEL);
2197 if (!vma_filesz)
2198 goto end_coredump;
2199
2200 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2201 vma = next_vma(vma, gate_vma)) {
2202 unsigned long dump_size;
2203
2204 dump_size = vma_dump_size(vma, cprm->mm_flags);
2205 vma_filesz[i++] = dump_size;
2206 vma_data_size += dump_size;
2207 }
2208
2209 offset += vma_data_size;
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002210 offset += elf_core_extra_data_size();
2211 e_shoff = offset;
2212
2213 if (e_phnum == PN_XNUM) {
2214 shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);
2215 if (!shdr4extnum)
2216 goto end_coredump;
2217 fill_extnum_info(elf, shdr4extnum, e_shoff, segs);
2218 }
2219
2220 offset = dataoff;
2221
Al Viroecc8c772013-10-05 15:32:35 -04002222 if (!dump_emit(cprm, elf, sizeof(*elf)))
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002223 goto end_coredump;
2224
Al Viroecc8c772013-10-05 15:32:35 -04002225 if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note)))
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002226 goto end_coredump;
2227
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 /* Write program headers for segments dump */
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002229 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
Roland McGrathf47aef52007-01-26 00:56:49 -08002230 vma = next_vma(vma, gate_vma)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231 struct elf_phdr phdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232
2233 phdr.p_type = PT_LOAD;
2234 phdr.p_offset = offset;
2235 phdr.p_vaddr = vma->vm_start;
2236 phdr.p_paddr = 0;
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002237 phdr.p_filesz = vma_filesz[i++];
Roland McGrath82df3972007-10-16 23:27:02 -07002238 phdr.p_memsz = vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239 offset += phdr.p_filesz;
2240 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002241 if (vma->vm_flags & VM_WRITE)
2242 phdr.p_flags |= PF_W;
2243 if (vma->vm_flags & VM_EXEC)
2244 phdr.p_flags |= PF_X;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 phdr.p_align = ELF_EXEC_PAGESIZE;
2246
Al Viroecc8c772013-10-05 15:32:35 -04002247 if (!dump_emit(cprm, &phdr, sizeof(phdr)))
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -08002248 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 }
2250
Al Viro506f21c2013-10-05 17:22:57 -04002251 if (!elf_core_write_extra_phdrs(cprm, offset))
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002252 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253
2254 /* write out the notes section */
Al Viroecc8c772013-10-05 15:32:35 -04002255 if (!write_note_info(&info, cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002256 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257
Al Virocdc3d562013-10-05 22:24:29 -04002258 if (elf_coredump_extra_notes_write(cprm))
Michael Ellermane5501492007-09-19 14:38:12 +10002259 goto end_coredump;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002260
Andi Kleend025c9d2006-09-30 23:29:28 -07002261 /* Align to page */
Al Viro9b56d542013-10-08 09:26:08 -04002262 if (!dump_skip(cprm, dataoff - cprm->written))
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002263 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002265 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
Roland McGrathf47aef52007-01-26 00:56:49 -08002266 vma = next_vma(vma, gate_vma)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267 unsigned long addr;
Roland McGrath82df3972007-10-16 23:27:02 -07002268 unsigned long end;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002269
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002270 end = vma->vm_start + vma_filesz[i++];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271
Roland McGrath82df3972007-10-16 23:27:02 -07002272 for (addr = vma->vm_start; addr < end; addr += PAGE_SIZE) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002273 struct page *page;
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002274 int stop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002276 page = get_dump_page(addr);
2277 if (page) {
2278 void *kaddr = kmap(page);
Al Viro13046ec2013-10-05 18:08:47 -04002279 stop = !dump_emit(cprm, kaddr, PAGE_SIZE);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002280 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281 page_cache_release(page);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002282 } else
Al Viro9b56d542013-10-08 09:26:08 -04002283 stop = !dump_skip(cprm, PAGE_SIZE);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002284 if (stop)
2285 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286 }
2287 }
2288
Al Viroaa3e7ea2013-10-05 17:50:15 -04002289 if (!elf_core_write_extra_data(cprm))
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002290 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002292 if (e_phnum == PN_XNUM) {
Al Viro13046ec2013-10-05 18:08:47 -04002293 if (!dump_emit(cprm, shdr4extnum, sizeof(*shdr4extnum)))
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002294 goto end_coredump;
2295 }
2296
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297end_coredump:
2298 set_fs(fs);
2299
2300cleanup:
Roland McGrath3aba4812008-01-30 13:31:44 +01002301 free_note_info(&info);
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002302 kfree(shdr4extnum);
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002303 kfree(vma_filesz);
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");