xref: /openbmc/linux/fs/binfmt_elf_fdpic.c (revision 726ccdba)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* binfmt_elf_fdpic.c: FDPIC ELF binary format
3  *
4  * Copyright (C) 2003, 2004, 2006 Red Hat, Inc. All Rights Reserved.
5  * Written by David Howells (dhowells@redhat.com)
6  * Derived from binfmt_elf.c
7  */
8 
9 #include <linux/module.h>
10 
11 #include <linux/fs.h>
12 #include <linux/stat.h>
13 #include <linux/sched.h>
14 #include <linux/sched/coredump.h>
15 #include <linux/sched/task_stack.h>
16 #include <linux/sched/cputime.h>
17 #include <linux/mm.h>
18 #include <linux/mman.h>
19 #include <linux/errno.h>
20 #include <linux/signal.h>
21 #include <linux/binfmts.h>
22 #include <linux/string.h>
23 #include <linux/file.h>
24 #include <linux/fcntl.h>
25 #include <linux/slab.h>
26 #include <linux/pagemap.h>
27 #include <linux/security.h>
28 #include <linux/highmem.h>
29 #include <linux/highuid.h>
30 #include <linux/personality.h>
31 #include <linux/ptrace.h>
32 #include <linux/init.h>
33 #include <linux/elf.h>
34 #include <linux/elf-fdpic.h>
35 #include <linux/elfcore.h>
36 #include <linux/coredump.h>
37 #include <linux/dax.h>
38 #include <linux/regset.h>
39 
40 #include <linux/uaccess.h>
41 #include <asm/param.h>
42 
43 typedef char *elf_caddr_t;
44 
45 #if 0
46 #define kdebug(fmt, ...) printk("FDPIC "fmt"\n" ,##__VA_ARGS__ )
47 #else
48 #define kdebug(fmt, ...) do {} while(0)
49 #endif
50 
51 #if 0
52 #define kdcore(fmt, ...) printk("FDPIC "fmt"\n" ,##__VA_ARGS__ )
53 #else
54 #define kdcore(fmt, ...) do {} while(0)
55 #endif
56 
57 MODULE_LICENSE("GPL");
58 
59 static int load_elf_fdpic_binary(struct linux_binprm *);
60 static int elf_fdpic_fetch_phdrs(struct elf_fdpic_params *, struct file *);
61 static int elf_fdpic_map_file(struct elf_fdpic_params *, struct file *,
62 			      struct mm_struct *, const char *);
63 
64 static int create_elf_fdpic_tables(struct linux_binprm *, struct mm_struct *,
65 				   struct elf_fdpic_params *,
66 				   struct elf_fdpic_params *);
67 
68 #ifndef CONFIG_MMU
69 static int elf_fdpic_map_file_constdisp_on_uclinux(struct elf_fdpic_params *,
70 						   struct file *,
71 						   struct mm_struct *);
72 #endif
73 
74 static int elf_fdpic_map_file_by_direct_mmap(struct elf_fdpic_params *,
75 					     struct file *, struct mm_struct *);
76 
77 #ifdef CONFIG_ELF_CORE
78 static int elf_fdpic_core_dump(struct coredump_params *cprm);
79 #endif
80 
81 static struct linux_binfmt elf_fdpic_format = {
82 	.module		= THIS_MODULE,
83 	.load_binary	= load_elf_fdpic_binary,
84 #ifdef CONFIG_ELF_CORE
85 	.core_dump	= elf_fdpic_core_dump,
86 	.min_coredump	= ELF_EXEC_PAGESIZE,
87 #endif
88 };
89 
90 static int __init init_elf_fdpic_binfmt(void)
91 {
92 	register_binfmt(&elf_fdpic_format);
93 	return 0;
94 }
95 
96 static void __exit exit_elf_fdpic_binfmt(void)
97 {
98 	unregister_binfmt(&elf_fdpic_format);
99 }
100 
101 core_initcall(init_elf_fdpic_binfmt);
102 module_exit(exit_elf_fdpic_binfmt);
103 
104 static int is_elf(struct elfhdr *hdr, struct file *file)
105 {
106 	if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) != 0)
107 		return 0;
108 	if (hdr->e_type != ET_EXEC && hdr->e_type != ET_DYN)
109 		return 0;
110 	if (!elf_check_arch(hdr))
111 		return 0;
112 	if (!file->f_op->mmap)
113 		return 0;
114 	return 1;
115 }
116 
117 #ifndef elf_check_fdpic
118 #define elf_check_fdpic(x) 0
119 #endif
120 
121 #ifndef elf_check_const_displacement
122 #define elf_check_const_displacement(x) 0
123 #endif
124 
125 static int is_constdisp(struct elfhdr *hdr)
126 {
127 	if (!elf_check_fdpic(hdr))
128 		return 1;
129 	if (elf_check_const_displacement(hdr))
130 		return 1;
131 	return 0;
132 }
133 
134 /*****************************************************************************/
135 /*
136  * read the program headers table into memory
137  */
138 static int elf_fdpic_fetch_phdrs(struct elf_fdpic_params *params,
139 				 struct file *file)
140 {
141 	struct elf32_phdr *phdr;
142 	unsigned long size;
143 	int retval, loop;
144 	loff_t pos = params->hdr.e_phoff;
145 
146 	if (params->hdr.e_phentsize != sizeof(struct elf_phdr))
147 		return -ENOMEM;
148 	if (params->hdr.e_phnum > 65536U / sizeof(struct elf_phdr))
149 		return -ENOMEM;
150 
151 	size = params->hdr.e_phnum * sizeof(struct elf_phdr);
152 	params->phdrs = kmalloc(size, GFP_KERNEL);
153 	if (!params->phdrs)
154 		return -ENOMEM;
155 
156 	retval = kernel_read(file, params->phdrs, size, &pos);
157 	if (unlikely(retval != size))
158 		return retval < 0 ? retval : -ENOEXEC;
159 
160 	/* determine stack size for this binary */
161 	phdr = params->phdrs;
162 	for (loop = 0; loop < params->hdr.e_phnum; loop++, phdr++) {
163 		if (phdr->p_type != PT_GNU_STACK)
164 			continue;
165 
166 		if (phdr->p_flags & PF_X)
167 			params->flags |= ELF_FDPIC_FLAG_EXEC_STACK;
168 		else
169 			params->flags |= ELF_FDPIC_FLAG_NOEXEC_STACK;
170 
171 		params->stack_size = phdr->p_memsz;
172 		break;
173 	}
174 
175 	return 0;
176 }
177 
178 /*****************************************************************************/
179 /*
180  * load an fdpic binary into various bits of memory
181  */
182 static int load_elf_fdpic_binary(struct linux_binprm *bprm)
183 {
184 	struct elf_fdpic_params exec_params, interp_params;
185 	struct pt_regs *regs = current_pt_regs();
186 	struct elf_phdr *phdr;
187 	unsigned long stack_size, entryaddr;
188 #ifdef ELF_FDPIC_PLAT_INIT
189 	unsigned long dynaddr;
190 #endif
191 #ifndef CONFIG_MMU
192 	unsigned long stack_prot;
193 #endif
194 	struct file *interpreter = NULL; /* to shut gcc up */
195 	char *interpreter_name = NULL;
196 	int executable_stack;
197 	int retval, i;
198 	loff_t pos;
199 
200 	kdebug("____ LOAD %d ____", current->pid);
201 
202 	memset(&exec_params, 0, sizeof(exec_params));
203 	memset(&interp_params, 0, sizeof(interp_params));
204 
205 	exec_params.hdr = *(struct elfhdr *) bprm->buf;
206 	exec_params.flags = ELF_FDPIC_FLAG_PRESENT | ELF_FDPIC_FLAG_EXECUTABLE;
207 
208 	/* check that this is a binary we know how to deal with */
209 	retval = -ENOEXEC;
210 	if (!is_elf(&exec_params.hdr, bprm->file))
211 		goto error;
212 	if (!elf_check_fdpic(&exec_params.hdr)) {
213 #ifdef CONFIG_MMU
214 		/* binfmt_elf handles non-fdpic elf except on nommu */
215 		goto error;
216 #else
217 		/* nommu can only load ET_DYN (PIE) ELF */
218 		if (exec_params.hdr.e_type != ET_DYN)
219 			goto error;
220 #endif
221 	}
222 
223 	/* read the program header table */
224 	retval = elf_fdpic_fetch_phdrs(&exec_params, bprm->file);
225 	if (retval < 0)
226 		goto error;
227 
228 	/* scan for a program header that specifies an interpreter */
229 	phdr = exec_params.phdrs;
230 
231 	for (i = 0; i < exec_params.hdr.e_phnum; i++, phdr++) {
232 		switch (phdr->p_type) {
233 		case PT_INTERP:
234 			retval = -ENOMEM;
235 			if (phdr->p_filesz > PATH_MAX)
236 				goto error;
237 			retval = -ENOENT;
238 			if (phdr->p_filesz < 2)
239 				goto error;
240 
241 			/* read the name of the interpreter into memory */
242 			interpreter_name = kmalloc(phdr->p_filesz, GFP_KERNEL);
243 			if (!interpreter_name)
244 				goto error;
245 
246 			pos = phdr->p_offset;
247 			retval = kernel_read(bprm->file, interpreter_name,
248 					     phdr->p_filesz, &pos);
249 			if (unlikely(retval != phdr->p_filesz)) {
250 				if (retval >= 0)
251 					retval = -ENOEXEC;
252 				goto error;
253 			}
254 
255 			retval = -ENOENT;
256 			if (interpreter_name[phdr->p_filesz - 1] != '\0')
257 				goto error;
258 
259 			kdebug("Using ELF interpreter %s", interpreter_name);
260 
261 			/* replace the program with the interpreter */
262 			interpreter = open_exec(interpreter_name);
263 			retval = PTR_ERR(interpreter);
264 			if (IS_ERR(interpreter)) {
265 				interpreter = NULL;
266 				goto error;
267 			}
268 
269 			/*
270 			 * If the binary is not readable then enforce
271 			 * mm->dumpable = 0 regardless of the interpreter's
272 			 * permissions.
273 			 */
274 			would_dump(bprm, interpreter);
275 
276 			pos = 0;
277 			retval = kernel_read(interpreter, bprm->buf,
278 					BINPRM_BUF_SIZE, &pos);
279 			if (unlikely(retval != BINPRM_BUF_SIZE)) {
280 				if (retval >= 0)
281 					retval = -ENOEXEC;
282 				goto error;
283 			}
284 
285 			interp_params.hdr = *((struct elfhdr *) bprm->buf);
286 			break;
287 
288 		case PT_LOAD:
289 #ifdef CONFIG_MMU
290 			if (exec_params.load_addr == 0)
291 				exec_params.load_addr = phdr->p_vaddr;
292 #endif
293 			break;
294 		}
295 
296 	}
297 
298 	if (is_constdisp(&exec_params.hdr))
299 		exec_params.flags |= ELF_FDPIC_FLAG_CONSTDISP;
300 
301 	/* perform insanity checks on the interpreter */
302 	if (interpreter_name) {
303 		retval = -ELIBBAD;
304 		if (!is_elf(&interp_params.hdr, interpreter))
305 			goto error;
306 
307 		interp_params.flags = ELF_FDPIC_FLAG_PRESENT;
308 
309 		/* read the interpreter's program header table */
310 		retval = elf_fdpic_fetch_phdrs(&interp_params, interpreter);
311 		if (retval < 0)
312 			goto error;
313 	}
314 
315 	stack_size = exec_params.stack_size;
316 	if (exec_params.flags & ELF_FDPIC_FLAG_EXEC_STACK)
317 		executable_stack = EXSTACK_ENABLE_X;
318 	else if (exec_params.flags & ELF_FDPIC_FLAG_NOEXEC_STACK)
319 		executable_stack = EXSTACK_DISABLE_X;
320 	else
321 		executable_stack = EXSTACK_DEFAULT;
322 
323 	if (stack_size == 0) {
324 		stack_size = interp_params.stack_size;
325 		if (interp_params.flags & ELF_FDPIC_FLAG_EXEC_STACK)
326 			executable_stack = EXSTACK_ENABLE_X;
327 		else if (interp_params.flags & ELF_FDPIC_FLAG_NOEXEC_STACK)
328 			executable_stack = EXSTACK_DISABLE_X;
329 		else
330 			executable_stack = EXSTACK_DEFAULT;
331 	}
332 
333 	retval = -ENOEXEC;
334 	if (stack_size == 0)
335 		stack_size = 131072UL; /* same as exec.c's default commit */
336 
337 	if (is_constdisp(&interp_params.hdr))
338 		interp_params.flags |= ELF_FDPIC_FLAG_CONSTDISP;
339 
340 	/* flush all traces of the currently running executable */
341 	retval = begin_new_exec(bprm);
342 	if (retval)
343 		goto error;
344 
345 	/* there's now no turning back... the old userspace image is dead,
346 	 * defunct, deceased, etc.
347 	 */
348 	if (elf_check_fdpic(&exec_params.hdr))
349 		set_personality(PER_LINUX_FDPIC);
350 	else
351 		set_personality(PER_LINUX);
352 	if (elf_read_implies_exec(&exec_params.hdr, executable_stack))
353 		current->personality |= READ_IMPLIES_EXEC;
354 
355 	setup_new_exec(bprm);
356 
357 	set_binfmt(&elf_fdpic_format);
358 
359 	current->mm->start_code = 0;
360 	current->mm->end_code = 0;
361 	current->mm->start_stack = 0;
362 	current->mm->start_data = 0;
363 	current->mm->end_data = 0;
364 	current->mm->context.exec_fdpic_loadmap = 0;
365 	current->mm->context.interp_fdpic_loadmap = 0;
366 
367 #ifdef CONFIG_MMU
368 	elf_fdpic_arch_lay_out_mm(&exec_params,
369 				  &interp_params,
370 				  &current->mm->start_stack,
371 				  &current->mm->start_brk);
372 
373 	retval = setup_arg_pages(bprm, current->mm->start_stack,
374 				 executable_stack);
375 	if (retval < 0)
376 		goto error;
377 #ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
378 	retval = arch_setup_additional_pages(bprm, !!interpreter_name);
379 	if (retval < 0)
380 		goto error;
381 #endif
382 #endif
383 
384 	/* load the executable and interpreter into memory */
385 	retval = elf_fdpic_map_file(&exec_params, bprm->file, current->mm,
386 				    "executable");
387 	if (retval < 0)
388 		goto error;
389 
390 	if (interpreter_name) {
391 		retval = elf_fdpic_map_file(&interp_params, interpreter,
392 					    current->mm, "interpreter");
393 		if (retval < 0) {
394 			printk(KERN_ERR "Unable to load interpreter\n");
395 			goto error;
396 		}
397 
398 		allow_write_access(interpreter);
399 		fput(interpreter);
400 		interpreter = NULL;
401 	}
402 
403 #ifdef CONFIG_MMU
404 	if (!current->mm->start_brk)
405 		current->mm->start_brk = current->mm->end_data;
406 
407 	current->mm->brk = current->mm->start_brk =
408 		PAGE_ALIGN(current->mm->start_brk);
409 
410 #else
411 	/* create a stack area and zero-size brk area */
412 	stack_size = (stack_size + PAGE_SIZE - 1) & PAGE_MASK;
413 	if (stack_size < PAGE_SIZE * 2)
414 		stack_size = PAGE_SIZE * 2;
415 
416 	stack_prot = PROT_READ | PROT_WRITE;
417 	if (executable_stack == EXSTACK_ENABLE_X ||
418 	    (executable_stack == EXSTACK_DEFAULT && VM_STACK_FLAGS & VM_EXEC))
419 		stack_prot |= PROT_EXEC;
420 
421 	current->mm->start_brk = vm_mmap(NULL, 0, stack_size, stack_prot,
422 					 MAP_PRIVATE | MAP_ANONYMOUS |
423 					 MAP_UNINITIALIZED | MAP_GROWSDOWN,
424 					 0);
425 
426 	if (IS_ERR_VALUE(current->mm->start_brk)) {
427 		retval = current->mm->start_brk;
428 		current->mm->start_brk = 0;
429 		goto error;
430 	}
431 
432 	current->mm->brk = current->mm->start_brk;
433 	current->mm->context.end_brk = current->mm->start_brk;
434 	current->mm->start_stack = current->mm->start_brk + stack_size;
435 #endif
436 
437 	retval = create_elf_fdpic_tables(bprm, current->mm, &exec_params,
438 					 &interp_params);
439 	if (retval < 0)
440 		goto error;
441 
442 	kdebug("- start_code  %lx", current->mm->start_code);
443 	kdebug("- end_code    %lx", current->mm->end_code);
444 	kdebug("- start_data  %lx", current->mm->start_data);
445 	kdebug("- end_data    %lx", current->mm->end_data);
446 	kdebug("- start_brk   %lx", current->mm->start_brk);
447 	kdebug("- brk         %lx", current->mm->brk);
448 	kdebug("- start_stack %lx", current->mm->start_stack);
449 
450 #ifdef ELF_FDPIC_PLAT_INIT
451 	/*
452 	 * The ABI may specify that certain registers be set up in special
453 	 * ways (on i386 %edx is the address of a DT_FINI function, for
454 	 * example.  This macro performs whatever initialization to
455 	 * the regs structure is required.
456 	 */
457 	dynaddr = interp_params.dynamic_addr ?: exec_params.dynamic_addr;
458 	ELF_FDPIC_PLAT_INIT(regs, exec_params.map_addr, interp_params.map_addr,
459 			    dynaddr);
460 #endif
461 
462 	finalize_exec(bprm);
463 	/* everything is now ready... get the userspace context ready to roll */
464 	entryaddr = interp_params.entry_addr ?: exec_params.entry_addr;
465 	start_thread(regs, entryaddr, current->mm->start_stack);
466 
467 	retval = 0;
468 
469 error:
470 	if (interpreter) {
471 		allow_write_access(interpreter);
472 		fput(interpreter);
473 	}
474 	kfree(interpreter_name);
475 	kfree(exec_params.phdrs);
476 	kfree(exec_params.loadmap);
477 	kfree(interp_params.phdrs);
478 	kfree(interp_params.loadmap);
479 	return retval;
480 }
481 
482 /*****************************************************************************/
483 
484 #ifndef ELF_BASE_PLATFORM
485 /*
486  * AT_BASE_PLATFORM indicates the "real" hardware/microarchitecture.
487  * If the arch defines ELF_BASE_PLATFORM (in asm/elf.h), the value
488  * will be copied to the user stack in the same manner as AT_PLATFORM.
489  */
490 #define ELF_BASE_PLATFORM NULL
491 #endif
492 
493 /*
494  * present useful information to the program by shovelling it onto the new
495  * process's stack
496  */
497 static int create_elf_fdpic_tables(struct linux_binprm *bprm,
498 				   struct mm_struct *mm,
499 				   struct elf_fdpic_params *exec_params,
500 				   struct elf_fdpic_params *interp_params)
501 {
502 	const struct cred *cred = current_cred();
503 	unsigned long sp, csp, nitems;
504 	elf_caddr_t __user *argv, *envp;
505 	size_t platform_len = 0, len;
506 	char *k_platform, *k_base_platform;
507 	char __user *u_platform, *u_base_platform, *p;
508 	int loop;
509 	int nr;	/* reset for each csp adjustment */
510 	unsigned long flags = 0;
511 
512 #ifdef CONFIG_MMU
513 	/* In some cases (e.g. Hyper-Threading), we want to avoid L1 evictions
514 	 * by the processes running on the same package. One thing we can do is
515 	 * to shuffle the initial stack for them, so we give the architecture
516 	 * an opportunity to do so here.
517 	 */
518 	sp = arch_align_stack(bprm->p);
519 #else
520 	sp = mm->start_stack;
521 
522 	/* stack the program arguments and environment */
523 	if (transfer_args_to_stack(bprm, &sp) < 0)
524 		return -EFAULT;
525 	sp &= ~15;
526 #endif
527 
528 	/*
529 	 * If this architecture has a platform capability string, copy it
530 	 * to userspace.  In some cases (Sparc), this info is impossible
531 	 * for userspace to get any other way, in others (i386) it is
532 	 * merely difficult.
533 	 */
534 	k_platform = ELF_PLATFORM;
535 	u_platform = NULL;
536 
537 	if (k_platform) {
538 		platform_len = strlen(k_platform) + 1;
539 		sp -= platform_len;
540 		u_platform = (char __user *) sp;
541 		if (copy_to_user(u_platform, k_platform, platform_len) != 0)
542 			return -EFAULT;
543 	}
544 
545 	/*
546 	 * If this architecture has a "base" platform capability
547 	 * string, copy it to userspace.
548 	 */
549 	k_base_platform = ELF_BASE_PLATFORM;
550 	u_base_platform = NULL;
551 
552 	if (k_base_platform) {
553 		platform_len = strlen(k_base_platform) + 1;
554 		sp -= platform_len;
555 		u_base_platform = (char __user *) sp;
556 		if (copy_to_user(u_base_platform, k_base_platform, platform_len) != 0)
557 			return -EFAULT;
558 	}
559 
560 	sp &= ~7UL;
561 
562 	/* stack the load map(s) */
563 	len = sizeof(struct elf32_fdpic_loadmap);
564 	len += sizeof(struct elf32_fdpic_loadseg) * exec_params->loadmap->nsegs;
565 	sp = (sp - len) & ~7UL;
566 	exec_params->map_addr = sp;
567 
568 	if (copy_to_user((void __user *) sp, exec_params->loadmap, len) != 0)
569 		return -EFAULT;
570 
571 	current->mm->context.exec_fdpic_loadmap = (unsigned long) sp;
572 
573 	if (interp_params->loadmap) {
574 		len = sizeof(struct elf32_fdpic_loadmap);
575 		len += sizeof(struct elf32_fdpic_loadseg) *
576 			interp_params->loadmap->nsegs;
577 		sp = (sp - len) & ~7UL;
578 		interp_params->map_addr = sp;
579 
580 		if (copy_to_user((void __user *) sp, interp_params->loadmap,
581 				 len) != 0)
582 			return -EFAULT;
583 
584 		current->mm->context.interp_fdpic_loadmap = (unsigned long) sp;
585 	}
586 
587 	/* force 16 byte _final_ alignment here for generality */
588 #define DLINFO_ITEMS 15
589 
590 	nitems = 1 + DLINFO_ITEMS + (k_platform ? 1 : 0) +
591 		(k_base_platform ? 1 : 0) + AT_VECTOR_SIZE_ARCH;
592 
593 	if (bprm->have_execfd)
594 		nitems++;
595 
596 	csp = sp;
597 	sp -= nitems * 2 * sizeof(unsigned long);
598 	sp -= (bprm->envc + 1) * sizeof(char *);	/* envv[] */
599 	sp -= (bprm->argc + 1) * sizeof(char *);	/* argv[] */
600 	sp -= 1 * sizeof(unsigned long);		/* argc */
601 
602 	csp -= sp & 15UL;
603 	sp -= sp & 15UL;
604 
605 	/* put the ELF interpreter info on the stack */
606 #define NEW_AUX_ENT(id, val)						\
607 	do {								\
608 		struct { unsigned long _id, _val; } __user *ent, v;	\
609 									\
610 		ent = (void __user *) csp;				\
611 		v._id = (id);						\
612 		v._val = (val);						\
613 		if (copy_to_user(ent + nr, &v, sizeof(v)))		\
614 			return -EFAULT;					\
615 		nr++;							\
616 	} while (0)
617 
618 	nr = 0;
619 	csp -= 2 * sizeof(unsigned long);
620 	NEW_AUX_ENT(AT_NULL, 0);
621 	if (k_platform) {
622 		nr = 0;
623 		csp -= 2 * sizeof(unsigned long);
624 		NEW_AUX_ENT(AT_PLATFORM,
625 			    (elf_addr_t) (unsigned long) u_platform);
626 	}
627 
628 	if (k_base_platform) {
629 		nr = 0;
630 		csp -= 2 * sizeof(unsigned long);
631 		NEW_AUX_ENT(AT_BASE_PLATFORM,
632 			    (elf_addr_t) (unsigned long) u_base_platform);
633 	}
634 
635 	if (bprm->have_execfd) {
636 		nr = 0;
637 		csp -= 2 * sizeof(unsigned long);
638 		NEW_AUX_ENT(AT_EXECFD, bprm->execfd);
639 	}
640 
641 	nr = 0;
642 	csp -= DLINFO_ITEMS * 2 * sizeof(unsigned long);
643 	NEW_AUX_ENT(AT_HWCAP,	ELF_HWCAP);
644 #ifdef ELF_HWCAP2
645 	NEW_AUX_ENT(AT_HWCAP2,	ELF_HWCAP2);
646 #endif
647 	NEW_AUX_ENT(AT_PAGESZ,	PAGE_SIZE);
648 	NEW_AUX_ENT(AT_CLKTCK,	CLOCKS_PER_SEC);
649 	NEW_AUX_ENT(AT_PHDR,	exec_params->ph_addr);
650 	NEW_AUX_ENT(AT_PHENT,	sizeof(struct elf_phdr));
651 	NEW_AUX_ENT(AT_PHNUM,	exec_params->hdr.e_phnum);
652 	NEW_AUX_ENT(AT_BASE,	interp_params->elfhdr_addr);
653 	if (bprm->interp_flags & BINPRM_FLAGS_PRESERVE_ARGV0)
654 		flags |= AT_FLAGS_PRESERVE_ARGV0;
655 	NEW_AUX_ENT(AT_FLAGS,	flags);
656 	NEW_AUX_ENT(AT_ENTRY,	exec_params->entry_addr);
657 	NEW_AUX_ENT(AT_UID,	(elf_addr_t) from_kuid_munged(cred->user_ns, cred->uid));
658 	NEW_AUX_ENT(AT_EUID,	(elf_addr_t) from_kuid_munged(cred->user_ns, cred->euid));
659 	NEW_AUX_ENT(AT_GID,	(elf_addr_t) from_kgid_munged(cred->user_ns, cred->gid));
660 	NEW_AUX_ENT(AT_EGID,	(elf_addr_t) from_kgid_munged(cred->user_ns, cred->egid));
661 	NEW_AUX_ENT(AT_SECURE,	bprm->secureexec);
662 	NEW_AUX_ENT(AT_EXECFN,	bprm->exec);
663 
664 #ifdef ARCH_DLINFO
665 	nr = 0;
666 	csp -= AT_VECTOR_SIZE_ARCH * 2 * sizeof(unsigned long);
667 
668 	/* ARCH_DLINFO must come last so platform specific code can enforce
669 	 * special alignment requirements on the AUXV if necessary (eg. PPC).
670 	 */
671 	ARCH_DLINFO;
672 #endif
673 #undef NEW_AUX_ENT
674 
675 	/* allocate room for argv[] and envv[] */
676 	csp -= (bprm->envc + 1) * sizeof(elf_caddr_t);
677 	envp = (elf_caddr_t __user *) csp;
678 	csp -= (bprm->argc + 1) * sizeof(elf_caddr_t);
679 	argv = (elf_caddr_t __user *) csp;
680 
681 	/* stack argc */
682 	csp -= sizeof(unsigned long);
683 	if (put_user(bprm->argc, (unsigned long __user *) csp))
684 		return -EFAULT;
685 
686 	BUG_ON(csp != sp);
687 
688 	/* fill in the argv[] array */
689 #ifdef CONFIG_MMU
690 	current->mm->arg_start = bprm->p;
691 #else
692 	current->mm->arg_start = current->mm->start_stack -
693 		(MAX_ARG_PAGES * PAGE_SIZE - bprm->p);
694 #endif
695 
696 	p = (char __user *) current->mm->arg_start;
697 	for (loop = bprm->argc; loop > 0; loop--) {
698 		if (put_user((elf_caddr_t) p, argv++))
699 			return -EFAULT;
700 		len = strnlen_user(p, MAX_ARG_STRLEN);
701 		if (!len || len > MAX_ARG_STRLEN)
702 			return -EINVAL;
703 		p += len;
704 	}
705 	if (put_user(NULL, argv))
706 		return -EFAULT;
707 	current->mm->arg_end = (unsigned long) p;
708 
709 	/* fill in the envv[] array */
710 	current->mm->env_start = (unsigned long) p;
711 	for (loop = bprm->envc; loop > 0; loop--) {
712 		if (put_user((elf_caddr_t)(unsigned long) p, envp++))
713 			return -EFAULT;
714 		len = strnlen_user(p, MAX_ARG_STRLEN);
715 		if (!len || len > MAX_ARG_STRLEN)
716 			return -EINVAL;
717 		p += len;
718 	}
719 	if (put_user(NULL, envp))
720 		return -EFAULT;
721 	current->mm->env_end = (unsigned long) p;
722 
723 	mm->start_stack = (unsigned long) sp;
724 	return 0;
725 }
726 
727 /*****************************************************************************/
728 /*
729  * load the appropriate binary image (executable or interpreter) into memory
730  * - we assume no MMU is available
731  * - if no other PIC bits are set in params->hdr->e_flags
732  *   - we assume that the LOADable segments in the binary are independently relocatable
733  *   - we assume R/O executable segments are shareable
734  * - else
735  *   - we assume the loadable parts of the image to require fixed displacement
736  *   - the image is not shareable
737  */
738 static int elf_fdpic_map_file(struct elf_fdpic_params *params,
739 			      struct file *file,
740 			      struct mm_struct *mm,
741 			      const char *what)
742 {
743 	struct elf32_fdpic_loadmap *loadmap;
744 #ifdef CONFIG_MMU
745 	struct elf32_fdpic_loadseg *mseg;
746 #endif
747 	struct elf32_fdpic_loadseg *seg;
748 	struct elf32_phdr *phdr;
749 	unsigned long load_addr, stop;
750 	unsigned nloads, tmp;
751 	size_t size;
752 	int loop, ret;
753 
754 	/* allocate a load map table */
755 	nloads = 0;
756 	for (loop = 0; loop < params->hdr.e_phnum; loop++)
757 		if (params->phdrs[loop].p_type == PT_LOAD)
758 			nloads++;
759 
760 	if (nloads == 0)
761 		return -ELIBBAD;
762 
763 	size = sizeof(*loadmap) + nloads * sizeof(*seg);
764 	loadmap = kzalloc(size, GFP_KERNEL);
765 	if (!loadmap)
766 		return -ENOMEM;
767 
768 	params->loadmap = loadmap;
769 
770 	loadmap->version = ELF32_FDPIC_LOADMAP_VERSION;
771 	loadmap->nsegs = nloads;
772 
773 	load_addr = params->load_addr;
774 	seg = loadmap->segs;
775 
776 	/* map the requested LOADs into the memory space */
777 	switch (params->flags & ELF_FDPIC_FLAG_ARRANGEMENT) {
778 	case ELF_FDPIC_FLAG_CONSTDISP:
779 	case ELF_FDPIC_FLAG_CONTIGUOUS:
780 #ifndef CONFIG_MMU
781 		ret = elf_fdpic_map_file_constdisp_on_uclinux(params, file, mm);
782 		if (ret < 0)
783 			return ret;
784 		break;
785 #endif
786 	default:
787 		ret = elf_fdpic_map_file_by_direct_mmap(params, file, mm);
788 		if (ret < 0)
789 			return ret;
790 		break;
791 	}
792 
793 	/* map the entry point */
794 	if (params->hdr.e_entry) {
795 		seg = loadmap->segs;
796 		for (loop = loadmap->nsegs; loop > 0; loop--, seg++) {
797 			if (params->hdr.e_entry >= seg->p_vaddr &&
798 			    params->hdr.e_entry < seg->p_vaddr + seg->p_memsz) {
799 				params->entry_addr =
800 					(params->hdr.e_entry - seg->p_vaddr) +
801 					seg->addr;
802 				break;
803 			}
804 		}
805 	}
806 
807 	/* determine where the program header table has wound up if mapped */
808 	stop = params->hdr.e_phoff;
809 	stop += params->hdr.e_phnum * sizeof (struct elf_phdr);
810 	phdr = params->phdrs;
811 
812 	for (loop = 0; loop < params->hdr.e_phnum; loop++, phdr++) {
813 		if (phdr->p_type != PT_LOAD)
814 			continue;
815 
816 		if (phdr->p_offset > params->hdr.e_phoff ||
817 		    phdr->p_offset + phdr->p_filesz < stop)
818 			continue;
819 
820 		seg = loadmap->segs;
821 		for (loop = loadmap->nsegs; loop > 0; loop--, seg++) {
822 			if (phdr->p_vaddr >= seg->p_vaddr &&
823 			    phdr->p_vaddr + phdr->p_filesz <=
824 			    seg->p_vaddr + seg->p_memsz) {
825 				params->ph_addr =
826 					(phdr->p_vaddr - seg->p_vaddr) +
827 					seg->addr +
828 					params->hdr.e_phoff - phdr->p_offset;
829 				break;
830 			}
831 		}
832 		break;
833 	}
834 
835 	/* determine where the dynamic section has wound up if there is one */
836 	phdr = params->phdrs;
837 	for (loop = 0; loop < params->hdr.e_phnum; loop++, phdr++) {
838 		if (phdr->p_type != PT_DYNAMIC)
839 			continue;
840 
841 		seg = loadmap->segs;
842 		for (loop = loadmap->nsegs; loop > 0; loop--, seg++) {
843 			if (phdr->p_vaddr >= seg->p_vaddr &&
844 			    phdr->p_vaddr + phdr->p_memsz <=
845 			    seg->p_vaddr + seg->p_memsz) {
846 				Elf32_Dyn __user *dyn;
847 				Elf32_Sword d_tag;
848 
849 				params->dynamic_addr =
850 					(phdr->p_vaddr - seg->p_vaddr) +
851 					seg->addr;
852 
853 				/* check the dynamic section contains at least
854 				 * one item, and that the last item is a NULL
855 				 * entry */
856 				if (phdr->p_memsz == 0 ||
857 				    phdr->p_memsz % sizeof(Elf32_Dyn) != 0)
858 					goto dynamic_error;
859 
860 				tmp = phdr->p_memsz / sizeof(Elf32_Dyn);
861 				dyn = (Elf32_Dyn __user *)params->dynamic_addr;
862 				if (get_user(d_tag, &dyn[tmp - 1].d_tag) ||
863 				    d_tag != 0)
864 					goto dynamic_error;
865 				break;
866 			}
867 		}
868 		break;
869 	}
870 
871 	/* now elide adjacent segments in the load map on MMU linux
872 	 * - on uClinux the holes between may actually be filled with system
873 	 *   stuff or stuff from other processes
874 	 */
875 #ifdef CONFIG_MMU
876 	nloads = loadmap->nsegs;
877 	mseg = loadmap->segs;
878 	seg = mseg + 1;
879 	for (loop = 1; loop < nloads; loop++) {
880 		/* see if we have a candidate for merging */
881 		if (seg->p_vaddr - mseg->p_vaddr == seg->addr - mseg->addr) {
882 			load_addr = PAGE_ALIGN(mseg->addr + mseg->p_memsz);
883 			if (load_addr == (seg->addr & PAGE_MASK)) {
884 				mseg->p_memsz +=
885 					load_addr -
886 					(mseg->addr + mseg->p_memsz);
887 				mseg->p_memsz += seg->addr & ~PAGE_MASK;
888 				mseg->p_memsz += seg->p_memsz;
889 				loadmap->nsegs--;
890 				continue;
891 			}
892 		}
893 
894 		mseg++;
895 		if (mseg != seg)
896 			*mseg = *seg;
897 	}
898 #endif
899 
900 	kdebug("Mapped Object [%s]:", what);
901 	kdebug("- elfhdr   : %lx", params->elfhdr_addr);
902 	kdebug("- entry    : %lx", params->entry_addr);
903 	kdebug("- PHDR[]   : %lx", params->ph_addr);
904 	kdebug("- DYNAMIC[]: %lx", params->dynamic_addr);
905 	seg = loadmap->segs;
906 	for (loop = 0; loop < loadmap->nsegs; loop++, seg++)
907 		kdebug("- LOAD[%d] : %08x-%08x [va=%x ms=%x]",
908 		       loop,
909 		       seg->addr, seg->addr + seg->p_memsz - 1,
910 		       seg->p_vaddr, seg->p_memsz);
911 
912 	return 0;
913 
914 dynamic_error:
915 	printk("ELF FDPIC %s with invalid DYNAMIC section (inode=%lu)\n",
916 	       what, file_inode(file)->i_ino);
917 	return -ELIBBAD;
918 }
919 
920 /*****************************************************************************/
921 /*
922  * map a file with constant displacement under uClinux
923  */
924 #ifndef CONFIG_MMU
925 static int elf_fdpic_map_file_constdisp_on_uclinux(
926 	struct elf_fdpic_params *params,
927 	struct file *file,
928 	struct mm_struct *mm)
929 {
930 	struct elf32_fdpic_loadseg *seg;
931 	struct elf32_phdr *phdr;
932 	unsigned long load_addr, base = ULONG_MAX, top = 0, maddr = 0;
933 	int loop, ret;
934 
935 	load_addr = params->load_addr;
936 	seg = params->loadmap->segs;
937 
938 	/* determine the bounds of the contiguous overall allocation we must
939 	 * make */
940 	phdr = params->phdrs;
941 	for (loop = 0; loop < params->hdr.e_phnum; loop++, phdr++) {
942 		if (params->phdrs[loop].p_type != PT_LOAD)
943 			continue;
944 
945 		if (base > phdr->p_vaddr)
946 			base = phdr->p_vaddr;
947 		if (top < phdr->p_vaddr + phdr->p_memsz)
948 			top = phdr->p_vaddr + phdr->p_memsz;
949 	}
950 
951 	/* allocate one big anon block for everything */
952 	maddr = vm_mmap(NULL, load_addr, top - base,
953 			PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE, 0);
954 	if (IS_ERR_VALUE(maddr))
955 		return (int) maddr;
956 
957 	if (load_addr != 0)
958 		load_addr += PAGE_ALIGN(top - base);
959 
960 	/* and then load the file segments into it */
961 	phdr = params->phdrs;
962 	for (loop = 0; loop < params->hdr.e_phnum; loop++, phdr++) {
963 		if (params->phdrs[loop].p_type != PT_LOAD)
964 			continue;
965 
966 		seg->addr = maddr + (phdr->p_vaddr - base);
967 		seg->p_vaddr = phdr->p_vaddr;
968 		seg->p_memsz = phdr->p_memsz;
969 
970 		ret = read_code(file, seg->addr, phdr->p_offset,
971 				       phdr->p_filesz);
972 		if (ret < 0)
973 			return ret;
974 
975 		/* map the ELF header address if in this segment */
976 		if (phdr->p_offset == 0)
977 			params->elfhdr_addr = seg->addr;
978 
979 		/* clear any space allocated but not loaded */
980 		if (phdr->p_filesz < phdr->p_memsz) {
981 			if (clear_user((void *) (seg->addr + phdr->p_filesz),
982 				       phdr->p_memsz - phdr->p_filesz))
983 				return -EFAULT;
984 		}
985 
986 		if (mm) {
987 			if (phdr->p_flags & PF_X) {
988 				if (!mm->start_code) {
989 					mm->start_code = seg->addr;
990 					mm->end_code = seg->addr +
991 						phdr->p_memsz;
992 				}
993 			} else if (!mm->start_data) {
994 				mm->start_data = seg->addr;
995 				mm->end_data = seg->addr + phdr->p_memsz;
996 			}
997 		}
998 
999 		seg++;
1000 	}
1001 
1002 	return 0;
1003 }
1004 #endif
1005 
1006 /*****************************************************************************/
1007 /*
1008  * map a binary by direct mmap() of the individual PT_LOAD segments
1009  */
1010 static int elf_fdpic_map_file_by_direct_mmap(struct elf_fdpic_params *params,
1011 					     struct file *file,
1012 					     struct mm_struct *mm)
1013 {
1014 	struct elf32_fdpic_loadseg *seg;
1015 	struct elf32_phdr *phdr;
1016 	unsigned long load_addr, delta_vaddr;
1017 	int loop, dvset;
1018 
1019 	load_addr = params->load_addr;
1020 	delta_vaddr = 0;
1021 	dvset = 0;
1022 
1023 	seg = params->loadmap->segs;
1024 
1025 	/* deal with each load segment separately */
1026 	phdr = params->phdrs;
1027 	for (loop = 0; loop < params->hdr.e_phnum; loop++, phdr++) {
1028 		unsigned long maddr, disp, excess, excess1;
1029 		int prot = 0, flags;
1030 
1031 		if (phdr->p_type != PT_LOAD)
1032 			continue;
1033 
1034 		kdebug("[LOAD] va=%lx of=%lx fs=%lx ms=%lx",
1035 		       (unsigned long) phdr->p_vaddr,
1036 		       (unsigned long) phdr->p_offset,
1037 		       (unsigned long) phdr->p_filesz,
1038 		       (unsigned long) phdr->p_memsz);
1039 
1040 		/* determine the mapping parameters */
1041 		if (phdr->p_flags & PF_R) prot |= PROT_READ;
1042 		if (phdr->p_flags & PF_W) prot |= PROT_WRITE;
1043 		if (phdr->p_flags & PF_X) prot |= PROT_EXEC;
1044 
1045 		flags = MAP_PRIVATE;
1046 		maddr = 0;
1047 
1048 		switch (params->flags & ELF_FDPIC_FLAG_ARRANGEMENT) {
1049 		case ELF_FDPIC_FLAG_INDEPENDENT:
1050 			/* PT_LOADs are independently locatable */
1051 			break;
1052 
1053 		case ELF_FDPIC_FLAG_HONOURVADDR:
1054 			/* the specified virtual address must be honoured */
1055 			maddr = phdr->p_vaddr;
1056 			flags |= MAP_FIXED;
1057 			break;
1058 
1059 		case ELF_FDPIC_FLAG_CONSTDISP:
1060 			/* constant displacement
1061 			 * - can be mapped anywhere, but must be mapped as a
1062 			 *   unit
1063 			 */
1064 			if (!dvset) {
1065 				maddr = load_addr;
1066 				delta_vaddr = phdr->p_vaddr;
1067 				dvset = 1;
1068 			} else {
1069 				maddr = load_addr + phdr->p_vaddr - delta_vaddr;
1070 				flags |= MAP_FIXED;
1071 			}
1072 			break;
1073 
1074 		case ELF_FDPIC_FLAG_CONTIGUOUS:
1075 			/* contiguity handled later */
1076 			break;
1077 
1078 		default:
1079 			BUG();
1080 		}
1081 
1082 		maddr &= PAGE_MASK;
1083 
1084 		/* create the mapping */
1085 		disp = phdr->p_vaddr & ~PAGE_MASK;
1086 		maddr = vm_mmap(file, maddr, phdr->p_memsz + disp, prot, flags,
1087 				phdr->p_offset - disp);
1088 
1089 		kdebug("mmap[%d] <file> sz=%lx pr=%x fl=%x of=%lx --> %08lx",
1090 		       loop, phdr->p_memsz + disp, prot, flags,
1091 		       phdr->p_offset - disp, maddr);
1092 
1093 		if (IS_ERR_VALUE(maddr))
1094 			return (int) maddr;
1095 
1096 		if ((params->flags & ELF_FDPIC_FLAG_ARRANGEMENT) ==
1097 		    ELF_FDPIC_FLAG_CONTIGUOUS)
1098 			load_addr += PAGE_ALIGN(phdr->p_memsz + disp);
1099 
1100 		seg->addr = maddr + disp;
1101 		seg->p_vaddr = phdr->p_vaddr;
1102 		seg->p_memsz = phdr->p_memsz;
1103 
1104 		/* map the ELF header address if in this segment */
1105 		if (phdr->p_offset == 0)
1106 			params->elfhdr_addr = seg->addr;
1107 
1108 		/* clear the bit between beginning of mapping and beginning of
1109 		 * PT_LOAD */
1110 		if (prot & PROT_WRITE && disp > 0) {
1111 			kdebug("clear[%d] ad=%lx sz=%lx", loop, maddr, disp);
1112 			if (clear_user((void __user *) maddr, disp))
1113 				return -EFAULT;
1114 			maddr += disp;
1115 		}
1116 
1117 		/* clear any space allocated but not loaded
1118 		 * - on uClinux we can just clear the lot
1119 		 * - on MMU linux we'll get a SIGBUS beyond the last page
1120 		 *   extant in the file
1121 		 */
1122 		excess = phdr->p_memsz - phdr->p_filesz;
1123 		excess1 = PAGE_SIZE - ((maddr + phdr->p_filesz) & ~PAGE_MASK);
1124 
1125 #ifdef CONFIG_MMU
1126 		if (excess > excess1) {
1127 			unsigned long xaddr = maddr + phdr->p_filesz + excess1;
1128 			unsigned long xmaddr;
1129 
1130 			flags |= MAP_FIXED | MAP_ANONYMOUS;
1131 			xmaddr = vm_mmap(NULL, xaddr, excess - excess1,
1132 					 prot, flags, 0);
1133 
1134 			kdebug("mmap[%d] <anon>"
1135 			       " ad=%lx sz=%lx pr=%x fl=%x of=0 --> %08lx",
1136 			       loop, xaddr, excess - excess1, prot, flags,
1137 			       xmaddr);
1138 
1139 			if (xmaddr != xaddr)
1140 				return -ENOMEM;
1141 		}
1142 
1143 		if (prot & PROT_WRITE && excess1 > 0) {
1144 			kdebug("clear[%d] ad=%lx sz=%lx",
1145 			       loop, maddr + phdr->p_filesz, excess1);
1146 			if (clear_user((void __user *) maddr + phdr->p_filesz,
1147 				       excess1))
1148 				return -EFAULT;
1149 		}
1150 
1151 #else
1152 		if (excess > 0) {
1153 			kdebug("clear[%d] ad=%lx sz=%lx",
1154 			       loop, maddr + phdr->p_filesz, excess);
1155 			if (clear_user((void *) maddr + phdr->p_filesz, excess))
1156 				return -EFAULT;
1157 		}
1158 #endif
1159 
1160 		if (mm) {
1161 			if (phdr->p_flags & PF_X) {
1162 				if (!mm->start_code) {
1163 					mm->start_code = maddr;
1164 					mm->end_code = maddr + phdr->p_memsz;
1165 				}
1166 			} else if (!mm->start_data) {
1167 				mm->start_data = maddr;
1168 				mm->end_data = maddr + phdr->p_memsz;
1169 			}
1170 		}
1171 
1172 		seg++;
1173 	}
1174 
1175 	return 0;
1176 }
1177 
1178 /*****************************************************************************/
1179 /*
1180  * ELF-FDPIC core dumper
1181  *
1182  * Modelled on fs/exec.c:aout_core_dump()
1183  * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1184  *
1185  * Modelled on fs/binfmt_elf.c core dumper
1186  */
1187 #ifdef CONFIG_ELF_CORE
1188 
1189 struct elf_prstatus_fdpic
1190 {
1191 	struct elf_prstatus_common	common;
1192 	elf_gregset_t pr_reg;	/* GP registers */
1193 	/* When using FDPIC, the loadmap addresses need to be communicated
1194 	 * to GDB in order for GDB to do the necessary relocations.  The
1195 	 * fields (below) used to communicate this information are placed
1196 	 * immediately after ``pr_reg'', so that the loadmap addresses may
1197 	 * be viewed as part of the register set if so desired.
1198 	 */
1199 	unsigned long pr_exec_fdpic_loadmap;
1200 	unsigned long pr_interp_fdpic_loadmap;
1201 	int pr_fpvalid;		/* True if math co-processor being used.  */
1202 };
1203 
1204 /* An ELF note in memory */
1205 struct memelfnote
1206 {
1207 	const char *name;
1208 	int type;
1209 	unsigned int datasz;
1210 	void *data;
1211 };
1212 
1213 static int notesize(struct memelfnote *en)
1214 {
1215 	int sz;
1216 
1217 	sz = sizeof(struct elf_note);
1218 	sz += roundup(strlen(en->name) + 1, 4);
1219 	sz += roundup(en->datasz, 4);
1220 
1221 	return sz;
1222 }
1223 
1224 /* #define DEBUG */
1225 
1226 static int writenote(struct memelfnote *men, struct coredump_params *cprm)
1227 {
1228 	struct elf_note en;
1229 	en.n_namesz = strlen(men->name) + 1;
1230 	en.n_descsz = men->datasz;
1231 	en.n_type = men->type;
1232 
1233 	return dump_emit(cprm, &en, sizeof(en)) &&
1234 		dump_emit(cprm, men->name, en.n_namesz) && dump_align(cprm, 4) &&
1235 		dump_emit(cprm, men->data, men->datasz) && dump_align(cprm, 4);
1236 }
1237 
1238 static inline void fill_elf_fdpic_header(struct elfhdr *elf, int segs)
1239 {
1240 	memcpy(elf->e_ident, ELFMAG, SELFMAG);
1241 	elf->e_ident[EI_CLASS] = ELF_CLASS;
1242 	elf->e_ident[EI_DATA] = ELF_DATA;
1243 	elf->e_ident[EI_VERSION] = EV_CURRENT;
1244 	elf->e_ident[EI_OSABI] = ELF_OSABI;
1245 	memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);
1246 
1247 	elf->e_type = ET_CORE;
1248 	elf->e_machine = ELF_ARCH;
1249 	elf->e_version = EV_CURRENT;
1250 	elf->e_entry = 0;
1251 	elf->e_phoff = sizeof(struct elfhdr);
1252 	elf->e_shoff = 0;
1253 	elf->e_flags = ELF_FDPIC_CORE_EFLAGS;
1254 	elf->e_ehsize = sizeof(struct elfhdr);
1255 	elf->e_phentsize = sizeof(struct elf_phdr);
1256 	elf->e_phnum = segs;
1257 	elf->e_shentsize = 0;
1258 	elf->e_shnum = 0;
1259 	elf->e_shstrndx = 0;
1260 	return;
1261 }
1262 
1263 static inline void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
1264 {
1265 	phdr->p_type = PT_NOTE;
1266 	phdr->p_offset = offset;
1267 	phdr->p_vaddr = 0;
1268 	phdr->p_paddr = 0;
1269 	phdr->p_filesz = sz;
1270 	phdr->p_memsz = 0;
1271 	phdr->p_flags = 0;
1272 	phdr->p_align = 0;
1273 	return;
1274 }
1275 
1276 static inline void fill_note(struct memelfnote *note, const char *name, int type,
1277 		unsigned int sz, void *data)
1278 {
1279 	note->name = name;
1280 	note->type = type;
1281 	note->datasz = sz;
1282 	note->data = data;
1283 	return;
1284 }
1285 
1286 /*
1287  * fill up all the fields in prstatus from the given task struct, except
1288  * registers which need to be filled up separately.
1289  */
1290 static void fill_prstatus(struct elf_prstatus_common *prstatus,
1291 			  struct task_struct *p, long signr)
1292 {
1293 	prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1294 	prstatus->pr_sigpend = p->pending.signal.sig[0];
1295 	prstatus->pr_sighold = p->blocked.sig[0];
1296 	rcu_read_lock();
1297 	prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1298 	rcu_read_unlock();
1299 	prstatus->pr_pid = task_pid_vnr(p);
1300 	prstatus->pr_pgrp = task_pgrp_vnr(p);
1301 	prstatus->pr_sid = task_session_vnr(p);
1302 	if (thread_group_leader(p)) {
1303 		struct task_cputime cputime;
1304 
1305 		/*
1306 		 * This is the record for the group leader.  It shows the
1307 		 * group-wide total, not its individual thread total.
1308 		 */
1309 		thread_group_cputime(p, &cputime);
1310 		prstatus->pr_utime = ns_to_kernel_old_timeval(cputime.utime);
1311 		prstatus->pr_stime = ns_to_kernel_old_timeval(cputime.stime);
1312 	} else {
1313 		u64 utime, stime;
1314 
1315 		task_cputime(p, &utime, &stime);
1316 		prstatus->pr_utime = ns_to_kernel_old_timeval(utime);
1317 		prstatus->pr_stime = ns_to_kernel_old_timeval(stime);
1318 	}
1319 	prstatus->pr_cutime = ns_to_kernel_old_timeval(p->signal->cutime);
1320 	prstatus->pr_cstime = ns_to_kernel_old_timeval(p->signal->cstime);
1321 }
1322 
1323 static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1324 		       struct mm_struct *mm)
1325 {
1326 	const struct cred *cred;
1327 	unsigned int i, len;
1328 	unsigned int state;
1329 
1330 	/* first copy the parameters from user space */
1331 	memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1332 
1333 	len = mm->arg_end - mm->arg_start;
1334 	if (len >= ELF_PRARGSZ)
1335 		len = ELF_PRARGSZ - 1;
1336 	if (copy_from_user(&psinfo->pr_psargs,
1337 		           (const char __user *) mm->arg_start, len))
1338 		return -EFAULT;
1339 	for (i = 0; i < len; i++)
1340 		if (psinfo->pr_psargs[i] == 0)
1341 			psinfo->pr_psargs[i] = ' ';
1342 	psinfo->pr_psargs[len] = 0;
1343 
1344 	rcu_read_lock();
1345 	psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1346 	rcu_read_unlock();
1347 	psinfo->pr_pid = task_pid_vnr(p);
1348 	psinfo->pr_pgrp = task_pgrp_vnr(p);
1349 	psinfo->pr_sid = task_session_vnr(p);
1350 
1351 	state = READ_ONCE(p->__state);
1352 	i = state ? ffz(~state) + 1 : 0;
1353 	psinfo->pr_state = i;
1354 	psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
1355 	psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1356 	psinfo->pr_nice = task_nice(p);
1357 	psinfo->pr_flag = p->flags;
1358 	rcu_read_lock();
1359 	cred = __task_cred(p);
1360 	SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
1361 	SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
1362 	rcu_read_unlock();
1363 	strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1364 
1365 	return 0;
1366 }
1367 
1368 /* Here is the structure in which status of each thread is captured. */
1369 struct elf_thread_status
1370 {
1371 	struct elf_thread_status *next;
1372 	struct elf_prstatus_fdpic prstatus;	/* NT_PRSTATUS */
1373 	elf_fpregset_t fpu;		/* NT_PRFPREG */
1374 	struct memelfnote notes[2];
1375 	int num_notes;
1376 };
1377 
1378 /*
1379  * In order to add the specific thread information for the elf file format,
1380  * we need to keep a linked list of every thread's pr_status and then create
1381  * a single section for them in the final core file.
1382  */
1383 static struct elf_thread_status *elf_dump_thread_status(long signr, struct task_struct *p, int *sz)
1384 {
1385 	const struct user_regset_view *view = task_user_regset_view(p);
1386 	struct elf_thread_status *t;
1387 	int i, ret;
1388 
1389 	t = kzalloc(sizeof(struct elf_thread_status), GFP_KERNEL);
1390 	if (!t)
1391 		return t;
1392 
1393 	fill_prstatus(&t->prstatus.common, p, signr);
1394 	t->prstatus.pr_exec_fdpic_loadmap = p->mm->context.exec_fdpic_loadmap;
1395 	t->prstatus.pr_interp_fdpic_loadmap = p->mm->context.interp_fdpic_loadmap;
1396 	regset_get(p, &view->regsets[0],
1397 		   sizeof(t->prstatus.pr_reg), &t->prstatus.pr_reg);
1398 
1399 	fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1400 		  &t->prstatus);
1401 	t->num_notes++;
1402 	*sz += notesize(&t->notes[0]);
1403 
1404 	for (i = 1; i < view->n; ++i) {
1405 		const struct user_regset *regset = &view->regsets[i];
1406 		if (regset->core_note_type != NT_PRFPREG)
1407 			continue;
1408 		if (regset->active && regset->active(p, regset) <= 0)
1409 			continue;
1410 		ret = regset_get(p, regset, sizeof(t->fpu), &t->fpu);
1411 		if (ret >= 0)
1412 			t->prstatus.pr_fpvalid = 1;
1413 		break;
1414 	}
1415 
1416 	if (t->prstatus.pr_fpvalid) {
1417 		fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1418 			  &t->fpu);
1419 		t->num_notes++;
1420 		*sz += notesize(&t->notes[1]);
1421 	}
1422 	return t;
1423 }
1424 
1425 static void fill_extnum_info(struct elfhdr *elf, struct elf_shdr *shdr4extnum,
1426 			     elf_addr_t e_shoff, int segs)
1427 {
1428 	elf->e_shoff = e_shoff;
1429 	elf->e_shentsize = sizeof(*shdr4extnum);
1430 	elf->e_shnum = 1;
1431 	elf->e_shstrndx = SHN_UNDEF;
1432 
1433 	memset(shdr4extnum, 0, sizeof(*shdr4extnum));
1434 
1435 	shdr4extnum->sh_type = SHT_NULL;
1436 	shdr4extnum->sh_size = elf->e_shnum;
1437 	shdr4extnum->sh_link = elf->e_shstrndx;
1438 	shdr4extnum->sh_info = segs;
1439 }
1440 
1441 /*
1442  * dump the segments for an MMU process
1443  */
1444 static bool elf_fdpic_dump_segments(struct coredump_params *cprm,
1445 				    struct core_vma_metadata *vma_meta,
1446 				    int vma_count)
1447 {
1448 	int i;
1449 
1450 	for (i = 0; i < vma_count; i++) {
1451 		struct core_vma_metadata *meta = vma_meta + i;
1452 
1453 		if (!dump_user_range(cprm, meta->start, meta->dump_size))
1454 			return false;
1455 	}
1456 	return true;
1457 }
1458 
1459 /*
1460  * Actual dumper
1461  *
1462  * This is a two-pass process; first we find the offsets of the bits,
1463  * and then they are actually written out.  If we run out of core limit
1464  * we just truncate.
1465  */
1466 static int elf_fdpic_core_dump(struct coredump_params *cprm)
1467 {
1468 	int has_dumped = 0;
1469 	int segs;
1470 	int i;
1471 	struct elfhdr *elf = NULL;
1472 	loff_t offset = 0, dataoff;
1473 	struct memelfnote psinfo_note, auxv_note;
1474 	struct elf_prpsinfo *psinfo = NULL;	/* NT_PRPSINFO */
1475 	struct elf_thread_status *thread_list = NULL;
1476 	int thread_status_size = 0;
1477 	elf_addr_t *auxv;
1478 	struct elf_phdr *phdr4note = NULL;
1479 	struct elf_shdr *shdr4extnum = NULL;
1480 	Elf_Half e_phnum;
1481 	elf_addr_t e_shoff;
1482 	struct core_thread *ct;
1483 	struct elf_thread_status *tmp;
1484 
1485 	/* alloc memory for large data structures: too large to be on stack */
1486 	elf = kmalloc(sizeof(*elf), GFP_KERNEL);
1487 	if (!elf)
1488 		goto end_coredump;
1489 	psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
1490 	if (!psinfo)
1491 		goto end_coredump;
1492 
1493 	for (ct = current->signal->core_state->dumper.next;
1494 					ct; ct = ct->next) {
1495 		tmp = elf_dump_thread_status(cprm->siginfo->si_signo,
1496 					     ct->task, &thread_status_size);
1497 		if (!tmp)
1498 			goto end_coredump;
1499 
1500 		tmp->next = thread_list;
1501 		thread_list = tmp;
1502 	}
1503 
1504 	/* now collect the dump for the current */
1505 	tmp = elf_dump_thread_status(cprm->siginfo->si_signo,
1506 				     current, &thread_status_size);
1507 	if (!tmp)
1508 		goto end_coredump;
1509 	tmp->next = thread_list;
1510 	thread_list = tmp;
1511 
1512 	segs = cprm->vma_count + elf_core_extra_phdrs(cprm);
1513 
1514 	/* for notes section */
1515 	segs++;
1516 
1517 	/* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
1518 	 * this, kernel supports extended numbering. Have a look at
1519 	 * include/linux/elf.h for further information. */
1520 	e_phnum = segs > PN_XNUM ? PN_XNUM : segs;
1521 
1522 	/* Set up header */
1523 	fill_elf_fdpic_header(elf, e_phnum);
1524 
1525 	has_dumped = 1;
1526 	/*
1527 	 * Set up the notes in similar form to SVR4 core dumps made
1528 	 * with info from their /proc.
1529 	 */
1530 
1531 	fill_psinfo(psinfo, current->group_leader, current->mm);
1532 	fill_note(&psinfo_note, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1533 	thread_status_size += notesize(&psinfo_note);
1534 
1535 	auxv = (elf_addr_t *) current->mm->saved_auxv;
1536 	i = 0;
1537 	do
1538 		i += 2;
1539 	while (auxv[i - 2] != AT_NULL);
1540 	fill_note(&auxv_note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);
1541 	thread_status_size += notesize(&auxv_note);
1542 
1543 	offset = sizeof(*elf);				/* ELF header */
1544 	offset += segs * sizeof(struct elf_phdr);	/* Program headers */
1545 
1546 	/* Write notes phdr entry */
1547 	phdr4note = kmalloc(sizeof(*phdr4note), GFP_KERNEL);
1548 	if (!phdr4note)
1549 		goto end_coredump;
1550 
1551 	fill_elf_note_phdr(phdr4note, thread_status_size, offset);
1552 	offset += thread_status_size;
1553 
1554 	/* Page-align dumped data */
1555 	dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
1556 
1557 	offset += cprm->vma_data_size;
1558 	offset += elf_core_extra_data_size(cprm);
1559 	e_shoff = offset;
1560 
1561 	if (e_phnum == PN_XNUM) {
1562 		shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);
1563 		if (!shdr4extnum)
1564 			goto end_coredump;
1565 		fill_extnum_info(elf, shdr4extnum, e_shoff, segs);
1566 	}
1567 
1568 	offset = dataoff;
1569 
1570 	if (!dump_emit(cprm, elf, sizeof(*elf)))
1571 		goto end_coredump;
1572 
1573 	if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note)))
1574 		goto end_coredump;
1575 
1576 	/* write program headers for segments dump */
1577 	for (i = 0; i < cprm->vma_count; i++) {
1578 		struct core_vma_metadata *meta = cprm->vma_meta + i;
1579 		struct elf_phdr phdr;
1580 		size_t sz;
1581 
1582 		sz = meta->end - meta->start;
1583 
1584 		phdr.p_type = PT_LOAD;
1585 		phdr.p_offset = offset;
1586 		phdr.p_vaddr = meta->start;
1587 		phdr.p_paddr = 0;
1588 		phdr.p_filesz = meta->dump_size;
1589 		phdr.p_memsz = sz;
1590 		offset += phdr.p_filesz;
1591 		phdr.p_flags = 0;
1592 		if (meta->flags & VM_READ)
1593 			phdr.p_flags |= PF_R;
1594 		if (meta->flags & VM_WRITE)
1595 			phdr.p_flags |= PF_W;
1596 		if (meta->flags & VM_EXEC)
1597 			phdr.p_flags |= PF_X;
1598 		phdr.p_align = ELF_EXEC_PAGESIZE;
1599 
1600 		if (!dump_emit(cprm, &phdr, sizeof(phdr)))
1601 			goto end_coredump;
1602 	}
1603 
1604 	if (!elf_core_write_extra_phdrs(cprm, offset))
1605 		goto end_coredump;
1606 
1607 	/* write out the notes section */
1608 	if (!writenote(thread_list->notes, cprm))
1609 		goto end_coredump;
1610 	if (!writenote(&psinfo_note, cprm))
1611 		goto end_coredump;
1612 	if (!writenote(&auxv_note, cprm))
1613 		goto end_coredump;
1614 	for (i = 1; i < thread_list->num_notes; i++)
1615 		if (!writenote(thread_list->notes + i, cprm))
1616 			goto end_coredump;
1617 
1618 	/* write out the thread status notes section */
1619 	for (tmp = thread_list->next; tmp; tmp = tmp->next) {
1620 		for (i = 0; i < tmp->num_notes; i++)
1621 			if (!writenote(&tmp->notes[i], cprm))
1622 				goto end_coredump;
1623 	}
1624 
1625 	dump_skip_to(cprm, dataoff);
1626 
1627 	if (!elf_fdpic_dump_segments(cprm, cprm->vma_meta, cprm->vma_count))
1628 		goto end_coredump;
1629 
1630 	if (!elf_core_write_extra_data(cprm))
1631 		goto end_coredump;
1632 
1633 	if (e_phnum == PN_XNUM) {
1634 		if (!dump_emit(cprm, shdr4extnum, sizeof(*shdr4extnum)))
1635 			goto end_coredump;
1636 	}
1637 
1638 	if (cprm->file->f_pos != offset) {
1639 		/* Sanity check */
1640 		printk(KERN_WARNING
1641 		       "elf_core_dump: file->f_pos (%lld) != offset (%lld)\n",
1642 		       cprm->file->f_pos, offset);
1643 	}
1644 
1645 end_coredump:
1646 	while (thread_list) {
1647 		tmp = thread_list;
1648 		thread_list = thread_list->next;
1649 		kfree(tmp);
1650 	}
1651 	kfree(phdr4note);
1652 	kfree(elf);
1653 	kfree(psinfo);
1654 	kfree(shdr4extnum);
1655 	return has_dumped;
1656 }
1657 
1658 #endif		/* CONFIG_ELF_CORE */
1659