1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/module.h>
14#include <linux/kernel.h>
15#include <linux/fs.h>
16#include <linux/mm.h>
17#include <linux/mman.h>
18#include <linux/errno.h>
19#include <linux/signal.h>
20#include <linux/binfmts.h>
21#include <linux/string.h>
22#include <linux/file.h>
23#include <linux/slab.h>
24#include <linux/personality.h>
25#include <linux/elfcore.h>
26#include <linux/init.h>
27#include <linux/highuid.h>
28#include <linux/compiler.h>
29#include <linux/highmem.h>
30#include <linux/pagemap.h>
31#include <linux/vmalloc.h>
32#include <linux/security.h>
33#include <linux/random.h>
34#include <linux/elf.h>
35#include <linux/elf-randomize.h>
36#include <linux/utsname.h>
37#include <linux/coredump.h>
38#include <linux/sched.h>
39#include <linux/sched/coredump.h>
40#include <linux/sched/task_stack.h>
41#include <linux/sched/cputime.h>
42#include <linux/cred.h>
43#include <linux/dax.h>
44#include <linux/uaccess.h>
45#include <asm/param.h>
46#include <asm/page.h>
47
48#ifndef user_long_t
49#define user_long_t long
50#endif
51#ifndef user_siginfo_t
52#define user_siginfo_t siginfo_t
53#endif
54
55
56#ifndef elf_check_fdpic
57#define elf_check_fdpic(ex) false
58#endif
59
60static int load_elf_binary(struct linux_binprm *bprm);
61
62#ifdef CONFIG_USELIB
63static int load_elf_library(struct file *);
64#else
65#define load_elf_library NULL
66#endif
67
68
69
70
71
72#ifdef CONFIG_ELF_CORE
73static int elf_core_dump(struct coredump_params *cprm);
74#else
75#define elf_core_dump NULL
76#endif
77
78#if ELF_EXEC_PAGESIZE > PAGE_SIZE
79#define ELF_MIN_ALIGN ELF_EXEC_PAGESIZE
80#else
81#define ELF_MIN_ALIGN PAGE_SIZE
82#endif
83
84#ifndef ELF_CORE_EFLAGS
85#define ELF_CORE_EFLAGS 0
86#endif
87
88#define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
89#define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
90#define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
91
92static struct linux_binfmt elf_format = {
93 .module = THIS_MODULE,
94 .load_binary = load_elf_binary,
95 .load_shlib = load_elf_library,
96 .core_dump = elf_core_dump,
97 .min_coredump = ELF_EXEC_PAGESIZE,
98};
99
100#define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
101
102static int set_brk(unsigned long start, unsigned long end, int prot)
103{
104 start = ELF_PAGEALIGN(start);
105 end = ELF_PAGEALIGN(end);
106 if (end > start) {
107
108
109
110
111
112 int error = vm_brk_flags(start, end - start,
113 prot & PROT_EXEC ? VM_EXEC : 0);
114 if (error)
115 return error;
116 }
117 current->mm->start_brk = current->mm->brk = end;
118 return 0;
119}
120
121
122
123
124
125
126static int padzero(unsigned long elf_bss)
127{
128 unsigned long nbyte;
129
130 nbyte = ELF_PAGEOFFSET(elf_bss);
131 if (nbyte) {
132 nbyte = ELF_MIN_ALIGN - nbyte;
133 if (clear_user((void __user *) elf_bss, nbyte))
134 return -EFAULT;
135 }
136 return 0;
137}
138
139
140#ifdef CONFIG_STACK_GROWSUP
141#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))
142#define STACK_ROUND(sp, items) \
143 ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
144#define STACK_ALLOC(sp, len) ({ \
145 elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; \
146 old_sp; })
147#else
148#define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))
149#define STACK_ROUND(sp, items) \
150 (((unsigned long) (sp - items)) &~ 15UL)
151#define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })
152#endif
153
154#ifndef ELF_BASE_PLATFORM
155
156
157
158
159
160#define ELF_BASE_PLATFORM NULL
161#endif
162
163static int
164create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
165 unsigned long load_addr, unsigned long interp_load_addr)
166{
167 unsigned long p = bprm->p;
168 int argc = bprm->argc;
169 int envc = bprm->envc;
170 elf_addr_t __user *sp;
171 elf_addr_t __user *u_platform;
172 elf_addr_t __user *u_base_platform;
173 elf_addr_t __user *u_rand_bytes;
174 const char *k_platform = ELF_PLATFORM;
175 const char *k_base_platform = ELF_BASE_PLATFORM;
176 unsigned char k_rand_bytes[16];
177 int items;
178 elf_addr_t *elf_info;
179 int ei_index = 0;
180 const struct cred *cred = current_cred();
181 struct vm_area_struct *vma;
182
183
184
185
186
187
188
189 p = arch_align_stack(p);
190
191
192
193
194
195
196
197 u_platform = NULL;
198 if (k_platform) {
199 size_t len = strlen(k_platform) + 1;
200
201 u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
202 if (__copy_to_user(u_platform, k_platform, len))
203 return -EFAULT;
204 }
205
206
207
208
209
210 u_base_platform = NULL;
211 if (k_base_platform) {
212 size_t len = strlen(k_base_platform) + 1;
213
214 u_base_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
215 if (__copy_to_user(u_base_platform, k_base_platform, len))
216 return -EFAULT;
217 }
218
219
220
221
222 get_random_bytes(k_rand_bytes, sizeof(k_rand_bytes));
223 u_rand_bytes = (elf_addr_t __user *)
224 STACK_ALLOC(p, sizeof(k_rand_bytes));
225 if (__copy_to_user(u_rand_bytes, k_rand_bytes, sizeof(k_rand_bytes)))
226 return -EFAULT;
227
228
229 elf_info = (elf_addr_t *)current->mm->saved_auxv;
230
231#define NEW_AUX_ENT(id, val) \
232 do { \
233 elf_info[ei_index++] = id; \
234 elf_info[ei_index++] = val; \
235 } while (0)
236
237#ifdef ARCH_DLINFO
238
239
240
241
242
243
244 ARCH_DLINFO;
245#endif
246 NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);
247 NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
248 NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
249 NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);
250 NEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));
251 NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);
252 NEW_AUX_ENT(AT_BASE, interp_load_addr);
253 NEW_AUX_ENT(AT_FLAGS, 0);
254 NEW_AUX_ENT(AT_ENTRY, exec->e_entry);
255 NEW_AUX_ENT(AT_UID, from_kuid_munged(cred->user_ns, cred->uid));
256 NEW_AUX_ENT(AT_EUID, from_kuid_munged(cred->user_ns, cred->euid));
257 NEW_AUX_ENT(AT_GID, from_kgid_munged(cred->user_ns, cred->gid));
258 NEW_AUX_ENT(AT_EGID, from_kgid_munged(cred->user_ns, cred->egid));
259 NEW_AUX_ENT(AT_SECURE, bprm->secureexec);
260 NEW_AUX_ENT(AT_RANDOM, (elf_addr_t)(unsigned long)u_rand_bytes);
261#ifdef ELF_HWCAP2
262 NEW_AUX_ENT(AT_HWCAP2, ELF_HWCAP2);
263#endif
264 NEW_AUX_ENT(AT_EXECFN, bprm->exec);
265 if (k_platform) {
266 NEW_AUX_ENT(AT_PLATFORM,
267 (elf_addr_t)(unsigned long)u_platform);
268 }
269 if (k_base_platform) {
270 NEW_AUX_ENT(AT_BASE_PLATFORM,
271 (elf_addr_t)(unsigned long)u_base_platform);
272 }
273 if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
274 NEW_AUX_ENT(AT_EXECFD, bprm->interp_data);
275 }
276#undef NEW_AUX_ENT
277
278 memset(&elf_info[ei_index], 0,
279 sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);
280
281
282 ei_index += 2;
283
284 sp = STACK_ADD(p, ei_index);
285
286 items = (argc + 1) + (envc + 1) + 1;
287 bprm->p = STACK_ROUND(sp, items);
288
289
290#ifdef CONFIG_STACK_GROWSUP
291 sp = (elf_addr_t __user *)bprm->p - items - ei_index;
292 bprm->exec = (unsigned long)sp;
293#else
294 sp = (elf_addr_t __user *)bprm->p;
295#endif
296
297
298
299
300
301
302 vma = find_extend_vma(current->mm, bprm->p);
303 if (!vma)
304 return -EFAULT;
305
306
307 if (__put_user(argc, sp++))
308 return -EFAULT;
309
310
311 p = current->mm->arg_end = current->mm->arg_start;
312 while (argc-- > 0) {
313 size_t len;
314 if (__put_user((elf_addr_t)p, sp++))
315 return -EFAULT;
316 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
317 if (!len || len > MAX_ARG_STRLEN)
318 return -EINVAL;
319 p += len;
320 }
321 if (__put_user(0, sp++))
322 return -EFAULT;
323 current->mm->arg_end = p;
324
325
326 current->mm->env_end = current->mm->env_start = p;
327 while (envc-- > 0) {
328 size_t len;
329 if (__put_user((elf_addr_t)p, sp++))
330 return -EFAULT;
331 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
332 if (!len || len > MAX_ARG_STRLEN)
333 return -EINVAL;
334 p += len;
335 }
336 if (__put_user(0, sp++))
337 return -EFAULT;
338 current->mm->env_end = p;
339
340
341 if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))
342 return -EFAULT;
343 return 0;
344}
345
346#ifndef elf_map
347
348static unsigned long elf_map(struct file *filep, unsigned long addr,
349 const struct elf_phdr *eppnt, int prot, int type,
350 unsigned long total_size)
351{
352 unsigned long map_addr;
353 unsigned long size = eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr);
354 unsigned long off = eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr);
355 addr = ELF_PAGESTART(addr);
356 size = ELF_PAGEALIGN(size);
357
358
359
360 if (!size)
361 return addr;
362
363
364
365
366
367
368
369
370
371 if (total_size) {
372 total_size = ELF_PAGEALIGN(total_size);
373 map_addr = vm_mmap(filep, addr, total_size, prot, type, off);
374 if (!BAD_ADDR(map_addr))
375 vm_munmap(map_addr+size, total_size-size);
376 } else
377 map_addr = vm_mmap(filep, addr, size, prot, type, off);
378
379 if ((type & MAP_FIXED_NOREPLACE) &&
380 PTR_ERR((void *)map_addr) == -EEXIST)
381 pr_info("%d (%s): Uhuuh, elf segment at %px requested but the memory is mapped already\n",
382 task_pid_nr(current), current->comm, (void *)addr);
383
384 return(map_addr);
385}
386
387#endif
388
389static unsigned long total_mapping_size(const struct elf_phdr *cmds, int nr)
390{
391 int i, first_idx = -1, last_idx = -1;
392
393 for (i = 0; i < nr; i++) {
394 if (cmds[i].p_type == PT_LOAD) {
395 last_idx = i;
396 if (first_idx == -1)
397 first_idx = i;
398 }
399 }
400 if (first_idx == -1)
401 return 0;
402
403 return cmds[last_idx].p_vaddr + cmds[last_idx].p_memsz -
404 ELF_PAGESTART(cmds[first_idx].p_vaddr);
405}
406
407
408
409
410
411
412
413
414
415
416static struct elf_phdr *load_elf_phdrs(const struct elfhdr *elf_ex,
417 struct file *elf_file)
418{
419 struct elf_phdr *elf_phdata = NULL;
420 int retval, err = -1;
421 loff_t pos = elf_ex->e_phoff;
422 unsigned int size;
423
424
425
426
427
428 if (elf_ex->e_phentsize != sizeof(struct elf_phdr))
429 goto out;
430
431
432
433 size = sizeof(struct elf_phdr) * elf_ex->e_phnum;
434 if (size == 0 || size > 65536 || size > ELF_MIN_ALIGN)
435 goto out;
436
437 elf_phdata = kmalloc(size, GFP_KERNEL);
438 if (!elf_phdata)
439 goto out;
440
441
442 retval = kernel_read(elf_file, elf_phdata, size, &pos);
443 if (retval != size) {
444 err = (retval < 0) ? retval : -EIO;
445 goto out;
446 }
447
448
449 err = 0;
450out:
451 if (err) {
452 kfree(elf_phdata);
453 elf_phdata = NULL;
454 }
455 return elf_phdata;
456}
457
458#ifndef CONFIG_ARCH_BINFMT_ELF_STATE
459
460
461
462
463
464
465
466
467
468
469
470
471struct arch_elf_state {
472};
473
474#define INIT_ARCH_ELF_STATE {}
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494static inline int arch_elf_pt_proc(struct elfhdr *ehdr,
495 struct elf_phdr *phdr,
496 struct file *elf, bool is_interp,
497 struct arch_elf_state *state)
498{
499
500 return 0;
501}
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518static inline int arch_check_elf(struct elfhdr *ehdr, bool has_interp,
519 struct elfhdr *interp_ehdr,
520 struct arch_elf_state *state)
521{
522
523 return 0;
524}
525
526#endif
527
528static inline int make_prot(u32 p_flags)
529{
530 int prot = 0;
531
532 if (p_flags & PF_R)
533 prot |= PROT_READ;
534 if (p_flags & PF_W)
535 prot |= PROT_WRITE;
536 if (p_flags & PF_X)
537 prot |= PROT_EXEC;
538 return prot;
539}
540
541
542
543
544
545
546static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
547 struct file *interpreter, unsigned long *interp_map_addr,
548 unsigned long no_base, struct elf_phdr *interp_elf_phdata)
549{
550 struct elf_phdr *eppnt;
551 unsigned long load_addr = 0;
552 int load_addr_set = 0;
553 unsigned long last_bss = 0, elf_bss = 0;
554 int bss_prot = 0;
555 unsigned long error = ~0UL;
556 unsigned long total_size;
557 int i;
558
559
560 if (interp_elf_ex->e_type != ET_EXEC &&
561 interp_elf_ex->e_type != ET_DYN)
562 goto out;
563 if (!elf_check_arch(interp_elf_ex) ||
564 elf_check_fdpic(interp_elf_ex))
565 goto out;
566 if (!interpreter->f_op->mmap)
567 goto out;
568
569 total_size = total_mapping_size(interp_elf_phdata,
570 interp_elf_ex->e_phnum);
571 if (!total_size) {
572 error = -EINVAL;
573 goto out;
574 }
575
576 eppnt = interp_elf_phdata;
577 for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
578 if (eppnt->p_type == PT_LOAD) {
579 int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
580 int elf_prot = make_prot(eppnt->p_flags);
581 unsigned long vaddr = 0;
582 unsigned long k, map_addr;
583
584 vaddr = eppnt->p_vaddr;
585 if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
586 elf_type |= MAP_FIXED_NOREPLACE;
587 else if (no_base && interp_elf_ex->e_type == ET_DYN)
588 load_addr = -vaddr;
589
590 map_addr = elf_map(interpreter, load_addr + vaddr,
591 eppnt, elf_prot, elf_type, total_size);
592 total_size = 0;
593 if (!*interp_map_addr)
594 *interp_map_addr = map_addr;
595 error = map_addr;
596 if (BAD_ADDR(map_addr))
597 goto out;
598
599 if (!load_addr_set &&
600 interp_elf_ex->e_type == ET_DYN) {
601 load_addr = map_addr - ELF_PAGESTART(vaddr);
602 load_addr_set = 1;
603 }
604
605
606
607
608
609
610 k = load_addr + eppnt->p_vaddr;
611 if (BAD_ADDR(k) ||
612 eppnt->p_filesz > eppnt->p_memsz ||
613 eppnt->p_memsz > TASK_SIZE ||
614 TASK_SIZE - eppnt->p_memsz < k) {
615 error = -ENOMEM;
616 goto out;
617 }
618
619
620
621
622
623 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
624 if (k > elf_bss)
625 elf_bss = k;
626
627
628
629
630
631 k = load_addr + eppnt->p_vaddr + eppnt->p_memsz;
632 if (k > last_bss) {
633 last_bss = k;
634 bss_prot = elf_prot;
635 }
636 }
637 }
638
639
640
641
642
643
644 if (padzero(elf_bss)) {
645 error = -EFAULT;
646 goto out;
647 }
648
649
650
651
652
653 elf_bss = ELF_PAGEALIGN(elf_bss);
654 last_bss = ELF_PAGEALIGN(last_bss);
655
656 if (last_bss > elf_bss) {
657 error = vm_brk_flags(elf_bss, last_bss - elf_bss,
658 bss_prot & PROT_EXEC ? VM_EXEC : 0);
659 if (error)
660 goto out;
661 }
662
663 error = load_addr;
664out:
665 return error;
666}
667
668
669
670
671
672
673#ifndef STACK_RND_MASK
674#define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12))
675#endif
676
677static unsigned long randomize_stack_top(unsigned long stack_top)
678{
679 unsigned long random_variable = 0;
680
681 if (current->flags & PF_RANDOMIZE) {
682 random_variable = get_random_long();
683 random_variable &= STACK_RND_MASK;
684 random_variable <<= PAGE_SHIFT;
685 }
686#ifdef CONFIG_STACK_GROWSUP
687 return PAGE_ALIGN(stack_top) + random_variable;
688#else
689 return PAGE_ALIGN(stack_top) - random_variable;
690#endif
691}
692
693static int load_elf_binary(struct linux_binprm *bprm)
694{
695 struct file *interpreter = NULL;
696 unsigned long load_addr = 0, load_bias = 0;
697 int load_addr_set = 0;
698 unsigned long error;
699 struct elf_phdr *elf_ppnt, *elf_phdata, *interp_elf_phdata = NULL;
700 unsigned long elf_bss, elf_brk;
701 int bss_prot = 0;
702 int retval, i;
703 unsigned long elf_entry;
704 unsigned long interp_load_addr = 0;
705 unsigned long start_code, end_code, start_data, end_data;
706 unsigned long reloc_func_desc __maybe_unused = 0;
707 int executable_stack = EXSTACK_DEFAULT;
708 struct {
709 struct elfhdr elf_ex;
710 struct elfhdr interp_elf_ex;
711 } *loc;
712 struct arch_elf_state arch_state = INIT_ARCH_ELF_STATE;
713 struct pt_regs *regs;
714
715 loc = kmalloc(sizeof(*loc), GFP_KERNEL);
716 if (!loc) {
717 retval = -ENOMEM;
718 goto out_ret;
719 }
720
721
722 loc->elf_ex = *((struct elfhdr *)bprm->buf);
723
724 retval = -ENOEXEC;
725
726 if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
727 goto out;
728
729 if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
730 goto out;
731 if (!elf_check_arch(&loc->elf_ex))
732 goto out;
733 if (elf_check_fdpic(&loc->elf_ex))
734 goto out;
735 if (!bprm->file->f_op->mmap)
736 goto out;
737
738 elf_phdata = load_elf_phdrs(&loc->elf_ex, bprm->file);
739 if (!elf_phdata)
740 goto out;
741
742 elf_ppnt = elf_phdata;
743 for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
744 char *elf_interpreter;
745 loff_t pos;
746
747 if (elf_ppnt->p_type != PT_INTERP)
748 continue;
749
750
751
752
753
754 retval = -ENOEXEC;
755 if (elf_ppnt->p_filesz > PATH_MAX || elf_ppnt->p_filesz < 2)
756 goto out_free_ph;
757
758 retval = -ENOMEM;
759 elf_interpreter = kmalloc(elf_ppnt->p_filesz, GFP_KERNEL);
760 if (!elf_interpreter)
761 goto out_free_ph;
762
763 pos = elf_ppnt->p_offset;
764 retval = kernel_read(bprm->file, elf_interpreter,
765 elf_ppnt->p_filesz, &pos);
766 if (retval != elf_ppnt->p_filesz) {
767 if (retval >= 0)
768 retval = -EIO;
769 goto out_free_interp;
770 }
771
772 retval = -ENOEXEC;
773 if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
774 goto out_free_interp;
775
776 interpreter = open_exec(elf_interpreter);
777 kfree(elf_interpreter);
778 retval = PTR_ERR(interpreter);
779 if (IS_ERR(interpreter))
780 goto out_free_ph;
781
782
783
784
785
786 would_dump(bprm, interpreter);
787
788
789 pos = 0;
790 retval = kernel_read(interpreter, &loc->interp_elf_ex,
791 sizeof(loc->interp_elf_ex), &pos);
792 if (retval != sizeof(loc->interp_elf_ex)) {
793 if (retval >= 0)
794 retval = -EIO;
795 goto out_free_dentry;
796 }
797
798 break;
799
800out_free_interp:
801 kfree(elf_interpreter);
802 goto out_free_ph;
803 }
804
805 elf_ppnt = elf_phdata;
806 for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
807 switch (elf_ppnt->p_type) {
808 case PT_GNU_STACK:
809 if (elf_ppnt->p_flags & PF_X)
810 executable_stack = EXSTACK_ENABLE_X;
811 else
812 executable_stack = EXSTACK_DISABLE_X;
813 break;
814
815 case PT_LOPROC ... PT_HIPROC:
816 retval = arch_elf_pt_proc(&loc->elf_ex, elf_ppnt,
817 bprm->file, false,
818 &arch_state);
819 if (retval)
820 goto out_free_dentry;
821 break;
822 }
823
824
825 if (interpreter) {
826 retval = -ELIBBAD;
827
828 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
829 goto out_free_dentry;
830
831 if (!elf_check_arch(&loc->interp_elf_ex) ||
832 elf_check_fdpic(&loc->interp_elf_ex))
833 goto out_free_dentry;
834
835
836 interp_elf_phdata = load_elf_phdrs(&loc->interp_elf_ex,
837 interpreter);
838 if (!interp_elf_phdata)
839 goto out_free_dentry;
840
841
842 elf_ppnt = interp_elf_phdata;
843 for (i = 0; i < loc->interp_elf_ex.e_phnum; i++, elf_ppnt++)
844 switch (elf_ppnt->p_type) {
845 case PT_LOPROC ... PT_HIPROC:
846 retval = arch_elf_pt_proc(&loc->interp_elf_ex,
847 elf_ppnt, interpreter,
848 true, &arch_state);
849 if (retval)
850 goto out_free_dentry;
851 break;
852 }
853 }
854
855
856
857
858
859
860 retval = arch_check_elf(&loc->elf_ex,
861 !!interpreter, &loc->interp_elf_ex,
862 &arch_state);
863 if (retval)
864 goto out_free_dentry;
865
866
867 retval = flush_old_exec(bprm);
868 if (retval)
869 goto out_free_dentry;
870
871
872
873 SET_PERSONALITY2(loc->elf_ex, &arch_state);
874 if (elf_read_implies_exec(loc->elf_ex, executable_stack))
875 current->personality |= READ_IMPLIES_EXEC;
876
877 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
878 current->flags |= PF_RANDOMIZE;
879
880 setup_new_exec(bprm);
881 install_exec_creds(bprm);
882
883
884
885 retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
886 executable_stack);
887 if (retval < 0)
888 goto out_free_dentry;
889
890 elf_bss = 0;
891 elf_brk = 0;
892
893 start_code = ~0UL;
894 end_code = 0;
895 start_data = 0;
896 end_data = 0;
897
898
899
900 for(i = 0, elf_ppnt = elf_phdata;
901 i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
902 int elf_prot, elf_flags, elf_fixed = MAP_FIXED_NOREPLACE;
903 unsigned long k, vaddr;
904 unsigned long total_size = 0;
905
906 if (elf_ppnt->p_type != PT_LOAD)
907 continue;
908
909 if (unlikely (elf_brk > elf_bss)) {
910 unsigned long nbyte;
911
912
913
914
915 retval = set_brk(elf_bss + load_bias,
916 elf_brk + load_bias,
917 bss_prot);
918 if (retval)
919 goto out_free_dentry;
920 nbyte = ELF_PAGEOFFSET(elf_bss);
921 if (nbyte) {
922 nbyte = ELF_MIN_ALIGN - nbyte;
923 if (nbyte > elf_brk - elf_bss)
924 nbyte = elf_brk - elf_bss;
925 if (clear_user((void __user *)elf_bss +
926 load_bias, nbyte)) {
927
928
929
930
931
932 }
933 }
934
935
936
937
938
939
940 elf_fixed = MAP_FIXED;
941 }
942
943 elf_prot = make_prot(elf_ppnt->p_flags);
944
945 elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
946
947 vaddr = elf_ppnt->p_vaddr;
948
949
950
951
952 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
953 elf_flags |= elf_fixed;
954 } else if (loc->elf_ex.e_type == ET_DYN) {
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985 if (interpreter) {
986 load_bias = ELF_ET_DYN_BASE;
987 if (current->flags & PF_RANDOMIZE)
988 load_bias += arch_mmap_rnd();
989 elf_flags |= elf_fixed;
990 } else
991 load_bias = 0;
992
993
994
995
996
997
998
999
1000 load_bias = ELF_PAGESTART(load_bias - vaddr);
1001
1002 total_size = total_mapping_size(elf_phdata,
1003 loc->elf_ex.e_phnum);
1004 if (!total_size) {
1005 retval = -EINVAL;
1006 goto out_free_dentry;
1007 }
1008 }
1009
1010 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
1011 elf_prot, elf_flags, total_size);
1012 if (BAD_ADDR(error)) {
1013 retval = IS_ERR((void *)error) ?
1014 PTR_ERR((void*)error) : -EINVAL;
1015 goto out_free_dentry;
1016 }
1017
1018 if (!load_addr_set) {
1019 load_addr_set = 1;
1020 load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
1021 if (loc->elf_ex.e_type == ET_DYN) {
1022 load_bias += error -
1023 ELF_PAGESTART(load_bias + vaddr);
1024 load_addr += load_bias;
1025 reloc_func_desc = load_bias;
1026 }
1027 }
1028 k = elf_ppnt->p_vaddr;
1029 if (k < start_code)
1030 start_code = k;
1031 if (start_data < k)
1032 start_data = k;
1033
1034
1035
1036
1037
1038
1039 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
1040 elf_ppnt->p_memsz > TASK_SIZE ||
1041 TASK_SIZE - elf_ppnt->p_memsz < k) {
1042
1043 retval = -EINVAL;
1044 goto out_free_dentry;
1045 }
1046
1047 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
1048
1049 if (k > elf_bss)
1050 elf_bss = k;
1051 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
1052 end_code = k;
1053 if (end_data < k)
1054 end_data = k;
1055 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
1056 if (k > elf_brk) {
1057 bss_prot = elf_prot;
1058 elf_brk = k;
1059 }
1060 }
1061
1062 loc->elf_ex.e_entry += load_bias;
1063 elf_bss += load_bias;
1064 elf_brk += load_bias;
1065 start_code += load_bias;
1066 end_code += load_bias;
1067 start_data += load_bias;
1068 end_data += load_bias;
1069
1070
1071
1072
1073
1074
1075 retval = set_brk(elf_bss, elf_brk, bss_prot);
1076 if (retval)
1077 goto out_free_dentry;
1078 if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
1079 retval = -EFAULT;
1080 goto out_free_dentry;
1081 }
1082
1083 if (interpreter) {
1084 unsigned long interp_map_addr = 0;
1085
1086 elf_entry = load_elf_interp(&loc->interp_elf_ex,
1087 interpreter,
1088 &interp_map_addr,
1089 load_bias, interp_elf_phdata);
1090 if (!IS_ERR((void *)elf_entry)) {
1091
1092
1093
1094
1095 interp_load_addr = elf_entry;
1096 elf_entry += loc->interp_elf_ex.e_entry;
1097 }
1098 if (BAD_ADDR(elf_entry)) {
1099 retval = IS_ERR((void *)elf_entry) ?
1100 (int)elf_entry : -EINVAL;
1101 goto out_free_dentry;
1102 }
1103 reloc_func_desc = interp_load_addr;
1104
1105 allow_write_access(interpreter);
1106 fput(interpreter);
1107 } else {
1108 elf_entry = loc->elf_ex.e_entry;
1109 if (BAD_ADDR(elf_entry)) {
1110 retval = -EINVAL;
1111 goto out_free_dentry;
1112 }
1113 }
1114
1115 kfree(interp_elf_phdata);
1116 kfree(elf_phdata);
1117
1118 set_binfmt(&elf_format);
1119
1120#ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
1121 retval = arch_setup_additional_pages(bprm, !!interpreter);
1122 if (retval < 0)
1123 goto out;
1124#endif
1125
1126 retval = create_elf_tables(bprm, &loc->elf_ex,
1127 load_addr, interp_load_addr);
1128 if (retval < 0)
1129 goto out;
1130
1131 current->mm->end_code = end_code;
1132 current->mm->start_code = start_code;
1133 current->mm->start_data = start_data;
1134 current->mm->end_data = end_data;
1135 current->mm->start_stack = bprm->p;
1136
1137 if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
1138
1139
1140
1141
1142
1143
1144
1145 if (IS_ENABLED(CONFIG_ARCH_HAS_ELF_RANDOMIZE) && !interpreter)
1146 current->mm->brk = current->mm->start_brk =
1147 ELF_ET_DYN_BASE;
1148
1149 current->mm->brk = current->mm->start_brk =
1150 arch_randomize_brk(current->mm);
1151#ifdef compat_brk_randomized
1152 current->brk_randomized = 1;
1153#endif
1154 }
1155
1156 if (current->personality & MMAP_PAGE_ZERO) {
1157
1158
1159
1160
1161 error = vm_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
1162 MAP_FIXED | MAP_PRIVATE, 0);
1163 }
1164
1165 regs = current_pt_regs();
1166#ifdef ELF_PLAT_INIT
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177 ELF_PLAT_INIT(regs, reloc_func_desc);
1178#endif
1179
1180 finalize_exec(bprm);
1181 start_thread(regs, elf_entry, bprm->p);
1182 retval = 0;
1183out:
1184 kfree(loc);
1185out_ret:
1186 return retval;
1187
1188
1189out_free_dentry:
1190 kfree(interp_elf_phdata);
1191 allow_write_access(interpreter);
1192 if (interpreter)
1193 fput(interpreter);
1194out_free_ph:
1195 kfree(elf_phdata);
1196 goto out;
1197}
1198
1199#ifdef CONFIG_USELIB
1200
1201
1202static int load_elf_library(struct file *file)
1203{
1204 struct elf_phdr *elf_phdata;
1205 struct elf_phdr *eppnt;
1206 unsigned long elf_bss, bss, len;
1207 int retval, error, i, j;
1208 struct elfhdr elf_ex;
1209 loff_t pos = 0;
1210
1211 error = -ENOEXEC;
1212 retval = kernel_read(file, &elf_ex, sizeof(elf_ex), &pos);
1213 if (retval != sizeof(elf_ex))
1214 goto out;
1215
1216 if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1217 goto out;
1218
1219
1220 if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
1221 !elf_check_arch(&elf_ex) || !file->f_op->mmap)
1222 goto out;
1223 if (elf_check_fdpic(&elf_ex))
1224 goto out;
1225
1226
1227
1228 j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1229
1230
1231 error = -ENOMEM;
1232 elf_phdata = kmalloc(j, GFP_KERNEL);
1233 if (!elf_phdata)
1234 goto out;
1235
1236 eppnt = elf_phdata;
1237 error = -ENOEXEC;
1238 pos = elf_ex.e_phoff;
1239 retval = kernel_read(file, eppnt, j, &pos);
1240 if (retval != j)
1241 goto out_free_ph;
1242
1243 for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1244 if ((eppnt + i)->p_type == PT_LOAD)
1245 j++;
1246 if (j != 1)
1247 goto out_free_ph;
1248
1249 while (eppnt->p_type != PT_LOAD)
1250 eppnt++;
1251
1252
1253 error = vm_mmap(file,
1254 ELF_PAGESTART(eppnt->p_vaddr),
1255 (eppnt->p_filesz +
1256 ELF_PAGEOFFSET(eppnt->p_vaddr)),
1257 PROT_READ | PROT_WRITE | PROT_EXEC,
1258 MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_DENYWRITE,
1259 (eppnt->p_offset -
1260 ELF_PAGEOFFSET(eppnt->p_vaddr)));
1261 if (error != ELF_PAGESTART(eppnt->p_vaddr))
1262 goto out_free_ph;
1263
1264 elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1265 if (padzero(elf_bss)) {
1266 error = -EFAULT;
1267 goto out_free_ph;
1268 }
1269
1270 len = ELF_PAGEALIGN(eppnt->p_filesz + eppnt->p_vaddr);
1271 bss = ELF_PAGEALIGN(eppnt->p_memsz + eppnt->p_vaddr);
1272 if (bss > len) {
1273 error = vm_brk(len, bss - len);
1274 if (error)
1275 goto out_free_ph;
1276 }
1277 error = 0;
1278
1279out_free_ph:
1280 kfree(elf_phdata);
1281out:
1282 return error;
1283}
1284#endif
1285
1286#ifdef CONFIG_ELF_CORE
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302static bool always_dump_vma(struct vm_area_struct *vma)
1303{
1304
1305 if (vma == get_gate_vma(vma->vm_mm))
1306 return true;
1307
1308
1309
1310
1311
1312 if (vma->vm_ops && vma->vm_ops->name && vma->vm_ops->name(vma))
1313 return true;
1314
1315
1316
1317
1318
1319 if (arch_vma_name(vma))
1320 return true;
1321
1322 return false;
1323}
1324
1325
1326
1327
1328static unsigned long vma_dump_size(struct vm_area_struct *vma,
1329 unsigned long mm_flags)
1330{
1331#define FILTER(type) (mm_flags & (1UL << MMF_DUMP_##type))
1332
1333
1334 if (always_dump_vma(vma))
1335 goto whole;
1336
1337 if (vma->vm_flags & VM_DONTDUMP)
1338 return 0;
1339
1340
1341 if (vma_is_dax(vma)) {
1342 if ((vma->vm_flags & VM_SHARED) && FILTER(DAX_SHARED))
1343 goto whole;
1344 if (!(vma->vm_flags & VM_SHARED) && FILTER(DAX_PRIVATE))
1345 goto whole;
1346 return 0;
1347 }
1348
1349
1350 if (vma->vm_flags & VM_HUGETLB) {
1351 if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))
1352 goto whole;
1353 if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))
1354 goto whole;
1355 return 0;
1356 }
1357
1358
1359 if (vma->vm_flags & VM_IO)
1360 return 0;
1361
1362
1363 if (vma->vm_flags & VM_SHARED) {
1364 if (file_inode(vma->vm_file)->i_nlink == 0 ?
1365 FILTER(ANON_SHARED) : FILTER(MAPPED_SHARED))
1366 goto whole;
1367 return 0;
1368 }
1369
1370
1371 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1372 goto whole;
1373 if (vma->vm_file == NULL)
1374 return 0;
1375
1376 if (FILTER(MAPPED_PRIVATE))
1377 goto whole;
1378
1379
1380
1381
1382
1383
1384 if (FILTER(ELF_HEADERS) &&
1385 vma->vm_pgoff == 0 && (vma->vm_flags & VM_READ)) {
1386 u32 __user *header = (u32 __user *) vma->vm_start;
1387 u32 word;
1388 mm_segment_t fs = get_fs();
1389
1390
1391
1392 union {
1393 u32 cmp;
1394 char elfmag[SELFMAG];
1395 } magic;
1396 BUILD_BUG_ON(SELFMAG != sizeof word);
1397 magic.elfmag[EI_MAG0] = ELFMAG0;
1398 magic.elfmag[EI_MAG1] = ELFMAG1;
1399 magic.elfmag[EI_MAG2] = ELFMAG2;
1400 magic.elfmag[EI_MAG3] = ELFMAG3;
1401
1402
1403
1404
1405 set_fs(USER_DS);
1406 if (unlikely(get_user(word, header)))
1407 word = 0;
1408 set_fs(fs);
1409 if (word == magic.cmp)
1410 return PAGE_SIZE;
1411 }
1412
1413#undef FILTER
1414
1415 return 0;
1416
1417whole:
1418 return vma->vm_end - vma->vm_start;
1419}
1420
1421
1422struct memelfnote
1423{
1424 const char *name;
1425 int type;
1426 unsigned int datasz;
1427 void *data;
1428};
1429
1430static int notesize(struct memelfnote *en)
1431{
1432 int sz;
1433
1434 sz = sizeof(struct elf_note);
1435 sz += roundup(strlen(en->name) + 1, 4);
1436 sz += roundup(en->datasz, 4);
1437
1438 return sz;
1439}
1440
1441static int writenote(struct memelfnote *men, struct coredump_params *cprm)
1442{
1443 struct elf_note en;
1444 en.n_namesz = strlen(men->name) + 1;
1445 en.n_descsz = men->datasz;
1446 en.n_type = men->type;
1447
1448 return dump_emit(cprm, &en, sizeof(en)) &&
1449 dump_emit(cprm, men->name, en.n_namesz) && dump_align(cprm, 4) &&
1450 dump_emit(cprm, men->data, men->datasz) && dump_align(cprm, 4);
1451}
1452
1453static void fill_elf_header(struct elfhdr *elf, int segs,
1454 u16 machine, u32 flags)
1455{
1456 memset(elf, 0, sizeof(*elf));
1457
1458 memcpy(elf->e_ident, ELFMAG, SELFMAG);
1459 elf->e_ident[EI_CLASS] = ELF_CLASS;
1460 elf->e_ident[EI_DATA] = ELF_DATA;
1461 elf->e_ident[EI_VERSION] = EV_CURRENT;
1462 elf->e_ident[EI_OSABI] = ELF_OSABI;
1463
1464 elf->e_type = ET_CORE;
1465 elf->e_machine = machine;
1466 elf->e_version = EV_CURRENT;
1467 elf->e_phoff = sizeof(struct elfhdr);
1468 elf->e_flags = flags;
1469 elf->e_ehsize = sizeof(struct elfhdr);
1470 elf->e_phentsize = sizeof(struct elf_phdr);
1471 elf->e_phnum = segs;
1472}
1473
1474static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
1475{
1476 phdr->p_type = PT_NOTE;
1477 phdr->p_offset = offset;
1478 phdr->p_vaddr = 0;
1479 phdr->p_paddr = 0;
1480 phdr->p_filesz = sz;
1481 phdr->p_memsz = 0;
1482 phdr->p_flags = 0;
1483 phdr->p_align = 0;
1484}
1485
1486static void fill_note(struct memelfnote *note, const char *name, int type,
1487 unsigned int sz, void *data)
1488{
1489 note->name = name;
1490 note->type = type;
1491 note->datasz = sz;
1492 note->data = data;
1493}
1494
1495
1496
1497
1498
1499static void fill_prstatus(struct elf_prstatus *prstatus,
1500 struct task_struct *p, long signr)
1501{
1502 prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1503 prstatus->pr_sigpend = p->pending.signal.sig[0];
1504 prstatus->pr_sighold = p->blocked.sig[0];
1505 rcu_read_lock();
1506 prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1507 rcu_read_unlock();
1508 prstatus->pr_pid = task_pid_vnr(p);
1509 prstatus->pr_pgrp = task_pgrp_vnr(p);
1510 prstatus->pr_sid = task_session_vnr(p);
1511 if (thread_group_leader(p)) {
1512 struct task_cputime cputime;
1513
1514
1515
1516
1517
1518 thread_group_cputime(p, &cputime);
1519 prstatus->pr_utime = ns_to_timeval(cputime.utime);
1520 prstatus->pr_stime = ns_to_timeval(cputime.stime);
1521 } else {
1522 u64 utime, stime;
1523
1524 task_cputime(p, &utime, &stime);
1525 prstatus->pr_utime = ns_to_timeval(utime);
1526 prstatus->pr_stime = ns_to_timeval(stime);
1527 }
1528
1529 prstatus->pr_cutime = ns_to_timeval(p->signal->cutime);
1530 prstatus->pr_cstime = ns_to_timeval(p->signal->cstime);
1531}
1532
1533static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1534 struct mm_struct *mm)
1535{
1536 const struct cred *cred;
1537 unsigned int i, len;
1538
1539
1540 memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1541
1542 len = mm->arg_end - mm->arg_start;
1543 if (len >= ELF_PRARGSZ)
1544 len = ELF_PRARGSZ-1;
1545 if (copy_from_user(&psinfo->pr_psargs,
1546 (const char __user *)mm->arg_start, len))
1547 return -EFAULT;
1548 for(i = 0; i < len; i++)
1549 if (psinfo->pr_psargs[i] == 0)
1550 psinfo->pr_psargs[i] = ' ';
1551 psinfo->pr_psargs[len] = 0;
1552
1553 rcu_read_lock();
1554 psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1555 rcu_read_unlock();
1556 psinfo->pr_pid = task_pid_vnr(p);
1557 psinfo->pr_pgrp = task_pgrp_vnr(p);
1558 psinfo->pr_sid = task_session_vnr(p);
1559
1560 i = p->state ? ffz(~p->state) + 1 : 0;
1561 psinfo->pr_state = i;
1562 psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
1563 psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1564 psinfo->pr_nice = task_nice(p);
1565 psinfo->pr_flag = p->flags;
1566 rcu_read_lock();
1567 cred = __task_cred(p);
1568 SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
1569 SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
1570 rcu_read_unlock();
1571 strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1572
1573 return 0;
1574}
1575
1576static void fill_auxv_note(struct memelfnote *note, struct mm_struct *mm)
1577{
1578 elf_addr_t *auxv = (elf_addr_t *) mm->saved_auxv;
1579 int i = 0;
1580 do
1581 i += 2;
1582 while (auxv[i - 2] != AT_NULL);
1583 fill_note(note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);
1584}
1585
1586static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,
1587 const kernel_siginfo_t *siginfo)
1588{
1589 mm_segment_t old_fs = get_fs();
1590 set_fs(KERNEL_DS);
1591 copy_siginfo_to_user((user_siginfo_t __user *) csigdata, siginfo);
1592 set_fs(old_fs);
1593 fill_note(note, "CORE", NT_SIGINFO, sizeof(*csigdata), csigdata);
1594}
1595
1596#define MAX_FILE_NOTE_SIZE (4*1024*1024)
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608static int fill_files_note(struct memelfnote *note)
1609{
1610 struct vm_area_struct *vma;
1611 unsigned count, size, names_ofs, remaining, n;
1612 user_long_t *data;
1613 user_long_t *start_end_ofs;
1614 char *name_base, *name_curpos;
1615
1616
1617 count = current->mm->map_count;
1618 if (count > UINT_MAX / 64)
1619 return -EINVAL;
1620 size = count * 64;
1621
1622 names_ofs = (2 + 3 * count) * sizeof(data[0]);
1623 alloc:
1624 if (size >= MAX_FILE_NOTE_SIZE)
1625 return -EINVAL;
1626 size = round_up(size, PAGE_SIZE);
1627 data = kvmalloc(size, GFP_KERNEL);
1628 if (ZERO_OR_NULL_PTR(data))
1629 return -ENOMEM;
1630
1631 start_end_ofs = data + 2;
1632 name_base = name_curpos = ((char *)data) + names_ofs;
1633 remaining = size - names_ofs;
1634 count = 0;
1635 for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1636 struct file *file;
1637 const char *filename;
1638
1639 file = vma->vm_file;
1640 if (!file)
1641 continue;
1642 filename = file_path(file, name_curpos, remaining);
1643 if (IS_ERR(filename)) {
1644 if (PTR_ERR(filename) == -ENAMETOOLONG) {
1645 kvfree(data);
1646 size = size * 5 / 4;
1647 goto alloc;
1648 }
1649 continue;
1650 }
1651
1652
1653
1654 n = (name_curpos + remaining) - filename;
1655 remaining = filename - name_curpos;
1656 memmove(name_curpos, filename, n);
1657 name_curpos += n;
1658
1659 *start_end_ofs++ = vma->vm_start;
1660 *start_end_ofs++ = vma->vm_end;
1661 *start_end_ofs++ = vma->vm_pgoff;
1662 count++;
1663 }
1664
1665
1666 data[0] = count;
1667 data[1] = PAGE_SIZE;
1668
1669
1670
1671
1672 n = current->mm->map_count - count;
1673 if (n != 0) {
1674 unsigned shift_bytes = n * 3 * sizeof(data[0]);
1675 memmove(name_base - shift_bytes, name_base,
1676 name_curpos - name_base);
1677 name_curpos -= shift_bytes;
1678 }
1679
1680 size = name_curpos - (char *)data;
1681 fill_note(note, "CORE", NT_FILE, size, data);
1682 return 0;
1683}
1684
1685#ifdef CORE_DUMP_USE_REGSET
1686#include <linux/regset.h>
1687
1688struct elf_thread_core_info {
1689 struct elf_thread_core_info *next;
1690 struct task_struct *task;
1691 struct elf_prstatus prstatus;
1692 struct memelfnote notes[0];
1693};
1694
1695struct elf_note_info {
1696 struct elf_thread_core_info *thread;
1697 struct memelfnote psinfo;
1698 struct memelfnote signote;
1699 struct memelfnote auxv;
1700 struct memelfnote files;
1701 user_siginfo_t csigdata;
1702 size_t size;
1703 int thread_notes;
1704};
1705
1706
1707
1708
1709
1710
1711static void do_thread_regset_writeback(struct task_struct *task,
1712 const struct user_regset *regset)
1713{
1714 if (regset->writeback)
1715 regset->writeback(task, regset, 1);
1716}
1717
1718#ifndef PRSTATUS_SIZE
1719#define PRSTATUS_SIZE(S, R) sizeof(S)
1720#endif
1721
1722#ifndef SET_PR_FPVALID
1723#define SET_PR_FPVALID(S, V, R) ((S)->pr_fpvalid = (V))
1724#endif
1725
1726static int fill_thread_core_info(struct elf_thread_core_info *t,
1727 const struct user_regset_view *view,
1728 long signr, size_t *total)
1729{
1730 unsigned int i;
1731 unsigned int regset0_size = regset_size(t->task, &view->regsets[0]);
1732
1733
1734
1735
1736
1737
1738
1739 fill_prstatus(&t->prstatus, t->task, signr);
1740 (void) view->regsets[0].get(t->task, &view->regsets[0], 0, regset0_size,
1741 &t->prstatus.pr_reg, NULL);
1742
1743 fill_note(&t->notes[0], "CORE", NT_PRSTATUS,
1744 PRSTATUS_SIZE(t->prstatus, regset0_size), &t->prstatus);
1745 *total += notesize(&t->notes[0]);
1746
1747 do_thread_regset_writeback(t->task, &view->regsets[0]);
1748
1749
1750
1751
1752
1753
1754 for (i = 1; i < view->n; ++i) {
1755 const struct user_regset *regset = &view->regsets[i];
1756 do_thread_regset_writeback(t->task, regset);
1757 if (regset->core_note_type && regset->get &&
1758 (!regset->active || regset->active(t->task, regset) > 0)) {
1759 int ret;
1760 size_t size = regset_size(t->task, regset);
1761 void *data = kmalloc(size, GFP_KERNEL);
1762 if (unlikely(!data))
1763 return 0;
1764 ret = regset->get(t->task, regset,
1765 0, size, data, NULL);
1766 if (unlikely(ret))
1767 kfree(data);
1768 else {
1769 if (regset->core_note_type != NT_PRFPREG)
1770 fill_note(&t->notes[i], "LINUX",
1771 regset->core_note_type,
1772 size, data);
1773 else {
1774 SET_PR_FPVALID(&t->prstatus,
1775 1, regset0_size);
1776 fill_note(&t->notes[i], "CORE",
1777 NT_PRFPREG, size, data);
1778 }
1779 *total += notesize(&t->notes[i]);
1780 }
1781 }
1782 }
1783
1784 return 1;
1785}
1786
1787static int fill_note_info(struct elfhdr *elf, int phdrs,
1788 struct elf_note_info *info,
1789 const kernel_siginfo_t *siginfo, struct pt_regs *regs)
1790{
1791 struct task_struct *dump_task = current;
1792 const struct user_regset_view *view = task_user_regset_view(dump_task);
1793 struct elf_thread_core_info *t;
1794 struct elf_prpsinfo *psinfo;
1795 struct core_thread *ct;
1796 unsigned int i;
1797
1798 info->size = 0;
1799 info->thread = NULL;
1800
1801 psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
1802 if (psinfo == NULL) {
1803 info->psinfo.data = NULL;
1804 return 0;
1805 }
1806
1807 fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1808
1809
1810
1811
1812 info->thread_notes = 0;
1813 for (i = 0; i < view->n; ++i)
1814 if (view->regsets[i].core_note_type != 0)
1815 ++info->thread_notes;
1816
1817
1818
1819
1820
1821 if (unlikely(info->thread_notes == 0) ||
1822 unlikely(view->regsets[0].core_note_type != NT_PRSTATUS)) {
1823 WARN_ON(1);
1824 return 0;
1825 }
1826
1827
1828
1829
1830 fill_elf_header(elf, phdrs,
1831 view->e_machine, view->e_flags);
1832
1833
1834
1835
1836 for (ct = &dump_task->mm->core_state->dumper; ct; ct = ct->next) {
1837 t = kzalloc(offsetof(struct elf_thread_core_info,
1838 notes[info->thread_notes]),
1839 GFP_KERNEL);
1840 if (unlikely(!t))
1841 return 0;
1842
1843 t->task = ct->task;
1844 if (ct->task == dump_task || !info->thread) {
1845 t->next = info->thread;
1846 info->thread = t;
1847 } else {
1848
1849
1850
1851
1852 t->next = info->thread->next;
1853 info->thread->next = t;
1854 }
1855 }
1856
1857
1858
1859
1860 for (t = info->thread; t != NULL; t = t->next)
1861 if (!fill_thread_core_info(t, view, siginfo->si_signo, &info->size))
1862 return 0;
1863
1864
1865
1866
1867 fill_psinfo(psinfo, dump_task->group_leader, dump_task->mm);
1868 info->size += notesize(&info->psinfo);
1869
1870 fill_siginfo_note(&info->signote, &info->csigdata, siginfo);
1871 info->size += notesize(&info->signote);
1872
1873 fill_auxv_note(&info->auxv, current->mm);
1874 info->size += notesize(&info->auxv);
1875
1876 if (fill_files_note(&info->files) == 0)
1877 info->size += notesize(&info->files);
1878
1879 return 1;
1880}
1881
1882static size_t get_note_info_size(struct elf_note_info *info)
1883{
1884 return info->size;
1885}
1886
1887
1888
1889
1890
1891static int write_note_info(struct elf_note_info *info,
1892 struct coredump_params *cprm)
1893{
1894 bool first = true;
1895 struct elf_thread_core_info *t = info->thread;
1896
1897 do {
1898 int i;
1899
1900 if (!writenote(&t->notes[0], cprm))
1901 return 0;
1902
1903 if (first && !writenote(&info->psinfo, cprm))
1904 return 0;
1905 if (first && !writenote(&info->signote, cprm))
1906 return 0;
1907 if (first && !writenote(&info->auxv, cprm))
1908 return 0;
1909 if (first && info->files.data &&
1910 !writenote(&info->files, cprm))
1911 return 0;
1912
1913 for (i = 1; i < info->thread_notes; ++i)
1914 if (t->notes[i].data &&
1915 !writenote(&t->notes[i], cprm))
1916 return 0;
1917
1918 first = false;
1919 t = t->next;
1920 } while (t);
1921
1922 return 1;
1923}
1924
1925static void free_note_info(struct elf_note_info *info)
1926{
1927 struct elf_thread_core_info *threads = info->thread;
1928 while (threads) {
1929 unsigned int i;
1930 struct elf_thread_core_info *t = threads;
1931 threads = t->next;
1932 WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);
1933 for (i = 1; i < info->thread_notes; ++i)
1934 kfree(t->notes[i].data);
1935 kfree(t);
1936 }
1937 kfree(info->psinfo.data);
1938 kvfree(info->files.data);
1939}
1940
1941#else
1942
1943
1944struct elf_thread_status
1945{
1946 struct list_head list;
1947 struct elf_prstatus prstatus;
1948 elf_fpregset_t fpu;
1949 struct task_struct *thread;
1950#ifdef ELF_CORE_COPY_XFPREGS
1951 elf_fpxregset_t xfpu;
1952#endif
1953 struct memelfnote notes[3];
1954 int num_notes;
1955};
1956
1957
1958
1959
1960
1961
1962static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1963{
1964 int sz = 0;
1965 struct task_struct *p = t->thread;
1966 t->num_notes = 0;
1967
1968 fill_prstatus(&t->prstatus, p, signr);
1969 elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1970
1971 fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1972 &(t->prstatus));
1973 t->num_notes++;
1974 sz += notesize(&t->notes[0]);
1975
1976 if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1977 &t->fpu))) {
1978 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1979 &(t->fpu));
1980 t->num_notes++;
1981 sz += notesize(&t->notes[1]);
1982 }
1983
1984#ifdef ELF_CORE_COPY_XFPREGS
1985 if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
1986 fill_note(&t->notes[2], "LINUX", ELF_CORE_XFPREG_TYPE,
1987 sizeof(t->xfpu), &t->xfpu);
1988 t->num_notes++;
1989 sz += notesize(&t->notes[2]);
1990 }
1991#endif
1992 return sz;
1993}
1994
1995struct elf_note_info {
1996 struct memelfnote *notes;
1997 struct memelfnote *notes_files;
1998 struct elf_prstatus *prstatus;
1999 struct elf_prpsinfo *psinfo;
2000 struct list_head thread_list;
2001 elf_fpregset_t *fpu;
2002#ifdef ELF_CORE_COPY_XFPREGS
2003 elf_fpxregset_t *xfpu;
2004#endif
2005 user_siginfo_t csigdata;
2006 int thread_status_size;
2007 int numnote;
2008};
2009
2010static int elf_note_info_init(struct elf_note_info *info)
2011{
2012 memset(info, 0, sizeof(*info));
2013 INIT_LIST_HEAD(&info->thread_list);
2014
2015
2016 info->notes = kmalloc_array(8, sizeof(struct memelfnote), GFP_KERNEL);
2017 if (!info->notes)
2018 return 0;
2019 info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL);
2020 if (!info->psinfo)
2021 return 0;
2022 info->prstatus = kmalloc(sizeof(*info->prstatus), GFP_KERNEL);
2023 if (!info->prstatus)
2024 return 0;
2025 info->fpu = kmalloc(sizeof(*info->fpu), GFP_KERNEL);
2026 if (!info->fpu)
2027 return 0;
2028#ifdef ELF_CORE_COPY_XFPREGS
2029 info->xfpu = kmalloc(sizeof(*info->xfpu), GFP_KERNEL);
2030 if (!info->xfpu)
2031 return 0;
2032#endif
2033 return 1;
2034}
2035
2036static int fill_note_info(struct elfhdr *elf, int phdrs,
2037 struct elf_note_info *info,
2038 const kernel_siginfo_t *siginfo, struct pt_regs *regs)
2039{
2040 struct core_thread *ct;
2041 struct elf_thread_status *ets;
2042
2043 if (!elf_note_info_init(info))
2044 return 0;
2045
2046 for (ct = current->mm->core_state->dumper.next;
2047 ct; ct = ct->next) {
2048 ets = kzalloc(sizeof(*ets), GFP_KERNEL);
2049 if (!ets)
2050 return 0;
2051
2052 ets->thread = ct->task;
2053 list_add(&ets->list, &info->thread_list);
2054 }
2055
2056 list_for_each_entry(ets, &info->thread_list, list) {
2057 int sz;
2058
2059 sz = elf_dump_thread_status(siginfo->si_signo, ets);
2060 info->thread_status_size += sz;
2061 }
2062
2063 memset(info->prstatus, 0, sizeof(*info->prstatus));
2064 fill_prstatus(info->prstatus, current, siginfo->si_signo);
2065 elf_core_copy_regs(&info->prstatus->pr_reg, regs);
2066
2067
2068 fill_elf_header(elf, phdrs, ELF_ARCH, ELF_CORE_EFLAGS);
2069
2070
2071
2072
2073
2074
2075 fill_note(info->notes + 0, "CORE", NT_PRSTATUS,
2076 sizeof(*info->prstatus), info->prstatus);
2077 fill_psinfo(info->psinfo, current->group_leader, current->mm);
2078 fill_note(info->notes + 1, "CORE", NT_PRPSINFO,
2079 sizeof(*info->psinfo), info->psinfo);
2080
2081 fill_siginfo_note(info->notes + 2, &info->csigdata, siginfo);
2082 fill_auxv_note(info->notes + 3, current->mm);
2083 info->numnote = 4;
2084
2085 if (fill_files_note(info->notes + info->numnote) == 0) {
2086 info->notes_files = info->notes + info->numnote;
2087 info->numnote++;
2088 }
2089
2090
2091 info->prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs,
2092 info->fpu);
2093 if (info->prstatus->pr_fpvalid)
2094 fill_note(info->notes + info->numnote++,
2095 "CORE", NT_PRFPREG, sizeof(*info->fpu), info->fpu);
2096#ifdef ELF_CORE_COPY_XFPREGS
2097 if (elf_core_copy_task_xfpregs(current, info->xfpu))
2098 fill_note(info->notes + info->numnote++,
2099 "LINUX", ELF_CORE_XFPREG_TYPE,
2100 sizeof(*info->xfpu), info->xfpu);
2101#endif
2102
2103 return 1;
2104}
2105
2106static size_t get_note_info_size(struct elf_note_info *info)
2107{
2108 int sz = 0;
2109 int i;
2110
2111 for (i = 0; i < info->numnote; i++)
2112 sz += notesize(info->notes + i);
2113
2114 sz += info->thread_status_size;
2115
2116 return sz;
2117}
2118
2119static int write_note_info(struct elf_note_info *info,
2120 struct coredump_params *cprm)
2121{
2122 struct elf_thread_status *ets;
2123 int i;
2124
2125 for (i = 0; i < info->numnote; i++)
2126 if (!writenote(info->notes + i, cprm))
2127 return 0;
2128
2129
2130 list_for_each_entry(ets, &info->thread_list, list) {
2131 for (i = 0; i < ets->num_notes; i++)
2132 if (!writenote(&ets->notes[i], cprm))
2133 return 0;
2134 }
2135
2136 return 1;
2137}
2138
2139static void free_note_info(struct elf_note_info *info)
2140{
2141 while (!list_empty(&info->thread_list)) {
2142 struct list_head *tmp = info->thread_list.next;
2143 list_del(tmp);
2144 kfree(list_entry(tmp, struct elf_thread_status, list));
2145 }
2146
2147
2148 if (info->notes_files)
2149 kvfree(info->notes_files->data);
2150
2151 kfree(info->prstatus);
2152 kfree(info->psinfo);
2153 kfree(info->notes);
2154 kfree(info->fpu);
2155#ifdef ELF_CORE_COPY_XFPREGS
2156 kfree(info->xfpu);
2157#endif
2158}
2159
2160#endif
2161
2162static struct vm_area_struct *first_vma(struct task_struct *tsk,
2163 struct vm_area_struct *gate_vma)
2164{
2165 struct vm_area_struct *ret = tsk->mm->mmap;
2166
2167 if (ret)
2168 return ret;
2169 return gate_vma;
2170}
2171
2172
2173
2174
2175static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
2176 struct vm_area_struct *gate_vma)
2177{
2178 struct vm_area_struct *ret;
2179
2180 ret = this_vma->vm_next;
2181 if (ret)
2182 return ret;
2183 if (this_vma == gate_vma)
2184 return NULL;
2185 return gate_vma;
2186}
2187
2188static void fill_extnum_info(struct elfhdr *elf, struct elf_shdr *shdr4extnum,
2189 elf_addr_t e_shoff, int segs)
2190{
2191 elf->e_shoff = e_shoff;
2192 elf->e_shentsize = sizeof(*shdr4extnum);
2193 elf->e_shnum = 1;
2194 elf->e_shstrndx = SHN_UNDEF;
2195
2196 memset(shdr4extnum, 0, sizeof(*shdr4extnum));
2197
2198 shdr4extnum->sh_type = SHT_NULL;
2199 shdr4extnum->sh_size = elf->e_shnum;
2200 shdr4extnum->sh_link = elf->e_shstrndx;
2201 shdr4extnum->sh_info = segs;
2202}
2203
2204
2205
2206
2207
2208
2209
2210
2211static int elf_core_dump(struct coredump_params *cprm)
2212{
2213 int has_dumped = 0;
2214 mm_segment_t fs;
2215 int segs, i;
2216 size_t vma_data_size = 0;
2217 struct vm_area_struct *vma, *gate_vma;
2218 struct elfhdr *elf = NULL;
2219 loff_t offset = 0, dataoff;
2220 struct elf_note_info info = { };
2221 struct elf_phdr *phdr4note = NULL;
2222 struct elf_shdr *shdr4extnum = NULL;
2223 Elf_Half e_phnum;
2224 elf_addr_t e_shoff;
2225 elf_addr_t *vma_filesz = NULL;
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240 elf = kmalloc(sizeof(*elf), GFP_KERNEL);
2241 if (!elf)
2242 goto out;
2243
2244
2245
2246
2247 segs = current->mm->map_count;
2248 segs += elf_core_extra_phdrs();
2249
2250 gate_vma = get_gate_vma(current->mm);
2251 if (gate_vma != NULL)
2252 segs++;
2253
2254
2255 segs++;
2256
2257
2258
2259
2260 e_phnum = segs > PN_XNUM ? PN_XNUM : segs;
2261
2262
2263
2264
2265
2266 if (!fill_note_info(elf, e_phnum, &info, cprm->siginfo, cprm->regs))
2267 goto cleanup;
2268
2269 has_dumped = 1;
2270
2271 fs = get_fs();
2272 set_fs(KERNEL_DS);
2273
2274 offset += sizeof(*elf);
2275 offset += segs * sizeof(struct elf_phdr);
2276
2277
2278 {
2279 size_t sz = get_note_info_size(&info);
2280
2281 sz += elf_coredump_extra_notes_size();
2282
2283 phdr4note = kmalloc(sizeof(*phdr4note), GFP_KERNEL);
2284 if (!phdr4note)
2285 goto end_coredump;
2286
2287 fill_elf_note_phdr(phdr4note, sz, offset);
2288 offset += sz;
2289 }
2290
2291 dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
2292
2293 if (segs - 1 > ULONG_MAX / sizeof(*vma_filesz))
2294 goto end_coredump;
2295 vma_filesz = kvmalloc(array_size(sizeof(*vma_filesz), (segs - 1)),
2296 GFP_KERNEL);
2297 if (ZERO_OR_NULL_PTR(vma_filesz))
2298 goto end_coredump;
2299
2300 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2301 vma = next_vma(vma, gate_vma)) {
2302 unsigned long dump_size;
2303
2304 dump_size = vma_dump_size(vma, cprm->mm_flags);
2305 vma_filesz[i++] = dump_size;
2306 vma_data_size += dump_size;
2307 }
2308
2309 offset += vma_data_size;
2310 offset += elf_core_extra_data_size();
2311 e_shoff = offset;
2312
2313 if (e_phnum == PN_XNUM) {
2314 shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);
2315 if (!shdr4extnum)
2316 goto end_coredump;
2317 fill_extnum_info(elf, shdr4extnum, e_shoff, segs);
2318 }
2319
2320 offset = dataoff;
2321
2322 if (!dump_emit(cprm, elf, sizeof(*elf)))
2323 goto end_coredump;
2324
2325 if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note)))
2326 goto end_coredump;
2327
2328
2329 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2330 vma = next_vma(vma, gate_vma)) {
2331 struct elf_phdr phdr;
2332
2333 phdr.p_type = PT_LOAD;
2334 phdr.p_offset = offset;
2335 phdr.p_vaddr = vma->vm_start;
2336 phdr.p_paddr = 0;
2337 phdr.p_filesz = vma_filesz[i++];
2338 phdr.p_memsz = vma->vm_end - vma->vm_start;
2339 offset += phdr.p_filesz;
2340 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
2341 if (vma->vm_flags & VM_WRITE)
2342 phdr.p_flags |= PF_W;
2343 if (vma->vm_flags & VM_EXEC)
2344 phdr.p_flags |= PF_X;
2345 phdr.p_align = ELF_EXEC_PAGESIZE;
2346
2347 if (!dump_emit(cprm, &phdr, sizeof(phdr)))
2348 goto end_coredump;
2349 }
2350
2351 if (!elf_core_write_extra_phdrs(cprm, offset))
2352 goto end_coredump;
2353
2354
2355 if (!write_note_info(&info, cprm))
2356 goto end_coredump;
2357
2358 if (elf_coredump_extra_notes_write(cprm))
2359 goto end_coredump;
2360
2361
2362 if (!dump_skip(cprm, dataoff - cprm->pos))
2363 goto end_coredump;
2364
2365 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2366 vma = next_vma(vma, gate_vma)) {
2367 unsigned long addr;
2368 unsigned long end;
2369
2370 end = vma->vm_start + vma_filesz[i++];
2371
2372 for (addr = vma->vm_start; addr < end; addr += PAGE_SIZE) {
2373 struct page *page;
2374 int stop;
2375
2376 page = get_dump_page(addr);
2377 if (page) {
2378 void *kaddr = kmap(page);
2379 stop = !dump_emit(cprm, kaddr, PAGE_SIZE);
2380 kunmap(page);
2381 put_page(page);
2382 } else
2383 stop = !dump_skip(cprm, PAGE_SIZE);
2384 if (stop)
2385 goto end_coredump;
2386 }
2387 }
2388 dump_truncate(cprm);
2389
2390 if (!elf_core_write_extra_data(cprm))
2391 goto end_coredump;
2392
2393 if (e_phnum == PN_XNUM) {
2394 if (!dump_emit(cprm, shdr4extnum, sizeof(*shdr4extnum)))
2395 goto end_coredump;
2396 }
2397
2398end_coredump:
2399 set_fs(fs);
2400
2401cleanup:
2402 free_note_info(&info);
2403 kfree(shdr4extnum);
2404 kvfree(vma_filesz);
2405 kfree(phdr4note);
2406 kfree(elf);
2407out:
2408 return has_dumped;
2409}
2410
2411#endif
2412
2413static int __init init_elf_binfmt(void)
2414{
2415 register_binfmt(&elf_format);
2416 return 0;
2417}
2418
2419static void __exit exit_elf_binfmt(void)
2420{
2421
2422 unregister_binfmt(&elf_format);
2423}
2424
2425core_initcall(init_elf_binfmt);
2426module_exit(exit_elf_binfmt);
2427MODULE_LICENSE("GPL");
2428