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 current->mm->end_code = end_code;
1131 current->mm->start_code = start_code;
1132 current->mm->start_data = start_data;
1133 current->mm->end_data = end_data;
1134 current->mm->start_stack = bprm->p;
1135
1136 if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
1137
1138
1139
1140
1141
1142
1143
1144 if (IS_ENABLED(CONFIG_ARCH_HAS_ELF_RANDOMIZE) && !interpreter)
1145 current->mm->brk = current->mm->start_brk =
1146 ELF_ET_DYN_BASE;
1147
1148 current->mm->brk = current->mm->start_brk =
1149 arch_randomize_brk(current->mm);
1150#ifdef compat_brk_randomized
1151 current->brk_randomized = 1;
1152#endif
1153 }
1154
1155 if (current->personality & MMAP_PAGE_ZERO) {
1156
1157
1158
1159
1160 error = vm_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
1161 MAP_FIXED | MAP_PRIVATE, 0);
1162 }
1163
1164 regs = current_pt_regs();
1165#ifdef ELF_PLAT_INIT
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176 ELF_PLAT_INIT(regs, reloc_func_desc);
1177#endif
1178
1179 finalize_exec(bprm);
1180 start_thread(regs, elf_entry, bprm->p);
1181 retval = 0;
1182out:
1183 kfree(loc);
1184out_ret:
1185 return retval;
1186
1187
1188out_free_dentry:
1189 kfree(interp_elf_phdata);
1190 allow_write_access(interpreter);
1191 if (interpreter)
1192 fput(interpreter);
1193out_free_ph:
1194 kfree(elf_phdata);
1195 goto out;
1196}
1197
1198#ifdef CONFIG_USELIB
1199
1200
1201static int load_elf_library(struct file *file)
1202{
1203 struct elf_phdr *elf_phdata;
1204 struct elf_phdr *eppnt;
1205 unsigned long elf_bss, bss, len;
1206 int retval, error, i, j;
1207 struct elfhdr elf_ex;
1208 loff_t pos = 0;
1209
1210 error = -ENOEXEC;
1211 retval = kernel_read(file, &elf_ex, sizeof(elf_ex), &pos);
1212 if (retval != sizeof(elf_ex))
1213 goto out;
1214
1215 if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1216 goto out;
1217
1218
1219 if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
1220 !elf_check_arch(&elf_ex) || !file->f_op->mmap)
1221 goto out;
1222 if (elf_check_fdpic(&elf_ex))
1223 goto out;
1224
1225
1226
1227 j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1228
1229
1230 error = -ENOMEM;
1231 elf_phdata = kmalloc(j, GFP_KERNEL);
1232 if (!elf_phdata)
1233 goto out;
1234
1235 eppnt = elf_phdata;
1236 error = -ENOEXEC;
1237 pos = elf_ex.e_phoff;
1238 retval = kernel_read(file, eppnt, j, &pos);
1239 if (retval != j)
1240 goto out_free_ph;
1241
1242 for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1243 if ((eppnt + i)->p_type == PT_LOAD)
1244 j++;
1245 if (j != 1)
1246 goto out_free_ph;
1247
1248 while (eppnt->p_type != PT_LOAD)
1249 eppnt++;
1250
1251
1252 error = vm_mmap(file,
1253 ELF_PAGESTART(eppnt->p_vaddr),
1254 (eppnt->p_filesz +
1255 ELF_PAGEOFFSET(eppnt->p_vaddr)),
1256 PROT_READ | PROT_WRITE | PROT_EXEC,
1257 MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_DENYWRITE,
1258 (eppnt->p_offset -
1259 ELF_PAGEOFFSET(eppnt->p_vaddr)));
1260 if (error != ELF_PAGESTART(eppnt->p_vaddr))
1261 goto out_free_ph;
1262
1263 elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1264 if (padzero(elf_bss)) {
1265 error = -EFAULT;
1266 goto out_free_ph;
1267 }
1268
1269 len = ELF_PAGEALIGN(eppnt->p_filesz + eppnt->p_vaddr);
1270 bss = ELF_PAGEALIGN(eppnt->p_memsz + eppnt->p_vaddr);
1271 if (bss > len) {
1272 error = vm_brk(len, bss - len);
1273 if (error)
1274 goto out_free_ph;
1275 }
1276 error = 0;
1277
1278out_free_ph:
1279 kfree(elf_phdata);
1280out:
1281 return error;
1282}
1283#endif
1284
1285#ifdef CONFIG_ELF_CORE
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301static bool always_dump_vma(struct vm_area_struct *vma)
1302{
1303
1304 if (vma == get_gate_vma(vma->vm_mm))
1305 return true;
1306
1307
1308
1309
1310
1311 if (vma->vm_ops && vma->vm_ops->name && vma->vm_ops->name(vma))
1312 return true;
1313
1314
1315
1316
1317
1318 if (arch_vma_name(vma))
1319 return true;
1320
1321 return false;
1322}
1323
1324
1325
1326
1327static unsigned long vma_dump_size(struct vm_area_struct *vma,
1328 unsigned long mm_flags)
1329{
1330#define FILTER(type) (mm_flags & (1UL << MMF_DUMP_##type))
1331
1332
1333 if (always_dump_vma(vma))
1334 goto whole;
1335
1336 if (vma->vm_flags & VM_DONTDUMP)
1337 return 0;
1338
1339
1340 if (vma_is_dax(vma)) {
1341 if ((vma->vm_flags & VM_SHARED) && FILTER(DAX_SHARED))
1342 goto whole;
1343 if (!(vma->vm_flags & VM_SHARED) && FILTER(DAX_PRIVATE))
1344 goto whole;
1345 return 0;
1346 }
1347
1348
1349 if (vma->vm_flags & VM_HUGETLB) {
1350 if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))
1351 goto whole;
1352 if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))
1353 goto whole;
1354 return 0;
1355 }
1356
1357
1358 if (vma->vm_flags & VM_IO)
1359 return 0;
1360
1361
1362 if (vma->vm_flags & VM_SHARED) {
1363 if (file_inode(vma->vm_file)->i_nlink == 0 ?
1364 FILTER(ANON_SHARED) : FILTER(MAPPED_SHARED))
1365 goto whole;
1366 return 0;
1367 }
1368
1369
1370 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1371 goto whole;
1372 if (vma->vm_file == NULL)
1373 return 0;
1374
1375 if (FILTER(MAPPED_PRIVATE))
1376 goto whole;
1377
1378
1379
1380
1381
1382
1383 if (FILTER(ELF_HEADERS) &&
1384 vma->vm_pgoff == 0 && (vma->vm_flags & VM_READ)) {
1385 u32 __user *header = (u32 __user *) vma->vm_start;
1386 u32 word;
1387 mm_segment_t fs = get_fs();
1388
1389
1390
1391 union {
1392 u32 cmp;
1393 char elfmag[SELFMAG];
1394 } magic;
1395 BUILD_BUG_ON(SELFMAG != sizeof word);
1396 magic.elfmag[EI_MAG0] = ELFMAG0;
1397 magic.elfmag[EI_MAG1] = ELFMAG1;
1398 magic.elfmag[EI_MAG2] = ELFMAG2;
1399 magic.elfmag[EI_MAG3] = ELFMAG3;
1400
1401
1402
1403
1404 set_fs(USER_DS);
1405 if (unlikely(get_user(word, header)))
1406 word = 0;
1407 set_fs(fs);
1408 if (word == magic.cmp)
1409 return PAGE_SIZE;
1410 }
1411
1412#undef FILTER
1413
1414 return 0;
1415
1416whole:
1417 return vma->vm_end - vma->vm_start;
1418}
1419
1420
1421struct memelfnote
1422{
1423 const char *name;
1424 int type;
1425 unsigned int datasz;
1426 void *data;
1427};
1428
1429static int notesize(struct memelfnote *en)
1430{
1431 int sz;
1432
1433 sz = sizeof(struct elf_note);
1434 sz += roundup(strlen(en->name) + 1, 4);
1435 sz += roundup(en->datasz, 4);
1436
1437 return sz;
1438}
1439
1440static int writenote(struct memelfnote *men, struct coredump_params *cprm)
1441{
1442 struct elf_note en;
1443 en.n_namesz = strlen(men->name) + 1;
1444 en.n_descsz = men->datasz;
1445 en.n_type = men->type;
1446
1447 return dump_emit(cprm, &en, sizeof(en)) &&
1448 dump_emit(cprm, men->name, en.n_namesz) && dump_align(cprm, 4) &&
1449 dump_emit(cprm, men->data, men->datasz) && dump_align(cprm, 4);
1450}
1451
1452static void fill_elf_header(struct elfhdr *elf, int segs,
1453 u16 machine, u32 flags)
1454{
1455 memset(elf, 0, sizeof(*elf));
1456
1457 memcpy(elf->e_ident, ELFMAG, SELFMAG);
1458 elf->e_ident[EI_CLASS] = ELF_CLASS;
1459 elf->e_ident[EI_DATA] = ELF_DATA;
1460 elf->e_ident[EI_VERSION] = EV_CURRENT;
1461 elf->e_ident[EI_OSABI] = ELF_OSABI;
1462
1463 elf->e_type = ET_CORE;
1464 elf->e_machine = machine;
1465 elf->e_version = EV_CURRENT;
1466 elf->e_phoff = sizeof(struct elfhdr);
1467 elf->e_flags = flags;
1468 elf->e_ehsize = sizeof(struct elfhdr);
1469 elf->e_phentsize = sizeof(struct elf_phdr);
1470 elf->e_phnum = segs;
1471}
1472
1473static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
1474{
1475 phdr->p_type = PT_NOTE;
1476 phdr->p_offset = offset;
1477 phdr->p_vaddr = 0;
1478 phdr->p_paddr = 0;
1479 phdr->p_filesz = sz;
1480 phdr->p_memsz = 0;
1481 phdr->p_flags = 0;
1482 phdr->p_align = 0;
1483}
1484
1485static void fill_note(struct memelfnote *note, const char *name, int type,
1486 unsigned int sz, void *data)
1487{
1488 note->name = name;
1489 note->type = type;
1490 note->datasz = sz;
1491 note->data = data;
1492}
1493
1494
1495
1496
1497
1498static void fill_prstatus(struct elf_prstatus *prstatus,
1499 struct task_struct *p, long signr)
1500{
1501 prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1502 prstatus->pr_sigpend = p->pending.signal.sig[0];
1503 prstatus->pr_sighold = p->blocked.sig[0];
1504 rcu_read_lock();
1505 prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1506 rcu_read_unlock();
1507 prstatus->pr_pid = task_pid_vnr(p);
1508 prstatus->pr_pgrp = task_pgrp_vnr(p);
1509 prstatus->pr_sid = task_session_vnr(p);
1510 if (thread_group_leader(p)) {
1511 struct task_cputime cputime;
1512
1513
1514
1515
1516
1517 thread_group_cputime(p, &cputime);
1518 prstatus->pr_utime = ns_to_timeval(cputime.utime);
1519 prstatus->pr_stime = ns_to_timeval(cputime.stime);
1520 } else {
1521 u64 utime, stime;
1522
1523 task_cputime(p, &utime, &stime);
1524 prstatus->pr_utime = ns_to_timeval(utime);
1525 prstatus->pr_stime = ns_to_timeval(stime);
1526 }
1527
1528 prstatus->pr_cutime = ns_to_timeval(p->signal->cutime);
1529 prstatus->pr_cstime = ns_to_timeval(p->signal->cstime);
1530}
1531
1532static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1533 struct mm_struct *mm)
1534{
1535 const struct cred *cred;
1536 unsigned int i, len;
1537
1538
1539 memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1540
1541 len = mm->arg_end - mm->arg_start;
1542 if (len >= ELF_PRARGSZ)
1543 len = ELF_PRARGSZ-1;
1544 if (copy_from_user(&psinfo->pr_psargs,
1545 (const char __user *)mm->arg_start, len))
1546 return -EFAULT;
1547 for(i = 0; i < len; i++)
1548 if (psinfo->pr_psargs[i] == 0)
1549 psinfo->pr_psargs[i] = ' ';
1550 psinfo->pr_psargs[len] = 0;
1551
1552 rcu_read_lock();
1553 psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1554 rcu_read_unlock();
1555 psinfo->pr_pid = task_pid_vnr(p);
1556 psinfo->pr_pgrp = task_pgrp_vnr(p);
1557 psinfo->pr_sid = task_session_vnr(p);
1558
1559 i = p->state ? ffz(~p->state) + 1 : 0;
1560 psinfo->pr_state = i;
1561 psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
1562 psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1563 psinfo->pr_nice = task_nice(p);
1564 psinfo->pr_flag = p->flags;
1565 rcu_read_lock();
1566 cred = __task_cred(p);
1567 SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
1568 SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
1569 rcu_read_unlock();
1570 strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1571
1572 return 0;
1573}
1574
1575static void fill_auxv_note(struct memelfnote *note, struct mm_struct *mm)
1576{
1577 elf_addr_t *auxv = (elf_addr_t *) mm->saved_auxv;
1578 int i = 0;
1579 do
1580 i += 2;
1581 while (auxv[i - 2] != AT_NULL);
1582 fill_note(note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);
1583}
1584
1585static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,
1586 const kernel_siginfo_t *siginfo)
1587{
1588 mm_segment_t old_fs = get_fs();
1589 set_fs(KERNEL_DS);
1590 copy_siginfo_to_user((user_siginfo_t __user *) csigdata, siginfo);
1591 set_fs(old_fs);
1592 fill_note(note, "CORE", NT_SIGINFO, sizeof(*csigdata), csigdata);
1593}
1594
1595#define MAX_FILE_NOTE_SIZE (4*1024*1024)
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607static int fill_files_note(struct memelfnote *note)
1608{
1609 struct vm_area_struct *vma;
1610 unsigned count, size, names_ofs, remaining, n;
1611 user_long_t *data;
1612 user_long_t *start_end_ofs;
1613 char *name_base, *name_curpos;
1614
1615
1616 count = current->mm->map_count;
1617 if (count > UINT_MAX / 64)
1618 return -EINVAL;
1619 size = count * 64;
1620
1621 names_ofs = (2 + 3 * count) * sizeof(data[0]);
1622 alloc:
1623 if (size >= MAX_FILE_NOTE_SIZE)
1624 return -EINVAL;
1625 size = round_up(size, PAGE_SIZE);
1626 data = kvmalloc(size, GFP_KERNEL);
1627 if (ZERO_OR_NULL_PTR(data))
1628 return -ENOMEM;
1629
1630 start_end_ofs = data + 2;
1631 name_base = name_curpos = ((char *)data) + names_ofs;
1632 remaining = size - names_ofs;
1633 count = 0;
1634 for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1635 struct file *file;
1636 const char *filename;
1637
1638 file = vma->vm_file;
1639 if (!file)
1640 continue;
1641 filename = file_path(file, name_curpos, remaining);
1642 if (IS_ERR(filename)) {
1643 if (PTR_ERR(filename) == -ENAMETOOLONG) {
1644 kvfree(data);
1645 size = size * 5 / 4;
1646 goto alloc;
1647 }
1648 continue;
1649 }
1650
1651
1652
1653 n = (name_curpos + remaining) - filename;
1654 remaining = filename - name_curpos;
1655 memmove(name_curpos, filename, n);
1656 name_curpos += n;
1657
1658 *start_end_ofs++ = vma->vm_start;
1659 *start_end_ofs++ = vma->vm_end;
1660 *start_end_ofs++ = vma->vm_pgoff;
1661 count++;
1662 }
1663
1664
1665 data[0] = count;
1666 data[1] = PAGE_SIZE;
1667
1668
1669
1670
1671 n = current->mm->map_count - count;
1672 if (n != 0) {
1673 unsigned shift_bytes = n * 3 * sizeof(data[0]);
1674 memmove(name_base - shift_bytes, name_base,
1675 name_curpos - name_base);
1676 name_curpos -= shift_bytes;
1677 }
1678
1679 size = name_curpos - (char *)data;
1680 fill_note(note, "CORE", NT_FILE, size, data);
1681 return 0;
1682}
1683
1684#ifdef CORE_DUMP_USE_REGSET
1685#include <linux/regset.h>
1686
1687struct elf_thread_core_info {
1688 struct elf_thread_core_info *next;
1689 struct task_struct *task;
1690 struct elf_prstatus prstatus;
1691 struct memelfnote notes[0];
1692};
1693
1694struct elf_note_info {
1695 struct elf_thread_core_info *thread;
1696 struct memelfnote psinfo;
1697 struct memelfnote signote;
1698 struct memelfnote auxv;
1699 struct memelfnote files;
1700 user_siginfo_t csigdata;
1701 size_t size;
1702 int thread_notes;
1703};
1704
1705
1706
1707
1708
1709
1710static void do_thread_regset_writeback(struct task_struct *task,
1711 const struct user_regset *regset)
1712{
1713 if (regset->writeback)
1714 regset->writeback(task, regset, 1);
1715}
1716
1717#ifndef PRSTATUS_SIZE
1718#define PRSTATUS_SIZE(S, R) sizeof(S)
1719#endif
1720
1721#ifndef SET_PR_FPVALID
1722#define SET_PR_FPVALID(S, V, R) ((S)->pr_fpvalid = (V))
1723#endif
1724
1725static int fill_thread_core_info(struct elf_thread_core_info *t,
1726 const struct user_regset_view *view,
1727 long signr, size_t *total)
1728{
1729 unsigned int i;
1730 unsigned int regset0_size = regset_size(t->task, &view->regsets[0]);
1731
1732
1733
1734
1735
1736
1737
1738 fill_prstatus(&t->prstatus, t->task, signr);
1739 (void) view->regsets[0].get(t->task, &view->regsets[0], 0, regset0_size,
1740 &t->prstatus.pr_reg, NULL);
1741
1742 fill_note(&t->notes[0], "CORE", NT_PRSTATUS,
1743 PRSTATUS_SIZE(t->prstatus, regset0_size), &t->prstatus);
1744 *total += notesize(&t->notes[0]);
1745
1746 do_thread_regset_writeback(t->task, &view->regsets[0]);
1747
1748
1749
1750
1751
1752
1753 for (i = 1; i < view->n; ++i) {
1754 const struct user_regset *regset = &view->regsets[i];
1755 do_thread_regset_writeback(t->task, regset);
1756 if (regset->core_note_type && regset->get &&
1757 (!regset->active || regset->active(t->task, regset) > 0)) {
1758 int ret;
1759 size_t size = regset_size(t->task, regset);
1760 void *data = kmalloc(size, GFP_KERNEL);
1761 if (unlikely(!data))
1762 return 0;
1763 ret = regset->get(t->task, regset,
1764 0, size, data, NULL);
1765 if (unlikely(ret))
1766 kfree(data);
1767 else {
1768 if (regset->core_note_type != NT_PRFPREG)
1769 fill_note(&t->notes[i], "LINUX",
1770 regset->core_note_type,
1771 size, data);
1772 else {
1773 SET_PR_FPVALID(&t->prstatus,
1774 1, regset0_size);
1775 fill_note(&t->notes[i], "CORE",
1776 NT_PRFPREG, size, data);
1777 }
1778 *total += notesize(&t->notes[i]);
1779 }
1780 }
1781 }
1782
1783 return 1;
1784}
1785
1786static int fill_note_info(struct elfhdr *elf, int phdrs,
1787 struct elf_note_info *info,
1788 const kernel_siginfo_t *siginfo, struct pt_regs *regs)
1789{
1790 struct task_struct *dump_task = current;
1791 const struct user_regset_view *view = task_user_regset_view(dump_task);
1792 struct elf_thread_core_info *t;
1793 struct elf_prpsinfo *psinfo;
1794 struct core_thread *ct;
1795 unsigned int i;
1796
1797 info->size = 0;
1798 info->thread = NULL;
1799
1800 psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
1801 if (psinfo == NULL) {
1802 info->psinfo.data = NULL;
1803 return 0;
1804 }
1805
1806 fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1807
1808
1809
1810
1811 info->thread_notes = 0;
1812 for (i = 0; i < view->n; ++i)
1813 if (view->regsets[i].core_note_type != 0)
1814 ++info->thread_notes;
1815
1816
1817
1818
1819
1820 if (unlikely(info->thread_notes == 0) ||
1821 unlikely(view->regsets[0].core_note_type != NT_PRSTATUS)) {
1822 WARN_ON(1);
1823 return 0;
1824 }
1825
1826
1827
1828
1829 fill_elf_header(elf, phdrs,
1830 view->e_machine, view->e_flags);
1831
1832
1833
1834
1835 for (ct = &dump_task->mm->core_state->dumper; ct; ct = ct->next) {
1836 t = kzalloc(offsetof(struct elf_thread_core_info,
1837 notes[info->thread_notes]),
1838 GFP_KERNEL);
1839 if (unlikely(!t))
1840 return 0;
1841
1842 t->task = ct->task;
1843 if (ct->task == dump_task || !info->thread) {
1844 t->next = info->thread;
1845 info->thread = t;
1846 } else {
1847
1848
1849
1850
1851 t->next = info->thread->next;
1852 info->thread->next = t;
1853 }
1854 }
1855
1856
1857
1858
1859 for (t = info->thread; t != NULL; t = t->next)
1860 if (!fill_thread_core_info(t, view, siginfo->si_signo, &info->size))
1861 return 0;
1862
1863
1864
1865
1866 fill_psinfo(psinfo, dump_task->group_leader, dump_task->mm);
1867 info->size += notesize(&info->psinfo);
1868
1869 fill_siginfo_note(&info->signote, &info->csigdata, siginfo);
1870 info->size += notesize(&info->signote);
1871
1872 fill_auxv_note(&info->auxv, current->mm);
1873 info->size += notesize(&info->auxv);
1874
1875 if (fill_files_note(&info->files) == 0)
1876 info->size += notesize(&info->files);
1877
1878 return 1;
1879}
1880
1881static size_t get_note_info_size(struct elf_note_info *info)
1882{
1883 return info->size;
1884}
1885
1886
1887
1888
1889
1890static int write_note_info(struct elf_note_info *info,
1891 struct coredump_params *cprm)
1892{
1893 bool first = true;
1894 struct elf_thread_core_info *t = info->thread;
1895
1896 do {
1897 int i;
1898
1899 if (!writenote(&t->notes[0], cprm))
1900 return 0;
1901
1902 if (first && !writenote(&info->psinfo, cprm))
1903 return 0;
1904 if (first && !writenote(&info->signote, cprm))
1905 return 0;
1906 if (first && !writenote(&info->auxv, cprm))
1907 return 0;
1908 if (first && info->files.data &&
1909 !writenote(&info->files, cprm))
1910 return 0;
1911
1912 for (i = 1; i < info->thread_notes; ++i)
1913 if (t->notes[i].data &&
1914 !writenote(&t->notes[i], cprm))
1915 return 0;
1916
1917 first = false;
1918 t = t->next;
1919 } while (t);
1920
1921 return 1;
1922}
1923
1924static void free_note_info(struct elf_note_info *info)
1925{
1926 struct elf_thread_core_info *threads = info->thread;
1927 while (threads) {
1928 unsigned int i;
1929 struct elf_thread_core_info *t = threads;
1930 threads = t->next;
1931 WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);
1932 for (i = 1; i < info->thread_notes; ++i)
1933 kfree(t->notes[i].data);
1934 kfree(t);
1935 }
1936 kfree(info->psinfo.data);
1937 kvfree(info->files.data);
1938}
1939
1940#else
1941
1942
1943struct elf_thread_status
1944{
1945 struct list_head list;
1946 struct elf_prstatus prstatus;
1947 elf_fpregset_t fpu;
1948 struct task_struct *thread;
1949#ifdef ELF_CORE_COPY_XFPREGS
1950 elf_fpxregset_t xfpu;
1951#endif
1952 struct memelfnote notes[3];
1953 int num_notes;
1954};
1955
1956
1957
1958
1959
1960
1961static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1962{
1963 int sz = 0;
1964 struct task_struct *p = t->thread;
1965 t->num_notes = 0;
1966
1967 fill_prstatus(&t->prstatus, p, signr);
1968 elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1969
1970 fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1971 &(t->prstatus));
1972 t->num_notes++;
1973 sz += notesize(&t->notes[0]);
1974
1975 if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1976 &t->fpu))) {
1977 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1978 &(t->fpu));
1979 t->num_notes++;
1980 sz += notesize(&t->notes[1]);
1981 }
1982
1983#ifdef ELF_CORE_COPY_XFPREGS
1984 if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
1985 fill_note(&t->notes[2], "LINUX", ELF_CORE_XFPREG_TYPE,
1986 sizeof(t->xfpu), &t->xfpu);
1987 t->num_notes++;
1988 sz += notesize(&t->notes[2]);
1989 }
1990#endif
1991 return sz;
1992}
1993
1994struct elf_note_info {
1995 struct memelfnote *notes;
1996 struct memelfnote *notes_files;
1997 struct elf_prstatus *prstatus;
1998 struct elf_prpsinfo *psinfo;
1999 struct list_head thread_list;
2000 elf_fpregset_t *fpu;
2001#ifdef ELF_CORE_COPY_XFPREGS
2002 elf_fpxregset_t *xfpu;
2003#endif
2004 user_siginfo_t csigdata;
2005 int thread_status_size;
2006 int numnote;
2007};
2008
2009static int elf_note_info_init(struct elf_note_info *info)
2010{
2011 memset(info, 0, sizeof(*info));
2012 INIT_LIST_HEAD(&info->thread_list);
2013
2014
2015 info->notes = kmalloc_array(8, sizeof(struct memelfnote), GFP_KERNEL);
2016 if (!info->notes)
2017 return 0;
2018 info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL);
2019 if (!info->psinfo)
2020 return 0;
2021 info->prstatus = kmalloc(sizeof(*info->prstatus), GFP_KERNEL);
2022 if (!info->prstatus)
2023 return 0;
2024 info->fpu = kmalloc(sizeof(*info->fpu), GFP_KERNEL);
2025 if (!info->fpu)
2026 return 0;
2027#ifdef ELF_CORE_COPY_XFPREGS
2028 info->xfpu = kmalloc(sizeof(*info->xfpu), GFP_KERNEL);
2029 if (!info->xfpu)
2030 return 0;
2031#endif
2032 return 1;
2033}
2034
2035static int fill_note_info(struct elfhdr *elf, int phdrs,
2036 struct elf_note_info *info,
2037 const kernel_siginfo_t *siginfo, struct pt_regs *regs)
2038{
2039 struct core_thread *ct;
2040 struct elf_thread_status *ets;
2041
2042 if (!elf_note_info_init(info))
2043 return 0;
2044
2045 for (ct = current->mm->core_state->dumper.next;
2046 ct; ct = ct->next) {
2047 ets = kzalloc(sizeof(*ets), GFP_KERNEL);
2048 if (!ets)
2049 return 0;
2050
2051 ets->thread = ct->task;
2052 list_add(&ets->list, &info->thread_list);
2053 }
2054
2055 list_for_each_entry(ets, &info->thread_list, list) {
2056 int sz;
2057
2058 sz = elf_dump_thread_status(siginfo->si_signo, ets);
2059 info->thread_status_size += sz;
2060 }
2061
2062 memset(info->prstatus, 0, sizeof(*info->prstatus));
2063 fill_prstatus(info->prstatus, current, siginfo->si_signo);
2064 elf_core_copy_regs(&info->prstatus->pr_reg, regs);
2065
2066
2067 fill_elf_header(elf, phdrs, ELF_ARCH, ELF_CORE_EFLAGS);
2068
2069
2070
2071
2072
2073
2074 fill_note(info->notes + 0, "CORE", NT_PRSTATUS,
2075 sizeof(*info->prstatus), info->prstatus);
2076 fill_psinfo(info->psinfo, current->group_leader, current->mm);
2077 fill_note(info->notes + 1, "CORE", NT_PRPSINFO,
2078 sizeof(*info->psinfo), info->psinfo);
2079
2080 fill_siginfo_note(info->notes + 2, &info->csigdata, siginfo);
2081 fill_auxv_note(info->notes + 3, current->mm);
2082 info->numnote = 4;
2083
2084 if (fill_files_note(info->notes + info->numnote) == 0) {
2085 info->notes_files = info->notes + info->numnote;
2086 info->numnote++;
2087 }
2088
2089
2090 info->prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs,
2091 info->fpu);
2092 if (info->prstatus->pr_fpvalid)
2093 fill_note(info->notes + info->numnote++,
2094 "CORE", NT_PRFPREG, sizeof(*info->fpu), info->fpu);
2095#ifdef ELF_CORE_COPY_XFPREGS
2096 if (elf_core_copy_task_xfpregs(current, info->xfpu))
2097 fill_note(info->notes + info->numnote++,
2098 "LINUX", ELF_CORE_XFPREG_TYPE,
2099 sizeof(*info->xfpu), info->xfpu);
2100#endif
2101
2102 return 1;
2103}
2104
2105static size_t get_note_info_size(struct elf_note_info *info)
2106{
2107 int sz = 0;
2108 int i;
2109
2110 for (i = 0; i < info->numnote; i++)
2111 sz += notesize(info->notes + i);
2112
2113 sz += info->thread_status_size;
2114
2115 return sz;
2116}
2117
2118static int write_note_info(struct elf_note_info *info,
2119 struct coredump_params *cprm)
2120{
2121 struct elf_thread_status *ets;
2122 int i;
2123
2124 for (i = 0; i < info->numnote; i++)
2125 if (!writenote(info->notes + i, cprm))
2126 return 0;
2127
2128
2129 list_for_each_entry(ets, &info->thread_list, list) {
2130 for (i = 0; i < ets->num_notes; i++)
2131 if (!writenote(&ets->notes[i], cprm))
2132 return 0;
2133 }
2134
2135 return 1;
2136}
2137
2138static void free_note_info(struct elf_note_info *info)
2139{
2140 while (!list_empty(&info->thread_list)) {
2141 struct list_head *tmp = info->thread_list.next;
2142 list_del(tmp);
2143 kfree(list_entry(tmp, struct elf_thread_status, list));
2144 }
2145
2146
2147 if (info->notes_files)
2148 kvfree(info->notes_files->data);
2149
2150 kfree(info->prstatus);
2151 kfree(info->psinfo);
2152 kfree(info->notes);
2153 kfree(info->fpu);
2154#ifdef ELF_CORE_COPY_XFPREGS
2155 kfree(info->xfpu);
2156#endif
2157}
2158
2159#endif
2160
2161static struct vm_area_struct *first_vma(struct task_struct *tsk,
2162 struct vm_area_struct *gate_vma)
2163{
2164 struct vm_area_struct *ret = tsk->mm->mmap;
2165
2166 if (ret)
2167 return ret;
2168 return gate_vma;
2169}
2170
2171
2172
2173
2174static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
2175 struct vm_area_struct *gate_vma)
2176{
2177 struct vm_area_struct *ret;
2178
2179 ret = this_vma->vm_next;
2180 if (ret)
2181 return ret;
2182 if (this_vma == gate_vma)
2183 return NULL;
2184 return gate_vma;
2185}
2186
2187static void fill_extnum_info(struct elfhdr *elf, struct elf_shdr *shdr4extnum,
2188 elf_addr_t e_shoff, int segs)
2189{
2190 elf->e_shoff = e_shoff;
2191 elf->e_shentsize = sizeof(*shdr4extnum);
2192 elf->e_shnum = 1;
2193 elf->e_shstrndx = SHN_UNDEF;
2194
2195 memset(shdr4extnum, 0, sizeof(*shdr4extnum));
2196
2197 shdr4extnum->sh_type = SHT_NULL;
2198 shdr4extnum->sh_size = elf->e_shnum;
2199 shdr4extnum->sh_link = elf->e_shstrndx;
2200 shdr4extnum->sh_info = segs;
2201}
2202
2203
2204
2205
2206
2207
2208
2209
2210static int elf_core_dump(struct coredump_params *cprm)
2211{
2212 int has_dumped = 0;
2213 mm_segment_t fs;
2214 int segs, i;
2215 size_t vma_data_size = 0;
2216 struct vm_area_struct *vma, *gate_vma;
2217 struct elfhdr *elf = NULL;
2218 loff_t offset = 0, dataoff;
2219 struct elf_note_info info = { };
2220 struct elf_phdr *phdr4note = NULL;
2221 struct elf_shdr *shdr4extnum = NULL;
2222 Elf_Half e_phnum;
2223 elf_addr_t e_shoff;
2224 elf_addr_t *vma_filesz = NULL;
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239 elf = kmalloc(sizeof(*elf), GFP_KERNEL);
2240 if (!elf)
2241 goto out;
2242
2243
2244
2245
2246 segs = current->mm->map_count;
2247 segs += elf_core_extra_phdrs();
2248
2249 gate_vma = get_gate_vma(current->mm);
2250 if (gate_vma != NULL)
2251 segs++;
2252
2253
2254 segs++;
2255
2256
2257
2258
2259 e_phnum = segs > PN_XNUM ? PN_XNUM : segs;
2260
2261
2262
2263
2264
2265 if (!fill_note_info(elf, e_phnum, &info, cprm->siginfo, cprm->regs))
2266 goto cleanup;
2267
2268 has_dumped = 1;
2269
2270 fs = get_fs();
2271 set_fs(KERNEL_DS);
2272
2273 offset += sizeof(*elf);
2274 offset += segs * sizeof(struct elf_phdr);
2275
2276
2277 {
2278 size_t sz = get_note_info_size(&info);
2279
2280 sz += elf_coredump_extra_notes_size();
2281
2282 phdr4note = kmalloc(sizeof(*phdr4note), GFP_KERNEL);
2283 if (!phdr4note)
2284 goto end_coredump;
2285
2286 fill_elf_note_phdr(phdr4note, sz, offset);
2287 offset += sz;
2288 }
2289
2290 dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
2291
2292 if (segs - 1 > ULONG_MAX / sizeof(*vma_filesz))
2293 goto end_coredump;
2294 vma_filesz = kvmalloc(array_size(sizeof(*vma_filesz), (segs - 1)),
2295 GFP_KERNEL);
2296 if (ZERO_OR_NULL_PTR(vma_filesz))
2297 goto end_coredump;
2298
2299 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2300 vma = next_vma(vma, gate_vma)) {
2301 unsigned long dump_size;
2302
2303 dump_size = vma_dump_size(vma, cprm->mm_flags);
2304 vma_filesz[i++] = dump_size;
2305 vma_data_size += dump_size;
2306 }
2307
2308 offset += vma_data_size;
2309 offset += elf_core_extra_data_size();
2310 e_shoff = offset;
2311
2312 if (e_phnum == PN_XNUM) {
2313 shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);
2314 if (!shdr4extnum)
2315 goto end_coredump;
2316 fill_extnum_info(elf, shdr4extnum, e_shoff, segs);
2317 }
2318
2319 offset = dataoff;
2320
2321 if (!dump_emit(cprm, elf, sizeof(*elf)))
2322 goto end_coredump;
2323
2324 if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note)))
2325 goto end_coredump;
2326
2327
2328 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2329 vma = next_vma(vma, gate_vma)) {
2330 struct elf_phdr phdr;
2331
2332 phdr.p_type = PT_LOAD;
2333 phdr.p_offset = offset;
2334 phdr.p_vaddr = vma->vm_start;
2335 phdr.p_paddr = 0;
2336 phdr.p_filesz = vma_filesz[i++];
2337 phdr.p_memsz = vma->vm_end - vma->vm_start;
2338 offset += phdr.p_filesz;
2339 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
2340 if (vma->vm_flags & VM_WRITE)
2341 phdr.p_flags |= PF_W;
2342 if (vma->vm_flags & VM_EXEC)
2343 phdr.p_flags |= PF_X;
2344 phdr.p_align = ELF_EXEC_PAGESIZE;
2345
2346 if (!dump_emit(cprm, &phdr, sizeof(phdr)))
2347 goto end_coredump;
2348 }
2349
2350 if (!elf_core_write_extra_phdrs(cprm, offset))
2351 goto end_coredump;
2352
2353
2354 if (!write_note_info(&info, cprm))
2355 goto end_coredump;
2356
2357 if (elf_coredump_extra_notes_write(cprm))
2358 goto end_coredump;
2359
2360
2361 if (!dump_skip(cprm, dataoff - cprm->pos))
2362 goto end_coredump;
2363
2364 for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2365 vma = next_vma(vma, gate_vma)) {
2366 unsigned long addr;
2367 unsigned long end;
2368
2369 end = vma->vm_start + vma_filesz[i++];
2370
2371 for (addr = vma->vm_start; addr < end; addr += PAGE_SIZE) {
2372 struct page *page;
2373 int stop;
2374
2375 page = get_dump_page(addr);
2376 if (page) {
2377 void *kaddr = kmap(page);
2378 stop = !dump_emit(cprm, kaddr, PAGE_SIZE);
2379 kunmap(page);
2380 put_page(page);
2381 } else
2382 stop = !dump_skip(cprm, PAGE_SIZE);
2383 if (stop)
2384 goto end_coredump;
2385 }
2386 }
2387 dump_truncate(cprm);
2388
2389 if (!elf_core_write_extra_data(cprm))
2390 goto end_coredump;
2391
2392 if (e_phnum == PN_XNUM) {
2393 if (!dump_emit(cprm, shdr4extnum, sizeof(*shdr4extnum)))
2394 goto end_coredump;
2395 }
2396
2397end_coredump:
2398 set_fs(fs);
2399
2400cleanup:
2401 free_note_info(&info);
2402 kfree(shdr4extnum);
2403 kvfree(vma_filesz);
2404 kfree(phdr4note);
2405 kfree(elf);
2406out:
2407 return has_dumped;
2408}
2409
2410#endif
2411
2412static int __init init_elf_binfmt(void)
2413{
2414 register_binfmt(&elf_format);
2415 return 0;
2416}
2417
2418static void __exit exit_elf_binfmt(void)
2419{
2420
2421 unregister_binfmt(&elf_format);
2422}
2423
2424core_initcall(init_elf_binfmt);
2425module_exit(exit_elf_binfmt);
2426MODULE_LICENSE("GPL");
2427