blob: 73cd7482c1fa02c0282f53c1d7e2f616684dca37 [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. Rozycki54d15712015-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 */
Kees Cook0036d1f2016-08-02 14:04:51 -0700608 k = load_addr + eppnt->p_vaddr + eppnt->p_memsz;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700609 if (k > last_bss)
610 last_bss = k;
611 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 }
613
Kees Cook0036d1f2016-08-02 14:04:51 -0700614 /*
615 * Now fill out the bss section: first pad the last page from
616 * the file up to the page boundary, and zero it from elf_bss
617 * up to the end of the page.
618 */
619 if (padzero(elf_bss)) {
620 error = -EFAULT;
621 goto out;
622 }
623 /*
624 * Next, align both the file and mem bss up to the page size,
625 * since this is where elf_bss was just zeroed up to, and where
626 * last_bss will end after the vm_brk() below.
627 */
628 elf_bss = ELF_PAGEALIGN(elf_bss);
629 last_bss = ELF_PAGEALIGN(last_bss);
630 /* Finally, if there is still more bss to allocate, do it. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 if (last_bss > elf_bss) {
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -0700632 error = vm_brk(elf_bss, last_bss - elf_bss);
Linus Torvalds5d22fc22016-05-27 15:57:31 -0700633 if (error)
Paul Burtona9d9ef12014-09-11 08:30:15 +0100634 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 }
636
Jiri Kosinacc503c12008-01-30 13:31:07 +0100637 error = load_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638out:
639 return error;
640}
641
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642/*
643 * These are the functions used to load ELF style executables and shared
644 * libraries. There is no binary dependent code anywhere else.
645 */
646
Andi Kleen913bd902006-03-25 16:29:09 +0100647#ifndef STACK_RND_MASK
James Bottomleyd1cabd62007-03-16 13:38:35 -0800648#define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12)) /* 8MB of VA */
Andi Kleen913bd902006-03-25 16:29:09 +0100649#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
651static unsigned long randomize_stack_top(unsigned long stack_top)
652{
Hector Marco-Gisbert4e7c22d2015-02-14 09:33:50 -0800653 unsigned long random_variable = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
Andi Kleenc16b63e02006-09-26 10:52:28 +0200655 if ((current->flags & PF_RANDOMIZE) &&
656 !(current->personality & ADDR_NO_RANDOMIZE)) {
Daniel Cashman5ef11c32016-02-26 15:19:37 -0800657 random_variable = get_random_long();
Hector Marco-Gisbert4e7c22d2015-02-14 09:33:50 -0800658 random_variable &= STACK_RND_MASK;
Andi Kleen913bd902006-03-25 16:29:09 +0100659 random_variable <<= PAGE_SHIFT;
660 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661#ifdef CONFIG_STACK_GROWSUP
Andi Kleen913bd902006-03-25 16:29:09 +0100662 return PAGE_ALIGN(stack_top) + random_variable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663#else
Andi Kleen913bd902006-03-25 16:29:09 +0100664 return PAGE_ALIGN(stack_top) - random_variable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665#endif
666}
667
Al Viro71613c32012-10-20 22:00:48 -0400668static int load_elf_binary(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669{
670 struct file *interpreter = NULL; /* to shut gcc up */
671 unsigned long load_addr = 0, load_bias = 0;
672 int load_addr_set = 0;
673 char * elf_interpreter = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 unsigned long error;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100675 struct elf_phdr *elf_ppnt, *elf_phdata, *interp_elf_phdata = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 unsigned long elf_bss, elf_brk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 int retval, i;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100678 unsigned long elf_entry;
679 unsigned long interp_load_addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 unsigned long start_code, end_code, start_data, end_data;
David Daney1a530a62011-03-22 16:34:48 -0700681 unsigned long reloc_func_desc __maybe_unused = 0;
David Rientjes8de61e62006-12-06 20:40:16 -0800682 int executable_stack = EXSTACK_DEFAULT;
Al Viro71613c32012-10-20 22:00:48 -0400683 struct pt_regs *regs = current_pt_regs();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 struct {
685 struct elfhdr elf_ex;
686 struct elfhdr interp_elf_ex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 } *loc;
Paul Burton774c1052014-09-11 08:30:16 +0100688 struct arch_elf_state arch_state = INIT_ARCH_ELF_STATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
690 loc = kmalloc(sizeof(*loc), GFP_KERNEL);
691 if (!loc) {
692 retval = -ENOMEM;
693 goto out_ret;
694 }
695
696 /* Get the exec-header */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700697 loc->elf_ex = *((struct elfhdr *)bprm->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698
699 retval = -ENOEXEC;
700 /* First of all, some simple consistency checks */
701 if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
702 goto out;
703
704 if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
705 goto out;
706 if (!elf_check_arch(&loc->elf_ex))
707 goto out;
Al Viro72c2d532013-09-22 16:27:52 -0400708 if (!bprm->file->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 goto out;
710
Paul Burton6a8d3892014-09-11 08:30:14 +0100711 elf_phdata = load_elf_phdrs(&loc->elf_ex, bprm->file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 if (!elf_phdata)
713 goto out;
714
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 elf_ppnt = elf_phdata;
716 elf_bss = 0;
717 elf_brk = 0;
718
719 start_code = ~0UL;
720 end_code = 0;
721 start_data = 0;
722 end_data = 0;
723
724 for (i = 0; i < loc->elf_ex.e_phnum; i++) {
725 if (elf_ppnt->p_type == PT_INTERP) {
726 /* This is the program interpreter used for
727 * shared libraries - for now assume that this
728 * is an a.out format binary
729 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 retval = -ENOEXEC;
731 if (elf_ppnt->p_filesz > PATH_MAX ||
732 elf_ppnt->p_filesz < 2)
Al Viroe7b9b552009-03-29 16:31:16 -0400733 goto out_free_ph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
735 retval = -ENOMEM;
Jesper Juhl792db3a2006-01-09 20:54:45 -0800736 elf_interpreter = kmalloc(elf_ppnt->p_filesz,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700737 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 if (!elf_interpreter)
Al Viroe7b9b552009-03-29 16:31:16 -0400739 goto out_free_ph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
741 retval = kernel_read(bprm->file, elf_ppnt->p_offset,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700742 elf_interpreter,
743 elf_ppnt->p_filesz);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 if (retval != elf_ppnt->p_filesz) {
745 if (retval >= 0)
746 retval = -EIO;
747 goto out_free_interp;
748 }
749 /* make sure path is NULL terminated */
750 retval = -ENOEXEC;
751 if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
752 goto out_free_interp;
753
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 interpreter = open_exec(elf_interpreter);
755 retval = PTR_ERR(interpreter);
756 if (IS_ERR(interpreter))
757 goto out_free_interp;
Alexey Dobriyan1fb84492007-01-26 00:57:16 -0800758
759 /*
760 * If the binary is not readable then enforce
761 * mm->dumpable = 0 regardless of the interpreter's
762 * permissions.
763 */
Al Viro1b5d7832011-06-19 12:49:47 -0400764 would_dump(bprm, interpreter);
Alexey Dobriyan1fb84492007-01-26 00:57:16 -0800765
Maciej W. Rozyckib582ef52015-10-26 15:48:19 +0000766 /* Get the exec headers */
767 retval = kernel_read(interpreter, 0,
768 (void *)&loc->interp_elf_ex,
769 sizeof(loc->interp_elf_ex));
770 if (retval != sizeof(loc->interp_elf_ex)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 if (retval >= 0)
772 retval = -EIO;
773 goto out_free_dentry;
774 }
775
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 break;
777 }
778 elf_ppnt++;
779 }
780
781 elf_ppnt = elf_phdata;
782 for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
Paul Burton774c1052014-09-11 08:30:16 +0100783 switch (elf_ppnt->p_type) {
784 case PT_GNU_STACK:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 if (elf_ppnt->p_flags & PF_X)
786 executable_stack = EXSTACK_ENABLE_X;
787 else
788 executable_stack = EXSTACK_DISABLE_X;
789 break;
Paul Burton774c1052014-09-11 08:30:16 +0100790
791 case PT_LOPROC ... PT_HIPROC:
792 retval = arch_elf_pt_proc(&loc->elf_ex, elf_ppnt,
793 bprm->file, false,
794 &arch_state);
795 if (retval)
796 goto out_free_dentry;
797 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799
800 /* Some simple consistency checks for the interpreter */
801 if (elf_interpreter) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 retval = -ELIBBAD;
Andi Kleend20894a2008-02-08 04:21:54 -0800803 /* Not an ELF interpreter */
804 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 /* Verify the interpreter has a valid arch */
Andi Kleend20894a2008-02-08 04:21:54 -0800807 if (!elf_check_arch(&loc->interp_elf_ex))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 goto out_free_dentry;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100809
810 /* Load the interpreter program headers */
811 interp_elf_phdata = load_elf_phdrs(&loc->interp_elf_ex,
812 interpreter);
813 if (!interp_elf_phdata)
814 goto out_free_dentry;
Paul Burton774c1052014-09-11 08:30:16 +0100815
816 /* Pass PT_LOPROC..PT_HIPROC headers to arch code */
817 elf_ppnt = interp_elf_phdata;
818 for (i = 0; i < loc->interp_elf_ex.e_phnum; i++, elf_ppnt++)
819 switch (elf_ppnt->p_type) {
820 case PT_LOPROC ... PT_HIPROC:
821 retval = arch_elf_pt_proc(&loc->interp_elf_ex,
822 elf_ppnt, interpreter,
823 true, &arch_state);
824 if (retval)
825 goto out_free_dentry;
826 break;
827 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 }
829
Paul Burton774c1052014-09-11 08:30:16 +0100830 /*
831 * Allow arch code to reject the ELF at this point, whilst it's
832 * still possible to return an error to the code that invoked
833 * the exec syscall.
834 */
Maciej W. Rozyckieb4bc072015-11-13 00:47:48 +0000835 retval = arch_check_elf(&loc->elf_ex,
836 !!interpreter, &loc->interp_elf_ex,
837 &arch_state);
Paul Burton774c1052014-09-11 08:30:16 +0100838 if (retval)
839 goto out_free_dentry;
840
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 /* Flush all traces of the currently running executable */
842 retval = flush_old_exec(bprm);
843 if (retval)
844 goto out_free_dentry;
845
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 /* Do this immediately, since STACK_TOP as used in setup_arg_pages
847 may depend on the personality. */
Paul Burton774c1052014-09-11 08:30:16 +0100848 SET_PERSONALITY2(loc->elf_ex, &arch_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 if (elf_read_implies_exec(loc->elf_ex, executable_stack))
850 current->personality |= READ_IMPLIES_EXEC;
851
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700852 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 current->flags |= PF_RANDOMIZE;
Linus Torvalds221af7f2010-01-28 22:14:42 -0800854
855 setup_new_exec(bprm);
Linus Torvalds9f834ec2016-08-22 16:41:46 -0700856 install_exec_creds(bprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857
858 /* Do this so that we can load the interpreter, if need be. We will
859 change some of these later */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
861 executable_stack);
Al Viro19d860a2014-05-04 20:11:36 -0400862 if (retval < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 current->mm->start_stack = bprm->p;
866
André Goddard Rosaaf901ca2009-11-14 13:09:05 -0200867 /* Now we do a little grungy work by mmapping the ELF image into
Jiri Kosinacc503c12008-01-30 13:31:07 +0100868 the correct location in memory. */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700869 for(i = 0, elf_ppnt = elf_phdata;
870 i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 int elf_prot = 0, elf_flags;
872 unsigned long k, vaddr;
Michael Davidsona87938b2015-04-14 15:47:38 -0700873 unsigned long total_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874
875 if (elf_ppnt->p_type != PT_LOAD)
876 continue;
877
878 if (unlikely (elf_brk > elf_bss)) {
879 unsigned long nbyte;
880
881 /* There was a PT_LOAD segment with p_memsz > p_filesz
882 before this one. Map anonymous pages, if needed,
883 and clear the area. */
Mikael Petterssonf670d0e2011-01-12 17:00:02 -0800884 retval = set_brk(elf_bss + load_bias,
885 elf_brk + load_bias);
Al Viro19d860a2014-05-04 20:11:36 -0400886 if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 nbyte = ELF_PAGEOFFSET(elf_bss);
889 if (nbyte) {
890 nbyte = ELF_MIN_ALIGN - nbyte;
891 if (nbyte > elf_brk - elf_bss)
892 nbyte = elf_brk - elf_bss;
893 if (clear_user((void __user *)elf_bss +
894 load_bias, nbyte)) {
895 /*
896 * This bss-zeroing can fail if the ELF
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700897 * file specifies odd protections. So
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 * we don't check the return value
899 */
900 }
901 }
902 }
903
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700904 if (elf_ppnt->p_flags & PF_R)
905 elf_prot |= PROT_READ;
906 if (elf_ppnt->p_flags & PF_W)
907 elf_prot |= PROT_WRITE;
908 if (elf_ppnt->p_flags & PF_X)
909 elf_prot |= PROT_EXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700911 elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
913 vaddr = elf_ppnt->p_vaddr;
Kees Cook63c2f8f2017-07-10 15:52:37 -0700914 /*
915 * If we are loading ET_EXEC or we have already performed
916 * the ET_DYN load_addr calculations, proceed normally.
917 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
919 elf_flags |= MAP_FIXED;
920 } else if (loc->elf_ex.e_type == ET_DYN) {
Kees Cook63c2f8f2017-07-10 15:52:37 -0700921 /*
922 * This logic is run once for the first LOAD Program
923 * Header for ET_DYN binaries to calculate the
924 * randomization (load_bias) for all the LOAD
925 * Program Headers, and to calculate the entire
926 * size of the ELF mapping (total_size). (Note that
927 * load_addr_set is set to true later once the
928 * initial mapping is performed.)
929 *
930 * There are effectively two types of ET_DYN
931 * binaries: programs (i.e. PIE: ET_DYN with INTERP)
932 * and loaders (ET_DYN without INTERP, since they
933 * _are_ the ELF interpreter). The loaders must
934 * be loaded away from programs since the program
935 * may otherwise collide with the loader (especially
936 * for ET_EXEC which does not have a randomized
937 * position). For example to handle invocations of
938 * "./ld.so someprog" to test out a new version of
939 * the loader, the subsequent program that the
940 * loader loads must avoid the loader itself, so
941 * they cannot share the same load range. Sufficient
942 * room for the brk must be allocated with the
943 * loader as well, since brk must be available with
944 * the loader.
945 *
946 * Therefore, programs are loaded offset from
947 * ELF_ET_DYN_BASE and loaders are loaded into the
948 * independently randomized mmap region (0 load_bias
949 * without MAP_FIXED).
950 */
951 if (elf_interpreter) {
952 load_bias = ELF_ET_DYN_BASE;
953 if (current->flags & PF_RANDOMIZE)
954 load_bias += arch_mmap_rnd();
955 elf_flags |= MAP_FIXED;
956 } else
957 load_bias = 0;
958
959 /*
960 * Since load_bias is used for all subsequent loading
961 * calculations, we must lower it by the first vaddr
962 * so that the remaining calculations based on the
963 * ELF vaddrs will be correctly offset. The result
964 * is then page aligned.
965 */
966 load_bias = ELF_PAGESTART(load_bias - vaddr);
967
Michael Davidsona87938b2015-04-14 15:47:38 -0700968 total_size = total_mapping_size(elf_phdata,
969 loc->elf_ex.e_phnum);
970 if (!total_size) {
Andrew Morton2b1d3ae2015-05-28 15:44:24 -0700971 retval = -EINVAL;
Michael Davidsona87938b2015-04-14 15:47:38 -0700972 goto out_free_dentry;
973 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 }
975
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700976 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
Michael Davidsona87938b2015-04-14 15:47:38 -0700977 elf_prot, elf_flags, total_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 if (BAD_ADDR(error)) {
Alexey Kuznetsovb140f2512007-05-08 00:31:57 -0700979 retval = IS_ERR((void *)error) ?
980 PTR_ERR((void*)error) : -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 goto out_free_dentry;
982 }
983
984 if (!load_addr_set) {
985 load_addr_set = 1;
986 load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
987 if (loc->elf_ex.e_type == ET_DYN) {
988 load_bias += error -
989 ELF_PAGESTART(load_bias + vaddr);
990 load_addr += load_bias;
991 reloc_func_desc = load_bias;
992 }
993 }
994 k = elf_ppnt->p_vaddr;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700995 if (k < start_code)
996 start_code = k;
997 if (start_data < k)
998 start_data = k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999
1000 /*
1001 * Check to see if the section's size will overflow the
1002 * allowed task size. Note that p_filesz must always be
1003 * <= p_memsz so it is only necessary to check p_memsz.
1004 */
Chuck Ebbertce510592006-07-03 00:24:14 -07001005 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 elf_ppnt->p_memsz > TASK_SIZE ||
1007 TASK_SIZE - elf_ppnt->p_memsz < k) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001008 /* set_brk can never work. Avoid overflows. */
Alexey Kuznetsovb140f2512007-05-08 00:31:57 -07001009 retval = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 goto out_free_dentry;
1011 }
1012
1013 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
1014
1015 if (k > elf_bss)
1016 elf_bss = k;
1017 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
1018 end_code = k;
1019 if (end_data < k)
1020 end_data = k;
1021 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
1022 if (k > elf_brk)
1023 elf_brk = k;
1024 }
1025
1026 loc->elf_ex.e_entry += load_bias;
1027 elf_bss += load_bias;
1028 elf_brk += load_bias;
1029 start_code += load_bias;
1030 end_code += load_bias;
1031 start_data += load_bias;
1032 end_data += load_bias;
1033
1034 /* Calling set_brk effectively mmaps the pages that we need
1035 * for the bss and break sections. We must do this before
1036 * mapping in the interpreter, to make sure it doesn't wind
1037 * up getting placed where the bss needs to go.
1038 */
1039 retval = set_brk(elf_bss, elf_brk);
Al Viro19d860a2014-05-04 20:11:36 -04001040 if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 goto out_free_dentry;
akpm@osdl.org6de50512005-10-11 08:29:08 -07001042 if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 retval = -EFAULT; /* Nobody gets to see this, but.. */
1044 goto out_free_dentry;
1045 }
1046
1047 if (elf_interpreter) {
Alan Cox6eec4822012-10-04 17:13:42 -07001048 unsigned long interp_map_addr = 0;
Jiri Kosinacc503c12008-01-30 13:31:07 +01001049
Andi Kleend20894a2008-02-08 04:21:54 -08001050 elf_entry = load_elf_interp(&loc->interp_elf_ex,
1051 interpreter,
1052 &interp_map_addr,
Paul Burtona9d9ef12014-09-11 08:30:15 +01001053 load_bias, interp_elf_phdata);
Andi Kleend20894a2008-02-08 04:21:54 -08001054 if (!IS_ERR((void *)elf_entry)) {
1055 /*
1056 * load_elf_interp() returns relocation
1057 * adjustment
1058 */
1059 interp_load_addr = elf_entry;
1060 elf_entry += loc->interp_elf_ex.e_entry;
Jiri Kosinacc503c12008-01-30 13:31:07 +01001061 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 if (BAD_ADDR(elf_entry)) {
Chuck Ebbertce510592006-07-03 00:24:14 -07001063 retval = IS_ERR((void *)elf_entry) ?
1064 (int)elf_entry : -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 goto out_free_dentry;
1066 }
1067 reloc_func_desc = interp_load_addr;
1068
1069 allow_write_access(interpreter);
1070 fput(interpreter);
1071 kfree(elf_interpreter);
1072 } else {
1073 elf_entry = loc->elf_ex.e_entry;
Suresh Siddha5342fba2006-02-26 04:18:28 +01001074 if (BAD_ADDR(elf_entry)) {
Chuck Ebbertce510592006-07-03 00:24:14 -07001075 retval = -EINVAL;
Suresh Siddha5342fba2006-02-26 04:18:28 +01001076 goto out_free_dentry;
1077 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 }
1079
Paul Burton774c1052014-09-11 08:30:16 +01001080 kfree(interp_elf_phdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 kfree(elf_phdata);
1082
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 set_binfmt(&elf_format);
1084
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -07001085#ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
Martin Schwidefskyfc5243d2008-12-25 13:38:35 +01001086 retval = arch_setup_additional_pages(bprm, !!elf_interpreter);
Al Viro19d860a2014-05-04 20:11:36 -04001087 if (retval < 0)
Roland McGrath18c8baf2005-04-28 15:17:19 -07001088 goto out;
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -07001089#endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
1090
Ollie Wildb6a2fea2007-07-19 01:48:16 -07001091 retval = create_elf_tables(bprm, &loc->elf_ex,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001092 load_addr, interp_load_addr);
Al Viro19d860a2014-05-04 20:11:36 -04001093 if (retval < 0)
Ollie Wildb6a2fea2007-07-19 01:48:16 -07001094 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 /* N.B. passed_fileno might not be initialized? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 current->mm->end_code = end_code;
1097 current->mm->start_code = start_code;
1098 current->mm->start_data = start_data;
1099 current->mm->end_data = end_data;
1100 current->mm->start_stack = bprm->p;
1101
Jiri Kosina4471a672011-04-14 15:22:09 -07001102 if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
Kees Cook4e3f9b32019-05-14 15:43:57 -07001103 /*
1104 * For architectures with ELF randomization, when executing
1105 * a loader directly (i.e. no interpreter listed in ELF
1106 * headers), move the brk area out of the mmap region
1107 * (since it grows up, and may collide early with the stack
1108 * growing down), and into the unused ELF_ET_DYN_BASE region.
1109 */
Kees Cookc7adf032019-09-26 10:15:25 -07001110 if (IS_ENABLED(CONFIG_ARCH_HAS_ELF_RANDOMIZE) &&
1111 loc->elf_ex.e_type == ET_DYN && !interpreter)
Kees Cook4e3f9b32019-05-14 15:43:57 -07001112 current->mm->brk = current->mm->start_brk =
1113 ELF_ET_DYN_BASE;
1114
Jiri Kosinac1d171a2008-01-30 13:30:40 +01001115 current->mm->brk = current->mm->start_brk =
1116 arch_randomize_brk(current->mm);
Kees Cook204db6e2015-04-14 15:48:12 -07001117#ifdef compat_brk_randomized
Jiri Kosina4471a672011-04-14 15:22:09 -07001118 current->brk_randomized = 1;
1119#endif
1120 }
Jiri Kosinac1d171a2008-01-30 13:30:40 +01001121
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 if (current->personality & MMAP_PAGE_ZERO) {
1123 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1124 and some applications "depend" upon this behavior.
1125 Since we do not have the power to recompile these, we
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001126 emulate the SVr4 behavior. Sigh. */
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001127 error = vm_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 MAP_FIXED | MAP_PRIVATE, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 }
1130
1131#ifdef ELF_PLAT_INIT
1132 /*
1133 * The ABI may specify that certain registers be set up in special
1134 * ways (on i386 %edx is the address of a DT_FINI function, for
1135 * example. In addition, it may also specify (eg, PowerPC64 ELF)
1136 * that the e_entry field is the address of the function descriptor
1137 * for the startup routine, rather than the address of the startup
1138 * routine itself. This macro performs whatever initialization to
1139 * the regs structure is required as well as any relocations to the
1140 * function descriptor entries when executing dynamically links apps.
1141 */
1142 ELF_PLAT_INIT(regs, reloc_func_desc);
1143#endif
1144
1145 start_thread(regs, elf_entry, bprm->p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 retval = 0;
1147out:
1148 kfree(loc);
1149out_ret:
1150 return retval;
1151
1152 /* error cleanup */
1153out_free_dentry:
Paul Burtona9d9ef12014-09-11 08:30:15 +01001154 kfree(interp_elf_phdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 allow_write_access(interpreter);
1156 if (interpreter)
1157 fput(interpreter);
1158out_free_interp:
Jesper Juhlf99d49a2005-11-07 01:01:34 -08001159 kfree(elf_interpreter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160out_free_ph:
1161 kfree(elf_phdata);
1162 goto out;
1163}
1164
Josh Triplett69369a72014-04-03 14:48:27 -07001165#ifdef CONFIG_USELIB
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166/* This is really simpleminded and specialized - we are loading an
1167 a.out library that is given an ELF header. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168static int load_elf_library(struct file *file)
1169{
1170 struct elf_phdr *elf_phdata;
1171 struct elf_phdr *eppnt;
1172 unsigned long elf_bss, bss, len;
1173 int retval, error, i, j;
1174 struct elfhdr elf_ex;
1175
1176 error = -ENOEXEC;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001177 retval = kernel_read(file, 0, (char *)&elf_ex, sizeof(elf_ex));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 if (retval != sizeof(elf_ex))
1179 goto out;
1180
1181 if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1182 goto out;
1183
1184 /* First of all, some simple consistency checks */
1185 if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
Al Viro72c2d532013-09-22 16:27:52 -04001186 !elf_check_arch(&elf_ex) || !file->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 goto out;
1188
1189 /* Now read in all of the header information */
1190
1191 j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1192 /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1193
1194 error = -ENOMEM;
1195 elf_phdata = kmalloc(j, GFP_KERNEL);
1196 if (!elf_phdata)
1197 goto out;
1198
1199 eppnt = elf_phdata;
1200 error = -ENOEXEC;
1201 retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);
1202 if (retval != j)
1203 goto out_free_ph;
1204
1205 for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1206 if ((eppnt + i)->p_type == PT_LOAD)
1207 j++;
1208 if (j != 1)
1209 goto out_free_ph;
1210
1211 while (eppnt->p_type != PT_LOAD)
1212 eppnt++;
1213
1214 /* Now use mmap to map the library into memory. */
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001215 error = vm_mmap(file,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 ELF_PAGESTART(eppnt->p_vaddr),
1217 (eppnt->p_filesz +
1218 ELF_PAGEOFFSET(eppnt->p_vaddr)),
1219 PROT_READ | PROT_WRITE | PROT_EXEC,
1220 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
1221 (eppnt->p_offset -
1222 ELF_PAGEOFFSET(eppnt->p_vaddr)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 if (error != ELF_PAGESTART(eppnt->p_vaddr))
1224 goto out_free_ph;
1225
1226 elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1227 if (padzero(elf_bss)) {
1228 error = -EFAULT;
1229 goto out_free_ph;
1230 }
1231
Oscar Salvadordb2858f2018-07-13 16:59:13 -07001232 len = ELF_PAGEALIGN(eppnt->p_filesz + eppnt->p_vaddr);
1233 bss = ELF_PAGEALIGN(eppnt->p_memsz + eppnt->p_vaddr);
Michal Hockoecc2bc82016-05-23 16:25:39 -07001234 if (bss > len) {
1235 error = vm_brk(len, bss - len);
Linus Torvalds5d22fc22016-05-27 15:57:31 -07001236 if (error)
Michal Hockoecc2bc82016-05-23 16:25:39 -07001237 goto out_free_ph;
1238 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 error = 0;
1240
1241out_free_ph:
1242 kfree(elf_phdata);
1243out:
1244 return error;
1245}
Josh Triplett69369a72014-04-03 14:48:27 -07001246#endif /* #ifdef CONFIG_USELIB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08001248#ifdef CONFIG_ELF_CORE
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249/*
1250 * ELF core dumper
1251 *
1252 * Modelled on fs/exec.c:aout_core_dump()
1253 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1254 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255
1256/*
Jason Baron909af762012-03-23 15:02:51 -07001257 * The purpose of always_dump_vma() is to make sure that special kernel mappings
1258 * that are useful for post-mortem analysis are included in every core dump.
1259 * In that way we ensure that the core dump is fully interpretable later
1260 * without matching up the same kernel and hardware config to see what PC values
1261 * meant. These special mappings include - vDSO, vsyscall, and other
1262 * architecture specific mappings
1263 */
1264static bool always_dump_vma(struct vm_area_struct *vma)
1265{
1266 /* Any vsyscall mappings? */
1267 if (vma == get_gate_vma(vma->vm_mm))
1268 return true;
Andy Lutomirski78d683e2014-05-19 15:58:32 -07001269
1270 /*
1271 * Assume that all vmas with a .name op should always be dumped.
1272 * If this changes, a new vm_ops field can easily be added.
1273 */
1274 if (vma->vm_ops && vma->vm_ops->name && vma->vm_ops->name(vma))
1275 return true;
1276
Jason Baron909af762012-03-23 15:02:51 -07001277 /*
1278 * arch_vma_name() returns non-NULL for special architecture mappings,
1279 * such as vDSO sections.
1280 */
1281 if (arch_vma_name(vma))
1282 return true;
1283
1284 return false;
1285}
1286
1287/*
Roland McGrath82df3972007-10-16 23:27:02 -07001288 * Decide what to dump of a segment, part, all or none.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 */
Roland McGrath82df3972007-10-16 23:27:02 -07001290static unsigned long vma_dump_size(struct vm_area_struct *vma,
1291 unsigned long mm_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292{
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001293#define FILTER(type) (mm_flags & (1UL << MMF_DUMP_##type))
1294
Jason Baron909af762012-03-23 15:02:51 -07001295 /* always dump the vdso and vsyscall sections */
1296 if (always_dump_vma(vma))
Roland McGrath82df3972007-10-16 23:27:02 -07001297 goto whole;
Roland McGrathe5b97dd2007-01-26 00:56:48 -08001298
Konstantin Khlebnikov0103bd12012-10-08 16:28:59 -07001299 if (vma->vm_flags & VM_DONTDUMP)
Jason Baronaccb61f2012-03-23 15:02:51 -07001300 return 0;
1301
Ross Zwisler50378352015-10-05 16:33:36 -06001302 /* support for DAX */
1303 if (vma_is_dax(vma)) {
1304 if ((vma->vm_flags & VM_SHARED) && FILTER(DAX_SHARED))
1305 goto whole;
1306 if (!(vma->vm_flags & VM_SHARED) && FILTER(DAX_PRIVATE))
1307 goto whole;
1308 return 0;
1309 }
1310
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001311 /* Hugetlb memory check */
1312 if (vma->vm_flags & VM_HUGETLB) {
1313 if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))
1314 goto whole;
1315 if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))
1316 goto whole;
Naoya Horiguchi23d9e482013-04-17 15:58:28 -07001317 return 0;
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001318 }
1319
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 /* Do not dump I/O mapped devices or special mappings */
Konstantin Khlebnikov314e51b2012-10-08 16:29:02 -07001321 if (vma->vm_flags & VM_IO)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 return 0;
1323
Kawai, Hidehiroa1b59e82007-07-19 01:48:29 -07001324 /* By default, dump shared memory if mapped from an anonymous file. */
1325 if (vma->vm_flags & VM_SHARED) {
Al Viro496ad9a2013-01-23 17:07:38 -05001326 if (file_inode(vma->vm_file)->i_nlink == 0 ?
Roland McGrath82df3972007-10-16 23:27:02 -07001327 FILTER(ANON_SHARED) : FILTER(MAPPED_SHARED))
1328 goto whole;
1329 return 0;
Kawai, Hidehiroa1b59e82007-07-19 01:48:29 -07001330 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331
Roland McGrath82df3972007-10-16 23:27:02 -07001332 /* Dump segments that have been written to. */
1333 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1334 goto whole;
1335 if (vma->vm_file == NULL)
1336 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337
Roland McGrath82df3972007-10-16 23:27:02 -07001338 if (FILTER(MAPPED_PRIVATE))
1339 goto whole;
1340
1341 /*
1342 * If this looks like the beginning of a DSO or executable mapping,
1343 * check for an ELF header. If we find one, dump the first page to
1344 * aid in determining what was mapped here.
1345 */
Roland McGrath92dc07b2009-02-06 17:34:07 -08001346 if (FILTER(ELF_HEADERS) &&
1347 vma->vm_pgoff == 0 && (vma->vm_flags & VM_READ)) {
Roland McGrath82df3972007-10-16 23:27:02 -07001348 u32 __user *header = (u32 __user *) vma->vm_start;
1349 u32 word;
Roland McGrath92dc07b2009-02-06 17:34:07 -08001350 mm_segment_t fs = get_fs();
Roland McGrath82df3972007-10-16 23:27:02 -07001351 /*
1352 * Doing it this way gets the constant folded by GCC.
1353 */
1354 union {
1355 u32 cmp;
1356 char elfmag[SELFMAG];
1357 } magic;
1358 BUILD_BUG_ON(SELFMAG != sizeof word);
1359 magic.elfmag[EI_MAG0] = ELFMAG0;
1360 magic.elfmag[EI_MAG1] = ELFMAG1;
1361 magic.elfmag[EI_MAG2] = ELFMAG2;
1362 magic.elfmag[EI_MAG3] = ELFMAG3;
Roland McGrath92dc07b2009-02-06 17:34:07 -08001363 /*
1364 * Switch to the user "segment" for get_user(),
1365 * then put back what elf_core_dump() had in place.
1366 */
1367 set_fs(USER_DS);
1368 if (unlikely(get_user(word, header)))
1369 word = 0;
1370 set_fs(fs);
1371 if (word == magic.cmp)
Roland McGrath82df3972007-10-16 23:27:02 -07001372 return PAGE_SIZE;
1373 }
1374
1375#undef FILTER
1376
1377 return 0;
1378
1379whole:
1380 return vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381}
1382
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383/* An ELF note in memory */
1384struct memelfnote
1385{
1386 const char *name;
1387 int type;
1388 unsigned int datasz;
1389 void *data;
1390};
1391
1392static int notesize(struct memelfnote *en)
1393{
1394 int sz;
1395
1396 sz = sizeof(struct elf_note);
1397 sz += roundup(strlen(en->name) + 1, 4);
1398 sz += roundup(en->datasz, 4);
1399
1400 return sz;
1401}
1402
Al Viroecc8c772013-10-05 15:32:35 -04001403static int writenote(struct memelfnote *men, struct coredump_params *cprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404{
1405 struct elf_note en;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 en.n_namesz = strlen(men->name) + 1;
1407 en.n_descsz = men->datasz;
1408 en.n_type = men->type;
1409
Al Viroecc8c772013-10-05 15:32:35 -04001410 return dump_emit(cprm, &en, sizeof(en)) &&
Al Viro22a8cb82013-10-08 11:05:01 -04001411 dump_emit(cprm, men->name, en.n_namesz) && dump_align(cprm, 4) &&
1412 dump_emit(cprm, men->data, men->datasz) && dump_align(cprm, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414
Roland McGrath3aba4812008-01-30 13:31:44 +01001415static void fill_elf_header(struct elfhdr *elf, int segs,
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08001416 u16 machine, u32 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417{
Cyrill Gorcunov6970c8e2008-04-29 01:01:18 -07001418 memset(elf, 0, sizeof(*elf));
1419
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 memcpy(elf->e_ident, ELFMAG, SELFMAG);
1421 elf->e_ident[EI_CLASS] = ELF_CLASS;
1422 elf->e_ident[EI_DATA] = ELF_DATA;
1423 elf->e_ident[EI_VERSION] = EV_CURRENT;
1424 elf->e_ident[EI_OSABI] = ELF_OSABI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425
1426 elf->e_type = ET_CORE;
Roland McGrath3aba4812008-01-30 13:31:44 +01001427 elf->e_machine = machine;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 elf->e_version = EV_CURRENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 elf->e_phoff = sizeof(struct elfhdr);
Roland McGrath3aba4812008-01-30 13:31:44 +01001430 elf->e_flags = flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 elf->e_ehsize = sizeof(struct elfhdr);
1432 elf->e_phentsize = sizeof(struct elf_phdr);
1433 elf->e_phnum = segs;
Cyrill Gorcunov6970c8e2008-04-29 01:01:18 -07001434
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 return;
1436}
1437
Andrew Morton8d6b5eee2006-09-25 23:32:04 -07001438static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439{
1440 phdr->p_type = PT_NOTE;
1441 phdr->p_offset = offset;
1442 phdr->p_vaddr = 0;
1443 phdr->p_paddr = 0;
1444 phdr->p_filesz = sz;
1445 phdr->p_memsz = 0;
1446 phdr->p_flags = 0;
1447 phdr->p_align = 0;
1448 return;
1449}
1450
1451static void fill_note(struct memelfnote *note, const char *name, int type,
1452 unsigned int sz, void *data)
1453{
1454 note->name = name;
1455 note->type = type;
1456 note->datasz = sz;
1457 note->data = data;
1458 return;
1459}
1460
1461/*
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001462 * fill up all the fields in prstatus from the given task struct, except
1463 * registers which need to be filled up separately.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 */
1465static void fill_prstatus(struct elf_prstatus *prstatus,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001466 struct task_struct *p, long signr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467{
1468 prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1469 prstatus->pr_sigpend = p->pending.signal.sig[0];
1470 prstatus->pr_sighold = p->blocked.sig[0];
Oleg Nesterov3b34fc52009-06-17 16:27:38 -07001471 rcu_read_lock();
1472 prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1473 rcu_read_unlock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001474 prstatus->pr_pid = task_pid_vnr(p);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001475 prstatus->pr_pgrp = task_pgrp_vnr(p);
1476 prstatus->pr_sid = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 if (thread_group_leader(p)) {
Frank Mayharf06febc2008-09-12 09:54:39 -07001478 struct task_cputime cputime;
1479
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 /*
Frank Mayharf06febc2008-09-12 09:54:39 -07001481 * This is the record for the group leader. It shows the
1482 * group-wide total, not its individual thread total.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 */
Frank Mayharf06febc2008-09-12 09:54:39 -07001484 thread_group_cputime(p, &cputime);
1485 cputime_to_timeval(cputime.utime, &prstatus->pr_utime);
1486 cputime_to_timeval(cputime.stime, &prstatus->pr_stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 } else {
Frederic Weisbecker6fac4822012-11-13 14:20:55 +01001488 cputime_t utime, stime;
1489
1490 task_cputime(p, &utime, &stime);
1491 cputime_to_timeval(utime, &prstatus->pr_utime);
1492 cputime_to_timeval(stime, &prstatus->pr_stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 }
1494 cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
1495 cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
1496}
1497
1498static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1499 struct mm_struct *mm)
1500{
David Howellsc69e8d92008-11-14 10:39:19 +11001501 const struct cred *cred;
Greg Kroah-Hartmana84a5052005-05-11 00:10:44 -07001502 unsigned int i, len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503
1504 /* first copy the parameters from user space */
1505 memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1506
1507 len = mm->arg_end - mm->arg_start;
1508 if (len >= ELF_PRARGSZ)
1509 len = ELF_PRARGSZ-1;
1510 if (copy_from_user(&psinfo->pr_psargs,
1511 (const char __user *)mm->arg_start, len))
1512 return -EFAULT;
1513 for(i = 0; i < len; i++)
1514 if (psinfo->pr_psargs[i] == 0)
1515 psinfo->pr_psargs[i] = ' ';
1516 psinfo->pr_psargs[len] = 0;
1517
Oleg Nesterov3b34fc52009-06-17 16:27:38 -07001518 rcu_read_lock();
1519 psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1520 rcu_read_unlock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001521 psinfo->pr_pid = task_pid_vnr(p);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001522 psinfo->pr_pgrp = task_pgrp_vnr(p);
1523 psinfo->pr_sid = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524
1525 i = p->state ? ffz(~p->state) + 1 : 0;
1526 psinfo->pr_state = i;
Carsten Otte55148542006-03-25 03:08:22 -08001527 psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1529 psinfo->pr_nice = task_nice(p);
1530 psinfo->pr_flag = p->flags;
David Howellsc69e8d92008-11-14 10:39:19 +11001531 rcu_read_lock();
1532 cred = __task_cred(p);
Eric W. Biedermanebc887b2012-02-07 18:36:10 -08001533 SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
1534 SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
David Howellsc69e8d92008-11-14 10:39:19 +11001535 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1537
1538 return 0;
1539}
1540
Roland McGrath3aba4812008-01-30 13:31:44 +01001541static void fill_auxv_note(struct memelfnote *note, struct mm_struct *mm)
1542{
1543 elf_addr_t *auxv = (elf_addr_t *) mm->saved_auxv;
1544 int i = 0;
1545 do
1546 i += 2;
1547 while (auxv[i - 2] != AT_NULL);
1548 fill_note(note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);
1549}
1550
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001551static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,
Al Viroce395962013-10-13 17:23:53 -04001552 const siginfo_t *siginfo)
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001553{
1554 mm_segment_t old_fs = get_fs();
1555 set_fs(KERNEL_DS);
1556 copy_siginfo_to_user((user_siginfo_t __user *) csigdata, siginfo);
1557 set_fs(old_fs);
1558 fill_note(note, "CORE", NT_SIGINFO, sizeof(*csigdata), csigdata);
1559}
1560
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001561#define MAX_FILE_NOTE_SIZE (4*1024*1024)
1562/*
1563 * Format of NT_FILE note:
1564 *
1565 * long count -- how many files are mapped
1566 * long page_size -- units for file_ofs
1567 * array of [COUNT] elements of
1568 * long start
1569 * long end
1570 * long file_ofs
1571 * followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1572 */
Dan Aloni72023652013-09-30 13:45:02 -07001573static int fill_files_note(struct memelfnote *note)
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001574{
1575 struct vm_area_struct *vma;
1576 unsigned count, size, names_ofs, remaining, n;
1577 user_long_t *data;
1578 user_long_t *start_end_ofs;
1579 char *name_base, *name_curpos;
1580
1581 /* *Estimated* file count and total data size needed */
1582 count = current->mm->map_count;
1583 size = count * 64;
1584
1585 names_ofs = (2 + 3 * count) * sizeof(data[0]);
1586 alloc:
1587 if (size >= MAX_FILE_NOTE_SIZE) /* paranoia check */
Dan Aloni72023652013-09-30 13:45:02 -07001588 return -EINVAL;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001589 size = round_up(size, PAGE_SIZE);
1590 data = vmalloc(size);
1591 if (!data)
Dan Aloni72023652013-09-30 13:45:02 -07001592 return -ENOMEM;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001593
1594 start_end_ofs = data + 2;
1595 name_base = name_curpos = ((char *)data) + names_ofs;
1596 remaining = size - names_ofs;
1597 count = 0;
1598 for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1599 struct file *file;
1600 const char *filename;
1601
1602 file = vma->vm_file;
1603 if (!file)
1604 continue;
Miklos Szeredi9bf39ab2015-06-19 10:29:13 +02001605 filename = file_path(file, name_curpos, remaining);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001606 if (IS_ERR(filename)) {
1607 if (PTR_ERR(filename) == -ENAMETOOLONG) {
1608 vfree(data);
1609 size = size * 5 / 4;
1610 goto alloc;
1611 }
1612 continue;
1613 }
1614
Miklos Szeredi9bf39ab2015-06-19 10:29:13 +02001615 /* file_path() fills at the end, move name down */
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001616 /* n = strlen(filename) + 1: */
1617 n = (name_curpos + remaining) - filename;
1618 remaining = filename - name_curpos;
1619 memmove(name_curpos, filename, n);
1620 name_curpos += n;
1621
1622 *start_end_ofs++ = vma->vm_start;
1623 *start_end_ofs++ = vma->vm_end;
1624 *start_end_ofs++ = vma->vm_pgoff;
1625 count++;
1626 }
1627
1628 /* Now we know exact count of files, can store it */
1629 data[0] = count;
1630 data[1] = PAGE_SIZE;
1631 /*
1632 * Count usually is less than current->mm->map_count,
1633 * we need to move filenames down.
1634 */
1635 n = current->mm->map_count - count;
1636 if (n != 0) {
1637 unsigned shift_bytes = n * 3 * sizeof(data[0]);
1638 memmove(name_base - shift_bytes, name_base,
1639 name_curpos - name_base);
1640 name_curpos -= shift_bytes;
1641 }
1642
1643 size = name_curpos - (char *)data;
1644 fill_note(note, "CORE", NT_FILE, size, data);
Dan Aloni72023652013-09-30 13:45:02 -07001645 return 0;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001646}
1647
Roland McGrath4206d3a2008-01-30 13:31:45 +01001648#ifdef CORE_DUMP_USE_REGSET
1649#include <linux/regset.h>
1650
1651struct elf_thread_core_info {
1652 struct elf_thread_core_info *next;
1653 struct task_struct *task;
1654 struct elf_prstatus prstatus;
1655 struct memelfnote notes[0];
1656};
1657
1658struct elf_note_info {
1659 struct elf_thread_core_info *thread;
1660 struct memelfnote psinfo;
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001661 struct memelfnote signote;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001662 struct memelfnote auxv;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001663 struct memelfnote files;
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001664 user_siginfo_t csigdata;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001665 size_t size;
1666 int thread_notes;
1667};
1668
Roland McGrathd31472b2008-03-04 14:28:30 -08001669/*
1670 * When a regset has a writeback hook, we call it on each thread before
1671 * dumping user memory. On register window machines, this makes sure the
1672 * user memory backing the register data is up to date before we read it.
1673 */
1674static void do_thread_regset_writeback(struct task_struct *task,
1675 const struct user_regset *regset)
1676{
1677 if (regset->writeback)
1678 regset->writeback(task, regset, 1);
1679}
1680
H. J. Lu0953f65d2012-02-14 13:34:52 -08001681#ifndef PRSTATUS_SIZE
Dmitry Safonov90954e72016-09-05 16:33:06 +03001682#define PRSTATUS_SIZE(S, R) sizeof(S)
H. J. Lu0953f65d2012-02-14 13:34:52 -08001683#endif
1684
1685#ifndef SET_PR_FPVALID
Dmitry Safonov90954e72016-09-05 16:33:06 +03001686#define SET_PR_FPVALID(S, V, R) ((S)->pr_fpvalid = (V))
H. J. Lu0953f65d2012-02-14 13:34:52 -08001687#endif
1688
Roland McGrath4206d3a2008-01-30 13:31:45 +01001689static int fill_thread_core_info(struct elf_thread_core_info *t,
1690 const struct user_regset_view *view,
1691 long signr, size_t *total)
1692{
1693 unsigned int i;
Dmitry Safonov90954e72016-09-05 16:33:06 +03001694 unsigned int regset_size = view->regsets[0].n * view->regsets[0].size;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001695
1696 /*
1697 * NT_PRSTATUS is the one special case, because the regset data
1698 * goes into the pr_reg field inside the note contents, rather
1699 * than being the whole note contents. We fill the reset in here.
1700 * We assume that regset 0 is NT_PRSTATUS.
1701 */
1702 fill_prstatus(&t->prstatus, t->task, signr);
Dmitry Safonov90954e72016-09-05 16:33:06 +03001703 (void) view->regsets[0].get(t->task, &view->regsets[0], 0, regset_size,
1704 &t->prstatus.pr_reg, NULL);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001705
1706 fill_note(&t->notes[0], "CORE", NT_PRSTATUS,
Dmitry Safonov90954e72016-09-05 16:33:06 +03001707 PRSTATUS_SIZE(t->prstatus, regset_size), &t->prstatus);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001708 *total += notesize(&t->notes[0]);
1709
Roland McGrathd31472b2008-03-04 14:28:30 -08001710 do_thread_regset_writeback(t->task, &view->regsets[0]);
1711
Roland McGrath4206d3a2008-01-30 13:31:45 +01001712 /*
1713 * Each other regset might generate a note too. For each regset
1714 * that has no core_note_type or is inactive, we leave t->notes[i]
1715 * all zero and we'll know to skip writing it later.
1716 */
1717 for (i = 1; i < view->n; ++i) {
1718 const struct user_regset *regset = &view->regsets[i];
Roland McGrathd31472b2008-03-04 14:28:30 -08001719 do_thread_regset_writeback(t->task, regset);
H. Peter Anvinc8e25252012-03-02 10:43:48 -08001720 if (regset->core_note_type && regset->get &&
Maciej W. Rozyckie0c76342018-05-15 23:32:45 +01001721 (!regset->active || regset->active(t->task, regset) > 0)) {
Roland McGrath4206d3a2008-01-30 13:31:45 +01001722 int ret;
1723 size_t size = regset->n * regset->size;
Alexander Potapenkod228bc42020-05-27 22:20:52 -07001724 void *data = kzalloc(size, GFP_KERNEL);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001725 if (unlikely(!data))
1726 return 0;
1727 ret = regset->get(t->task, regset,
1728 0, size, data, NULL);
1729 if (unlikely(ret))
1730 kfree(data);
1731 else {
1732 if (regset->core_note_type != NT_PRFPREG)
1733 fill_note(&t->notes[i], "LINUX",
1734 regset->core_note_type,
1735 size, data);
1736 else {
Dmitry Safonov90954e72016-09-05 16:33:06 +03001737 SET_PR_FPVALID(&t->prstatus,
1738 1, regset_size);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001739 fill_note(&t->notes[i], "CORE",
1740 NT_PRFPREG, size, data);
1741 }
1742 *total += notesize(&t->notes[i]);
1743 }
1744 }
1745 }
1746
1747 return 1;
1748}
1749
1750static int fill_note_info(struct elfhdr *elf, int phdrs,
1751 struct elf_note_info *info,
Al Viroec579412013-10-13 17:57:29 -04001752 const siginfo_t *siginfo, struct pt_regs *regs)
Roland McGrath4206d3a2008-01-30 13:31:45 +01001753{
1754 struct task_struct *dump_task = current;
1755 const struct user_regset_view *view = task_user_regset_view(dump_task);
1756 struct elf_thread_core_info *t;
1757 struct elf_prpsinfo *psinfo;
Oleg Nesterov83914442008-07-25 01:47:45 -07001758 struct core_thread *ct;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001759 unsigned int i;
1760
1761 info->size = 0;
1762 info->thread = NULL;
1763
1764 psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
Alan Cox6899e922012-12-17 16:02:09 -08001765 if (psinfo == NULL) {
1766 info->psinfo.data = NULL; /* So we don't free this wrongly */
Roland McGrath4206d3a2008-01-30 13:31:45 +01001767 return 0;
Alan Cox6899e922012-12-17 16:02:09 -08001768 }
Roland McGrath4206d3a2008-01-30 13:31:45 +01001769
Amerigo Wange2dbe122009-07-01 01:06:26 -04001770 fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1771
Roland McGrath4206d3a2008-01-30 13:31:45 +01001772 /*
1773 * Figure out how many notes we're going to need for each thread.
1774 */
1775 info->thread_notes = 0;
1776 for (i = 0; i < view->n; ++i)
1777 if (view->regsets[i].core_note_type != 0)
1778 ++info->thread_notes;
1779
1780 /*
1781 * Sanity check. We rely on regset 0 being in NT_PRSTATUS,
1782 * since it is our one special case.
1783 */
1784 if (unlikely(info->thread_notes == 0) ||
1785 unlikely(view->regsets[0].core_note_type != NT_PRSTATUS)) {
1786 WARN_ON(1);
1787 return 0;
1788 }
1789
1790 /*
1791 * Initialize the ELF file header.
1792 */
1793 fill_elf_header(elf, phdrs,
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08001794 view->e_machine, view->e_flags);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001795
1796 /*
1797 * Allocate a structure for each thread.
1798 */
Oleg Nesterov83914442008-07-25 01:47:45 -07001799 for (ct = &dump_task->mm->core_state->dumper; ct; ct = ct->next) {
1800 t = kzalloc(offsetof(struct elf_thread_core_info,
1801 notes[info->thread_notes]),
1802 GFP_KERNEL);
1803 if (unlikely(!t))
1804 return 0;
Oleg Nesterov24d52882008-07-25 01:47:40 -07001805
Oleg Nesterov83914442008-07-25 01:47:45 -07001806 t->task = ct->task;
1807 if (ct->task == dump_task || !info->thread) {
1808 t->next = info->thread;
1809 info->thread = t;
1810 } else {
1811 /*
1812 * Make sure to keep the original task at
1813 * the head of the list.
1814 */
1815 t->next = info->thread->next;
1816 info->thread->next = t;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001817 }
Oleg Nesterov83914442008-07-25 01:47:45 -07001818 }
Roland McGrath4206d3a2008-01-30 13:31:45 +01001819
1820 /*
1821 * Now fill in each thread's information.
1822 */
1823 for (t = info->thread; t != NULL; t = t->next)
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001824 if (!fill_thread_core_info(t, view, siginfo->si_signo, &info->size))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001825 return 0;
1826
1827 /*
1828 * Fill in the two process-wide notes.
1829 */
1830 fill_psinfo(psinfo, dump_task->group_leader, dump_task->mm);
1831 info->size += notesize(&info->psinfo);
1832
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001833 fill_siginfo_note(&info->signote, &info->csigdata, siginfo);
1834 info->size += notesize(&info->signote);
1835
Roland McGrath4206d3a2008-01-30 13:31:45 +01001836 fill_auxv_note(&info->auxv, current->mm);
1837 info->size += notesize(&info->auxv);
1838
Dan Aloni72023652013-09-30 13:45:02 -07001839 if (fill_files_note(&info->files) == 0)
1840 info->size += notesize(&info->files);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001841
Roland McGrath4206d3a2008-01-30 13:31:45 +01001842 return 1;
1843}
1844
1845static size_t get_note_info_size(struct elf_note_info *info)
1846{
1847 return info->size;
1848}
1849
1850/*
1851 * Write all the notes for each thread. When writing the first thread, the
1852 * process-wide notes are interleaved after the first thread-specific note.
1853 */
1854static int write_note_info(struct elf_note_info *info,
Al Viroecc8c772013-10-05 15:32:35 -04001855 struct coredump_params *cprm)
Roland McGrath4206d3a2008-01-30 13:31:45 +01001856{
Fabian Frederickb219e252014-06-04 16:12:14 -07001857 bool first = true;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001858 struct elf_thread_core_info *t = info->thread;
1859
1860 do {
1861 int i;
1862
Al Viroecc8c772013-10-05 15:32:35 -04001863 if (!writenote(&t->notes[0], cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001864 return 0;
1865
Al Viroecc8c772013-10-05 15:32:35 -04001866 if (first && !writenote(&info->psinfo, cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001867 return 0;
Al Viroecc8c772013-10-05 15:32:35 -04001868 if (first && !writenote(&info->signote, cprm))
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001869 return 0;
Al Viroecc8c772013-10-05 15:32:35 -04001870 if (first && !writenote(&info->auxv, cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001871 return 0;
Dan Aloni72023652013-09-30 13:45:02 -07001872 if (first && info->files.data &&
Al Viroecc8c772013-10-05 15:32:35 -04001873 !writenote(&info->files, cprm))
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001874 return 0;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001875
1876 for (i = 1; i < info->thread_notes; ++i)
1877 if (t->notes[i].data &&
Al Viroecc8c772013-10-05 15:32:35 -04001878 !writenote(&t->notes[i], cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001879 return 0;
1880
Fabian Frederickb219e252014-06-04 16:12:14 -07001881 first = false;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001882 t = t->next;
1883 } while (t);
1884
1885 return 1;
1886}
1887
1888static void free_note_info(struct elf_note_info *info)
1889{
1890 struct elf_thread_core_info *threads = info->thread;
1891 while (threads) {
1892 unsigned int i;
1893 struct elf_thread_core_info *t = threads;
1894 threads = t->next;
1895 WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);
1896 for (i = 1; i < info->thread_notes; ++i)
1897 kfree(t->notes[i].data);
1898 kfree(t);
1899 }
1900 kfree(info->psinfo.data);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001901 vfree(info->files.data);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001902}
1903
1904#else
1905
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906/* Here is the structure in which status of each thread is captured. */
1907struct elf_thread_status
1908{
1909 struct list_head list;
1910 struct elf_prstatus prstatus; /* NT_PRSTATUS */
1911 elf_fpregset_t fpu; /* NT_PRFPREG */
1912 struct task_struct *thread;
1913#ifdef ELF_CORE_COPY_XFPREGS
Mark Nelson5b20cd82007-10-16 23:25:39 -07001914 elf_fpxregset_t xfpu; /* ELF_CORE_XFPREG_TYPE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915#endif
1916 struct memelfnote notes[3];
1917 int num_notes;
1918};
1919
1920/*
1921 * In order to add the specific thread information for the elf file format,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001922 * we need to keep a linked list of every threads pr_status and then create
1923 * a single section for them in the final core file.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 */
1925static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1926{
1927 int sz = 0;
1928 struct task_struct *p = t->thread;
1929 t->num_notes = 0;
1930
1931 fill_prstatus(&t->prstatus, p, signr);
1932 elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1933
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001934 fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1935 &(t->prstatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 t->num_notes++;
1937 sz += notesize(&t->notes[0]);
1938
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001939 if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1940 &t->fpu))) {
1941 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1942 &(t->fpu));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 t->num_notes++;
1944 sz += notesize(&t->notes[1]);
1945 }
1946
1947#ifdef ELF_CORE_COPY_XFPREGS
1948 if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
Mark Nelson5b20cd82007-10-16 23:25:39 -07001949 fill_note(&t->notes[2], "LINUX", ELF_CORE_XFPREG_TYPE,
1950 sizeof(t->xfpu), &t->xfpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 t->num_notes++;
1952 sz += notesize(&t->notes[2]);
1953 }
1954#endif
1955 return sz;
1956}
1957
Roland McGrath3aba4812008-01-30 13:31:44 +01001958struct elf_note_info {
1959 struct memelfnote *notes;
Dan Aloni72023652013-09-30 13:45:02 -07001960 struct memelfnote *notes_files;
Roland McGrath3aba4812008-01-30 13:31:44 +01001961 struct elf_prstatus *prstatus; /* NT_PRSTATUS */
1962 struct elf_prpsinfo *psinfo; /* NT_PRPSINFO */
1963 struct list_head thread_list;
1964 elf_fpregset_t *fpu;
1965#ifdef ELF_CORE_COPY_XFPREGS
1966 elf_fpxregset_t *xfpu;
1967#endif
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001968 user_siginfo_t csigdata;
Roland McGrath3aba4812008-01-30 13:31:44 +01001969 int thread_status_size;
1970 int numnote;
1971};
1972
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001973static int elf_note_info_init(struct elf_note_info *info)
Roland McGrath3aba4812008-01-30 13:31:44 +01001974{
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001975 memset(info, 0, sizeof(*info));
Roland McGrath3aba4812008-01-30 13:31:44 +01001976 INIT_LIST_HEAD(&info->thread_list);
1977
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001978 /* Allocate space for ELF notes */
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001979 info->notes = kmalloc(8 * sizeof(struct memelfnote), GFP_KERNEL);
Roland McGrath3aba4812008-01-30 13:31:44 +01001980 if (!info->notes)
1981 return 0;
1982 info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL);
1983 if (!info->psinfo)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001984 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001985 info->prstatus = kmalloc(sizeof(*info->prstatus), GFP_KERNEL);
1986 if (!info->prstatus)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001987 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001988 info->fpu = kmalloc(sizeof(*info->fpu), GFP_KERNEL);
1989 if (!info->fpu)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001990 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001991#ifdef ELF_CORE_COPY_XFPREGS
1992 info->xfpu = kmalloc(sizeof(*info->xfpu), GFP_KERNEL);
1993 if (!info->xfpu)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001994 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001995#endif
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001996 return 1;
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001997}
Roland McGrath3aba4812008-01-30 13:31:44 +01001998
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001999static int fill_note_info(struct elfhdr *elf, int phdrs,
2000 struct elf_note_info *info,
Al Viroec579412013-10-13 17:57:29 -04002001 const siginfo_t *siginfo, struct pt_regs *regs)
Amerigo Wang0cf062d2009-09-23 15:57:05 -07002002{
2003 struct list_head *t;
Al Viroafabada2013-10-14 07:39:56 -04002004 struct core_thread *ct;
2005 struct elf_thread_status *ets;
Amerigo Wang0cf062d2009-09-23 15:57:05 -07002006
2007 if (!elf_note_info_init(info))
2008 return 0;
2009
Al Viroafabada2013-10-14 07:39:56 -04002010 for (ct = current->mm->core_state->dumper.next;
2011 ct; ct = ct->next) {
2012 ets = kzalloc(sizeof(*ets), GFP_KERNEL);
2013 if (!ets)
2014 return 0;
Oleg Nesterov24d52882008-07-25 01:47:40 -07002015
Al Viroafabada2013-10-14 07:39:56 -04002016 ets->thread = ct->task;
2017 list_add(&ets->list, &info->thread_list);
2018 }
Oleg Nesterov83914442008-07-25 01:47:45 -07002019
Al Viroafabada2013-10-14 07:39:56 -04002020 list_for_each(t, &info->thread_list) {
2021 int sz;
Oleg Nesterov83914442008-07-25 01:47:45 -07002022
Al Viroafabada2013-10-14 07:39:56 -04002023 ets = list_entry(t, struct elf_thread_status, list);
2024 sz = elf_dump_thread_status(siginfo->si_signo, ets);
2025 info->thread_status_size += sz;
Roland McGrath3aba4812008-01-30 13:31:44 +01002026 }
2027 /* now collect the dump for the current */
2028 memset(info->prstatus, 0, sizeof(*info->prstatus));
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07002029 fill_prstatus(info->prstatus, current, siginfo->si_signo);
Roland McGrath3aba4812008-01-30 13:31:44 +01002030 elf_core_copy_regs(&info->prstatus->pr_reg, regs);
2031
2032 /* Set up header */
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08002033 fill_elf_header(elf, phdrs, ELF_ARCH, ELF_CORE_EFLAGS);
Roland McGrath3aba4812008-01-30 13:31:44 +01002034
2035 /*
2036 * Set up the notes in similar form to SVR4 core dumps made
2037 * with info from their /proc.
2038 */
2039
2040 fill_note(info->notes + 0, "CORE", NT_PRSTATUS,
2041 sizeof(*info->prstatus), info->prstatus);
2042 fill_psinfo(info->psinfo, current->group_leader, current->mm);
2043 fill_note(info->notes + 1, "CORE", NT_PRPSINFO,
2044 sizeof(*info->psinfo), info->psinfo);
2045
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07002046 fill_siginfo_note(info->notes + 2, &info->csigdata, siginfo);
2047 fill_auxv_note(info->notes + 3, current->mm);
Dan Aloni72023652013-09-30 13:45:02 -07002048 info->numnote = 4;
Roland McGrath3aba4812008-01-30 13:31:44 +01002049
Dan Aloni72023652013-09-30 13:45:02 -07002050 if (fill_files_note(info->notes + info->numnote) == 0) {
2051 info->notes_files = info->notes + info->numnote;
2052 info->numnote++;
2053 }
Roland McGrath3aba4812008-01-30 13:31:44 +01002054
2055 /* Try to dump the FPU. */
2056 info->prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs,
2057 info->fpu);
2058 if (info->prstatus->pr_fpvalid)
2059 fill_note(info->notes + info->numnote++,
2060 "CORE", NT_PRFPREG, sizeof(*info->fpu), info->fpu);
2061#ifdef ELF_CORE_COPY_XFPREGS
2062 if (elf_core_copy_task_xfpregs(current, info->xfpu))
2063 fill_note(info->notes + info->numnote++,
2064 "LINUX", ELF_CORE_XFPREG_TYPE,
2065 sizeof(*info->xfpu), info->xfpu);
2066#endif
2067
2068 return 1;
Roland McGrath3aba4812008-01-30 13:31:44 +01002069}
2070
2071static size_t get_note_info_size(struct elf_note_info *info)
2072{
2073 int sz = 0;
2074 int i;
2075
2076 for (i = 0; i < info->numnote; i++)
2077 sz += notesize(info->notes + i);
2078
2079 sz += info->thread_status_size;
2080
2081 return sz;
2082}
2083
2084static int write_note_info(struct elf_note_info *info,
Al Viroecc8c772013-10-05 15:32:35 -04002085 struct coredump_params *cprm)
Roland McGrath3aba4812008-01-30 13:31:44 +01002086{
2087 int i;
2088 struct list_head *t;
2089
2090 for (i = 0; i < info->numnote; i++)
Al Viroecc8c772013-10-05 15:32:35 -04002091 if (!writenote(info->notes + i, cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002092 return 0;
2093
2094 /* write out the thread status notes section */
2095 list_for_each(t, &info->thread_list) {
2096 struct elf_thread_status *tmp =
2097 list_entry(t, struct elf_thread_status, list);
2098
2099 for (i = 0; i < tmp->num_notes; i++)
Al Viroecc8c772013-10-05 15:32:35 -04002100 if (!writenote(&tmp->notes[i], cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002101 return 0;
2102 }
2103
2104 return 1;
2105}
2106
2107static void free_note_info(struct elf_note_info *info)
2108{
2109 while (!list_empty(&info->thread_list)) {
2110 struct list_head *tmp = info->thread_list.next;
2111 list_del(tmp);
2112 kfree(list_entry(tmp, struct elf_thread_status, list));
2113 }
2114
Dan Aloni72023652013-09-30 13:45:02 -07002115 /* Free data possibly allocated by fill_files_note(): */
2116 if (info->notes_files)
2117 vfree(info->notes_files->data);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07002118
Roland McGrath3aba4812008-01-30 13:31:44 +01002119 kfree(info->prstatus);
2120 kfree(info->psinfo);
2121 kfree(info->notes);
2122 kfree(info->fpu);
2123#ifdef ELF_CORE_COPY_XFPREGS
2124 kfree(info->xfpu);
2125#endif
2126}
2127
Roland McGrath4206d3a2008-01-30 13:31:45 +01002128#endif
2129
Roland McGrathf47aef52007-01-26 00:56:49 -08002130static struct vm_area_struct *first_vma(struct task_struct *tsk,
2131 struct vm_area_struct *gate_vma)
2132{
2133 struct vm_area_struct *ret = tsk->mm->mmap;
2134
2135 if (ret)
2136 return ret;
2137 return gate_vma;
2138}
2139/*
2140 * Helper function for iterating across a vma list. It ensures that the caller
2141 * will visit `gate_vma' prior to terminating the search.
2142 */
2143static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
2144 struct vm_area_struct *gate_vma)
2145{
2146 struct vm_area_struct *ret;
2147
2148 ret = this_vma->vm_next;
2149 if (ret)
2150 return ret;
2151 if (this_vma == gate_vma)
2152 return NULL;
2153 return gate_vma;
2154}
2155
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002156static void fill_extnum_info(struct elfhdr *elf, struct elf_shdr *shdr4extnum,
2157 elf_addr_t e_shoff, int segs)
2158{
2159 elf->e_shoff = e_shoff;
2160 elf->e_shentsize = sizeof(*shdr4extnum);
2161 elf->e_shnum = 1;
2162 elf->e_shstrndx = SHN_UNDEF;
2163
2164 memset(shdr4extnum, 0, sizeof(*shdr4extnum));
2165
2166 shdr4extnum->sh_type = SHT_NULL;
2167 shdr4extnum->sh_size = elf->e_shnum;
2168 shdr4extnum->sh_link = elf->e_shstrndx;
2169 shdr4extnum->sh_info = segs;
2170}
2171
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172/*
2173 * Actual dumper
2174 *
2175 * This is a two-pass process; first we find the offsets of the bits,
2176 * and then they are actually written out. If we run out of core limit
2177 * we just truncate.
2178 */
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002179static int elf_core_dump(struct coredump_params *cprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181 int has_dumped = 0;
2182 mm_segment_t fs;
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002183 int segs, i;
2184 size_t vma_data_size = 0;
Roland McGrathf47aef52007-01-26 00:56:49 -08002185 struct vm_area_struct *vma, *gate_vma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186 struct elfhdr *elf = NULL;
Al Virocdc3d562013-10-05 22:24:29 -04002187 loff_t offset = 0, dataoff;
Dan Aloni72023652013-09-30 13:45:02 -07002188 struct elf_note_info info = { };
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002189 struct elf_phdr *phdr4note = NULL;
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002190 struct elf_shdr *shdr4extnum = NULL;
2191 Elf_Half e_phnum;
2192 elf_addr_t e_shoff;
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002193 elf_addr_t *vma_filesz = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194
2195 /*
2196 * We no longer stop all VM operations.
2197 *
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002198 * This is because those proceses that could possibly change map_count
2199 * or the mmap / vma pages are now blocked in do_exit on current
2200 * finishing this core dump.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201 *
2202 * Only ptrace can touch these memory addresses, but it doesn't change
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002203 * the map_count or the pages allocated. So no possibility of crashing
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204 * exists while dumping the mm->vm_next areas to the core file.
2205 */
2206
2207 /* alloc memory for large data structures: too large to be on stack */
2208 elf = kmalloc(sizeof(*elf), GFP_KERNEL);
2209 if (!elf)
WANG Cong5f719552008-05-06 12:45:35 +08002210 goto out;
KAMEZAWA Hiroyuki341c87b2009-06-30 11:41:23 -07002211 /*
2212 * The number of segs are recored into ELF header as 16bit value.
2213 * Please check DEFAULT_MAX_MAP_COUNT definition when you modify here.
2214 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215 segs = current->mm->map_count;
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002216 segs += elf_core_extra_phdrs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217
Stephen Wilson31db58b2011-03-13 15:49:15 -04002218 gate_vma = get_gate_vma(current->mm);
Roland McGrathf47aef52007-01-26 00:56:49 -08002219 if (gate_vma != NULL)
2220 segs++;
2221
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002222 /* for notes section */
2223 segs++;
2224
2225 /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
2226 * this, kernel supports extended numbering. Have a look at
2227 * include/linux/elf.h for further information. */
2228 e_phnum = segs > PN_XNUM ? PN_XNUM : segs;
2229
Roland McGrath3aba4812008-01-30 13:31:44 +01002230 /*
2231 * Collect all the non-memory information about the process for the
2232 * notes. This also sets up the file header.
2233 */
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07002234 if (!fill_note_info(elf, e_phnum, &info, cprm->siginfo, cprm->regs))
Roland McGrath3aba4812008-01-30 13:31:44 +01002235 goto cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236
2237 has_dumped = 1;
Oleg Nesterov079148b2013-04-30 15:28:16 -07002238
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239 fs = get_fs();
2240 set_fs(KERNEL_DS);
2241
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 offset += sizeof(*elf); /* Elf header */
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002243 offset += segs * sizeof(struct elf_phdr); /* Program headers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244
2245 /* Write notes phdr entry */
2246 {
Roland McGrath3aba4812008-01-30 13:31:44 +01002247 size_t sz = get_note_info_size(&info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248
Michael Ellermane5501492007-09-19 14:38:12 +10002249 sz += elf_coredump_extra_notes_size();
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002250
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002251 phdr4note = kmalloc(sizeof(*phdr4note), GFP_KERNEL);
2252 if (!phdr4note)
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -08002253 goto end_coredump;
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002254
2255 fill_elf_note_phdr(phdr4note, sz, offset);
2256 offset += sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257 }
2258
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
2260
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002261 vma_filesz = kmalloc_array(segs - 1, sizeof(*vma_filesz), GFP_KERNEL);
2262 if (!vma_filesz)
2263 goto end_coredump;
2264
2265 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2266 vma = next_vma(vma, gate_vma)) {
2267 unsigned long dump_size;
2268
2269 dump_size = vma_dump_size(vma, cprm->mm_flags);
2270 vma_filesz[i++] = dump_size;
2271 vma_data_size += dump_size;
2272 }
2273
2274 offset += vma_data_size;
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002275 offset += elf_core_extra_data_size();
2276 e_shoff = offset;
2277
2278 if (e_phnum == PN_XNUM) {
2279 shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);
2280 if (!shdr4extnum)
2281 goto end_coredump;
2282 fill_extnum_info(elf, shdr4extnum, e_shoff, segs);
2283 }
2284
2285 offset = dataoff;
2286
Al Viroecc8c772013-10-05 15:32:35 -04002287 if (!dump_emit(cprm, elf, sizeof(*elf)))
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002288 goto end_coredump;
2289
Al Viroecc8c772013-10-05 15:32:35 -04002290 if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note)))
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002291 goto end_coredump;
2292
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293 /* Write program headers for segments dump */
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002294 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
Roland McGrathf47aef52007-01-26 00:56:49 -08002295 vma = next_vma(vma, gate_vma)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296 struct elf_phdr phdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297
2298 phdr.p_type = PT_LOAD;
2299 phdr.p_offset = offset;
2300 phdr.p_vaddr = vma->vm_start;
2301 phdr.p_paddr = 0;
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002302 phdr.p_filesz = vma_filesz[i++];
Roland McGrath82df3972007-10-16 23:27:02 -07002303 phdr.p_memsz = vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 offset += phdr.p_filesz;
2305 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002306 if (vma->vm_flags & VM_WRITE)
2307 phdr.p_flags |= PF_W;
2308 if (vma->vm_flags & VM_EXEC)
2309 phdr.p_flags |= PF_X;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310 phdr.p_align = ELF_EXEC_PAGESIZE;
2311
Al Viroecc8c772013-10-05 15:32:35 -04002312 if (!dump_emit(cprm, &phdr, sizeof(phdr)))
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -08002313 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 }
2315
Al Viro506f21c2013-10-05 17:22:57 -04002316 if (!elf_core_write_extra_phdrs(cprm, offset))
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002317 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318
2319 /* write out the notes section */
Al Viroecc8c772013-10-05 15:32:35 -04002320 if (!write_note_info(&info, cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002321 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322
Al Virocdc3d562013-10-05 22:24:29 -04002323 if (elf_coredump_extra_notes_write(cprm))
Michael Ellermane5501492007-09-19 14:38:12 +10002324 goto end_coredump;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002325
Andi Kleend025c9d2006-09-30 23:29:28 -07002326 /* Align to page */
Mateusz Guzik1607f092016-06-05 23:14:14 +02002327 if (!dump_skip(cprm, dataoff - cprm->pos))
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002328 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002330 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
Roland McGrathf47aef52007-01-26 00:56:49 -08002331 vma = next_vma(vma, gate_vma)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332 unsigned long addr;
Roland McGrath82df3972007-10-16 23:27:02 -07002333 unsigned long end;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002335 end = vma->vm_start + vma_filesz[i++];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336
Roland McGrath82df3972007-10-16 23:27:02 -07002337 for (addr = vma->vm_start; addr < end; addr += PAGE_SIZE) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002338 struct page *page;
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002339 int stop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002341 page = get_dump_page(addr);
2342 if (page) {
2343 void *kaddr = kmap(page);
Al Viro13046ec2013-10-05 18:08:47 -04002344 stop = !dump_emit(cprm, kaddr, PAGE_SIZE);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002345 kunmap(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002346 put_page(page);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002347 } else
Al Viro9b56d542013-10-08 09:26:08 -04002348 stop = !dump_skip(cprm, PAGE_SIZE);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002349 if (stop)
2350 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002351 }
2352 }
Dave Kleikamp68a5dc32017-01-11 13:25:00 -06002353 dump_truncate(cprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354
Al Viroaa3e7ea2013-10-05 17:50:15 -04002355 if (!elf_core_write_extra_data(cprm))
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002356 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002357
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002358 if (e_phnum == PN_XNUM) {
Al Viro13046ec2013-10-05 18:08:47 -04002359 if (!dump_emit(cprm, shdr4extnum, sizeof(*shdr4extnum)))
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002360 goto end_coredump;
2361 }
2362
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363end_coredump:
2364 set_fs(fs);
2365
2366cleanup:
Roland McGrath3aba4812008-01-30 13:31:44 +01002367 free_note_info(&info);
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002368 kfree(shdr4extnum);
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002369 kfree(vma_filesz);
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002370 kfree(phdr4note);
WANG Cong5f719552008-05-06 12:45:35 +08002371 kfree(elf);
2372out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373 return has_dumped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374}
2375
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08002376#endif /* CONFIG_ELF_CORE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377
2378static int __init init_elf_binfmt(void)
2379{
Al Viro8fc3dc52012-03-17 03:05:16 -04002380 register_binfmt(&elf_format);
2381 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382}
2383
2384static void __exit exit_elf_binfmt(void)
2385{
2386 /* Remove the COFF and ELF loaders. */
2387 unregister_binfmt(&elf_format);
2388}
2389
2390core_initcall(init_elf_binfmt);
2391module_exit(exit_elf_binfmt);
2392MODULE_LICENSE("GPL");