blob: 81381cc0dd177f5f891234a9b065c78a2eec1714 [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) {
99 unsigned long addr;
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -0700100 addr = vm_brk(start, end - start);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 if (BAD_ADDR(addr))
102 return addr;
103 }
104 current->mm->start_brk = current->mm->brk = end;
105 return 0;
106}
107
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108/* We need to explicitly zero any fractional pages
109 after the data section (i.e. bss). This would
110 contain the junk from the file that should not
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700111 be in memory
112 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113static int padzero(unsigned long elf_bss)
114{
115 unsigned long nbyte;
116
117 nbyte = ELF_PAGEOFFSET(elf_bss);
118 if (nbyte) {
119 nbyte = ELF_MIN_ALIGN - nbyte;
120 if (clear_user((void __user *) elf_bss, nbyte))
121 return -EFAULT;
122 }
123 return 0;
124}
125
Ohad Ben-Cohen09c6dd32008-02-03 18:05:15 +0200126/* Let's use some macros to make this stack manipulation a little clearer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127#ifdef CONFIG_STACK_GROWSUP
128#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))
129#define STACK_ROUND(sp, items) \
130 ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700131#define STACK_ALLOC(sp, len) ({ \
132 elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; \
133 old_sp; })
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134#else
135#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))
136#define STACK_ROUND(sp, items) \
137 (((unsigned long) (sp - items)) &~ 15UL)
138#define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })
139#endif
140
Nathan Lynch483fad12008-07-22 04:48:46 +1000141#ifndef ELF_BASE_PLATFORM
142/*
143 * AT_BASE_PLATFORM indicates the "real" hardware/microarchitecture.
144 * If the arch defines ELF_BASE_PLATFORM (in asm/elf.h), the value
145 * will be copied to the user stack in the same manner as AT_PLATFORM.
146 */
147#define ELF_BASE_PLATFORM NULL
148#endif
149
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150static int
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700151create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
Andi Kleend20894a2008-02-08 04:21:54 -0800152 unsigned long load_addr, unsigned long interp_load_addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153{
154 unsigned long p = bprm->p;
155 int argc = bprm->argc;
156 int envc = bprm->envc;
157 elf_addr_t __user *argv;
158 elf_addr_t __user *envp;
159 elf_addr_t __user *sp;
160 elf_addr_t __user *u_platform;
Nathan Lynch483fad12008-07-22 04:48:46 +1000161 elf_addr_t __user *u_base_platform;
Kees Cookf06295b2009-01-07 18:08:52 -0800162 elf_addr_t __user *u_rand_bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 const char *k_platform = ELF_PLATFORM;
Nathan Lynch483fad12008-07-22 04:48:46 +1000164 const char *k_base_platform = ELF_BASE_PLATFORM;
Kees Cookf06295b2009-01-07 18:08:52 -0800165 unsigned char k_rand_bytes[16];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 int items;
167 elf_addr_t *elf_info;
168 int ei_index = 0;
David Howells86a264a2008-11-14 10:39:18 +1100169 const struct cred *cred = current_cred();
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700170 struct vm_area_struct *vma;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171
172 /*
Franck Bui-Huud68c9d62007-10-16 23:30:24 -0700173 * In some cases (e.g. Hyper-Threading), we want to avoid L1
174 * evictions by the processes running on the same package. One
175 * thing we can do is to shuffle the initial stack for them.
176 */
177
178 p = arch_align_stack(p);
179
180 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 * If this architecture has a platform capability string, copy it
182 * to userspace. In some cases (Sparc), this info is impossible
183 * for userspace to get any other way, in others (i386) it is
184 * merely difficult.
185 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 u_platform = NULL;
187 if (k_platform) {
188 size_t len = strlen(k_platform) + 1;
189
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
191 if (__copy_to_user(u_platform, k_platform, len))
192 return -EFAULT;
193 }
194
Nathan Lynch483fad12008-07-22 04:48:46 +1000195 /*
196 * If this architecture has a "base" platform capability
197 * string, copy it to userspace.
198 */
199 u_base_platform = NULL;
200 if (k_base_platform) {
201 size_t len = strlen(k_base_platform) + 1;
202
203 u_base_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
204 if (__copy_to_user(u_base_platform, k_base_platform, len))
205 return -EFAULT;
206 }
207
Kees Cookf06295b2009-01-07 18:08:52 -0800208 /*
209 * Generate 16 random bytes for userspace PRNG seeding.
210 */
211 get_random_bytes(k_rand_bytes, sizeof(k_rand_bytes));
212 u_rand_bytes = (elf_addr_t __user *)
213 STACK_ALLOC(p, sizeof(k_rand_bytes));
214 if (__copy_to_user(u_rand_bytes, k_rand_bytes, sizeof(k_rand_bytes)))
215 return -EFAULT;
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 /* Create the ELF interpreter info */
Jesper Juhl785d5572006-06-23 02:05:35 -0700218 elf_info = (elf_addr_t *)current->mm->saved_auxv;
Olaf Hering4f9a58d2007-10-16 23:30:12 -0700219 /* update AT_VECTOR_SIZE_BASE if the number of NEW_AUX_ENT() changes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220#define NEW_AUX_ENT(id, val) \
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700221 do { \
Jesper Juhl785d5572006-06-23 02:05:35 -0700222 elf_info[ei_index++] = id; \
223 elf_info[ei_index++] = val; \
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700224 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
226#ifdef ARCH_DLINFO
227 /*
228 * ARCH_DLINFO must come first so PPC can do its special alignment of
229 * AUXV.
Olaf Hering4f9a58d2007-10-16 23:30:12 -0700230 * update AT_VECTOR_SIZE_ARCH if the number of NEW_AUX_ENT() in
231 * ARCH_DLINFO changes
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 */
233 ARCH_DLINFO;
234#endif
235 NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);
236 NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
237 NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
238 NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700239 NEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);
241 NEW_AUX_ENT(AT_BASE, interp_load_addr);
242 NEW_AUX_ENT(AT_FLAGS, 0);
243 NEW_AUX_ENT(AT_ENTRY, exec->e_entry);
Eric W. Biedermanebc887b2012-02-07 18:36:10 -0800244 NEW_AUX_ENT(AT_UID, from_kuid_munged(cred->user_ns, cred->uid));
245 NEW_AUX_ENT(AT_EUID, from_kuid_munged(cred->user_ns, cred->euid));
246 NEW_AUX_ENT(AT_GID, from_kgid_munged(cred->user_ns, cred->gid));
247 NEW_AUX_ENT(AT_EGID, from_kgid_munged(cred->user_ns, cred->egid));
Jesper Juhl785d5572006-06-23 02:05:35 -0700248 NEW_AUX_ENT(AT_SECURE, security_bprm_secureexec(bprm));
Kees Cookf06295b2009-01-07 18:08:52 -0800249 NEW_AUX_ENT(AT_RANDOM, (elf_addr_t)(unsigned long)u_rand_bytes);
Michael Neuling21713642013-04-17 17:33:11 +0000250#ifdef ELF_HWCAP2
251 NEW_AUX_ENT(AT_HWCAP2, ELF_HWCAP2);
252#endif
John Reiser65191082008-07-21 14:21:32 -0700253 NEW_AUX_ENT(AT_EXECFN, bprm->exec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 if (k_platform) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700255 NEW_AUX_ENT(AT_PLATFORM,
Jesper Juhl785d5572006-06-23 02:05:35 -0700256 (elf_addr_t)(unsigned long)u_platform);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 }
Nathan Lynch483fad12008-07-22 04:48:46 +1000258 if (k_base_platform) {
259 NEW_AUX_ENT(AT_BASE_PLATFORM,
260 (elf_addr_t)(unsigned long)u_base_platform);
261 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
Jesper Juhl785d5572006-06-23 02:05:35 -0700263 NEW_AUX_ENT(AT_EXECFD, bprm->interp_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 }
265#undef NEW_AUX_ENT
266 /* AT_NULL is zero; clear the rest too */
267 memset(&elf_info[ei_index], 0,
268 sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);
269
270 /* And advance past the AT_NULL entry. */
271 ei_index += 2;
272
273 sp = STACK_ADD(p, ei_index);
274
Andi Kleend20894a2008-02-08 04:21:54 -0800275 items = (argc + 1) + (envc + 1) + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 bprm->p = STACK_ROUND(sp, items);
277
278 /* Point sp at the lowest address on the stack */
279#ifdef CONFIG_STACK_GROWSUP
280 sp = (elf_addr_t __user *)bprm->p - items - ei_index;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700281 bprm->exec = (unsigned long)sp; /* XXX: PARISC HACK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282#else
283 sp = (elf_addr_t __user *)bprm->p;
284#endif
285
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700286
287 /*
288 * Grow the stack manually; some architectures have a limit on how
289 * far ahead a user-space access may be in order to grow the stack.
290 */
291 vma = find_extend_vma(current->mm, bprm->p);
292 if (!vma)
293 return -EFAULT;
294
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 /* Now, let's put argc (and argv, envp if appropriate) on the stack */
296 if (__put_user(argc, sp++))
297 return -EFAULT;
Andi Kleend20894a2008-02-08 04:21:54 -0800298 argv = sp;
299 envp = argv + argc + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
301 /* Populate argv and envp */
Greg Kroah-Hartmana84a5052005-05-11 00:10:44 -0700302 p = current->mm->arg_end = current->mm->arg_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 while (argc-- > 0) {
304 size_t len;
Heiko Carstens841d5fb2006-12-06 20:36:35 -0800305 if (__put_user((elf_addr_t)p, argv++))
306 return -EFAULT;
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700307 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
308 if (!len || len > MAX_ARG_STRLEN)
WANG Cong23c49712008-05-08 21:52:33 +0800309 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 p += len;
311 }
312 if (__put_user(0, argv))
313 return -EFAULT;
314 current->mm->arg_end = current->mm->env_start = p;
315 while (envc-- > 0) {
316 size_t len;
Heiko Carstens841d5fb2006-12-06 20:36:35 -0800317 if (__put_user((elf_addr_t)p, envp++))
318 return -EFAULT;
Ollie Wildb6a2fea2007-07-19 01:48:16 -0700319 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
320 if (!len || len > MAX_ARG_STRLEN)
WANG Cong23c49712008-05-08 21:52:33 +0800321 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 p += len;
323 }
324 if (__put_user(0, envp))
325 return -EFAULT;
326 current->mm->env_end = p;
327
328 /* Put the elf_info on the stack in the right place. */
329 sp = (elf_addr_t __user *)envp + 1;
330 if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))
331 return -EFAULT;
332 return 0;
333}
334
James Hoganc07380b2011-05-09 10:58:40 +0100335#ifndef elf_map
336
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337static unsigned long elf_map(struct file *filep, unsigned long addr,
Jiri Kosinacc503c12008-01-30 13:31:07 +0100338 struct elf_phdr *eppnt, int prot, int type,
339 unsigned long total_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340{
341 unsigned long map_addr;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100342 unsigned long size = eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr);
343 unsigned long off = eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr);
344 addr = ELF_PAGESTART(addr);
345 size = ELF_PAGEALIGN(size);
Jan Kratochvil60bfba72007-07-15 23:40:06 -0700346
Andrew Mortond4e3cc32007-07-21 04:37:32 -0700347 /* mmap() will return -EINVAL if given a zero size, but a
348 * segment with zero filesize is perfectly valid */
Jiri Kosinacc503c12008-01-30 13:31:07 +0100349 if (!size)
350 return addr;
351
Jiri Kosinacc503c12008-01-30 13:31:07 +0100352 /*
353 * total_size is the size of the ELF (interpreter) image.
354 * The _first_ mmap needs to know the full size, otherwise
355 * randomization might put this image into an overlapping
356 * position with the ELF binary image. (since size < total_size)
357 * So we first map the 'big' image - and unmap the remainder at
358 * the end. (which unmap is needed for ELF images with holes.)
359 */
360 if (total_size) {
361 total_size = ELF_PAGEALIGN(total_size);
Al Viro5a5e4c22012-05-30 01:49:38 -0400362 map_addr = vm_mmap(filep, addr, total_size, prot, type, off);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100363 if (!BAD_ADDR(map_addr))
Al Viro5a5e4c22012-05-30 01:49:38 -0400364 vm_munmap(map_addr+size, total_size-size);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100365 } else
Al Viro5a5e4c22012-05-30 01:49:38 -0400366 map_addr = vm_mmap(filep, addr, size, prot, type, off);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100367
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 return(map_addr);
369}
370
James Hoganc07380b2011-05-09 10:58:40 +0100371#endif /* !elf_map */
372
Jiri Kosinacc503c12008-01-30 13:31:07 +0100373static unsigned long total_mapping_size(struct elf_phdr *cmds, int nr)
374{
375 int i, first_idx = -1, last_idx = -1;
376
377 for (i = 0; i < nr; i++) {
378 if (cmds[i].p_type == PT_LOAD) {
379 last_idx = i;
380 if (first_idx == -1)
381 first_idx = i;
382 }
383 }
384 if (first_idx == -1)
385 return 0;
386
387 return cmds[last_idx].p_vaddr + cmds[last_idx].p_memsz -
388 ELF_PAGESTART(cmds[first_idx].p_vaddr);
389}
390
Paul Burton6a8d3892014-09-11 08:30:14 +0100391/**
392 * load_elf_phdrs() - load ELF program headers
393 * @elf_ex: ELF header of the binary whose program headers should be loaded
394 * @elf_file: the opened ELF binary file
395 *
396 * Loads ELF program headers from the binary file elf_file, which has the ELF
397 * header pointed to by elf_ex, into a newly allocated array. The caller is
398 * responsible for freeing the allocated data. Returns an ERR_PTR upon failure.
399 */
400static struct elf_phdr *load_elf_phdrs(struct elfhdr *elf_ex,
401 struct file *elf_file)
402{
403 struct elf_phdr *elf_phdata = NULL;
404 int retval, size, err = -1;
405
406 /*
407 * If the size of this structure has changed, then punt, since
408 * we will be doing the wrong thing.
409 */
410 if (elf_ex->e_phentsize != sizeof(struct elf_phdr))
411 goto out;
412
413 /* Sanity check the number of program headers... */
414 if (elf_ex->e_phnum < 1 ||
415 elf_ex->e_phnum > 65536U / sizeof(struct elf_phdr))
416 goto out;
417
418 /* ...and their total size. */
419 size = sizeof(struct elf_phdr) * elf_ex->e_phnum;
420 if (size > ELF_MIN_ALIGN)
421 goto out;
422
423 elf_phdata = kmalloc(size, GFP_KERNEL);
424 if (!elf_phdata)
425 goto out;
426
427 /* Read in the program headers */
428 retval = kernel_read(elf_file, elf_ex->e_phoff,
429 (char *)elf_phdata, size);
430 if (retval != size) {
431 err = (retval < 0) ? retval : -EIO;
432 goto out;
433 }
434
435 /* Success! */
436 err = 0;
437out:
438 if (err) {
439 kfree(elf_phdata);
440 elf_phdata = NULL;
441 }
442 return elf_phdata;
443}
Jiri Kosinacc503c12008-01-30 13:31:07 +0100444
Paul Burton774c1052014-09-11 08:30:16 +0100445#ifndef CONFIG_ARCH_BINFMT_ELF_STATE
446
447/**
448 * struct arch_elf_state - arch-specific ELF loading state
449 *
450 * This structure is used to preserve architecture specific data during
451 * the loading of an ELF file, throughout the checking of architecture
452 * specific ELF headers & through to the point where the ELF load is
453 * known to be proceeding (ie. SET_PERSONALITY).
454 *
455 * This implementation is a dummy for architectures which require no
456 * specific state.
457 */
458struct arch_elf_state {
459};
460
461#define INIT_ARCH_ELF_STATE {}
462
463/**
464 * arch_elf_pt_proc() - check a PT_LOPROC..PT_HIPROC ELF program header
465 * @ehdr: The main ELF header
466 * @phdr: The program header to check
467 * @elf: The open ELF file
468 * @is_interp: True if the phdr is from the interpreter of the ELF being
469 * loaded, else false.
470 * @state: Architecture-specific state preserved throughout the process
471 * of loading the ELF.
472 *
473 * Inspects the program header phdr to validate its correctness and/or
474 * suitability for the system. Called once per ELF program header in the
475 * range PT_LOPROC to PT_HIPROC, for both the ELF being loaded and its
476 * interpreter.
477 *
478 * Return: Zero to proceed with the ELF load, non-zero to fail the ELF load
479 * with that return code.
480 */
481static inline int arch_elf_pt_proc(struct elfhdr *ehdr,
482 struct elf_phdr *phdr,
483 struct file *elf, bool is_interp,
484 struct arch_elf_state *state)
485{
486 /* Dummy implementation, always proceed */
487 return 0;
488}
489
490/**
Maciej W. Rozycki54d157142015-10-26 15:47:57 +0000491 * arch_check_elf() - check an ELF executable
Paul Burton774c1052014-09-11 08:30:16 +0100492 * @ehdr: The main ELF header
493 * @has_interp: True if the ELF has an interpreter, else false.
Maciej W. Rozyckieb4bc072015-11-13 00:47:48 +0000494 * @interp_ehdr: The interpreter's ELF header
Paul Burton774c1052014-09-11 08:30:16 +0100495 * @state: Architecture-specific state preserved throughout the process
496 * of loading the ELF.
497 *
498 * Provides a final opportunity for architecture code to reject the loading
499 * of the ELF & cause an exec syscall to return an error. This is called after
500 * all program headers to be checked by arch_elf_pt_proc have been.
501 *
502 * Return: Zero to proceed with the ELF load, non-zero to fail the ELF load
503 * with that return code.
504 */
505static inline int arch_check_elf(struct elfhdr *ehdr, bool has_interp,
Maciej W. Rozyckieb4bc072015-11-13 00:47:48 +0000506 struct elfhdr *interp_ehdr,
Paul Burton774c1052014-09-11 08:30:16 +0100507 struct arch_elf_state *state)
508{
509 /* Dummy implementation, always proceed */
510 return 0;
511}
512
513#endif /* !CONFIG_ARCH_BINFMT_ELF_STATE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
515/* This is much more generalized than the library routine read function,
516 so we keep this separate. Technically the library read function
517 is only provided so that we can read a.out libraries that have
518 an ELF header */
519
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700520static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
Jiri Kosinacc503c12008-01-30 13:31:07 +0100521 struct file *interpreter, unsigned long *interp_map_addr,
Paul Burtona9d9ef12014-09-11 08:30:15 +0100522 unsigned long no_base, struct elf_phdr *interp_elf_phdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 struct elf_phdr *eppnt;
525 unsigned long load_addr = 0;
526 int load_addr_set = 0;
527 unsigned long last_bss = 0, elf_bss = 0;
528 unsigned long error = ~0UL;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100529 unsigned long total_size;
Paul Burton6a8d3892014-09-11 08:30:14 +0100530 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
532 /* First of all, some simple consistency checks */
533 if (interp_elf_ex->e_type != ET_EXEC &&
534 interp_elf_ex->e_type != ET_DYN)
535 goto out;
536 if (!elf_check_arch(interp_elf_ex))
537 goto out;
Al Viro72c2d532013-09-22 16:27:52 -0400538 if (!interpreter->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 goto out;
540
Paul Burtona9d9ef12014-09-11 08:30:15 +0100541 total_size = total_mapping_size(interp_elf_phdata,
542 interp_elf_ex->e_phnum);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100543 if (!total_size) {
544 error = -EINVAL;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100545 goto out;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100546 }
547
Paul Burtona9d9ef12014-09-11 08:30:15 +0100548 eppnt = interp_elf_phdata;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700549 for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
550 if (eppnt->p_type == PT_LOAD) {
551 int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
552 int elf_prot = 0;
553 unsigned long vaddr = 0;
554 unsigned long k, map_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700556 if (eppnt->p_flags & PF_R)
557 elf_prot = PROT_READ;
558 if (eppnt->p_flags & PF_W)
559 elf_prot |= PROT_WRITE;
560 if (eppnt->p_flags & PF_X)
561 elf_prot |= PROT_EXEC;
562 vaddr = eppnt->p_vaddr;
563 if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
564 elf_type |= MAP_FIXED;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100565 else if (no_base && interp_elf_ex->e_type == ET_DYN)
566 load_addr = -vaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700568 map_addr = elf_map(interpreter, load_addr + vaddr,
Andrew Mortonbb1ad822008-01-30 13:31:07 +0100569 eppnt, elf_prot, elf_type, total_size);
Jiri Kosinacc503c12008-01-30 13:31:07 +0100570 total_size = 0;
571 if (!*interp_map_addr)
572 *interp_map_addr = map_addr;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700573 error = map_addr;
574 if (BAD_ADDR(map_addr))
Paul Burtona9d9ef12014-09-11 08:30:15 +0100575 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700577 if (!load_addr_set &&
578 interp_elf_ex->e_type == ET_DYN) {
579 load_addr = map_addr - ELF_PAGESTART(vaddr);
580 load_addr_set = 1;
581 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700583 /*
584 * Check to see if the section's size will overflow the
585 * allowed task size. Note that p_filesz must always be
586 * <= p_memsize so it's only necessary to check p_memsz.
587 */
588 k = load_addr + eppnt->p_vaddr;
Chuck Ebbertce510592006-07-03 00:24:14 -0700589 if (BAD_ADDR(k) ||
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700590 eppnt->p_filesz > eppnt->p_memsz ||
591 eppnt->p_memsz > TASK_SIZE ||
592 TASK_SIZE - eppnt->p_memsz < k) {
593 error = -ENOMEM;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100594 goto out;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700595 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700597 /*
598 * Find the end of the file mapping for this phdr, and
599 * keep track of the largest address we see for this.
600 */
601 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
602 if (k > elf_bss)
603 elf_bss = k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700605 /*
606 * Do the same thing for the memory mapping - between
607 * elf_bss and last_bss is the bss section.
608 */
609 k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
610 if (k > last_bss)
611 last_bss = k;
612 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 }
614
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 if (last_bss > elf_bss) {
Roland McGrath752015d2009-09-08 19:49:40 -0700616 /*
617 * Now fill out the bss section. First pad the last page up
618 * to the page boundary, and then perform a mmap to make sure
619 * that there are zero-mapped pages up to and including the
620 * last bss page.
621 */
622 if (padzero(elf_bss)) {
623 error = -EFAULT;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100624 goto out;
Roland McGrath752015d2009-09-08 19:49:40 -0700625 }
626
627 /* What we have mapped so far */
628 elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1);
629
630 /* Map the last of the bss segment */
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -0700631 error = vm_brk(elf_bss, last_bss - elf_bss);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 if (BAD_ADDR(error))
Paul Burtona9d9ef12014-09-11 08:30:15 +0100633 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 }
635
Jiri Kosinacc503c12008-01-30 13:31:07 +0100636 error = load_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637out:
638 return error;
639}
640
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641/*
642 * These are the functions used to load ELF style executables and shared
643 * libraries. There is no binary dependent code anywhere else.
644 */
645
Andi Kleen913bd902006-03-25 16:29:09 +0100646#ifndef STACK_RND_MASK
James Bottomleyd1cabd62007-03-16 13:38:35 -0800647#define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12)) /* 8MB of VA */
Andi Kleen913bd902006-03-25 16:29:09 +0100648#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
650static unsigned long randomize_stack_top(unsigned long stack_top)
651{
Hector Marco-Gisbert4e7c22d2015-02-14 09:33:50 -0800652 unsigned long random_variable = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
Andi Kleenc16b63e02006-09-26 10:52:28 +0200654 if ((current->flags & PF_RANDOMIZE) &&
655 !(current->personality & ADDR_NO_RANDOMIZE)) {
Daniel Cashman5ef11c32016-02-26 15:19:37 -0800656 random_variable = get_random_long();
Hector Marco-Gisbert4e7c22d2015-02-14 09:33:50 -0800657 random_variable &= STACK_RND_MASK;
Andi Kleen913bd902006-03-25 16:29:09 +0100658 random_variable <<= PAGE_SHIFT;
659 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660#ifdef CONFIG_STACK_GROWSUP
Andi Kleen913bd902006-03-25 16:29:09 +0100661 return PAGE_ALIGN(stack_top) + random_variable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662#else
Andi Kleen913bd902006-03-25 16:29:09 +0100663 return PAGE_ALIGN(stack_top) - random_variable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664#endif
665}
666
Al Viro71613c32012-10-20 22:00:48 -0400667static int load_elf_binary(struct linux_binprm *bprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668{
669 struct file *interpreter = NULL; /* to shut gcc up */
670 unsigned long load_addr = 0, load_bias = 0;
671 int load_addr_set = 0;
672 char * elf_interpreter = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 unsigned long error;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100674 struct elf_phdr *elf_ppnt, *elf_phdata, *interp_elf_phdata = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 unsigned long elf_bss, elf_brk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 int retval, i;
Jiri Kosinacc503c12008-01-30 13:31:07 +0100677 unsigned long elf_entry;
678 unsigned long interp_load_addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 unsigned long start_code, end_code, start_data, end_data;
David Daney1a530a62011-03-22 16:34:48 -0700680 unsigned long reloc_func_desc __maybe_unused = 0;
David Rientjes8de61e62006-12-06 20:40:16 -0800681 int executable_stack = EXSTACK_DEFAULT;
Al Viro71613c32012-10-20 22:00:48 -0400682 struct pt_regs *regs = current_pt_regs();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 struct {
684 struct elfhdr elf_ex;
685 struct elfhdr interp_elf_ex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 } *loc;
Paul Burton774c1052014-09-11 08:30:16 +0100687 struct arch_elf_state arch_state = INIT_ARCH_ELF_STATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
689 loc = kmalloc(sizeof(*loc), GFP_KERNEL);
690 if (!loc) {
691 retval = -ENOMEM;
692 goto out_ret;
693 }
694
695 /* Get the exec-header */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700696 loc->elf_ex = *((struct elfhdr *)bprm->buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
698 retval = -ENOEXEC;
699 /* First of all, some simple consistency checks */
700 if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
701 goto out;
702
703 if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
704 goto out;
705 if (!elf_check_arch(&loc->elf_ex))
706 goto out;
Al Viro72c2d532013-09-22 16:27:52 -0400707 if (!bprm->file->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 goto out;
709
Paul Burton6a8d3892014-09-11 08:30:14 +0100710 elf_phdata = load_elf_phdrs(&loc->elf_ex, bprm->file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 if (!elf_phdata)
712 goto out;
713
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 elf_ppnt = elf_phdata;
715 elf_bss = 0;
716 elf_brk = 0;
717
718 start_code = ~0UL;
719 end_code = 0;
720 start_data = 0;
721 end_data = 0;
722
723 for (i = 0; i < loc->elf_ex.e_phnum; i++) {
724 if (elf_ppnt->p_type == PT_INTERP) {
725 /* This is the program interpreter used for
726 * shared libraries - for now assume that this
727 * is an a.out format binary
728 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 retval = -ENOEXEC;
730 if (elf_ppnt->p_filesz > PATH_MAX ||
731 elf_ppnt->p_filesz < 2)
Al Viroe7b9b552009-03-29 16:31:16 -0400732 goto out_free_ph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733
734 retval = -ENOMEM;
Jesper Juhl792db3a2006-01-09 20:54:45 -0800735 elf_interpreter = kmalloc(elf_ppnt->p_filesz,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700736 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 if (!elf_interpreter)
Al Viroe7b9b552009-03-29 16:31:16 -0400738 goto out_free_ph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
740 retval = kernel_read(bprm->file, elf_ppnt->p_offset,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700741 elf_interpreter,
742 elf_ppnt->p_filesz);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 if (retval != elf_ppnt->p_filesz) {
744 if (retval >= 0)
745 retval = -EIO;
746 goto out_free_interp;
747 }
748 /* make sure path is NULL terminated */
749 retval = -ENOEXEC;
750 if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
751 goto out_free_interp;
752
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 interpreter = open_exec(elf_interpreter);
754 retval = PTR_ERR(interpreter);
755 if (IS_ERR(interpreter))
756 goto out_free_interp;
Alexey Dobriyan1fb84492007-01-26 00:57:16 -0800757
758 /*
759 * If the binary is not readable then enforce
760 * mm->dumpable = 0 regardless of the interpreter's
761 * permissions.
762 */
Al Viro1b5d7832011-06-19 12:49:47 -0400763 would_dump(bprm, interpreter);
Alexey Dobriyan1fb84492007-01-26 00:57:16 -0800764
Maciej W. Rozyckib582ef5c2015-10-26 15:48:19 +0000765 /* Get the exec headers */
766 retval = kernel_read(interpreter, 0,
767 (void *)&loc->interp_elf_ex,
768 sizeof(loc->interp_elf_ex));
769 if (retval != sizeof(loc->interp_elf_ex)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 if (retval >= 0)
771 retval = -EIO;
772 goto out_free_dentry;
773 }
774
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 break;
776 }
777 elf_ppnt++;
778 }
779
780 elf_ppnt = elf_phdata;
781 for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
Paul Burton774c1052014-09-11 08:30:16 +0100782 switch (elf_ppnt->p_type) {
783 case PT_GNU_STACK:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 if (elf_ppnt->p_flags & PF_X)
785 executable_stack = EXSTACK_ENABLE_X;
786 else
787 executable_stack = EXSTACK_DISABLE_X;
788 break;
Paul Burton774c1052014-09-11 08:30:16 +0100789
790 case PT_LOPROC ... PT_HIPROC:
791 retval = arch_elf_pt_proc(&loc->elf_ex, elf_ppnt,
792 bprm->file, false,
793 &arch_state);
794 if (retval)
795 goto out_free_dentry;
796 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
799 /* Some simple consistency checks for the interpreter */
800 if (elf_interpreter) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 retval = -ELIBBAD;
Andi Kleend20894a2008-02-08 04:21:54 -0800802 /* Not an ELF interpreter */
803 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 /* Verify the interpreter has a valid arch */
Andi Kleend20894a2008-02-08 04:21:54 -0800806 if (!elf_check_arch(&loc->interp_elf_ex))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 goto out_free_dentry;
Paul Burtona9d9ef12014-09-11 08:30:15 +0100808
809 /* Load the interpreter program headers */
810 interp_elf_phdata = load_elf_phdrs(&loc->interp_elf_ex,
811 interpreter);
812 if (!interp_elf_phdata)
813 goto out_free_dentry;
Paul Burton774c1052014-09-11 08:30:16 +0100814
815 /* Pass PT_LOPROC..PT_HIPROC headers to arch code */
816 elf_ppnt = interp_elf_phdata;
817 for (i = 0; i < loc->interp_elf_ex.e_phnum; i++, elf_ppnt++)
818 switch (elf_ppnt->p_type) {
819 case PT_LOPROC ... PT_HIPROC:
820 retval = arch_elf_pt_proc(&loc->interp_elf_ex,
821 elf_ppnt, interpreter,
822 true, &arch_state);
823 if (retval)
824 goto out_free_dentry;
825 break;
826 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 }
828
Paul Burton774c1052014-09-11 08:30:16 +0100829 /*
830 * Allow arch code to reject the ELF at this point, whilst it's
831 * still possible to return an error to the code that invoked
832 * the exec syscall.
833 */
Maciej W. Rozyckieb4bc072015-11-13 00:47:48 +0000834 retval = arch_check_elf(&loc->elf_ex,
835 !!interpreter, &loc->interp_elf_ex,
836 &arch_state);
Paul Burton774c1052014-09-11 08:30:16 +0100837 if (retval)
838 goto out_free_dentry;
839
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 /* Flush all traces of the currently running executable */
841 retval = flush_old_exec(bprm);
842 if (retval)
843 goto out_free_dentry;
844
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 /* Do this immediately, since STACK_TOP as used in setup_arg_pages
846 may depend on the personality. */
Paul Burton774c1052014-09-11 08:30:16 +0100847 SET_PERSONALITY2(loc->elf_ex, &arch_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 if (elf_read_implies_exec(loc->elf_ex, executable_stack))
849 current->personality |= READ_IMPLIES_EXEC;
850
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700851 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 current->flags |= PF_RANDOMIZE;
Linus Torvalds221af7f2010-01-28 22:14:42 -0800853
854 setup_new_exec(bprm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855
856 /* Do this so that we can load the interpreter, if need be. We will
857 change some of these later */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
859 executable_stack);
Al Viro19d860a2014-05-04 20:11:36 -0400860 if (retval < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 current->mm->start_stack = bprm->p;
864
André Goddard Rosaaf901ca2009-11-14 13:09:05 -0200865 /* Now we do a little grungy work by mmapping the ELF image into
Jiri Kosinacc503c12008-01-30 13:31:07 +0100866 the correct location in memory. */
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700867 for(i = 0, elf_ppnt = elf_phdata;
868 i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 int elf_prot = 0, elf_flags;
870 unsigned long k, vaddr;
Michael Davidsona87938b2015-04-14 15:47:38 -0700871 unsigned long total_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872
873 if (elf_ppnt->p_type != PT_LOAD)
874 continue;
875
876 if (unlikely (elf_brk > elf_bss)) {
877 unsigned long nbyte;
878
879 /* There was a PT_LOAD segment with p_memsz > p_filesz
880 before this one. Map anonymous pages, if needed,
881 and clear the area. */
Mikael Petterssonf670d0e2011-01-12 17:00:02 -0800882 retval = set_brk(elf_bss + load_bias,
883 elf_brk + load_bias);
Al Viro19d860a2014-05-04 20:11:36 -0400884 if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 goto out_free_dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 nbyte = ELF_PAGEOFFSET(elf_bss);
887 if (nbyte) {
888 nbyte = ELF_MIN_ALIGN - nbyte;
889 if (nbyte > elf_brk - elf_bss)
890 nbyte = elf_brk - elf_bss;
891 if (clear_user((void __user *)elf_bss +
892 load_bias, nbyte)) {
893 /*
894 * This bss-zeroing can fail if the ELF
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700895 * file specifies odd protections. So
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 * we don't check the return value
897 */
898 }
899 }
900 }
901
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700902 if (elf_ppnt->p_flags & PF_R)
903 elf_prot |= PROT_READ;
904 if (elf_ppnt->p_flags & PF_W)
905 elf_prot |= PROT_WRITE;
906 if (elf_ppnt->p_flags & PF_X)
907 elf_prot |= PROT_EXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700909 elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910
911 vaddr = elf_ppnt->p_vaddr;
912 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
913 elf_flags |= MAP_FIXED;
914 } else if (loc->elf_ex.e_type == ET_DYN) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700915 /* Try and get dynamic programs out of the way of the
916 * default mmap base, as well as whatever program they
917 * might try to exec. This is because the brk will
918 * follow the loader, and is not movable. */
Kees Cookd1fd8362015-04-14 15:48:07 -0700919 load_bias = ELF_ET_DYN_BASE - vaddr;
Jiri Kosinaa3defbe2011-11-02 13:37:41 -0700920 if (current->flags & PF_RANDOMIZE)
Kees Cookd1fd8362015-04-14 15:48:07 -0700921 load_bias += arch_mmap_rnd();
922 load_bias = ELF_PAGESTART(load_bias);
Michael Davidsona87938b2015-04-14 15:47:38 -0700923 total_size = total_mapping_size(elf_phdata,
924 loc->elf_ex.e_phnum);
925 if (!total_size) {
Andrew Morton2b1d3ae2015-05-28 15:44:24 -0700926 retval = -EINVAL;
Michael Davidsona87938b2015-04-14 15:47:38 -0700927 goto out_free_dentry;
928 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 }
930
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700931 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
Michael Davidsona87938b2015-04-14 15:47:38 -0700932 elf_prot, elf_flags, total_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 if (BAD_ADDR(error)) {
Alexey Kuznetsovb140f2512007-05-08 00:31:57 -0700934 retval = IS_ERR((void *)error) ?
935 PTR_ERR((void*)error) : -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 goto out_free_dentry;
937 }
938
939 if (!load_addr_set) {
940 load_addr_set = 1;
941 load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
942 if (loc->elf_ex.e_type == ET_DYN) {
943 load_bias += error -
944 ELF_PAGESTART(load_bias + vaddr);
945 load_addr += load_bias;
946 reloc_func_desc = load_bias;
947 }
948 }
949 k = elf_ppnt->p_vaddr;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700950 if (k < start_code)
951 start_code = k;
952 if (start_data < k)
953 start_data = k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954
955 /*
956 * Check to see if the section's size will overflow the
957 * allowed task size. Note that p_filesz must always be
958 * <= p_memsz so it is only necessary to check p_memsz.
959 */
Chuck Ebbertce510592006-07-03 00:24:14 -0700960 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 elf_ppnt->p_memsz > TASK_SIZE ||
962 TASK_SIZE - elf_ppnt->p_memsz < k) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -0700963 /* set_brk can never work. Avoid overflows. */
Alexey Kuznetsovb140f2512007-05-08 00:31:57 -0700964 retval = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 goto out_free_dentry;
966 }
967
968 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
969
970 if (k > elf_bss)
971 elf_bss = k;
972 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
973 end_code = k;
974 if (end_data < k)
975 end_data = k;
976 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
977 if (k > elf_brk)
978 elf_brk = k;
979 }
980
981 loc->elf_ex.e_entry += load_bias;
982 elf_bss += load_bias;
983 elf_brk += load_bias;
984 start_code += load_bias;
985 end_code += load_bias;
986 start_data += load_bias;
987 end_data += load_bias;
988
989 /* Calling set_brk effectively mmaps the pages that we need
990 * for the bss and break sections. We must do this before
991 * mapping in the interpreter, to make sure it doesn't wind
992 * up getting placed where the bss needs to go.
993 */
994 retval = set_brk(elf_bss, elf_brk);
Al Viro19d860a2014-05-04 20:11:36 -0400995 if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 goto out_free_dentry;
akpm@osdl.org6de50512005-10-11 08:29:08 -0700997 if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 retval = -EFAULT; /* Nobody gets to see this, but.. */
999 goto out_free_dentry;
1000 }
1001
1002 if (elf_interpreter) {
Alan Cox6eec4822012-10-04 17:13:42 -07001003 unsigned long interp_map_addr = 0;
Jiri Kosinacc503c12008-01-30 13:31:07 +01001004
Andi Kleend20894a2008-02-08 04:21:54 -08001005 elf_entry = load_elf_interp(&loc->interp_elf_ex,
1006 interpreter,
1007 &interp_map_addr,
Paul Burtona9d9ef12014-09-11 08:30:15 +01001008 load_bias, interp_elf_phdata);
Andi Kleend20894a2008-02-08 04:21:54 -08001009 if (!IS_ERR((void *)elf_entry)) {
1010 /*
1011 * load_elf_interp() returns relocation
1012 * adjustment
1013 */
1014 interp_load_addr = elf_entry;
1015 elf_entry += loc->interp_elf_ex.e_entry;
Jiri Kosinacc503c12008-01-30 13:31:07 +01001016 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 if (BAD_ADDR(elf_entry)) {
Chuck Ebbertce510592006-07-03 00:24:14 -07001018 retval = IS_ERR((void *)elf_entry) ?
1019 (int)elf_entry : -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 goto out_free_dentry;
1021 }
1022 reloc_func_desc = interp_load_addr;
1023
1024 allow_write_access(interpreter);
1025 fput(interpreter);
1026 kfree(elf_interpreter);
1027 } else {
1028 elf_entry = loc->elf_ex.e_entry;
Suresh Siddha5342fba2006-02-26 04:18:28 +01001029 if (BAD_ADDR(elf_entry)) {
Chuck Ebbertce510592006-07-03 00:24:14 -07001030 retval = -EINVAL;
Suresh Siddha5342fba2006-02-26 04:18:28 +01001031 goto out_free_dentry;
1032 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 }
1034
Paul Burton774c1052014-09-11 08:30:16 +01001035 kfree(interp_elf_phdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 kfree(elf_phdata);
1037
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 set_binfmt(&elf_format);
1039
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -07001040#ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
Martin Schwidefskyfc5243d2008-12-25 13:38:35 +01001041 retval = arch_setup_additional_pages(bprm, !!elf_interpreter);
Al Viro19d860a2014-05-04 20:11:36 -04001042 if (retval < 0)
Roland McGrath18c8baf2005-04-28 15:17:19 -07001043 goto out;
Benjamin Herrenschmidt547ee842005-04-16 15:24:35 -07001044#endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
1045
David Howellsa6f76f22008-11-14 10:39:24 +11001046 install_exec_creds(bprm);
Ollie Wildb6a2fea2007-07-19 01:48:16 -07001047 retval = create_elf_tables(bprm, &loc->elf_ex,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001048 load_addr, interp_load_addr);
Al Viro19d860a2014-05-04 20:11:36 -04001049 if (retval < 0)
Ollie Wildb6a2fea2007-07-19 01:48:16 -07001050 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 /* N.B. passed_fileno might not be initialized? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 current->mm->end_code = end_code;
1053 current->mm->start_code = start_code;
1054 current->mm->start_data = start_data;
1055 current->mm->end_data = end_data;
1056 current->mm->start_stack = bprm->p;
1057
Jiri Kosina4471a672011-04-14 15:22:09 -07001058 if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
Jiri Kosinac1d171a2008-01-30 13:30:40 +01001059 current->mm->brk = current->mm->start_brk =
1060 arch_randomize_brk(current->mm);
Kees Cook204db6e2015-04-14 15:48:12 -07001061#ifdef compat_brk_randomized
Jiri Kosina4471a672011-04-14 15:22:09 -07001062 current->brk_randomized = 1;
1063#endif
1064 }
Jiri Kosinac1d171a2008-01-30 13:30:40 +01001065
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 if (current->personality & MMAP_PAGE_ZERO) {
1067 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1068 and some applications "depend" upon this behavior.
1069 Since we do not have the power to recompile these, we
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001070 emulate the SVr4 behavior. Sigh. */
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001071 error = vm_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 MAP_FIXED | MAP_PRIVATE, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 }
1074
1075#ifdef ELF_PLAT_INIT
1076 /*
1077 * The ABI may specify that certain registers be set up in special
1078 * ways (on i386 %edx is the address of a DT_FINI function, for
1079 * example. In addition, it may also specify (eg, PowerPC64 ELF)
1080 * that the e_entry field is the address of the function descriptor
1081 * for the startup routine, rather than the address of the startup
1082 * routine itself. This macro performs whatever initialization to
1083 * the regs structure is required as well as any relocations to the
1084 * function descriptor entries when executing dynamically links apps.
1085 */
1086 ELF_PLAT_INIT(regs, reloc_func_desc);
1087#endif
1088
1089 start_thread(regs, elf_entry, bprm->p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 retval = 0;
1091out:
1092 kfree(loc);
1093out_ret:
1094 return retval;
1095
1096 /* error cleanup */
1097out_free_dentry:
Paul Burtona9d9ef12014-09-11 08:30:15 +01001098 kfree(interp_elf_phdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 allow_write_access(interpreter);
1100 if (interpreter)
1101 fput(interpreter);
1102out_free_interp:
Jesper Juhlf99d49a2005-11-07 01:01:34 -08001103 kfree(elf_interpreter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104out_free_ph:
1105 kfree(elf_phdata);
1106 goto out;
1107}
1108
Josh Triplett69369a72014-04-03 14:48:27 -07001109#ifdef CONFIG_USELIB
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110/* This is really simpleminded and specialized - we are loading an
1111 a.out library that is given an ELF header. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112static int load_elf_library(struct file *file)
1113{
1114 struct elf_phdr *elf_phdata;
1115 struct elf_phdr *eppnt;
1116 unsigned long elf_bss, bss, len;
1117 int retval, error, i, j;
1118 struct elfhdr elf_ex;
1119
1120 error = -ENOEXEC;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001121 retval = kernel_read(file, 0, (char *)&elf_ex, sizeof(elf_ex));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 if (retval != sizeof(elf_ex))
1123 goto out;
1124
1125 if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1126 goto out;
1127
1128 /* First of all, some simple consistency checks */
1129 if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
Al Viro72c2d532013-09-22 16:27:52 -04001130 !elf_check_arch(&elf_ex) || !file->f_op->mmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 goto out;
1132
1133 /* Now read in all of the header information */
1134
1135 j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1136 /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1137
1138 error = -ENOMEM;
1139 elf_phdata = kmalloc(j, GFP_KERNEL);
1140 if (!elf_phdata)
1141 goto out;
1142
1143 eppnt = elf_phdata;
1144 error = -ENOEXEC;
1145 retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);
1146 if (retval != j)
1147 goto out_free_ph;
1148
1149 for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1150 if ((eppnt + i)->p_type == PT_LOAD)
1151 j++;
1152 if (j != 1)
1153 goto out_free_ph;
1154
1155 while (eppnt->p_type != PT_LOAD)
1156 eppnt++;
1157
1158 /* Now use mmap to map the library into memory. */
Linus Torvalds6be5ceb2012-04-20 17:13:58 -07001159 error = vm_mmap(file,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 ELF_PAGESTART(eppnt->p_vaddr),
1161 (eppnt->p_filesz +
1162 ELF_PAGEOFFSET(eppnt->p_vaddr)),
1163 PROT_READ | PROT_WRITE | PROT_EXEC,
1164 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
1165 (eppnt->p_offset -
1166 ELF_PAGEOFFSET(eppnt->p_vaddr)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 if (error != ELF_PAGESTART(eppnt->p_vaddr))
1168 goto out_free_ph;
1169
1170 elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1171 if (padzero(elf_bss)) {
1172 error = -EFAULT;
1173 goto out_free_ph;
1174 }
1175
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001176 len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr +
1177 ELF_MIN_ALIGN - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 bss = eppnt->p_memsz + eppnt->p_vaddr;
Linus Torvaldse4eb1ff2012-04-20 15:35:40 -07001179 if (bss > len)
1180 vm_brk(len, bss - len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 error = 0;
1182
1183out_free_ph:
1184 kfree(elf_phdata);
1185out:
1186 return error;
1187}
Josh Triplett69369a72014-04-03 14:48:27 -07001188#endif /* #ifdef CONFIG_USELIB */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08001190#ifdef CONFIG_ELF_CORE
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191/*
1192 * ELF core dumper
1193 *
1194 * Modelled on fs/exec.c:aout_core_dump()
1195 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1196 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197
1198/*
Jason Baron909af762012-03-23 15:02:51 -07001199 * The purpose of always_dump_vma() is to make sure that special kernel mappings
1200 * that are useful for post-mortem analysis are included in every core dump.
1201 * In that way we ensure that the core dump is fully interpretable later
1202 * without matching up the same kernel and hardware config to see what PC values
1203 * meant. These special mappings include - vDSO, vsyscall, and other
1204 * architecture specific mappings
1205 */
1206static bool always_dump_vma(struct vm_area_struct *vma)
1207{
1208 /* Any vsyscall mappings? */
1209 if (vma == get_gate_vma(vma->vm_mm))
1210 return true;
Andy Lutomirski78d683e2014-05-19 15:58:32 -07001211
1212 /*
1213 * Assume that all vmas with a .name op should always be dumped.
1214 * If this changes, a new vm_ops field can easily be added.
1215 */
1216 if (vma->vm_ops && vma->vm_ops->name && vma->vm_ops->name(vma))
1217 return true;
1218
Jason Baron909af762012-03-23 15:02:51 -07001219 /*
1220 * arch_vma_name() returns non-NULL for special architecture mappings,
1221 * such as vDSO sections.
1222 */
1223 if (arch_vma_name(vma))
1224 return true;
1225
1226 return false;
1227}
1228
1229/*
Roland McGrath82df3972007-10-16 23:27:02 -07001230 * Decide what to dump of a segment, part, all or none.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 */
Roland McGrath82df3972007-10-16 23:27:02 -07001232static unsigned long vma_dump_size(struct vm_area_struct *vma,
1233 unsigned long mm_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234{
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001235#define FILTER(type) (mm_flags & (1UL << MMF_DUMP_##type))
1236
Jason Baron909af762012-03-23 15:02:51 -07001237 /* always dump the vdso and vsyscall sections */
1238 if (always_dump_vma(vma))
Roland McGrath82df3972007-10-16 23:27:02 -07001239 goto whole;
Roland McGrathe5b97dd2007-01-26 00:56:48 -08001240
Konstantin Khlebnikov0103bd12012-10-08 16:28:59 -07001241 if (vma->vm_flags & VM_DONTDUMP)
Jason Baronaccb61f2012-03-23 15:02:51 -07001242 return 0;
1243
Ross Zwisler50378352015-10-05 16:33:36 -06001244 /* support for DAX */
1245 if (vma_is_dax(vma)) {
1246 if ((vma->vm_flags & VM_SHARED) && FILTER(DAX_SHARED))
1247 goto whole;
1248 if (!(vma->vm_flags & VM_SHARED) && FILTER(DAX_PRIVATE))
1249 goto whole;
1250 return 0;
1251 }
1252
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001253 /* Hugetlb memory check */
1254 if (vma->vm_flags & VM_HUGETLB) {
1255 if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))
1256 goto whole;
1257 if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))
1258 goto whole;
Naoya Horiguchi23d9e482013-04-17 15:58:28 -07001259 return 0;
KOSAKI Motohiroe575f112008-10-18 20:27:08 -07001260 }
1261
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 /* Do not dump I/O mapped devices or special mappings */
Konstantin Khlebnikov314e51b2012-10-08 16:29:02 -07001263 if (vma->vm_flags & VM_IO)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 return 0;
1265
Kawai, Hidehiroa1b59e82007-07-19 01:48:29 -07001266 /* By default, dump shared memory if mapped from an anonymous file. */
1267 if (vma->vm_flags & VM_SHARED) {
Al Viro496ad9a2013-01-23 17:07:38 -05001268 if (file_inode(vma->vm_file)->i_nlink == 0 ?
Roland McGrath82df3972007-10-16 23:27:02 -07001269 FILTER(ANON_SHARED) : FILTER(MAPPED_SHARED))
1270 goto whole;
1271 return 0;
Kawai, Hidehiroa1b59e82007-07-19 01:48:29 -07001272 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273
Roland McGrath82df3972007-10-16 23:27:02 -07001274 /* Dump segments that have been written to. */
1275 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1276 goto whole;
1277 if (vma->vm_file == NULL)
1278 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279
Roland McGrath82df3972007-10-16 23:27:02 -07001280 if (FILTER(MAPPED_PRIVATE))
1281 goto whole;
1282
1283 /*
1284 * If this looks like the beginning of a DSO or executable mapping,
1285 * check for an ELF header. If we find one, dump the first page to
1286 * aid in determining what was mapped here.
1287 */
Roland McGrath92dc07b2009-02-06 17:34:07 -08001288 if (FILTER(ELF_HEADERS) &&
1289 vma->vm_pgoff == 0 && (vma->vm_flags & VM_READ)) {
Roland McGrath82df3972007-10-16 23:27:02 -07001290 u32 __user *header = (u32 __user *) vma->vm_start;
1291 u32 word;
Roland McGrath92dc07b2009-02-06 17:34:07 -08001292 mm_segment_t fs = get_fs();
Roland McGrath82df3972007-10-16 23:27:02 -07001293 /*
1294 * Doing it this way gets the constant folded by GCC.
1295 */
1296 union {
1297 u32 cmp;
1298 char elfmag[SELFMAG];
1299 } magic;
1300 BUILD_BUG_ON(SELFMAG != sizeof word);
1301 magic.elfmag[EI_MAG0] = ELFMAG0;
1302 magic.elfmag[EI_MAG1] = ELFMAG1;
1303 magic.elfmag[EI_MAG2] = ELFMAG2;
1304 magic.elfmag[EI_MAG3] = ELFMAG3;
Roland McGrath92dc07b2009-02-06 17:34:07 -08001305 /*
1306 * Switch to the user "segment" for get_user(),
1307 * then put back what elf_core_dump() had in place.
1308 */
1309 set_fs(USER_DS);
1310 if (unlikely(get_user(word, header)))
1311 word = 0;
1312 set_fs(fs);
1313 if (word == magic.cmp)
Roland McGrath82df3972007-10-16 23:27:02 -07001314 return PAGE_SIZE;
1315 }
1316
1317#undef FILTER
1318
1319 return 0;
1320
1321whole:
1322 return vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323}
1324
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325/* An ELF note in memory */
1326struct memelfnote
1327{
1328 const char *name;
1329 int type;
1330 unsigned int datasz;
1331 void *data;
1332};
1333
1334static int notesize(struct memelfnote *en)
1335{
1336 int sz;
1337
1338 sz = sizeof(struct elf_note);
1339 sz += roundup(strlen(en->name) + 1, 4);
1340 sz += roundup(en->datasz, 4);
1341
1342 return sz;
1343}
1344
Al Viroecc8c772013-10-05 15:32:35 -04001345static int writenote(struct memelfnote *men, struct coredump_params *cprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346{
1347 struct elf_note en;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 en.n_namesz = strlen(men->name) + 1;
1349 en.n_descsz = men->datasz;
1350 en.n_type = men->type;
1351
Al Viroecc8c772013-10-05 15:32:35 -04001352 return dump_emit(cprm, &en, sizeof(en)) &&
Al Viro22a8cb82013-10-08 11:05:01 -04001353 dump_emit(cprm, men->name, en.n_namesz) && dump_align(cprm, 4) &&
1354 dump_emit(cprm, men->data, men->datasz) && dump_align(cprm, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356
Roland McGrath3aba4812008-01-30 13:31:44 +01001357static void fill_elf_header(struct elfhdr *elf, int segs,
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08001358 u16 machine, u32 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359{
Cyrill Gorcunov6970c8e2008-04-29 01:01:18 -07001360 memset(elf, 0, sizeof(*elf));
1361
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 memcpy(elf->e_ident, ELFMAG, SELFMAG);
1363 elf->e_ident[EI_CLASS] = ELF_CLASS;
1364 elf->e_ident[EI_DATA] = ELF_DATA;
1365 elf->e_ident[EI_VERSION] = EV_CURRENT;
1366 elf->e_ident[EI_OSABI] = ELF_OSABI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367
1368 elf->e_type = ET_CORE;
Roland McGrath3aba4812008-01-30 13:31:44 +01001369 elf->e_machine = machine;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 elf->e_version = EV_CURRENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371 elf->e_phoff = sizeof(struct elfhdr);
Roland McGrath3aba4812008-01-30 13:31:44 +01001372 elf->e_flags = flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 elf->e_ehsize = sizeof(struct elfhdr);
1374 elf->e_phentsize = sizeof(struct elf_phdr);
1375 elf->e_phnum = segs;
Cyrill Gorcunov6970c8e2008-04-29 01:01:18 -07001376
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 return;
1378}
1379
Andrew Morton8d6b5eee2006-09-25 23:32:04 -07001380static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381{
1382 phdr->p_type = PT_NOTE;
1383 phdr->p_offset = offset;
1384 phdr->p_vaddr = 0;
1385 phdr->p_paddr = 0;
1386 phdr->p_filesz = sz;
1387 phdr->p_memsz = 0;
1388 phdr->p_flags = 0;
1389 phdr->p_align = 0;
1390 return;
1391}
1392
1393static void fill_note(struct memelfnote *note, const char *name, int type,
1394 unsigned int sz, void *data)
1395{
1396 note->name = name;
1397 note->type = type;
1398 note->datasz = sz;
1399 note->data = data;
1400 return;
1401}
1402
1403/*
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001404 * fill up all the fields in prstatus from the given task struct, except
1405 * registers which need to be filled up separately.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 */
1407static void fill_prstatus(struct elf_prstatus *prstatus,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001408 struct task_struct *p, long signr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409{
1410 prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1411 prstatus->pr_sigpend = p->pending.signal.sig[0];
1412 prstatus->pr_sighold = p->blocked.sig[0];
Oleg Nesterov3b34fc52009-06-17 16:27:38 -07001413 rcu_read_lock();
1414 prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1415 rcu_read_unlock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001416 prstatus->pr_pid = task_pid_vnr(p);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001417 prstatus->pr_pgrp = task_pgrp_vnr(p);
1418 prstatus->pr_sid = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 if (thread_group_leader(p)) {
Frank Mayharf06febc2008-09-12 09:54:39 -07001420 struct task_cputime cputime;
1421
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 /*
Frank Mayharf06febc2008-09-12 09:54:39 -07001423 * This is the record for the group leader. It shows the
1424 * group-wide total, not its individual thread total.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425 */
Frank Mayharf06febc2008-09-12 09:54:39 -07001426 thread_group_cputime(p, &cputime);
1427 cputime_to_timeval(cputime.utime, &prstatus->pr_utime);
1428 cputime_to_timeval(cputime.stime, &prstatus->pr_stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 } else {
Frederic Weisbecker6fac4822012-11-13 14:20:55 +01001430 cputime_t utime, stime;
1431
1432 task_cputime(p, &utime, &stime);
1433 cputime_to_timeval(utime, &prstatus->pr_utime);
1434 cputime_to_timeval(stime, &prstatus->pr_stime);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 }
1436 cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
1437 cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
1438}
1439
1440static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1441 struct mm_struct *mm)
1442{
David Howellsc69e8d92008-11-14 10:39:19 +11001443 const struct cred *cred;
Greg Kroah-Hartmana84a5052005-05-11 00:10:44 -07001444 unsigned int i, len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445
1446 /* first copy the parameters from user space */
1447 memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1448
1449 len = mm->arg_end - mm->arg_start;
1450 if (len >= ELF_PRARGSZ)
1451 len = ELF_PRARGSZ-1;
1452 if (copy_from_user(&psinfo->pr_psargs,
1453 (const char __user *)mm->arg_start, len))
1454 return -EFAULT;
1455 for(i = 0; i < len; i++)
1456 if (psinfo->pr_psargs[i] == 0)
1457 psinfo->pr_psargs[i] = ' ';
1458 psinfo->pr_psargs[len] = 0;
1459
Oleg Nesterov3b34fc52009-06-17 16:27:38 -07001460 rcu_read_lock();
1461 psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1462 rcu_read_unlock();
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001463 psinfo->pr_pid = task_pid_vnr(p);
Pavel Emelyanovb4888932007-10-18 23:40:14 -07001464 psinfo->pr_pgrp = task_pgrp_vnr(p);
1465 psinfo->pr_sid = task_session_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466
1467 i = p->state ? ffz(~p->state) + 1 : 0;
1468 psinfo->pr_state = i;
Carsten Otte55148542006-03-25 03:08:22 -08001469 psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1471 psinfo->pr_nice = task_nice(p);
1472 psinfo->pr_flag = p->flags;
David Howellsc69e8d92008-11-14 10:39:19 +11001473 rcu_read_lock();
1474 cred = __task_cred(p);
Eric W. Biedermanebc887b2012-02-07 18:36:10 -08001475 SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
1476 SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
David Howellsc69e8d92008-11-14 10:39:19 +11001477 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1479
1480 return 0;
1481}
1482
Roland McGrath3aba4812008-01-30 13:31:44 +01001483static void fill_auxv_note(struct memelfnote *note, struct mm_struct *mm)
1484{
1485 elf_addr_t *auxv = (elf_addr_t *) mm->saved_auxv;
1486 int i = 0;
1487 do
1488 i += 2;
1489 while (auxv[i - 2] != AT_NULL);
1490 fill_note(note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);
1491}
1492
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001493static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,
Al Viroce395962013-10-13 17:23:53 -04001494 const siginfo_t *siginfo)
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001495{
1496 mm_segment_t old_fs = get_fs();
1497 set_fs(KERNEL_DS);
1498 copy_siginfo_to_user((user_siginfo_t __user *) csigdata, siginfo);
1499 set_fs(old_fs);
1500 fill_note(note, "CORE", NT_SIGINFO, sizeof(*csigdata), csigdata);
1501}
1502
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001503#define MAX_FILE_NOTE_SIZE (4*1024*1024)
1504/*
1505 * Format of NT_FILE note:
1506 *
1507 * long count -- how many files are mapped
1508 * long page_size -- units for file_ofs
1509 * array of [COUNT] elements of
1510 * long start
1511 * long end
1512 * long file_ofs
1513 * followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1514 */
Dan Aloni72023652013-09-30 13:45:02 -07001515static int fill_files_note(struct memelfnote *note)
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001516{
1517 struct vm_area_struct *vma;
1518 unsigned count, size, names_ofs, remaining, n;
1519 user_long_t *data;
1520 user_long_t *start_end_ofs;
1521 char *name_base, *name_curpos;
1522
1523 /* *Estimated* file count and total data size needed */
1524 count = current->mm->map_count;
1525 size = count * 64;
1526
1527 names_ofs = (2 + 3 * count) * sizeof(data[0]);
1528 alloc:
1529 if (size >= MAX_FILE_NOTE_SIZE) /* paranoia check */
Dan Aloni72023652013-09-30 13:45:02 -07001530 return -EINVAL;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001531 size = round_up(size, PAGE_SIZE);
1532 data = vmalloc(size);
1533 if (!data)
Dan Aloni72023652013-09-30 13:45:02 -07001534 return -ENOMEM;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001535
1536 start_end_ofs = data + 2;
1537 name_base = name_curpos = ((char *)data) + names_ofs;
1538 remaining = size - names_ofs;
1539 count = 0;
1540 for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1541 struct file *file;
1542 const char *filename;
1543
1544 file = vma->vm_file;
1545 if (!file)
1546 continue;
Miklos Szeredi9bf39ab2015-06-19 10:29:13 +02001547 filename = file_path(file, name_curpos, remaining);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001548 if (IS_ERR(filename)) {
1549 if (PTR_ERR(filename) == -ENAMETOOLONG) {
1550 vfree(data);
1551 size = size * 5 / 4;
1552 goto alloc;
1553 }
1554 continue;
1555 }
1556
Miklos Szeredi9bf39ab2015-06-19 10:29:13 +02001557 /* file_path() fills at the end, move name down */
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001558 /* n = strlen(filename) + 1: */
1559 n = (name_curpos + remaining) - filename;
1560 remaining = filename - name_curpos;
1561 memmove(name_curpos, filename, n);
1562 name_curpos += n;
1563
1564 *start_end_ofs++ = vma->vm_start;
1565 *start_end_ofs++ = vma->vm_end;
1566 *start_end_ofs++ = vma->vm_pgoff;
1567 count++;
1568 }
1569
1570 /* Now we know exact count of files, can store it */
1571 data[0] = count;
1572 data[1] = PAGE_SIZE;
1573 /*
1574 * Count usually is less than current->mm->map_count,
1575 * we need to move filenames down.
1576 */
1577 n = current->mm->map_count - count;
1578 if (n != 0) {
1579 unsigned shift_bytes = n * 3 * sizeof(data[0]);
1580 memmove(name_base - shift_bytes, name_base,
1581 name_curpos - name_base);
1582 name_curpos -= shift_bytes;
1583 }
1584
1585 size = name_curpos - (char *)data;
1586 fill_note(note, "CORE", NT_FILE, size, data);
Dan Aloni72023652013-09-30 13:45:02 -07001587 return 0;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001588}
1589
Roland McGrath4206d3a2008-01-30 13:31:45 +01001590#ifdef CORE_DUMP_USE_REGSET
1591#include <linux/regset.h>
1592
1593struct elf_thread_core_info {
1594 struct elf_thread_core_info *next;
1595 struct task_struct *task;
1596 struct elf_prstatus prstatus;
1597 struct memelfnote notes[0];
1598};
1599
1600struct elf_note_info {
1601 struct elf_thread_core_info *thread;
1602 struct memelfnote psinfo;
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001603 struct memelfnote signote;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001604 struct memelfnote auxv;
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001605 struct memelfnote files;
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001606 user_siginfo_t csigdata;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001607 size_t size;
1608 int thread_notes;
1609};
1610
Roland McGrathd31472b2008-03-04 14:28:30 -08001611/*
1612 * When a regset has a writeback hook, we call it on each thread before
1613 * dumping user memory. On register window machines, this makes sure the
1614 * user memory backing the register data is up to date before we read it.
1615 */
1616static void do_thread_regset_writeback(struct task_struct *task,
1617 const struct user_regset *regset)
1618{
1619 if (regset->writeback)
1620 regset->writeback(task, regset, 1);
1621}
1622
H. J. Lu0953f65d2012-02-14 13:34:52 -08001623#ifndef PR_REG_SIZE
1624#define PR_REG_SIZE(S) sizeof(S)
1625#endif
1626
1627#ifndef PRSTATUS_SIZE
1628#define PRSTATUS_SIZE(S) sizeof(S)
1629#endif
1630
1631#ifndef PR_REG_PTR
1632#define PR_REG_PTR(S) (&((S)->pr_reg))
1633#endif
1634
1635#ifndef SET_PR_FPVALID
1636#define SET_PR_FPVALID(S, V) ((S)->pr_fpvalid = (V))
1637#endif
1638
Roland McGrath4206d3a2008-01-30 13:31:45 +01001639static int fill_thread_core_info(struct elf_thread_core_info *t,
1640 const struct user_regset_view *view,
1641 long signr, size_t *total)
1642{
1643 unsigned int i;
1644
1645 /*
1646 * NT_PRSTATUS is the one special case, because the regset data
1647 * goes into the pr_reg field inside the note contents, rather
1648 * than being the whole note contents. We fill the reset in here.
1649 * We assume that regset 0 is NT_PRSTATUS.
1650 */
1651 fill_prstatus(&t->prstatus, t->task, signr);
1652 (void) view->regsets[0].get(t->task, &view->regsets[0],
H. J. Lu0953f65d2012-02-14 13:34:52 -08001653 0, PR_REG_SIZE(t->prstatus.pr_reg),
1654 PR_REG_PTR(&t->prstatus), NULL);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001655
1656 fill_note(&t->notes[0], "CORE", NT_PRSTATUS,
H. J. Lu0953f65d2012-02-14 13:34:52 -08001657 PRSTATUS_SIZE(t->prstatus), &t->prstatus);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001658 *total += notesize(&t->notes[0]);
1659
Roland McGrathd31472b2008-03-04 14:28:30 -08001660 do_thread_regset_writeback(t->task, &view->regsets[0]);
1661
Roland McGrath4206d3a2008-01-30 13:31:45 +01001662 /*
1663 * Each other regset might generate a note too. For each regset
1664 * that has no core_note_type or is inactive, we leave t->notes[i]
1665 * all zero and we'll know to skip writing it later.
1666 */
1667 for (i = 1; i < view->n; ++i) {
1668 const struct user_regset *regset = &view->regsets[i];
Roland McGrathd31472b2008-03-04 14:28:30 -08001669 do_thread_regset_writeback(t->task, regset);
H. Peter Anvinc8e25252012-03-02 10:43:48 -08001670 if (regset->core_note_type && regset->get &&
Roland McGrath4206d3a2008-01-30 13:31:45 +01001671 (!regset->active || regset->active(t->task, regset))) {
1672 int ret;
1673 size_t size = regset->n * regset->size;
1674 void *data = kmalloc(size, GFP_KERNEL);
1675 if (unlikely(!data))
1676 return 0;
1677 ret = regset->get(t->task, regset,
1678 0, size, data, NULL);
1679 if (unlikely(ret))
1680 kfree(data);
1681 else {
1682 if (regset->core_note_type != NT_PRFPREG)
1683 fill_note(&t->notes[i], "LINUX",
1684 regset->core_note_type,
1685 size, data);
1686 else {
H. J. Lu0953f65d2012-02-14 13:34:52 -08001687 SET_PR_FPVALID(&t->prstatus, 1);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001688 fill_note(&t->notes[i], "CORE",
1689 NT_PRFPREG, size, data);
1690 }
1691 *total += notesize(&t->notes[i]);
1692 }
1693 }
1694 }
1695
1696 return 1;
1697}
1698
1699static int fill_note_info(struct elfhdr *elf, int phdrs,
1700 struct elf_note_info *info,
Al Viroec579412013-10-13 17:57:29 -04001701 const siginfo_t *siginfo, struct pt_regs *regs)
Roland McGrath4206d3a2008-01-30 13:31:45 +01001702{
1703 struct task_struct *dump_task = current;
1704 const struct user_regset_view *view = task_user_regset_view(dump_task);
1705 struct elf_thread_core_info *t;
1706 struct elf_prpsinfo *psinfo;
Oleg Nesterov83914442008-07-25 01:47:45 -07001707 struct core_thread *ct;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001708 unsigned int i;
1709
1710 info->size = 0;
1711 info->thread = NULL;
1712
1713 psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
Alan Cox6899e922012-12-17 16:02:09 -08001714 if (psinfo == NULL) {
1715 info->psinfo.data = NULL; /* So we don't free this wrongly */
Roland McGrath4206d3a2008-01-30 13:31:45 +01001716 return 0;
Alan Cox6899e922012-12-17 16:02:09 -08001717 }
Roland McGrath4206d3a2008-01-30 13:31:45 +01001718
Amerigo Wange2dbe122009-07-01 01:06:26 -04001719 fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1720
Roland McGrath4206d3a2008-01-30 13:31:45 +01001721 /*
1722 * Figure out how many notes we're going to need for each thread.
1723 */
1724 info->thread_notes = 0;
1725 for (i = 0; i < view->n; ++i)
1726 if (view->regsets[i].core_note_type != 0)
1727 ++info->thread_notes;
1728
1729 /*
1730 * Sanity check. We rely on regset 0 being in NT_PRSTATUS,
1731 * since it is our one special case.
1732 */
1733 if (unlikely(info->thread_notes == 0) ||
1734 unlikely(view->regsets[0].core_note_type != NT_PRSTATUS)) {
1735 WARN_ON(1);
1736 return 0;
1737 }
1738
1739 /*
1740 * Initialize the ELF file header.
1741 */
1742 fill_elf_header(elf, phdrs,
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08001743 view->e_machine, view->e_flags);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001744
1745 /*
1746 * Allocate a structure for each thread.
1747 */
Oleg Nesterov83914442008-07-25 01:47:45 -07001748 for (ct = &dump_task->mm->core_state->dumper; ct; ct = ct->next) {
1749 t = kzalloc(offsetof(struct elf_thread_core_info,
1750 notes[info->thread_notes]),
1751 GFP_KERNEL);
1752 if (unlikely(!t))
1753 return 0;
Oleg Nesterov24d52882008-07-25 01:47:40 -07001754
Oleg Nesterov83914442008-07-25 01:47:45 -07001755 t->task = ct->task;
1756 if (ct->task == dump_task || !info->thread) {
1757 t->next = info->thread;
1758 info->thread = t;
1759 } else {
1760 /*
1761 * Make sure to keep the original task at
1762 * the head of the list.
1763 */
1764 t->next = info->thread->next;
1765 info->thread->next = t;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001766 }
Oleg Nesterov83914442008-07-25 01:47:45 -07001767 }
Roland McGrath4206d3a2008-01-30 13:31:45 +01001768
1769 /*
1770 * Now fill in each thread's information.
1771 */
1772 for (t = info->thread; t != NULL; t = t->next)
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001773 if (!fill_thread_core_info(t, view, siginfo->si_signo, &info->size))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001774 return 0;
1775
1776 /*
1777 * Fill in the two process-wide notes.
1778 */
1779 fill_psinfo(psinfo, dump_task->group_leader, dump_task->mm);
1780 info->size += notesize(&info->psinfo);
1781
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001782 fill_siginfo_note(&info->signote, &info->csigdata, siginfo);
1783 info->size += notesize(&info->signote);
1784
Roland McGrath4206d3a2008-01-30 13:31:45 +01001785 fill_auxv_note(&info->auxv, current->mm);
1786 info->size += notesize(&info->auxv);
1787
Dan Aloni72023652013-09-30 13:45:02 -07001788 if (fill_files_note(&info->files) == 0)
1789 info->size += notesize(&info->files);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001790
Roland McGrath4206d3a2008-01-30 13:31:45 +01001791 return 1;
1792}
1793
1794static size_t get_note_info_size(struct elf_note_info *info)
1795{
1796 return info->size;
1797}
1798
1799/*
1800 * Write all the notes for each thread. When writing the first thread, the
1801 * process-wide notes are interleaved after the first thread-specific note.
1802 */
1803static int write_note_info(struct elf_note_info *info,
Al Viroecc8c772013-10-05 15:32:35 -04001804 struct coredump_params *cprm)
Roland McGrath4206d3a2008-01-30 13:31:45 +01001805{
Fabian Frederickb219e252014-06-04 16:12:14 -07001806 bool first = true;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001807 struct elf_thread_core_info *t = info->thread;
1808
1809 do {
1810 int i;
1811
Al Viroecc8c772013-10-05 15:32:35 -04001812 if (!writenote(&t->notes[0], cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001813 return 0;
1814
Al Viroecc8c772013-10-05 15:32:35 -04001815 if (first && !writenote(&info->psinfo, cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001816 return 0;
Al Viroecc8c772013-10-05 15:32:35 -04001817 if (first && !writenote(&info->signote, cprm))
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001818 return 0;
Al Viroecc8c772013-10-05 15:32:35 -04001819 if (first && !writenote(&info->auxv, cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001820 return 0;
Dan Aloni72023652013-09-30 13:45:02 -07001821 if (first && info->files.data &&
Al Viroecc8c772013-10-05 15:32:35 -04001822 !writenote(&info->files, cprm))
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001823 return 0;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001824
1825 for (i = 1; i < info->thread_notes; ++i)
1826 if (t->notes[i].data &&
Al Viroecc8c772013-10-05 15:32:35 -04001827 !writenote(&t->notes[i], cprm))
Roland McGrath4206d3a2008-01-30 13:31:45 +01001828 return 0;
1829
Fabian Frederickb219e252014-06-04 16:12:14 -07001830 first = false;
Roland McGrath4206d3a2008-01-30 13:31:45 +01001831 t = t->next;
1832 } while (t);
1833
1834 return 1;
1835}
1836
1837static void free_note_info(struct elf_note_info *info)
1838{
1839 struct elf_thread_core_info *threads = info->thread;
1840 while (threads) {
1841 unsigned int i;
1842 struct elf_thread_core_info *t = threads;
1843 threads = t->next;
1844 WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);
1845 for (i = 1; i < info->thread_notes; ++i)
1846 kfree(t->notes[i].data);
1847 kfree(t);
1848 }
1849 kfree(info->psinfo.data);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001850 vfree(info->files.data);
Roland McGrath4206d3a2008-01-30 13:31:45 +01001851}
1852
1853#else
1854
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855/* Here is the structure in which status of each thread is captured. */
1856struct elf_thread_status
1857{
1858 struct list_head list;
1859 struct elf_prstatus prstatus; /* NT_PRSTATUS */
1860 elf_fpregset_t fpu; /* NT_PRFPREG */
1861 struct task_struct *thread;
1862#ifdef ELF_CORE_COPY_XFPREGS
Mark Nelson5b20cd82007-10-16 23:25:39 -07001863 elf_fpxregset_t xfpu; /* ELF_CORE_XFPREG_TYPE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864#endif
1865 struct memelfnote notes[3];
1866 int num_notes;
1867};
1868
1869/*
1870 * In order to add the specific thread information for the elf file format,
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001871 * we need to keep a linked list of every threads pr_status and then create
1872 * a single section for them in the final core file.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 */
1874static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1875{
1876 int sz = 0;
1877 struct task_struct *p = t->thread;
1878 t->num_notes = 0;
1879
1880 fill_prstatus(&t->prstatus, p, signr);
1881 elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1882
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001883 fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1884 &(t->prstatus));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 t->num_notes++;
1886 sz += notesize(&t->notes[0]);
1887
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07001888 if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1889 &t->fpu))) {
1890 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1891 &(t->fpu));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 t->num_notes++;
1893 sz += notesize(&t->notes[1]);
1894 }
1895
1896#ifdef ELF_CORE_COPY_XFPREGS
1897 if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
Mark Nelson5b20cd82007-10-16 23:25:39 -07001898 fill_note(&t->notes[2], "LINUX", ELF_CORE_XFPREG_TYPE,
1899 sizeof(t->xfpu), &t->xfpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 t->num_notes++;
1901 sz += notesize(&t->notes[2]);
1902 }
1903#endif
1904 return sz;
1905}
1906
Roland McGrath3aba4812008-01-30 13:31:44 +01001907struct elf_note_info {
1908 struct memelfnote *notes;
Dan Aloni72023652013-09-30 13:45:02 -07001909 struct memelfnote *notes_files;
Roland McGrath3aba4812008-01-30 13:31:44 +01001910 struct elf_prstatus *prstatus; /* NT_PRSTATUS */
1911 struct elf_prpsinfo *psinfo; /* NT_PRPSINFO */
1912 struct list_head thread_list;
1913 elf_fpregset_t *fpu;
1914#ifdef ELF_CORE_COPY_XFPREGS
1915 elf_fpxregset_t *xfpu;
1916#endif
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001917 user_siginfo_t csigdata;
Roland McGrath3aba4812008-01-30 13:31:44 +01001918 int thread_status_size;
1919 int numnote;
1920};
1921
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001922static int elf_note_info_init(struct elf_note_info *info)
Roland McGrath3aba4812008-01-30 13:31:44 +01001923{
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001924 memset(info, 0, sizeof(*info));
Roland McGrath3aba4812008-01-30 13:31:44 +01001925 INIT_LIST_HEAD(&info->thread_list);
1926
Denys Vlasenko49ae4d42012-10-04 17:15:35 -07001927 /* Allocate space for ELF notes */
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001928 info->notes = kmalloc(8 * sizeof(struct memelfnote), GFP_KERNEL);
Roland McGrath3aba4812008-01-30 13:31:44 +01001929 if (!info->notes)
1930 return 0;
1931 info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL);
1932 if (!info->psinfo)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001933 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001934 info->prstatus = kmalloc(sizeof(*info->prstatus), GFP_KERNEL);
1935 if (!info->prstatus)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001936 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001937 info->fpu = kmalloc(sizeof(*info->fpu), GFP_KERNEL);
1938 if (!info->fpu)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001939 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001940#ifdef ELF_CORE_COPY_XFPREGS
1941 info->xfpu = kmalloc(sizeof(*info->xfpu), GFP_KERNEL);
1942 if (!info->xfpu)
Denys Vlasenkof34f9d12012-09-26 11:34:50 +10001943 return 0;
Roland McGrath3aba4812008-01-30 13:31:44 +01001944#endif
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001945 return 1;
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001946}
Roland McGrath3aba4812008-01-30 13:31:44 +01001947
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001948static int fill_note_info(struct elfhdr *elf, int phdrs,
1949 struct elf_note_info *info,
Al Viroec579412013-10-13 17:57:29 -04001950 const siginfo_t *siginfo, struct pt_regs *regs)
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001951{
1952 struct list_head *t;
Al Viroafabada2013-10-14 07:39:56 -04001953 struct core_thread *ct;
1954 struct elf_thread_status *ets;
Amerigo Wang0cf062d2009-09-23 15:57:05 -07001955
1956 if (!elf_note_info_init(info))
1957 return 0;
1958
Al Viroafabada2013-10-14 07:39:56 -04001959 for (ct = current->mm->core_state->dumper.next;
1960 ct; ct = ct->next) {
1961 ets = kzalloc(sizeof(*ets), GFP_KERNEL);
1962 if (!ets)
1963 return 0;
Oleg Nesterov24d52882008-07-25 01:47:40 -07001964
Al Viroafabada2013-10-14 07:39:56 -04001965 ets->thread = ct->task;
1966 list_add(&ets->list, &info->thread_list);
1967 }
Oleg Nesterov83914442008-07-25 01:47:45 -07001968
Al Viroafabada2013-10-14 07:39:56 -04001969 list_for_each(t, &info->thread_list) {
1970 int sz;
Oleg Nesterov83914442008-07-25 01:47:45 -07001971
Al Viroafabada2013-10-14 07:39:56 -04001972 ets = list_entry(t, struct elf_thread_status, list);
1973 sz = elf_dump_thread_status(siginfo->si_signo, ets);
1974 info->thread_status_size += sz;
Roland McGrath3aba4812008-01-30 13:31:44 +01001975 }
1976 /* now collect the dump for the current */
1977 memset(info->prstatus, 0, sizeof(*info->prstatus));
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07001978 fill_prstatus(info->prstatus, current, siginfo->si_signo);
Roland McGrath3aba4812008-01-30 13:31:44 +01001979 elf_core_copy_regs(&info->prstatus->pr_reg, regs);
1980
1981 /* Set up header */
Zhang Yanfeid3330cf2013-02-21 16:44:20 -08001982 fill_elf_header(elf, phdrs, ELF_ARCH, ELF_CORE_EFLAGS);
Roland McGrath3aba4812008-01-30 13:31:44 +01001983
1984 /*
1985 * Set up the notes in similar form to SVR4 core dumps made
1986 * with info from their /proc.
1987 */
1988
1989 fill_note(info->notes + 0, "CORE", NT_PRSTATUS,
1990 sizeof(*info->prstatus), info->prstatus);
1991 fill_psinfo(info->psinfo, current->group_leader, current->mm);
1992 fill_note(info->notes + 1, "CORE", NT_PRPSINFO,
1993 sizeof(*info->psinfo), info->psinfo);
1994
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07001995 fill_siginfo_note(info->notes + 2, &info->csigdata, siginfo);
1996 fill_auxv_note(info->notes + 3, current->mm);
Dan Aloni72023652013-09-30 13:45:02 -07001997 info->numnote = 4;
Roland McGrath3aba4812008-01-30 13:31:44 +01001998
Dan Aloni72023652013-09-30 13:45:02 -07001999 if (fill_files_note(info->notes + info->numnote) == 0) {
2000 info->notes_files = info->notes + info->numnote;
2001 info->numnote++;
2002 }
Roland McGrath3aba4812008-01-30 13:31:44 +01002003
2004 /* Try to dump the FPU. */
2005 info->prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs,
2006 info->fpu);
2007 if (info->prstatus->pr_fpvalid)
2008 fill_note(info->notes + info->numnote++,
2009 "CORE", NT_PRFPREG, sizeof(*info->fpu), info->fpu);
2010#ifdef ELF_CORE_COPY_XFPREGS
2011 if (elf_core_copy_task_xfpregs(current, info->xfpu))
2012 fill_note(info->notes + info->numnote++,
2013 "LINUX", ELF_CORE_XFPREG_TYPE,
2014 sizeof(*info->xfpu), info->xfpu);
2015#endif
2016
2017 return 1;
Roland McGrath3aba4812008-01-30 13:31:44 +01002018}
2019
2020static size_t get_note_info_size(struct elf_note_info *info)
2021{
2022 int sz = 0;
2023 int i;
2024
2025 for (i = 0; i < info->numnote; i++)
2026 sz += notesize(info->notes + i);
2027
2028 sz += info->thread_status_size;
2029
2030 return sz;
2031}
2032
2033static int write_note_info(struct elf_note_info *info,
Al Viroecc8c772013-10-05 15:32:35 -04002034 struct coredump_params *cprm)
Roland McGrath3aba4812008-01-30 13:31:44 +01002035{
2036 int i;
2037 struct list_head *t;
2038
2039 for (i = 0; i < info->numnote; i++)
Al Viroecc8c772013-10-05 15:32:35 -04002040 if (!writenote(info->notes + i, cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002041 return 0;
2042
2043 /* write out the thread status notes section */
2044 list_for_each(t, &info->thread_list) {
2045 struct elf_thread_status *tmp =
2046 list_entry(t, struct elf_thread_status, list);
2047
2048 for (i = 0; i < tmp->num_notes; i++)
Al Viroecc8c772013-10-05 15:32:35 -04002049 if (!writenote(&tmp->notes[i], cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002050 return 0;
2051 }
2052
2053 return 1;
2054}
2055
2056static void free_note_info(struct elf_note_info *info)
2057{
2058 while (!list_empty(&info->thread_list)) {
2059 struct list_head *tmp = info->thread_list.next;
2060 list_del(tmp);
2061 kfree(list_entry(tmp, struct elf_thread_status, list));
2062 }
2063
Dan Aloni72023652013-09-30 13:45:02 -07002064 /* Free data possibly allocated by fill_files_note(): */
2065 if (info->notes_files)
2066 vfree(info->notes_files->data);
Denys Vlasenko2aa362c2012-10-04 17:15:36 -07002067
Roland McGrath3aba4812008-01-30 13:31:44 +01002068 kfree(info->prstatus);
2069 kfree(info->psinfo);
2070 kfree(info->notes);
2071 kfree(info->fpu);
2072#ifdef ELF_CORE_COPY_XFPREGS
2073 kfree(info->xfpu);
2074#endif
2075}
2076
Roland McGrath4206d3a2008-01-30 13:31:45 +01002077#endif
2078
Roland McGrathf47aef52007-01-26 00:56:49 -08002079static struct vm_area_struct *first_vma(struct task_struct *tsk,
2080 struct vm_area_struct *gate_vma)
2081{
2082 struct vm_area_struct *ret = tsk->mm->mmap;
2083
2084 if (ret)
2085 return ret;
2086 return gate_vma;
2087}
2088/*
2089 * Helper function for iterating across a vma list. It ensures that the caller
2090 * will visit `gate_vma' prior to terminating the search.
2091 */
2092static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
2093 struct vm_area_struct *gate_vma)
2094{
2095 struct vm_area_struct *ret;
2096
2097 ret = this_vma->vm_next;
2098 if (ret)
2099 return ret;
2100 if (this_vma == gate_vma)
2101 return NULL;
2102 return gate_vma;
2103}
2104
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002105static void fill_extnum_info(struct elfhdr *elf, struct elf_shdr *shdr4extnum,
2106 elf_addr_t e_shoff, int segs)
2107{
2108 elf->e_shoff = e_shoff;
2109 elf->e_shentsize = sizeof(*shdr4extnum);
2110 elf->e_shnum = 1;
2111 elf->e_shstrndx = SHN_UNDEF;
2112
2113 memset(shdr4extnum, 0, sizeof(*shdr4extnum));
2114
2115 shdr4extnum->sh_type = SHT_NULL;
2116 shdr4extnum->sh_size = elf->e_shnum;
2117 shdr4extnum->sh_link = elf->e_shstrndx;
2118 shdr4extnum->sh_info = segs;
2119}
2120
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121/*
2122 * Actual dumper
2123 *
2124 * This is a two-pass process; first we find the offsets of the bits,
2125 * and then they are actually written out. If we run out of core limit
2126 * we just truncate.
2127 */
Masami Hiramatsuf6151df2009-12-17 15:27:16 -08002128static int elf_core_dump(struct coredump_params *cprm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 int has_dumped = 0;
2131 mm_segment_t fs;
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002132 int segs, i;
2133 size_t vma_data_size = 0;
Roland McGrathf47aef52007-01-26 00:56:49 -08002134 struct vm_area_struct *vma, *gate_vma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135 struct elfhdr *elf = NULL;
Al Virocdc3d562013-10-05 22:24:29 -04002136 loff_t offset = 0, dataoff;
Dan Aloni72023652013-09-30 13:45:02 -07002137 struct elf_note_info info = { };
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002138 struct elf_phdr *phdr4note = NULL;
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002139 struct elf_shdr *shdr4extnum = NULL;
2140 Elf_Half e_phnum;
2141 elf_addr_t e_shoff;
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002142 elf_addr_t *vma_filesz = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143
2144 /*
2145 * We no longer stop all VM operations.
2146 *
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002147 * This is because those proceses that could possibly change map_count
2148 * or the mmap / vma pages are now blocked in do_exit on current
2149 * finishing this core dump.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150 *
2151 * Only ptrace can touch these memory addresses, but it doesn't change
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002152 * the map_count or the pages allocated. So no possibility of crashing
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 * exists while dumping the mm->vm_next areas to the core file.
2154 */
2155
2156 /* alloc memory for large data structures: too large to be on stack */
2157 elf = kmalloc(sizeof(*elf), GFP_KERNEL);
2158 if (!elf)
WANG Cong5f719552008-05-06 12:45:35 +08002159 goto out;
KAMEZAWA Hiroyuki341c87b2009-06-30 11:41:23 -07002160 /*
2161 * The number of segs are recored into ELF header as 16bit value.
2162 * Please check DEFAULT_MAX_MAP_COUNT definition when you modify here.
2163 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 segs = current->mm->map_count;
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002165 segs += elf_core_extra_phdrs();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166
Stephen Wilson31db58b2011-03-13 15:49:15 -04002167 gate_vma = get_gate_vma(current->mm);
Roland McGrathf47aef52007-01-26 00:56:49 -08002168 if (gate_vma != NULL)
2169 segs++;
2170
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002171 /* for notes section */
2172 segs++;
2173
2174 /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
2175 * this, kernel supports extended numbering. Have a look at
2176 * include/linux/elf.h for further information. */
2177 e_phnum = segs > PN_XNUM ? PN_XNUM : segs;
2178
Roland McGrath3aba4812008-01-30 13:31:44 +01002179 /*
2180 * Collect all the non-memory information about the process for the
2181 * notes. This also sets up the file header.
2182 */
Denys Vlasenko5ab1c302012-10-04 17:15:29 -07002183 if (!fill_note_info(elf, e_phnum, &info, cprm->siginfo, cprm->regs))
Roland McGrath3aba4812008-01-30 13:31:44 +01002184 goto cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185
2186 has_dumped = 1;
Oleg Nesterov079148b2013-04-30 15:28:16 -07002187
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188 fs = get_fs();
2189 set_fs(KERNEL_DS);
2190
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191 offset += sizeof(*elf); /* Elf header */
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002192 offset += segs * sizeof(struct elf_phdr); /* Program headers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193
2194 /* Write notes phdr entry */
2195 {
Roland McGrath3aba4812008-01-30 13:31:44 +01002196 size_t sz = get_note_info_size(&info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197
Michael Ellermane5501492007-09-19 14:38:12 +10002198 sz += elf_coredump_extra_notes_size();
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002199
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002200 phdr4note = kmalloc(sizeof(*phdr4note), GFP_KERNEL);
2201 if (!phdr4note)
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -08002202 goto end_coredump;
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002203
2204 fill_elf_note_phdr(phdr4note, sz, offset);
2205 offset += sz;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206 }
2207
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
2209
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002210 vma_filesz = kmalloc_array(segs - 1, sizeof(*vma_filesz), GFP_KERNEL);
2211 if (!vma_filesz)
2212 goto end_coredump;
2213
2214 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2215 vma = next_vma(vma, gate_vma)) {
2216 unsigned long dump_size;
2217
2218 dump_size = vma_dump_size(vma, cprm->mm_flags);
2219 vma_filesz[i++] = dump_size;
2220 vma_data_size += dump_size;
2221 }
2222
2223 offset += vma_data_size;
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002224 offset += elf_core_extra_data_size();
2225 e_shoff = offset;
2226
2227 if (e_phnum == PN_XNUM) {
2228 shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);
2229 if (!shdr4extnum)
2230 goto end_coredump;
2231 fill_extnum_info(elf, shdr4extnum, e_shoff, segs);
2232 }
2233
2234 offset = dataoff;
2235
Al Viroecc8c772013-10-05 15:32:35 -04002236 if (!dump_emit(cprm, elf, sizeof(*elf)))
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002237 goto end_coredump;
2238
Al Viroecc8c772013-10-05 15:32:35 -04002239 if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note)))
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002240 goto end_coredump;
2241
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 /* Write program headers for segments dump */
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002243 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
Roland McGrathf47aef52007-01-26 00:56:49 -08002244 vma = next_vma(vma, gate_vma)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245 struct elf_phdr phdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246
2247 phdr.p_type = PT_LOAD;
2248 phdr.p_offset = offset;
2249 phdr.p_vaddr = vma->vm_start;
2250 phdr.p_paddr = 0;
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002251 phdr.p_filesz = vma_filesz[i++];
Roland McGrath82df3972007-10-16 23:27:02 -07002252 phdr.p_memsz = vma->vm_end - vma->vm_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253 offset += phdr.p_filesz;
2254 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002255 if (vma->vm_flags & VM_WRITE)
2256 phdr.p_flags |= PF_W;
2257 if (vma->vm_flags & VM_EXEC)
2258 phdr.p_flags |= PF_X;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 phdr.p_align = ELF_EXEC_PAGESIZE;
2260
Al Viroecc8c772013-10-05 15:32:35 -04002261 if (!dump_emit(cprm, &phdr, sizeof(phdr)))
Daisuke HATAYAMA088e7af2010-03-05 13:44:06 -08002262 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263 }
2264
Al Viro506f21c2013-10-05 17:22:57 -04002265 if (!elf_core_write_extra_phdrs(cprm, offset))
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002266 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002267
2268 /* write out the notes section */
Al Viroecc8c772013-10-05 15:32:35 -04002269 if (!write_note_info(&info, cprm))
Roland McGrath3aba4812008-01-30 13:31:44 +01002270 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271
Al Virocdc3d562013-10-05 22:24:29 -04002272 if (elf_coredump_extra_notes_write(cprm))
Michael Ellermane5501492007-09-19 14:38:12 +10002273 goto end_coredump;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002274
Andi Kleend025c9d2006-09-30 23:29:28 -07002275 /* Align to page */
Al Viro9b56d542013-10-08 09:26:08 -04002276 if (!dump_skip(cprm, dataoff - cprm->written))
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002277 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002279 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
Roland McGrathf47aef52007-01-26 00:56:49 -08002280 vma = next_vma(vma, gate_vma)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281 unsigned long addr;
Roland McGrath82df3972007-10-16 23:27:02 -07002282 unsigned long end;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002284 end = vma->vm_start + vma_filesz[i++];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285
Roland McGrath82df3972007-10-16 23:27:02 -07002286 for (addr = vma->vm_start; addr < end; addr += PAGE_SIZE) {
Jesper Juhlf4e5cc22006-06-23 02:05:35 -07002287 struct page *page;
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002288 int stop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002290 page = get_dump_page(addr);
2291 if (page) {
2292 void *kaddr = kmap(page);
Al Viro13046ec2013-10-05 18:08:47 -04002293 stop = !dump_emit(cprm, kaddr, PAGE_SIZE);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002294 kunmap(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002295 put_page(page);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002296 } else
Al Viro9b56d542013-10-08 09:26:08 -04002297 stop = !dump_skip(cprm, PAGE_SIZE);
Hugh Dickinsf3e8fcc2009-09-21 17:03:25 -07002298 if (stop)
2299 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300 }
2301 }
2302
Al Viroaa3e7ea2013-10-05 17:50:15 -04002303 if (!elf_core_write_extra_data(cprm))
Daisuke HATAYAMA1fcccba2010-03-05 13:44:07 -08002304 goto end_coredump;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002306 if (e_phnum == PN_XNUM) {
Al Viro13046ec2013-10-05 18:08:47 -04002307 if (!dump_emit(cprm, shdr4extnum, sizeof(*shdr4extnum)))
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002308 goto end_coredump;
2309 }
2310
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311end_coredump:
2312 set_fs(fs);
2313
2314cleanup:
Roland McGrath3aba4812008-01-30 13:31:44 +01002315 free_note_info(&info);
Daisuke HATAYAMA8d9032b2010-03-05 13:44:10 -08002316 kfree(shdr4extnum);
Jungseung Lee52f5592e2014-12-10 15:52:16 -08002317 kfree(vma_filesz);
Daisuke HATAYAMA93eb2112010-03-05 13:44:09 -08002318 kfree(phdr4note);
WANG Cong5f719552008-05-06 12:45:35 +08002319 kfree(elf);
2320out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321 return has_dumped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322}
2323
Christoph Hellwig698ba7b2009-12-15 16:47:37 -08002324#endif /* CONFIG_ELF_CORE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325
2326static int __init init_elf_binfmt(void)
2327{
Al Viro8fc3dc52012-03-17 03:05:16 -04002328 register_binfmt(&elf_format);
2329 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330}
2331
2332static void __exit exit_elf_binfmt(void)
2333{
2334 /* Remove the COFF and ELF loaders. */
2335 unregister_binfmt(&elf_format);
2336}
2337
2338core_initcall(init_elf_binfmt);
2339module_exit(exit_elf_binfmt);
2340MODULE_LICENSE("GPL");