blob: e158b22ef32f16d2fcf61c29fbf6d15a65581c1e [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>
Ross Zwisler50378352015-10-05 16:33:36 -060038#include <linux/dax.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <asm/uaccess.h>
40#include <asm/param.h>
41#include <asm/page.h>
42
Denys Vlasenko2aa362c2012-10-04 17:15:36 -070043#ifndef user_long_t
44#define user_long_t long
45#endif
Denys Vlasenko49ae4d42012-10-04 17:15:35 -070046#ifndef user_siginfo_t
47#define user_siginfo_t siginfo_t
48#endif
49
Al Viro71613c32012-10-20 22:00:48 -040050static int load_elf_binary(struct linux_binprm *bprm);
Andrew Mortonbb1ad822008-01-30 13:31:07 +010051static unsigned long elf_map(struct file *, unsigned long, struct elf_phdr *,
52 int, int, unsigned long);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Josh Triplett69369a72014-04-03 14:48:27 -070054#ifdef CONFIG_USELIB
55static int load_elf_library(struct file *);
56#else
57#define load_elf_library NULL
58#endif
59
Linus Torvalds1da177e2005-04-16 15:20:36 -070060/*
61 * If we don't support core dumping, then supply a NULL so we
62 * don't even try.
63 */
Christoph Hellwig698ba7b2009-12-15 16:47:37 -080064#ifdef CONFIG_ELF_CORE
Masami Hiramatsuf6151df2009-12-17 15:27:16 -080065static int elf_core_dump(struct coredump_params *cprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#else
67#define elf_core_dump NULL
68#endif
69
70#if ELF_EXEC_PAGESIZE > PAGE_SIZE
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070071#define ELF_MIN_ALIGN ELF_EXEC_PAGESIZE
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#else
Jesper Juhlf4e5cc22006-06-23 02:05:35 -070073#define ELF_MIN_ALIGN PAGE_SIZE
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#endif
75
76#ifndef ELF_CORE_EFLAGS
77#define ELF_CORE_EFLAGS 0
78#endif
79
80#define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
81#define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
82#define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
83
84static struct linux_binfmt elf_format = {
Mikael Petterssonf670d0e2011-01-12 17:00:02 -080085 .module = THIS_MODULE,
86 .load_binary = load_elf_binary,
87 .load_shlib = load_elf_library,
88 .core_dump = elf_core_dump,
89 .min_coredump = ELF_EXEC_PAGESIZE,
Linus Torvalds1da177e2005-04-16 15:20:36 -070090};
91
Andrew Mortond4e3cc32007-07-21 04:37:32 -070092#define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
94static int set_brk(unsigned long start, unsigned long end)
95{
96 start = ELF_PAGEALIGN(start);
97 end = ELF_PAGEALIGN(end);
98 if (end > start) {
Linus Torvalds5d22fc22016-05-27 15:57:31 -070099 int error = vm_brk(start, end - start);
100 if (error)
101 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 }
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/**
Maciej W. Rozycki54d157142015-10-26 15:47:57 +0000490 * arch_check_elf() - check an ELF executable
Paul Burton774c1052014-09-11 08:30:16 +0100491 * @ehdr: The main ELF header
492 * @has_interp: True if the ELF has an interpreter, else false.
Maciej W. Rozyckieb4bc072015-11-13 00:47:48 +0000493 * @interp_ehdr: The interpreter's ELF header
Paul Burton774c1052014-09-11 08:30:16 +0100494 * @state: Architecture-specific state preserved throughout the process
495 * of loading the ELF.
496 *
497 * Provides a final opportunity for architecture code to reject the loading
498 * of the ELF & cause an exec syscall to return an error. This is called after
499 * all program headers to be checked by arch_elf_pt_proc have been.
500 *
501 * Return: Zero to proceed with the ELF load, non-zero to fail the ELF load
502 * with that return code.
503 */
504static inline int arch_check_elf(struct elfhdr *ehdr, bool has_interp,
Maciej W. Rozyckieb4bc072015-11-13 00:47:48 +0000505 struct elfhdr *interp_ehdr,
Paul Burton774c1052014-09-11 08:30:16 +0100506 struct arch_elf_state *state)
507{
508 /* Dummy implementation, always proceed */
509 return 0;
510}
511
512#endif /* !CONFIG_ARCH_BINFMT_ELF_STATE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
514/* This is much more generalized than the library routine read function,
515 so we keep this separate. Technically the library read function
516 is only provided so that we can read a.out libraries that have
517 an ELF header */
518
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700519static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
Jiri Kosinacc503c12008-01-30 13:31:07 +0100520 struct file *interpreter, unsigned long *interp_map_addr,
Paul Burtona9d9ef12014-09-11 08:30:15 +0100521 unsigned long no_base, struct elf_phdr *interp_elf_phdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 struct elf_phdr *eppnt;
524 unsigned long load_addr = 0;
525 int load_addr_set = 0;
526 unsigned long last_bss = 0, elf_bss = 0;
527 unsigned long error = ~0UL;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100528 unsigned long total_size;
Paul Burton6a8d3892014-09-11 08:30:14 +0100529 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
531 /* First of all, some simple consistency checks */
532 if (interp_elf_ex->e_type != ET_EXEC &&
533 interp_elf_ex->e_type != ET_DYN)
534 goto out;
535 if (!elf_check_arch(interp_elf_ex))
536 goto out;
Al Viro72c2d532013-09-22 16:27:52 -0400537 if (!interpreter->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 goto out;
539
Paul Burtona9d9ef12014-09-11 08:30:15 +0100540 total_size = total_mapping_size(interp_elf_phdata,
541 interp_elf_ex->e_phnum);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100542 if (!total_size) {
543 error = -EINVAL;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100544 goto out;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100545 }
546
Paul Burtona9d9ef12014-09-11 08:30:15 +0100547 eppnt = interp_elf_phdata;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700548 for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
549 if (eppnt->p_type == PT_LOAD) {
550 int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
551 int elf_prot = 0;
552 unsigned long vaddr = 0;
553 unsigned long k, map_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700555 if (eppnt->p_flags & PF_R)
556 elf_prot = PROT_READ;
557 if (eppnt->p_flags & PF_W)
558 elf_prot |= PROT_WRITE;
559 if (eppnt->p_flags & PF_X)
560 elf_prot |= PROT_EXEC;
561 vaddr = eppnt->p_vaddr;
562 if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
563 elf_type |= MAP_FIXED;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100564 else if (no_base && interp_elf_ex->e_type == ET_DYN)
565 load_addr = -vaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700567 map_addr = elf_map(interpreter, load_addr + vaddr,
Andrew Mortonbb1ad822008-01-30 13:31:07 +0100568 eppnt, elf_prot, elf_type, total_size);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100569 total_size = 0;
570 if (!*interp_map_addr)
571 *interp_map_addr = map_addr;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700572 error = map_addr;
573 if (BAD_ADDR(map_addr))
Paul Burtona9d9ef12014-09-11 08:30:15 +0100574 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700576 if (!load_addr_set &&
577 interp_elf_ex->e_type == ET_DYN) {
578 load_addr = map_addr - ELF_PAGESTART(vaddr);
579 load_addr_set = 1;
580 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700582 /*
583 * Check to see if the section's size will overflow the
584 * allowed task size. Note that p_filesz must always be
585 * <= p_memsize so it's only necessary to check p_memsz.
586 */
587 k = load_addr + eppnt->p_vaddr;
Chuck Ebbertce510592006-07-03 00:24:14 -0700588 if (BAD_ADDR(k) ||
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700589 eppnt->p_filesz > eppnt->p_memsz ||
590 eppnt->p_memsz > TASK_SIZE ||
591 TASK_SIZE - eppnt->p_memsz < k) {
592 error = -ENOMEM;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100593 goto out;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700594 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700596 /*
597 * Find the end of the file mapping for this phdr, and
598 * keep track of the largest address we see for this.
599 */
600 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
601 if (k > elf_bss)
602 elf_bss = k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700604 /*
605 * Do the same thing for the memory mapping - between
606 * elf_bss and last_bss is the bss section.
607 */
608 k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
609 if (k > last_bss)
610 last_bss = k;
611 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 }
613
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 if (last_bss > elf_bss) {
Roland McGrath752015d2009-09-08 19:49:40 -0700615 /*
616 * Now fill out the bss section. First pad the last page up
617 * to the page boundary, and then perform a mmap to make sure
618 * that there are zero-mapped pages up to and including the
619 * last bss page.
620 */
621 if (padzero(elf_bss)) {
622 error = -EFAULT;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100623 goto out;
Roland McGrath752015d2009-09-08 19:49:40 -0700624 }
625
626 /* What we have mapped so far */
627 elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1);
628
629 /* Map the last of the bss segment */
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -0700630 error = vm_brk(elf_bss, last_bss - elf_bss);
Linus Torvalds5d22fc22016-05-27 15:57:31 -0700631 if (error)
Paul Burtona9d9ef12014-09-11 08:30:15 +0100632 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 }
634
Jiri Kosinacc503c12008-01-30 13:31:07 +0100635 error = load_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636out:
637 return error;
638}
639
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640/*
641 * These are the functions used to load ELF style executables and shared
642 * libraries. There is no binary dependent code anywhere else.
643 */
644
Andi Kleen913bd902006-03-25 16:29:09 +0100645#ifndef STACK_RND_MASK
James Bottomleyd1cabd62007-03-16 13:38:35 -0800646#define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12)) /* 8MB of VA */
Andi Kleen913bd902006-03-25 16:29:09 +0100647#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
649static unsigned long randomize_stack_top(unsigned long stack_top)
650{
Hector Marco-Gisbert4e7c22d2015-02-14 09:33:50 -0800651 unsigned long random_variable = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
Andi Kleenc16b63e02006-09-26 10:52:28 +0200653 if ((current->flags & PF_RANDOMIZE) &&
654 !(current->personality & ADDR_NO_RANDOMIZE)) {
Daniel Cashman5ef11c32016-02-26 15:19:37 -0800655 random_variable = get_random_long();
Hector Marco-Gisbert4e7c22d2015-02-14 09:33:50 -0800656 random_variable &= STACK_RND_MASK;
Andi Kleen913bd902006-03-25 16:29:09 +0100657 random_variable <<= PAGE_SHIFT;
658 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659#ifdef CONFIG_STACK_GROWSUP
Andi Kleen913bd902006-03-25 16:29:09 +0100660 return PAGE_ALIGN(stack_top) + random_variable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661#else
Andi Kleen913bd902006-03-25 16:29:09 +0100662 return PAGE_ALIGN(stack_top) - random_variable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663#endif
664}
665
Al Viro71613c32012-10-20 22:00:48 -0400666static int load_elf_binary(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667{
668 struct file *interpreter = NULL; /* to shut gcc up */
669 unsigned long load_addr = 0, load_bias = 0;
670 int load_addr_set = 0;
671 char * elf_interpreter = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 unsigned long error;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100673 struct elf_phdr *elf_ppnt, *elf_phdata, *interp_elf_phdata = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 unsigned long elf_bss, elf_brk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 int retval, i;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100676 unsigned long elf_entry;
677 unsigned long interp_load_addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 unsigned long start_code, end_code, start_data, end_data;
David Daney1a530a62011-03-22 16:34:48 -0700679 unsigned long reloc_func_desc __maybe_unused = 0;
David Rientjes8de61e62006-12-06 20:40:16 -0800680 int executable_stack = EXSTACK_DEFAULT;
Al Viro71613c32012-10-20 22:00:48 -0400681 struct pt_regs *regs = current_pt_regs();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 struct {
683 struct elfhdr elf_ex;
684 struct elfhdr interp_elf_ex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 } *loc;
Paul Burton774c1052014-09-11 08:30:16 +0100686 struct arch_elf_state arch_state = INIT_ARCH_ELF_STATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
688 loc = kmalloc(sizeof(*loc), GFP_KERNEL);
689 if (!loc) {
690 retval = -ENOMEM;
691 goto out_ret;
692 }
693
694 /* Get the exec-header */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700695 loc->elf_ex = *((struct elfhdr *)bprm->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
697 retval = -ENOEXEC;
698 /* First of all, some simple consistency checks */
699 if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
700 goto out;
701
702 if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
703 goto out;
704 if (!elf_check_arch(&loc->elf_ex))
705 goto out;
Al Viro72c2d532013-09-22 16:27:52 -0400706 if (!bprm->file->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 goto out;
708
Paul Burton6a8d3892014-09-11 08:30:14 +0100709 elf_phdata = load_elf_phdrs(&loc->elf_ex, bprm->file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 if (!elf_phdata)
711 goto out;
712
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 elf_ppnt = elf_phdata;
714 elf_bss = 0;
715 elf_brk = 0;
716
717 start_code = ~0UL;
718 end_code = 0;
719 start_data = 0;
720 end_data = 0;
721
722 for (i = 0; i < loc->elf_ex.e_phnum; i++) {
723 if (elf_ppnt->p_type == PT_INTERP) {
724 /* This is the program interpreter used for
725 * shared libraries - for now assume that this
726 * is an a.out format binary
727 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 retval = -ENOEXEC;
729 if (elf_ppnt->p_filesz > PATH_MAX ||
730 elf_ppnt->p_filesz < 2)
Al Viroe7b9b552009-03-29 16:31:16 -0400731 goto out_free_ph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
733 retval = -ENOMEM;
Jesper Juhl792db3a2006-01-09 20:54:45 -0800734 elf_interpreter = kmalloc(elf_ppnt->p_filesz,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700735 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 if (!elf_interpreter)
Al Viroe7b9b552009-03-29 16:31:16 -0400737 goto out_free_ph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
739 retval = kernel_read(bprm->file, elf_ppnt->p_offset,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700740 elf_interpreter,
741 elf_ppnt->p_filesz);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 if (retval != elf_ppnt->p_filesz) {
743 if (retval >= 0)
744 retval = -EIO;
745 goto out_free_interp;
746 }
747 /* make sure path is NULL terminated */
748 retval = -ENOEXEC;
749 if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
750 goto out_free_interp;
751
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 interpreter = open_exec(elf_interpreter);
753 retval = PTR_ERR(interpreter);
754 if (IS_ERR(interpreter))
755 goto out_free_interp;
Alexey Dobriyan1fb84492007-01-26 00:57:16 -0800756
757 /*
758 * If the binary is not readable then enforce
759 * mm->dumpable = 0 regardless of the interpreter's
760 * permissions.
761 */
Al Viro1b5d7832011-06-19 12:49:47 -0400762 would_dump(bprm, interpreter);
Alexey Dobriyan1fb84492007-01-26 00:57:16 -0800763
Maciej W. Rozyckib582ef5c2015-10-26 15:48:19 +0000764 /* Get the exec headers */
765 retval = kernel_read(interpreter, 0,
766 (void *)&loc->interp_elf_ex,
767 sizeof(loc->interp_elf_ex));
768 if (retval != sizeof(loc->interp_elf_ex)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 if (retval >= 0)
770 retval = -EIO;
771 goto out_free_dentry;
772 }
773
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 break;
775 }
776 elf_ppnt++;
777 }
778
779 elf_ppnt = elf_phdata;
780 for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
Paul Burton774c1052014-09-11 08:30:16 +0100781 switch (elf_ppnt->p_type) {
782 case PT_GNU_STACK:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 if (elf_ppnt->p_flags & PF_X)
784 executable_stack = EXSTACK_ENABLE_X;
785 else
786 executable_stack = EXSTACK_DISABLE_X;
787 break;
Paul Burton774c1052014-09-11 08:30:16 +0100788
789 case PT_LOPROC ... PT_HIPROC:
790 retval = arch_elf_pt_proc(&loc->elf_ex, elf_ppnt,
791 bprm->file, false,
792 &arch_state);
793 if (retval)
794 goto out_free_dentry;
795 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
798 /* Some simple consistency checks for the interpreter */
799 if (elf_interpreter) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 retval = -ELIBBAD;
Andi Kleend20894a2008-02-08 04:21:54 -0800801 /* Not an ELF interpreter */
802 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 /* Verify the interpreter has a valid arch */
Andi Kleend20894a2008-02-08 04:21:54 -0800805 if (!elf_check_arch(&loc->interp_elf_ex))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 goto out_free_dentry;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100807
808 /* Load the interpreter program headers */
809 interp_elf_phdata = load_elf_phdrs(&loc->interp_elf_ex,
810 interpreter);
811 if (!interp_elf_phdata)
812 goto out_free_dentry;
Paul Burton774c1052014-09-11 08:30:16 +0100813
814 /* Pass PT_LOPROC..PT_HIPROC headers to arch code */
815 elf_ppnt = interp_elf_phdata;
816 for (i = 0; i < loc->interp_elf_ex.e_phnum; i++, elf_ppnt++)
817 switch (elf_ppnt->p_type) {
818 case PT_LOPROC ... PT_HIPROC:
819 retval = arch_elf_pt_proc(&loc->interp_elf_ex,
820 elf_ppnt, interpreter,
821 true, &arch_state);
822 if (retval)
823 goto out_free_dentry;
824 break;
825 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 }
827
Paul Burton774c1052014-09-11 08:30:16 +0100828 /*
829 * Allow arch code to reject the ELF at this point, whilst it's
830 * still possible to return an error to the code that invoked
831 * the exec syscall.
832 */
Maciej W. Rozyckieb4bc072015-11-13 00:47:48 +0000833 retval = arch_check_elf(&loc->elf_ex,
834 !!interpreter, &loc->interp_elf_ex,
835 &arch_state);
Paul Burton774c1052014-09-11 08:30:16 +0100836 if (retval)
837 goto out_free_dentry;
838
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 /* Flush all traces of the currently running executable */
840 retval = flush_old_exec(bprm);
841 if (retval)
842 goto out_free_dentry;
843
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 /* Do this immediately, since STACK_TOP as used in setup_arg_pages
845 may depend on the personality. */
Paul Burton774c1052014-09-11 08:30:16 +0100846 SET_PERSONALITY2(loc->elf_ex, &arch_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 if (elf_read_implies_exec(loc->elf_ex, executable_stack))
848 current->personality |= READ_IMPLIES_EXEC;
849
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700850 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 current->flags |= PF_RANDOMIZE;
Linus Torvalds221af7f2010-01-28 22:14:42 -0800852
853 setup_new_exec(bprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854
855 /* Do this so that we can load the interpreter, if need be. We will
856 change some of these later */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
858 executable_stack);
Al Viro19d860a2014-05-04 20:11:36 -0400859 if (retval < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 current->mm->start_stack = bprm->p;
863
André Goddard Rosaaf901ca2009-11-14 13:09:05 -0200864 /* Now we do a little grungy work by mmapping the ELF image into
Jiri Kosinacc503c12008-01-30 13:31:07 +0100865 the correct location in memory. */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700866 for(i = 0, elf_ppnt = elf_phdata;
867 i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 int elf_prot = 0, elf_flags;
869 unsigned long k, vaddr;
Michael Davidsona87938b2015-04-14 15:47:38 -0700870 unsigned long total_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
872 if (elf_ppnt->p_type != PT_LOAD)
873 continue;
874
875 if (unlikely (elf_brk > elf_bss)) {
876 unsigned long nbyte;
877
878 /* There was a PT_LOAD segment with p_memsz > p_filesz
879 before this one. Map anonymous pages, if needed,
880 and clear the area. */
Mikael Petterssonf670d0e2011-01-12 17:00:02 -0800881 retval = set_brk(elf_bss + load_bias,
882 elf_brk + load_bias);
Al Viro19d860a2014-05-04 20:11:36 -0400883 if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 nbyte = ELF_PAGEOFFSET(elf_bss);
886 if (nbyte) {
887 nbyte = ELF_MIN_ALIGN - nbyte;
888 if (nbyte > elf_brk - elf_bss)
889 nbyte = elf_brk - elf_bss;
890 if (clear_user((void __user *)elf_bss +
891 load_bias, nbyte)) {
892 /*
893 * This bss-zeroing can fail if the ELF
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700894 * file specifies odd protections. So
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 * we don't check the return value
896 */
897 }
898 }
899 }
900
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700901 if (elf_ppnt->p_flags & PF_R)
902 elf_prot |= PROT_READ;
903 if (elf_ppnt->p_flags & PF_W)
904 elf_prot |= PROT_WRITE;
905 if (elf_ppnt->p_flags & PF_X)
906 elf_prot |= PROT_EXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700908 elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909
910 vaddr = elf_ppnt->p_vaddr;
911 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
912 elf_flags |= MAP_FIXED;
913 } else if (loc->elf_ex.e_type == ET_DYN) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700914 /* Try and get dynamic programs out of the way of the
915 * default mmap base, as well as whatever program they
916 * might try to exec. This is because the brk will
917 * follow the loader, and is not movable. */
Kees Cookd1fd8362015-04-14 15:48:07 -0700918 load_bias = ELF_ET_DYN_BASE - vaddr;
Jiri Kosinaa3defbe2011-11-02 13:37:41 -0700919 if (current->flags & PF_RANDOMIZE)
Kees Cookd1fd8362015-04-14 15:48:07 -0700920 load_bias += arch_mmap_rnd();
921 load_bias = ELF_PAGESTART(load_bias);
Michael Davidsona87938b2015-04-14 15:47:38 -0700922 total_size = total_mapping_size(elf_phdata,
923 loc->elf_ex.e_phnum);
924 if (!total_size) {
Andrew Morton2b1d3ae2015-05-28 15:44:24 -0700925 retval = -EINVAL;
Michael Davidsona87938b2015-04-14 15:47:38 -0700926 goto out_free_dentry;
927 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 }
929
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700930 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
Michael Davidsona87938b2015-04-14 15:47:38 -0700931 elf_prot, elf_flags, total_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 if (BAD_ADDR(error)) {
Alexey Kuznetsovb140f2512007-05-08 00:31:57 -0700933 retval = IS_ERR((void *)error) ?
934 PTR_ERR((void*)error) : -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 goto out_free_dentry;
936 }
937
938 if (!load_addr_set) {
939 load_addr_set = 1;
940 load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
941 if (loc->elf_ex.e_type == ET_DYN) {
942 load_bias += error -
943 ELF_PAGESTART(load_bias + vaddr);
944 load_addr += load_bias;
945 reloc_func_desc = load_bias;
946 }
947 }
948 k = elf_ppnt->p_vaddr;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700949 if (k < start_code)
950 start_code = k;
951 if (start_data < k)
952 start_data = k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
954 /*
955 * Check to see if the section's size will overflow the
956 * allowed task size. Note that p_filesz must always be
957 * <= p_memsz so it is only necessary to check p_memsz.
958 */
Chuck Ebbertce510592006-07-03 00:24:14 -0700959 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 elf_ppnt->p_memsz > TASK_SIZE ||
961 TASK_SIZE - elf_ppnt->p_memsz < k) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700962 /* set_brk can never work. Avoid overflows. */
Alexey Kuznetsovb140f2512007-05-08 00:31:57 -0700963 retval = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 goto out_free_dentry;
965 }
966
967 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
968
969 if (k > elf_bss)
970 elf_bss = k;
971 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
972 end_code = k;
973 if (end_data < k)
974 end_data = k;
975 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
976 if (k > elf_brk)
977 elf_brk = k;
978 }
979
980 loc->elf_ex.e_entry += load_bias;
981 elf_bss += load_bias;
982 elf_brk += load_bias;
983 start_code += load_bias;
984 end_code += load_bias;
985 start_data += load_bias;
986 end_data += load_bias;
987
988 /* Calling set_brk effectively mmaps the pages that we need
989 * for the bss and break sections. We must do this before
990 * mapping in the interpreter, to make sure it doesn't wind
991 * up getting placed where the bss needs to go.
992 */
993 retval = set_brk(elf_bss, elf_brk);
Al Viro19d860a2014-05-04 20:11:36 -0400994 if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 goto out_free_dentry;
akpm@osdl.org6de50512005-10-11 08:29:08 -0700996 if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 retval = -EFAULT; /* Nobody gets to see this, but.. */
998 goto out_free_dentry;
999 }
1000
1001 if (elf_interpreter) {
Alan Cox6eec4822012-10-04 17:13:42 -07001002 unsigned long interp_map_addr = 0;
Jiri Kosinacc503c12008-01-30 13:31:07 +01001003
Andi Kleend20894a2008-02-08 04:21:54 -08001004 elf_entry = load_elf_interp(&loc->interp_elf_ex,
1005 interpreter,
1006 &interp_map_addr,
Paul Burtona9d9ef12014-09-11 08:30:15 +01001007 load_bias, interp_elf_phdata);
Andi Kleend20894a2008-02-08 04:21:54 -08001008 if (!IS_ERR((void *)elf_entry)) {
1009 /*
1010 * load_elf_interp() returns relocation
1011 * adjustment
1012 */
1013 interp_load_addr = elf_entry;
1014 elf_entry += loc->interp_elf_ex.e_entry;
Jiri Kosinacc503c12008-01-30 13:31:07 +01001015 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 if (BAD_ADDR(elf_entry)) {
Chuck Ebbertce510592006-07-03 00:24:14 -07001017 retval = IS_ERR((void *)elf_entry) ?
1018 (int)elf_entry : -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 goto out_free_dentry;
1020 }
1021 reloc_func_desc = interp_load_addr;
1022
1023 allow_write_access(interpreter);
1024 fput(interpreter);
1025 kfree(elf_interpreter);
1026 } else {
1027 elf_entry = loc->elf_ex.e_entry;
Suresh Siddha5342fba2006-02-26 04:18:28 +01001028 if (BAD_ADDR(elf_entry)) {
Chuck Ebbertce510592006-07-03 00:24:14 -07001029 retval = -EINVAL;
Suresh Siddha5342fba2006-02-26 04:18:28 +01001030 goto out_free_dentry;
1031 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 }
1033
Paul Burton774c1052014-09-11 08:30:16 +01001034 kfree(interp_elf_phdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 kfree(elf_phdata);
1036
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 set_binfmt(&elf_format);
1038
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -07001039#ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
Martin Schwidefskyfc5243d2008-12-25 13:38:35 +01001040 retval = arch_setup_additional_pages(bprm, !!elf_interpreter);
Al Viro19d860a2014-05-04 20:11:36 -04001041 if (retval < 0)
Roland McGrath18c8baf2005-04-28 15:17:19 -07001042 goto out;
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -07001043#endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
1044
David Howellsa6f76f22008-11-14 10:39:24 +11001045 install_exec_creds(bprm);
Ollie Wildb6a2fea2007-07-19 01:48:16 -07001046 retval = create_elf_tables(bprm, &loc->elf_ex,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001047 load_addr, interp_load_addr);
Al Viro19d860a2014-05-04 20:11:36 -04001048 if (retval < 0)
Ollie Wildb6a2fea2007-07-19 01:48:16 -07001049 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 /* N.B. passed_fileno might not be initialized? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 current->mm->end_code = end_code;
1052 current->mm->start_code = start_code;
1053 current->mm->start_data = start_data;
1054 current->mm->end_data = end_data;
1055 current->mm->start_stack = bprm->p;
1056
Jiri Kosina4471a672011-04-14 15:22:09 -07001057 if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
Jiri Kosinac1d171a2008-01-30 13:30:40 +01001058 current->mm->brk = current->mm->start_brk =
1059 arch_randomize_brk(current->mm);
Kees Cook204db6e2015-04-14 15:48:12 -07001060#ifdef compat_brk_randomized
Jiri Kosina4471a672011-04-14 15:22:09 -07001061 current->brk_randomized = 1;
1062#endif
1063 }
Jiri Kosinac1d171a2008-01-30 13:30:40 +01001064
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 if (current->personality & MMAP_PAGE_ZERO) {
1066 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1067 and some applications "depend" upon this behavior.
1068 Since we do not have the power to recompile these, we
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001069 emulate the SVr4 behavior. Sigh. */
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001070 error = vm_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 MAP_FIXED | MAP_PRIVATE, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 }
1073
1074#ifdef ELF_PLAT_INIT
1075 /*
1076 * The ABI may specify that certain registers be set up in special
1077 * ways (on i386 %edx is the address of a DT_FINI function, for
1078 * example. In addition, it may also specify (eg, PowerPC64 ELF)
1079 * that the e_entry field is the address of the function descriptor
1080 * for the startup routine, rather than the address of the startup
1081 * routine itself. This macro performs whatever initialization to
1082 * the regs structure is required as well as any relocations to the
1083 * function descriptor entries when executing dynamically links apps.
1084 */
1085 ELF_PLAT_INIT(regs, reloc_func_desc);
1086#endif
1087
1088 start_thread(regs, elf_entry, bprm->p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 retval = 0;
1090out:
1091 kfree(loc);
1092out_ret:
1093 return retval;
1094
1095 /* error cleanup */
1096out_free_dentry:
Paul Burtona9d9ef12014-09-11 08:30:15 +01001097 kfree(interp_elf_phdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 allow_write_access(interpreter);
1099 if (interpreter)
1100 fput(interpreter);
1101out_free_interp:
Jesper Juhlf99d49a2005-11-07 01:01:34 -08001102 kfree(elf_interpreter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103out_free_ph:
1104 kfree(elf_phdata);
1105 goto out;
1106}
1107
Josh Triplett69369a72014-04-03 14:48:27 -07001108#ifdef CONFIG_USELIB
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109/* This is really simpleminded and specialized - we are loading an
1110 a.out library that is given an ELF header. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111static int load_elf_library(struct file *file)
1112{
1113 struct elf_phdr *elf_phdata;
1114 struct elf_phdr *eppnt;
1115 unsigned long elf_bss, bss, len;
1116 int retval, error, i, j;
1117 struct elfhdr elf_ex;
1118
1119 error = -ENOEXEC;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001120 retval = kernel_read(file, 0, (char *)&elf_ex, sizeof(elf_ex));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 if (retval != sizeof(elf_ex))
1122 goto out;
1123
1124 if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1125 goto out;
1126
1127 /* First of all, some simple consistency checks */
1128 if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
Al Viro72c2d532013-09-22 16:27:52 -04001129 !elf_check_arch(&elf_ex) || !file->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 goto out;
1131
1132 /* Now read in all of the header information */
1133
1134 j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1135 /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1136
1137 error = -ENOMEM;
1138 elf_phdata = kmalloc(j, GFP_KERNEL);
1139 if (!elf_phdata)
1140 goto out;
1141
1142 eppnt = elf_phdata;
1143 error = -ENOEXEC;
1144 retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);
1145 if (retval != j)
1146 goto out_free_ph;
1147
1148 for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1149 if ((eppnt + i)->p_type == PT_LOAD)
1150 j++;
1151 if (j != 1)
1152 goto out_free_ph;
1153
1154 while (eppnt->p_type != PT_LOAD)
1155 eppnt++;
1156
1157 /* Now use mmap to map the library into memory. */
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001158 error = vm_mmap(file,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 ELF_PAGESTART(eppnt->p_vaddr),
1160 (eppnt->p_filesz +
1161 ELF_PAGEOFFSET(eppnt->p_vaddr)),
1162 PROT_READ | PROT_WRITE | PROT_EXEC,
1163 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
1164 (eppnt->p_offset -
1165 ELF_PAGEOFFSET(eppnt->p_vaddr)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 if (error != ELF_PAGESTART(eppnt->p_vaddr))
1167 goto out_free_ph;
1168
1169 elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1170 if (padzero(elf_bss)) {
1171 error = -EFAULT;
1172 goto out_free_ph;
1173 }
1174
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001175 len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr +
1176 ELF_MIN_ALIGN - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 bss = eppnt->p_memsz + eppnt->p_vaddr;
Michal Hockoecc2bc82016-05-23 16:25:39 -07001178 if (bss > len) {
1179 error = vm_brk(len, bss - len);
Linus Torvalds5d22fc22016-05-27 15:57:31 -07001180 if (error)
Michal Hockoecc2bc82016-05-23 16:25:39 -07001181 goto out_free_ph;
1182 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 error = 0;
1184
1185out_free_ph:
1186 kfree(elf_phdata);
1187out:
1188 return error;
1189}
Josh Triplett69369a72014-04-03 14:48:27 -07001190#endif /* #ifdef CONFIG_USELIB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08001192#ifdef CONFIG_ELF_CORE
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193/*
1194 * ELF core dumper
1195 *
1196 * Modelled on fs/exec.c:aout_core_dump()
1197 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1198 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199
1200/*
Jason Baron909af762012-03-23 15:02:51 -07001201 * The purpose of always_dump_vma() is to make sure that special kernel mappings
1202 * that are useful for post-mortem analysis are included in every core dump.
1203 * In that way we ensure that the core dump is fully interpretable later
1204 * without matching up the same kernel and hardware config to see what PC values
1205 * meant. These special mappings include - vDSO, vsyscall, and other
1206 * architecture specific mappings
1207 */
1208static bool always_dump_vma(struct vm_area_struct *vma)
1209{
1210 /* Any vsyscall mappings? */
1211 if (vma == get_gate_vma(vma->vm_mm))
1212 return true;
Andy Lutomirski78d683e2014-05-19 15:58:32 -07001213
1214 /*
1215 * Assume that all vmas with a .name op should always be dumped.
1216 * If this changes, a new vm_ops field can easily be added.
1217 */
1218 if (vma->vm_ops && vma->vm_ops->name && vma->vm_ops->name(vma))
1219 return true;
1220
Jason Baron909af762012-03-23 15:02:51 -07001221 /*
1222 * arch_vma_name() returns non-NULL for special architecture mappings,
1223 * such as vDSO sections.
1224 */
1225 if (arch_vma_name(vma))
1226 return true;
1227
1228 return false;
1229}
1230
1231/*
Roland McGrath82df3972007-10-16 23:27:02 -07001232 * Decide what to dump of a segment, part, all or none.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 */
Roland McGrath82df3972007-10-16 23:27:02 -07001234static unsigned long vma_dump_size(struct vm_area_struct *vma,
1235 unsigned long mm_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236{
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001237#define FILTER(type) (mm_flags & (1UL << MMF_DUMP_##type))
1238
Jason Baron909af762012-03-23 15:02:51 -07001239 /* always dump the vdso and vsyscall sections */
1240 if (always_dump_vma(vma))
Roland McGrath82df3972007-10-16 23:27:02 -07001241 goto whole;
Roland McGrathe5b97dd2007-01-26 00:56:48 -08001242
Konstantin Khlebnikov0103bd12012-10-08 16:28:59 -07001243 if (vma->vm_flags & VM_DONTDUMP)
Jason Baronaccb61f2012-03-23 15:02:51 -07001244 return 0;
1245
Ross Zwisler50378352015-10-05 16:33:36 -06001246 /* support for DAX */
1247 if (vma_is_dax(vma)) {
1248 if ((vma->vm_flags & VM_SHARED) && FILTER(DAX_SHARED))
1249 goto whole;
1250 if (!(vma->vm_flags & VM_SHARED) && FILTER(DAX_PRIVATE))
1251 goto whole;
1252 return 0;
1253 }
1254
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001255 /* Hugetlb memory check */
1256 if (vma->vm_flags & VM_HUGETLB) {
1257 if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))
1258 goto whole;
1259 if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))
1260 goto whole;
Naoya Horiguchi23d9e482013-04-17 15:58:28 -07001261 return 0;
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001262 }
1263
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 /* Do not dump I/O mapped devices or special mappings */
Konstantin Khlebnikov314e51b2012-10-08 16:29:02 -07001265 if (vma->vm_flags & VM_IO)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 return 0;
1267
Kawai, Hidehiroa1b59e82007-07-19 01:48:29 -07001268 /* By default, dump shared memory if mapped from an anonymous file. */
1269 if (vma->vm_flags & VM_SHARED) {
Al Viro496ad9a2013-01-23 17:07:38 -05001270 if (file_inode(vma->vm_file)->i_nlink == 0 ?
Roland McGrath82df3972007-10-16 23:27:02 -07001271 FILTER(ANON_SHARED) : FILTER(MAPPED_SHARED))
1272 goto whole;
1273 return 0;
Kawai, Hidehiroa1b59e82007-07-19 01:48:29 -07001274 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
Roland McGrath82df3972007-10-16 23:27:02 -07001276 /* Dump segments that have been written to. */
1277 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1278 goto whole;
1279 if (vma->vm_file == NULL)
1280 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281
Roland McGrath82df3972007-10-16 23:27:02 -07001282 if (FILTER(MAPPED_PRIVATE))
1283 goto whole;
1284
1285 /*
1286 * If this looks like the beginning of a DSO or executable mapping,
1287 * check for an ELF header. If we find one, dump the first page to
1288 * aid in determining what was mapped here.
1289 */
Roland McGrath92dc07b2009-02-06 17:34:07 -08001290 if (FILTER(ELF_HEADERS) &&
1291 vma->vm_pgoff == 0 && (vma->vm_flags & VM_READ)) {
Roland McGrath82df3972007-10-16 23:27:02 -07001292 u32 __user *header = (u32 __user *) vma->vm_start;
1293 u32 word;
Roland McGrath92dc07b2009-02-06 17:34:07 -08001294 mm_segment_t fs = get_fs();
Roland McGrath82df3972007-10-16 23:27:02 -07001295 /*
1296 * Doing it this way gets the constant folded by GCC.
1297 */
1298 union {
1299 u32 cmp;
1300 char elfmag[SELFMAG];
1301 } magic;
1302 BUILD_BUG_ON(SELFMAG != sizeof word);
1303 magic.elfmag[EI_MAG0] = ELFMAG0;
1304 magic.elfmag[EI_MAG1] = ELFMAG1;
1305 magic.elfmag[EI_MAG2] = ELFMAG2;
1306 magic.elfmag[EI_MAG3] = ELFMAG3;
Roland McGrath92dc07b2009-02-06 17:34:07 -08001307 /*
1308 * Switch to the user "segment" for get_user(),
1309 * then put back what elf_core_dump() had in place.
1310 */
1311 set_fs(USER_DS);
1312 if (unlikely(get_user(word, header)))
1313 word = 0;
1314 set_fs(fs);
1315 if (word == magic.cmp)
Roland McGrath82df3972007-10-16 23:27:02 -07001316 return PAGE_SIZE;
1317 }
1318
1319#undef FILTER
1320
1321 return 0;
1322
1323whole:
1324 return vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325}
1326
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327/* An ELF note in memory */
1328struct memelfnote
1329{
1330 const char *name;
1331 int type;
1332 unsigned int datasz;
1333 void *data;
1334};
1335
1336static int notesize(struct memelfnote *en)
1337{
1338 int sz;
1339
1340 sz = sizeof(struct elf_note);
1341 sz += roundup(strlen(en->name) + 1, 4);
1342 sz += roundup(en->datasz, 4);
1343
1344 return sz;
1345}
1346
Al Viroecc8c772013-10-05 15:32:35 -04001347static int writenote(struct memelfnote *men, struct coredump_params *cprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348{
1349 struct elf_note en;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 en.n_namesz = strlen(men->name) + 1;
1351 en.n_descsz = men->datasz;
1352 en.n_type = men->type;
1353
Al Viroecc8c772013-10-05 15:32:35 -04001354 return dump_emit(cprm, &en, sizeof(en)) &&
Al Viro22a8cb82013-10-08 11:05:01 -04001355 dump_emit(cprm, men->name, en.n_namesz) && dump_align(cprm, 4) &&
1356 dump_emit(cprm, men->data, men->datasz) && dump_align(cprm, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358
Roland McGrath3aba4812008-01-30 13:31:44 +01001359static void fill_elf_header(struct elfhdr *elf, int segs,
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08001360 u16 machine, u32 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361{
Cyrill Gorcunov6970c8e2008-04-29 01:01:18 -07001362 memset(elf, 0, sizeof(*elf));
1363
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 memcpy(elf->e_ident, ELFMAG, SELFMAG);
1365 elf->e_ident[EI_CLASS] = ELF_CLASS;
1366 elf->e_ident[EI_DATA] = ELF_DATA;
1367 elf->e_ident[EI_VERSION] = EV_CURRENT;
1368 elf->e_ident[EI_OSABI] = ELF_OSABI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369
1370 elf->e_type = ET_CORE;
Roland McGrath3aba4812008-01-30 13:31:44 +01001371 elf->e_machine = machine;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 elf->e_version = EV_CURRENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 elf->e_phoff = sizeof(struct elfhdr);
Roland McGrath3aba4812008-01-30 13:31:44 +01001374 elf->e_flags = flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 elf->e_ehsize = sizeof(struct elfhdr);
1376 elf->e_phentsize = sizeof(struct elf_phdr);
1377 elf->e_phnum = segs;
Cyrill Gorcunov6970c8e2008-04-29 01:01:18 -07001378
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 return;
1380}
1381
Andrew Morton8d6b5eee2006-09-25 23:32:04 -07001382static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383{
1384 phdr->p_type = PT_NOTE;
1385 phdr->p_offset = offset;
1386 phdr->p_vaddr = 0;
1387 phdr->p_paddr = 0;
1388 phdr->p_filesz = sz;
1389 phdr->p_memsz = 0;
1390 phdr->p_flags = 0;
1391 phdr->p_align = 0;
1392 return;
1393}
1394
1395static void fill_note(struct memelfnote *note, const char *name, int type,
1396 unsigned int sz, void *data)
1397{
1398 note->name = name;
1399 note->type = type;
1400 note->datasz = sz;
1401 note->data = data;
1402 return;
1403}
1404
1405/*
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001406 * fill up all the fields in prstatus from the given task struct, except
1407 * registers which need to be filled up separately.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 */
1409static void fill_prstatus(struct elf_prstatus *prstatus,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001410 struct task_struct *p, long signr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411{
1412 prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1413 prstatus->pr_sigpend = p->pending.signal.sig[0];
1414 prstatus->pr_sighold = p->blocked.sig[0];
Oleg Nesterov3b34fc52009-06-17 16:27:38 -07001415 rcu_read_lock();
1416 prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1417 rcu_read_unlock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001418 prstatus->pr_pid = task_pid_vnr(p);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001419 prstatus->pr_pgrp = task_pgrp_vnr(p);
1420 prstatus->pr_sid = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 if (thread_group_leader(p)) {
Frank Mayharf06febc2008-09-12 09:54:39 -07001422 struct task_cputime cputime;
1423
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 /*
Frank Mayharf06febc2008-09-12 09:54:39 -07001425 * This is the record for the group leader. It shows the
1426 * group-wide total, not its individual thread total.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 */
Frank Mayharf06febc2008-09-12 09:54:39 -07001428 thread_group_cputime(p, &cputime);
1429 cputime_to_timeval(cputime.utime, &prstatus->pr_utime);
1430 cputime_to_timeval(cputime.stime, &prstatus->pr_stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 } else {
Frederic Weisbecker6fac4822012-11-13 14:20:55 +01001432 cputime_t utime, stime;
1433
1434 task_cputime(p, &utime, &stime);
1435 cputime_to_timeval(utime, &prstatus->pr_utime);
1436 cputime_to_timeval(stime, &prstatus->pr_stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 }
1438 cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
1439 cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
1440}
1441
1442static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1443 struct mm_struct *mm)
1444{
David Howellsc69e8d92008-11-14 10:39:19 +11001445 const struct cred *cred;
Greg Kroah-Hartmana84a5052005-05-11 00:10:44 -07001446 unsigned int i, len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
1448 /* first copy the parameters from user space */
1449 memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1450
1451 len = mm->arg_end - mm->arg_start;
1452 if (len >= ELF_PRARGSZ)
1453 len = ELF_PRARGSZ-1;
1454 if (copy_from_user(&psinfo->pr_psargs,
1455 (const char __user *)mm->arg_start, len))
1456 return -EFAULT;
1457 for(i = 0; i < len; i++)
1458 if (psinfo->pr_psargs[i] == 0)
1459 psinfo->pr_psargs[i] = ' ';
1460 psinfo->pr_psargs[len] = 0;
1461
Oleg Nesterov3b34fc52009-06-17 16:27:38 -07001462 rcu_read_lock();
1463 psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1464 rcu_read_unlock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001465 psinfo->pr_pid = task_pid_vnr(p);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001466 psinfo->pr_pgrp = task_pgrp_vnr(p);
1467 psinfo->pr_sid = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468
1469 i = p->state ? ffz(~p->state) + 1 : 0;
1470 psinfo->pr_state = i;
Carsten Otte55148542006-03-25 03:08:22 -08001471 psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1473 psinfo->pr_nice = task_nice(p);
1474 psinfo->pr_flag = p->flags;
David Howellsc69e8d92008-11-14 10:39:19 +11001475 rcu_read_lock();
1476 cred = __task_cred(p);
Eric W. Biedermanebc887b2012-02-07 18:36:10 -08001477 SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
1478 SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
David Howellsc69e8d92008-11-14 10:39:19 +11001479 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1481
1482 return 0;
1483}
1484
Roland McGrath3aba4812008-01-30 13:31:44 +01001485static void fill_auxv_note(struct memelfnote *note, struct mm_struct *mm)
1486{
1487 elf_addr_t *auxv = (elf_addr_t *) mm->saved_auxv;
1488 int i = 0;
1489 do
1490 i += 2;
1491 while (auxv[i - 2] != AT_NULL);
1492 fill_note(note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);
1493}
1494
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001495static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,
Al Viroce395962013-10-13 17:23:53 -04001496 const siginfo_t *siginfo)
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001497{
1498 mm_segment_t old_fs = get_fs();
1499 set_fs(KERNEL_DS);
1500 copy_siginfo_to_user((user_siginfo_t __user *) csigdata, siginfo);
1501 set_fs(old_fs);
1502 fill_note(note, "CORE", NT_SIGINFO, sizeof(*csigdata), csigdata);
1503}
1504
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001505#define MAX_FILE_NOTE_SIZE (4*1024*1024)
1506/*
1507 * Format of NT_FILE note:
1508 *
1509 * long count -- how many files are mapped
1510 * long page_size -- units for file_ofs
1511 * array of [COUNT] elements of
1512 * long start
1513 * long end
1514 * long file_ofs
1515 * followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1516 */
Dan Aloni72023652013-09-30 13:45:02 -07001517static int fill_files_note(struct memelfnote *note)
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001518{
1519 struct vm_area_struct *vma;
1520 unsigned count, size, names_ofs, remaining, n;
1521 user_long_t *data;
1522 user_long_t *start_end_ofs;
1523 char *name_base, *name_curpos;
1524
1525 /* *Estimated* file count and total data size needed */
1526 count = current->mm->map_count;
1527 size = count * 64;
1528
1529 names_ofs = (2 + 3 * count) * sizeof(data[0]);
1530 alloc:
1531 if (size >= MAX_FILE_NOTE_SIZE) /* paranoia check */
Dan Aloni72023652013-09-30 13:45:02 -07001532 return -EINVAL;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001533 size = round_up(size, PAGE_SIZE);
1534 data = vmalloc(size);
1535 if (!data)
Dan Aloni72023652013-09-30 13:45:02 -07001536 return -ENOMEM;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001537
1538 start_end_ofs = data + 2;
1539 name_base = name_curpos = ((char *)data) + names_ofs;
1540 remaining = size - names_ofs;
1541 count = 0;
1542 for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1543 struct file *file;
1544 const char *filename;
1545
1546 file = vma->vm_file;
1547 if (!file)
1548 continue;
Miklos Szeredi9bf39ab2015-06-19 10:29:13 +02001549 filename = file_path(file, name_curpos, remaining);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001550 if (IS_ERR(filename)) {
1551 if (PTR_ERR(filename) == -ENAMETOOLONG) {
1552 vfree(data);
1553 size = size * 5 / 4;
1554 goto alloc;
1555 }
1556 continue;
1557 }
1558
Miklos Szeredi9bf39ab2015-06-19 10:29:13 +02001559 /* file_path() fills at the end, move name down */
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001560 /* n = strlen(filename) + 1: */
1561 n = (name_curpos + remaining) - filename;
1562 remaining = filename - name_curpos;
1563 memmove(name_curpos, filename, n);
1564 name_curpos += n;
1565
1566 *start_end_ofs++ = vma->vm_start;
1567 *start_end_ofs++ = vma->vm_end;
1568 *start_end_ofs++ = vma->vm_pgoff;
1569 count++;
1570 }
1571
1572 /* Now we know exact count of files, can store it */
1573 data[0] = count;
1574 data[1] = PAGE_SIZE;
1575 /*
1576 * Count usually is less than current->mm->map_count,
1577 * we need to move filenames down.
1578 */
1579 n = current->mm->map_count - count;
1580 if (n != 0) {
1581 unsigned shift_bytes = n * 3 * sizeof(data[0]);
1582 memmove(name_base - shift_bytes, name_base,
1583 name_curpos - name_base);
1584 name_curpos -= shift_bytes;
1585 }
1586
1587 size = name_curpos - (char *)data;
1588 fill_note(note, "CORE", NT_FILE, size, data);
Dan Aloni72023652013-09-30 13:45:02 -07001589 return 0;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001590}
1591
Roland McGrath4206d3a2008-01-30 13:31:45 +01001592#ifdef CORE_DUMP_USE_REGSET
1593#include <linux/regset.h>
1594
1595struct elf_thread_core_info {
1596 struct elf_thread_core_info *next;
1597 struct task_struct *task;
1598 struct elf_prstatus prstatus;
1599 struct memelfnote notes[0];
1600};
1601
1602struct elf_note_info {
1603 struct elf_thread_core_info *thread;
1604 struct memelfnote psinfo;
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001605 struct memelfnote signote;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001606 struct memelfnote auxv;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001607 struct memelfnote files;
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001608 user_siginfo_t csigdata;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001609 size_t size;
1610 int thread_notes;
1611};
1612
Roland McGrathd31472b2008-03-04 14:28:30 -08001613/*
1614 * When a regset has a writeback hook, we call it on each thread before
1615 * dumping user memory. On register window machines, this makes sure the
1616 * user memory backing the register data is up to date before we read it.
1617 */
1618static void do_thread_regset_writeback(struct task_struct *task,
1619 const struct user_regset *regset)
1620{
1621 if (regset->writeback)
1622 regset->writeback(task, regset, 1);
1623}
1624
H. J. Lu0953f65d2012-02-14 13:34:52 -08001625#ifndef PR_REG_SIZE
1626#define PR_REG_SIZE(S) sizeof(S)
1627#endif
1628
1629#ifndef PRSTATUS_SIZE
1630#define PRSTATUS_SIZE(S) sizeof(S)
1631#endif
1632
1633#ifndef PR_REG_PTR
1634#define PR_REG_PTR(S) (&((S)->pr_reg))
1635#endif
1636
1637#ifndef SET_PR_FPVALID
1638#define SET_PR_FPVALID(S, V) ((S)->pr_fpvalid = (V))
1639#endif
1640
Roland McGrath4206d3a2008-01-30 13:31:45 +01001641static int fill_thread_core_info(struct elf_thread_core_info *t,
1642 const struct user_regset_view *view,
1643 long signr, size_t *total)
1644{
1645 unsigned int i;
1646
1647 /*
1648 * NT_PRSTATUS is the one special case, because the regset data
1649 * goes into the pr_reg field inside the note contents, rather
1650 * than being the whole note contents. We fill the reset in here.
1651 * We assume that regset 0 is NT_PRSTATUS.
1652 */
1653 fill_prstatus(&t->prstatus, t->task, signr);
1654 (void) view->regsets[0].get(t->task, &view->regsets[0],
H. J. Lu0953f65d2012-02-14 13:34:52 -08001655 0, PR_REG_SIZE(t->prstatus.pr_reg),
1656 PR_REG_PTR(&t->prstatus), NULL);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001657
1658 fill_note(&t->notes[0], "CORE", NT_PRSTATUS,
H. J. Lu0953f65d2012-02-14 13:34:52 -08001659 PRSTATUS_SIZE(t->prstatus), &t->prstatus);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001660 *total += notesize(&t->notes[0]);
1661
Roland McGrathd31472b2008-03-04 14:28:30 -08001662 do_thread_regset_writeback(t->task, &view->regsets[0]);
1663
Roland McGrath4206d3a2008-01-30 13:31:45 +01001664 /*
1665 * Each other regset might generate a note too. For each regset
1666 * that has no core_note_type or is inactive, we leave t->notes[i]
1667 * all zero and we'll know to skip writing it later.
1668 */
1669 for (i = 1; i < view->n; ++i) {
1670 const struct user_regset *regset = &view->regsets[i];
Roland McGrathd31472b2008-03-04 14:28:30 -08001671 do_thread_regset_writeback(t->task, regset);
H. Peter Anvinc8e25252012-03-02 10:43:48 -08001672 if (regset->core_note_type && regset->get &&
Roland McGrath4206d3a2008-01-30 13:31:45 +01001673 (!regset->active || regset->active(t->task, regset))) {
1674 int ret;
1675 size_t size = regset->n * regset->size;
1676 void *data = kmalloc(size, GFP_KERNEL);
1677 if (unlikely(!data))
1678 return 0;
1679 ret = regset->get(t->task, regset,
1680 0, size, data, NULL);
1681 if (unlikely(ret))
1682 kfree(data);
1683 else {
1684 if (regset->core_note_type != NT_PRFPREG)
1685 fill_note(&t->notes[i], "LINUX",
1686 regset->core_note_type,
1687 size, data);
1688 else {
H. J. Lu0953f65d2012-02-14 13:34:52 -08001689 SET_PR_FPVALID(&t->prstatus, 1);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001690 fill_note(&t->notes[i], "CORE",
1691 NT_PRFPREG, size, data);
1692 }
1693 *total += notesize(&t->notes[i]);
1694 }
1695 }
1696 }
1697
1698 return 1;
1699}
1700
1701static int fill_note_info(struct elfhdr *elf, int phdrs,
1702 struct elf_note_info *info,
Al Viroec579412013-10-13 17:57:29 -04001703 const siginfo_t *siginfo, struct pt_regs *regs)
Roland McGrath4206d3a2008-01-30 13:31:45 +01001704{
1705 struct task_struct *dump_task = current;
1706 const struct user_regset_view *view = task_user_regset_view(dump_task);
1707 struct elf_thread_core_info *t;
1708 struct elf_prpsinfo *psinfo;
Oleg Nesterov83914442008-07-25 01:47:45 -07001709 struct core_thread *ct;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001710 unsigned int i;
1711
1712 info->size = 0;
1713 info->thread = NULL;
1714
1715 psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
Alan Cox6899e922012-12-17 16:02:09 -08001716 if (psinfo == NULL) {
1717 info->psinfo.data = NULL; /* So we don't free this wrongly */
Roland McGrath4206d3a2008-01-30 13:31:45 +01001718 return 0;
Alan Cox6899e922012-12-17 16:02:09 -08001719 }
Roland McGrath4206d3a2008-01-30 13:31:45 +01001720
Amerigo Wange2dbe122009-07-01 01:06:26 -04001721 fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1722
Roland McGrath4206d3a2008-01-30 13:31:45 +01001723 /*
1724 * Figure out how many notes we're going to need for each thread.
1725 */
1726 info->thread_notes = 0;
1727 for (i = 0; i < view->n; ++i)
1728 if (view->regsets[i].core_note_type != 0)
1729 ++info->thread_notes;
1730
1731 /*
1732 * Sanity check. We rely on regset 0 being in NT_PRSTATUS,
1733 * since it is our one special case.
1734 */
1735 if (unlikely(info->thread_notes == 0) ||
1736 unlikely(view->regsets[0].core_note_type != NT_PRSTATUS)) {
1737 WARN_ON(1);
1738 return 0;
1739 }
1740
1741 /*
1742 * Initialize the ELF file header.
1743 */
1744 fill_elf_header(elf, phdrs,
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08001745 view->e_machine, view->e_flags);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001746
1747 /*
1748 * Allocate a structure for each thread.
1749 */
Oleg Nesterov83914442008-07-25 01:47:45 -07001750 for (ct = &dump_task->mm->core_state->dumper; ct; ct = ct->next) {
1751 t = kzalloc(offsetof(struct elf_thread_core_info,
1752 notes[info->thread_notes]),
1753 GFP_KERNEL);
1754 if (unlikely(!t))
1755 return 0;
Oleg Nesterov24d52882008-07-25 01:47:40 -07001756
Oleg Nesterov83914442008-07-25 01:47:45 -07001757 t->task = ct->task;
1758 if (ct->task == dump_task || !info->thread) {
1759 t->next = info->thread;
1760 info->thread = t;
1761 } else {
1762 /*
1763 * Make sure to keep the original task at
1764 * the head of the list.
1765 */
1766 t->next = info->thread->next;
1767 info->thread->next = t;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001768 }
Oleg Nesterov83914442008-07-25 01:47:45 -07001769 }
Roland McGrath4206d3a2008-01-30 13:31:45 +01001770
1771 /*
1772 * Now fill in each thread's information.
1773 */
1774 for (t = info->thread; t != NULL; t = t->next)
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001775 if (!fill_thread_core_info(t, view, siginfo->si_signo, &info->size))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001776 return 0;
1777
1778 /*
1779 * Fill in the two process-wide notes.
1780 */
1781 fill_psinfo(psinfo, dump_task->group_leader, dump_task->mm);
1782 info->size += notesize(&info->psinfo);
1783
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001784 fill_siginfo_note(&info->signote, &info->csigdata, siginfo);
1785 info->size += notesize(&info->signote);
1786
Roland McGrath4206d3a2008-01-30 13:31:45 +01001787 fill_auxv_note(&info->auxv, current->mm);
1788 info->size += notesize(&info->auxv);
1789
Dan Aloni72023652013-09-30 13:45:02 -07001790 if (fill_files_note(&info->files) == 0)
1791 info->size += notesize(&info->files);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001792
Roland McGrath4206d3a2008-01-30 13:31:45 +01001793 return 1;
1794}
1795
1796static size_t get_note_info_size(struct elf_note_info *info)
1797{
1798 return info->size;
1799}
1800
1801/*
1802 * Write all the notes for each thread. When writing the first thread, the
1803 * process-wide notes are interleaved after the first thread-specific note.
1804 */
1805static int write_note_info(struct elf_note_info *info,
Al Viroecc8c772013-10-05 15:32:35 -04001806 struct coredump_params *cprm)
Roland McGrath4206d3a2008-01-30 13:31:45 +01001807{
Fabian Frederickb219e252014-06-04 16:12:14 -07001808 bool first = true;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001809 struct elf_thread_core_info *t = info->thread;
1810
1811 do {
1812 int i;
1813
Al Viroecc8c772013-10-05 15:32:35 -04001814 if (!writenote(&t->notes[0], cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001815 return 0;
1816
Al Viroecc8c772013-10-05 15:32:35 -04001817 if (first && !writenote(&info->psinfo, cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001818 return 0;
Al Viroecc8c772013-10-05 15:32:35 -04001819 if (first && !writenote(&info->signote, cprm))
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001820 return 0;
Al Viroecc8c772013-10-05 15:32:35 -04001821 if (first && !writenote(&info->auxv, cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001822 return 0;
Dan Aloni72023652013-09-30 13:45:02 -07001823 if (first && info->files.data &&
Al Viroecc8c772013-10-05 15:32:35 -04001824 !writenote(&info->files, cprm))
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001825 return 0;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001826
1827 for (i = 1; i < info->thread_notes; ++i)
1828 if (t->notes[i].data &&
Al Viroecc8c772013-10-05 15:32:35 -04001829 !writenote(&t->notes[i], cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001830 return 0;
1831
Fabian Frederickb219e252014-06-04 16:12:14 -07001832 first = false;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001833 t = t->next;
1834 } while (t);
1835
1836 return 1;
1837}
1838
1839static void free_note_info(struct elf_note_info *info)
1840{
1841 struct elf_thread_core_info *threads = info->thread;
1842 while (threads) {
1843 unsigned int i;
1844 struct elf_thread_core_info *t = threads;
1845 threads = t->next;
1846 WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);
1847 for (i = 1; i < info->thread_notes; ++i)
1848 kfree(t->notes[i].data);
1849 kfree(t);
1850 }
1851 kfree(info->psinfo.data);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001852 vfree(info->files.data);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001853}
1854
1855#else
1856
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857/* Here is the structure in which status of each thread is captured. */
1858struct elf_thread_status
1859{
1860 struct list_head list;
1861 struct elf_prstatus prstatus; /* NT_PRSTATUS */
1862 elf_fpregset_t fpu; /* NT_PRFPREG */
1863 struct task_struct *thread;
1864#ifdef ELF_CORE_COPY_XFPREGS
Mark Nelson5b20cd82007-10-16 23:25:39 -07001865 elf_fpxregset_t xfpu; /* ELF_CORE_XFPREG_TYPE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866#endif
1867 struct memelfnote notes[3];
1868 int num_notes;
1869};
1870
1871/*
1872 * In order to add the specific thread information for the elf file format,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001873 * we need to keep a linked list of every threads pr_status and then create
1874 * a single section for them in the final core file.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 */
1876static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1877{
1878 int sz = 0;
1879 struct task_struct *p = t->thread;
1880 t->num_notes = 0;
1881
1882 fill_prstatus(&t->prstatus, p, signr);
1883 elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1884
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001885 fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1886 &(t->prstatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 t->num_notes++;
1888 sz += notesize(&t->notes[0]);
1889
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001890 if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1891 &t->fpu))) {
1892 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1893 &(t->fpu));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 t->num_notes++;
1895 sz += notesize(&t->notes[1]);
1896 }
1897
1898#ifdef ELF_CORE_COPY_XFPREGS
1899 if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
Mark Nelson5b20cd82007-10-16 23:25:39 -07001900 fill_note(&t->notes[2], "LINUX", ELF_CORE_XFPREG_TYPE,
1901 sizeof(t->xfpu), &t->xfpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 t->num_notes++;
1903 sz += notesize(&t->notes[2]);
1904 }
1905#endif
1906 return sz;
1907}
1908
Roland McGrath3aba4812008-01-30 13:31:44 +01001909struct elf_note_info {
1910 struct memelfnote *notes;
Dan Aloni72023652013-09-30 13:45:02 -07001911 struct memelfnote *notes_files;
Roland McGrath3aba4812008-01-30 13:31:44 +01001912 struct elf_prstatus *prstatus; /* NT_PRSTATUS */
1913 struct elf_prpsinfo *psinfo; /* NT_PRPSINFO */
1914 struct list_head thread_list;
1915 elf_fpregset_t *fpu;
1916#ifdef ELF_CORE_COPY_XFPREGS
1917 elf_fpxregset_t *xfpu;
1918#endif
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001919 user_siginfo_t csigdata;
Roland McGrath3aba4812008-01-30 13:31:44 +01001920 int thread_status_size;
1921 int numnote;
1922};
1923
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001924static int elf_note_info_init(struct elf_note_info *info)
Roland McGrath3aba4812008-01-30 13:31:44 +01001925{
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001926 memset(info, 0, sizeof(*info));
Roland McGrath3aba4812008-01-30 13:31:44 +01001927 INIT_LIST_HEAD(&info->thread_list);
1928
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001929 /* Allocate space for ELF notes */
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001930 info->notes = kmalloc(8 * sizeof(struct memelfnote), GFP_KERNEL);
Roland McGrath3aba4812008-01-30 13:31:44 +01001931 if (!info->notes)
1932 return 0;
1933 info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL);
1934 if (!info->psinfo)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001935 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001936 info->prstatus = kmalloc(sizeof(*info->prstatus), GFP_KERNEL);
1937 if (!info->prstatus)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001938 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001939 info->fpu = kmalloc(sizeof(*info->fpu), GFP_KERNEL);
1940 if (!info->fpu)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001941 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001942#ifdef ELF_CORE_COPY_XFPREGS
1943 info->xfpu = kmalloc(sizeof(*info->xfpu), GFP_KERNEL);
1944 if (!info->xfpu)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001945 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001946#endif
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001947 return 1;
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001948}
Roland McGrath3aba4812008-01-30 13:31:44 +01001949
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001950static int fill_note_info(struct elfhdr *elf, int phdrs,
1951 struct elf_note_info *info,
Al Viroec579412013-10-13 17:57:29 -04001952 const siginfo_t *siginfo, struct pt_regs *regs)
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001953{
1954 struct list_head *t;
Al Viroafabada2013-10-14 07:39:56 -04001955 struct core_thread *ct;
1956 struct elf_thread_status *ets;
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001957
1958 if (!elf_note_info_init(info))
1959 return 0;
1960
Al Viroafabada2013-10-14 07:39:56 -04001961 for (ct = current->mm->core_state->dumper.next;
1962 ct; ct = ct->next) {
1963 ets = kzalloc(sizeof(*ets), GFP_KERNEL);
1964 if (!ets)
1965 return 0;
Oleg Nesterov24d52882008-07-25 01:47:40 -07001966
Al Viroafabada2013-10-14 07:39:56 -04001967 ets->thread = ct->task;
1968 list_add(&ets->list, &info->thread_list);
1969 }
Oleg Nesterov83914442008-07-25 01:47:45 -07001970
Al Viroafabada2013-10-14 07:39:56 -04001971 list_for_each(t, &info->thread_list) {
1972 int sz;
Oleg Nesterov83914442008-07-25 01:47:45 -07001973
Al Viroafabada2013-10-14 07:39:56 -04001974 ets = list_entry(t, struct elf_thread_status, list);
1975 sz = elf_dump_thread_status(siginfo->si_signo, ets);
1976 info->thread_status_size += sz;
Roland McGrath3aba4812008-01-30 13:31:44 +01001977 }
1978 /* now collect the dump for the current */
1979 memset(info->prstatus, 0, sizeof(*info->prstatus));
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001980 fill_prstatus(info->prstatus, current, siginfo->si_signo);
Roland McGrath3aba4812008-01-30 13:31:44 +01001981 elf_core_copy_regs(&info->prstatus->pr_reg, regs);
1982
1983 /* Set up header */
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08001984 fill_elf_header(elf, phdrs, ELF_ARCH, ELF_CORE_EFLAGS);
Roland McGrath3aba4812008-01-30 13:31:44 +01001985
1986 /*
1987 * Set up the notes in similar form to SVR4 core dumps made
1988 * with info from their /proc.
1989 */
1990
1991 fill_note(info->notes + 0, "CORE", NT_PRSTATUS,
1992 sizeof(*info->prstatus), info->prstatus);
1993 fill_psinfo(info->psinfo, current->group_leader, current->mm);
1994 fill_note(info->notes + 1, "CORE", NT_PRPSINFO,
1995 sizeof(*info->psinfo), info->psinfo);
1996
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001997 fill_siginfo_note(info->notes + 2, &info->csigdata, siginfo);
1998 fill_auxv_note(info->notes + 3, current->mm);
Dan Aloni72023652013-09-30 13:45:02 -07001999 info->numnote = 4;
Roland McGrath3aba4812008-01-30 13:31:44 +01002000
Dan Aloni72023652013-09-30 13:45:02 -07002001 if (fill_files_note(info->notes + info->numnote) == 0) {
2002 info->notes_files = info->notes + info->numnote;
2003 info->numnote++;
2004 }
Roland McGrath3aba4812008-01-30 13:31:44 +01002005
2006 /* Try to dump the FPU. */
2007 info->prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs,
2008 info->fpu);
2009 if (info->prstatus->pr_fpvalid)
2010 fill_note(info->notes + info->numnote++,
2011 "CORE", NT_PRFPREG, sizeof(*info->fpu), info->fpu);
2012#ifdef ELF_CORE_COPY_XFPREGS
2013 if (elf_core_copy_task_xfpregs(current, info->xfpu))
2014 fill_note(info->notes + info->numnote++,
2015 "LINUX", ELF_CORE_XFPREG_TYPE,
2016 sizeof(*info->xfpu), info->xfpu);
2017#endif
2018
2019 return 1;
Roland McGrath3aba4812008-01-30 13:31:44 +01002020}
2021
2022static size_t get_note_info_size(struct elf_note_info *info)
2023{
2024 int sz = 0;
2025 int i;
2026
2027 for (i = 0; i < info->numnote; i++)
2028 sz += notesize(info->notes + i);
2029
2030 sz += info->thread_status_size;
2031
2032 return sz;
2033}
2034
2035static int write_note_info(struct elf_note_info *info,
Al Viroecc8c772013-10-05 15:32:35 -04002036 struct coredump_params *cprm)
Roland McGrath3aba4812008-01-30 13:31:44 +01002037{
2038 int i;
2039 struct list_head *t;
2040
2041 for (i = 0; i < info->numnote; i++)
Al Viroecc8c772013-10-05 15:32:35 -04002042 if (!writenote(info->notes + i, cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002043 return 0;
2044
2045 /* write out the thread status notes section */
2046 list_for_each(t, &info->thread_list) {
2047 struct elf_thread_status *tmp =
2048 list_entry(t, struct elf_thread_status, list);
2049
2050 for (i = 0; i < tmp->num_notes; i++)
Al Viroecc8c772013-10-05 15:32:35 -04002051 if (!writenote(&tmp->notes[i], cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002052 return 0;
2053 }
2054
2055 return 1;
2056}
2057
2058static void free_note_info(struct elf_note_info *info)
2059{
2060 while (!list_empty(&info->thread_list)) {
2061 struct list_head *tmp = info->thread_list.next;
2062 list_del(tmp);
2063 kfree(list_entry(tmp, struct elf_thread_status, list));
2064 }
2065
Dan Aloni72023652013-09-30 13:45:02 -07002066 /* Free data possibly allocated by fill_files_note(): */
2067 if (info->notes_files)
2068 vfree(info->notes_files->data);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07002069
Roland McGrath3aba4812008-01-30 13:31:44 +01002070 kfree(info->prstatus);
2071 kfree(info->psinfo);
2072 kfree(info->notes);
2073 kfree(info->fpu);
2074#ifdef ELF_CORE_COPY_XFPREGS
2075 kfree(info->xfpu);
2076#endif
2077}
2078
Roland McGrath4206d3a2008-01-30 13:31:45 +01002079#endif
2080
Roland McGrathf47aef52007-01-26 00:56:49 -08002081static struct vm_area_struct *first_vma(struct task_struct *tsk,
2082 struct vm_area_struct *gate_vma)
2083{
2084 struct vm_area_struct *ret = tsk->mm->mmap;
2085
2086 if (ret)
2087 return ret;
2088 return gate_vma;
2089}
2090/*
2091 * Helper function for iterating across a vma list. It ensures that the caller
2092 * will visit `gate_vma' prior to terminating the search.
2093 */
2094static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
2095 struct vm_area_struct *gate_vma)
2096{
2097 struct vm_area_struct *ret;
2098
2099 ret = this_vma->vm_next;
2100 if (ret)
2101 return ret;
2102 if (this_vma == gate_vma)
2103 return NULL;
2104 return gate_vma;
2105}
2106
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002107static void fill_extnum_info(struct elfhdr *elf, struct elf_shdr *shdr4extnum,
2108 elf_addr_t e_shoff, int segs)
2109{
2110 elf->e_shoff = e_shoff;
2111 elf->e_shentsize = sizeof(*shdr4extnum);
2112 elf->e_shnum = 1;
2113 elf->e_shstrndx = SHN_UNDEF;
2114
2115 memset(shdr4extnum, 0, sizeof(*shdr4extnum));
2116
2117 shdr4extnum->sh_type = SHT_NULL;
2118 shdr4extnum->sh_size = elf->e_shnum;
2119 shdr4extnum->sh_link = elf->e_shstrndx;
2120 shdr4extnum->sh_info = segs;
2121}
2122
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123/*
2124 * Actual dumper
2125 *
2126 * This is a two-pass process; first we find the offsets of the bits,
2127 * and then they are actually written out. If we run out of core limit
2128 * we just truncate.
2129 */
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002130static int elf_core_dump(struct coredump_params *cprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 int has_dumped = 0;
2133 mm_segment_t fs;
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002134 int segs, i;
2135 size_t vma_data_size = 0;
Roland McGrathf47aef52007-01-26 00:56:49 -08002136 struct vm_area_struct *vma, *gate_vma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 struct elfhdr *elf = NULL;
Al Virocdc3d562013-10-05 22:24:29 -04002138 loff_t offset = 0, dataoff;
Dan Aloni72023652013-09-30 13:45:02 -07002139 struct elf_note_info info = { };
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002140 struct elf_phdr *phdr4note = NULL;
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002141 struct elf_shdr *shdr4extnum = NULL;
2142 Elf_Half e_phnum;
2143 elf_addr_t e_shoff;
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002144 elf_addr_t *vma_filesz = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145
2146 /*
2147 * We no longer stop all VM operations.
2148 *
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002149 * This is because those proceses that could possibly change map_count
2150 * or the mmap / vma pages are now blocked in do_exit on current
2151 * finishing this core dump.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152 *
2153 * Only ptrace can touch these memory addresses, but it doesn't change
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002154 * the map_count or the pages allocated. So no possibility of crashing
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155 * exists while dumping the mm->vm_next areas to the core file.
2156 */
2157
2158 /* alloc memory for large data structures: too large to be on stack */
2159 elf = kmalloc(sizeof(*elf), GFP_KERNEL);
2160 if (!elf)
WANG Cong5f719552008-05-06 12:45:35 +08002161 goto out;
KAMEZAWA Hiroyuki341c87b2009-06-30 11:41:23 -07002162 /*
2163 * The number of segs are recored into ELF header as 16bit value.
2164 * Please check DEFAULT_MAX_MAP_COUNT definition when you modify here.
2165 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166 segs = current->mm->map_count;
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002167 segs += elf_core_extra_phdrs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168
Stephen Wilson31db58b2011-03-13 15:49:15 -04002169 gate_vma = get_gate_vma(current->mm);
Roland McGrathf47aef52007-01-26 00:56:49 -08002170 if (gate_vma != NULL)
2171 segs++;
2172
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002173 /* for notes section */
2174 segs++;
2175
2176 /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
2177 * this, kernel supports extended numbering. Have a look at
2178 * include/linux/elf.h for further information. */
2179 e_phnum = segs > PN_XNUM ? PN_XNUM : segs;
2180
Roland McGrath3aba4812008-01-30 13:31:44 +01002181 /*
2182 * Collect all the non-memory information about the process for the
2183 * notes. This also sets up the file header.
2184 */
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07002185 if (!fill_note_info(elf, e_phnum, &info, cprm->siginfo, cprm->regs))
Roland McGrath3aba4812008-01-30 13:31:44 +01002186 goto cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187
2188 has_dumped = 1;
Oleg Nesterov079148b2013-04-30 15:28:16 -07002189
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190 fs = get_fs();
2191 set_fs(KERNEL_DS);
2192
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193 offset += sizeof(*elf); /* Elf header */
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002194 offset += segs * sizeof(struct elf_phdr); /* Program headers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195
2196 /* Write notes phdr entry */
2197 {
Roland McGrath3aba4812008-01-30 13:31:44 +01002198 size_t sz = get_note_info_size(&info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199
Michael Ellermane5501492007-09-19 14:38:12 +10002200 sz += elf_coredump_extra_notes_size();
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002201
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002202 phdr4note = kmalloc(sizeof(*phdr4note), GFP_KERNEL);
2203 if (!phdr4note)
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -08002204 goto end_coredump;
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002205
2206 fill_elf_note_phdr(phdr4note, sz, offset);
2207 offset += sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 }
2209
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210 dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
2211
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002212 vma_filesz = kmalloc_array(segs - 1, sizeof(*vma_filesz), GFP_KERNEL);
2213 if (!vma_filesz)
2214 goto end_coredump;
2215
2216 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2217 vma = next_vma(vma, gate_vma)) {
2218 unsigned long dump_size;
2219
2220 dump_size = vma_dump_size(vma, cprm->mm_flags);
2221 vma_filesz[i++] = dump_size;
2222 vma_data_size += dump_size;
2223 }
2224
2225 offset += vma_data_size;
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002226 offset += elf_core_extra_data_size();
2227 e_shoff = offset;
2228
2229 if (e_phnum == PN_XNUM) {
2230 shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);
2231 if (!shdr4extnum)
2232 goto end_coredump;
2233 fill_extnum_info(elf, shdr4extnum, e_shoff, segs);
2234 }
2235
2236 offset = dataoff;
2237
Al Viroecc8c772013-10-05 15:32:35 -04002238 if (!dump_emit(cprm, elf, sizeof(*elf)))
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002239 goto end_coredump;
2240
Al Viroecc8c772013-10-05 15:32:35 -04002241 if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note)))
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002242 goto end_coredump;
2243
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 /* Write program headers for segments dump */
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002245 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
Roland McGrathf47aef52007-01-26 00:56:49 -08002246 vma = next_vma(vma, gate_vma)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 struct elf_phdr phdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248
2249 phdr.p_type = PT_LOAD;
2250 phdr.p_offset = offset;
2251 phdr.p_vaddr = vma->vm_start;
2252 phdr.p_paddr = 0;
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002253 phdr.p_filesz = vma_filesz[i++];
Roland McGrath82df3972007-10-16 23:27:02 -07002254 phdr.p_memsz = vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 offset += phdr.p_filesz;
2256 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002257 if (vma->vm_flags & VM_WRITE)
2258 phdr.p_flags |= PF_W;
2259 if (vma->vm_flags & VM_EXEC)
2260 phdr.p_flags |= PF_X;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261 phdr.p_align = ELF_EXEC_PAGESIZE;
2262
Al Viroecc8c772013-10-05 15:32:35 -04002263 if (!dump_emit(cprm, &phdr, sizeof(phdr)))
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -08002264 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265 }
2266
Al Viro506f21c2013-10-05 17:22:57 -04002267 if (!elf_core_write_extra_phdrs(cprm, offset))
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002268 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002269
2270 /* write out the notes section */
Al Viroecc8c772013-10-05 15:32:35 -04002271 if (!write_note_info(&info, cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002272 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273
Al Virocdc3d562013-10-05 22:24:29 -04002274 if (elf_coredump_extra_notes_write(cprm))
Michael Ellermane5501492007-09-19 14:38:12 +10002275 goto end_coredump;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002276
Andi Kleend025c9d2006-09-30 23:29:28 -07002277 /* Align to page */
Omar Sandovala0083932016-05-11 15:16:36 -07002278 if (!dump_skip(cprm, dataoff - cprm->file->f_pos))
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002279 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002281 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
Roland McGrathf47aef52007-01-26 00:56:49 -08002282 vma = next_vma(vma, gate_vma)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 unsigned long addr;
Roland McGrath82df3972007-10-16 23:27:02 -07002284 unsigned long end;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002286 end = vma->vm_start + vma_filesz[i++];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287
Roland McGrath82df3972007-10-16 23:27:02 -07002288 for (addr = vma->vm_start; addr < end; addr += PAGE_SIZE) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002289 struct page *page;
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002290 int stop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002292 page = get_dump_page(addr);
2293 if (page) {
2294 void *kaddr = kmap(page);
Al Viro13046ec2013-10-05 18:08:47 -04002295 stop = !dump_emit(cprm, kaddr, PAGE_SIZE);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002296 kunmap(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002297 put_page(page);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002298 } else
Al Viro9b56d542013-10-08 09:26:08 -04002299 stop = !dump_skip(cprm, PAGE_SIZE);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002300 if (stop)
2301 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302 }
2303 }
2304
Al Viroaa3e7ea2013-10-05 17:50:15 -04002305 if (!elf_core_write_extra_data(cprm))
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002306 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002308 if (e_phnum == PN_XNUM) {
Al Viro13046ec2013-10-05 18:08:47 -04002309 if (!dump_emit(cprm, shdr4extnum, sizeof(*shdr4extnum)))
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002310 goto end_coredump;
2311 }
2312
Linus Torvalds1da177e2005-04-16 15:20:36 -07002313end_coredump:
2314 set_fs(fs);
2315
2316cleanup:
Roland McGrath3aba4812008-01-30 13:31:44 +01002317 free_note_info(&info);
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002318 kfree(shdr4extnum);
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002319 kfree(vma_filesz);
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002320 kfree(phdr4note);
WANG Cong5f719552008-05-06 12:45:35 +08002321 kfree(elf);
2322out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323 return has_dumped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324}
2325
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08002326#endif /* CONFIG_ELF_CORE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327
2328static int __init init_elf_binfmt(void)
2329{
Al Viro8fc3dc52012-03-17 03:05:16 -04002330 register_binfmt(&elf_format);
2331 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332}
2333
2334static void __exit exit_elf_binfmt(void)
2335{
2336 /* Remove the COFF and ELF loaders. */
2337 unregister_binfmt(&elf_format);
2338}
2339
2340core_initcall(init_elf_binfmt);
2341module_exit(exit_elf_binfmt);
2342MODULE_LICENSE("GPL");