This source file includes following definitions.
- register_binfmt
- unregister_binfmt
- open_inode
- aout_core_dump
- sys_uselib
- create_tables
- count
- copy_strings
- change_ldt
- read_exec
- flush_old_exec
- do_execve
- sys_execve
- set_brk
- load_aout_binary
- load_aout_library
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 #include <linux/fs.h>
27 #include <linux/sched.h>
28 #include <linux/kernel.h>
29 #include <linux/mm.h>
30 #include <linux/mman.h>
31 #include <linux/a.out.h>
32 #include <linux/errno.h>
33 #include <linux/signal.h>
34 #include <linux/string.h>
35 #include <linux/stat.h>
36 #include <linux/fcntl.h>
37 #include <linux/ptrace.h>
38 #include <linux/user.h>
39 #include <linux/segment.h>
40 #include <linux/malloc.h>
41
42 #include <asm/system.h>
43
44 #include <linux/binfmts.h>
45 #include <linux/personality.h>
46
47 #include <asm/segment.h>
48 #include <asm/system.h>
49
50 asmlinkage int sys_exit(int exit_code);
51 asmlinkage int sys_brk(unsigned long);
52
53 extern void shm_exit (void);
54
55 static int load_aout_binary(struct linux_binprm *, struct pt_regs * regs);
56 static int load_aout_library(int fd);
57 static int aout_core_dump(long signr, struct pt_regs * regs);
58
59
60
61
62
63 extern struct linux_binfmt elf_format;
64
65 static struct linux_binfmt aout_format = {
66 #ifndef CONFIG_BINFMT_ELF
67 NULL, NULL, load_aout_binary, load_aout_library, aout_core_dump
68 #else
69 &elf_format, NULL, load_aout_binary, load_aout_library, aout_core_dump
70 #endif
71 };
72
73 static struct linux_binfmt *formats = &aout_format;
74
75 int register_binfmt(struct linux_binfmt * fmt)
76 {
77 struct linux_binfmt ** tmp = &formats;
78
79 if (!fmt)
80 return -EINVAL;
81 if (fmt->next)
82 return -EBUSY;
83 while (*tmp) {
84 if (fmt == *tmp)
85 return -EBUSY;
86 tmp = &(*tmp)->next;
87 }
88 *tmp = fmt;
89 return 0;
90 }
91
92 int unregister_binfmt(struct linux_binfmt * fmt)
93 {
94 struct linux_binfmt ** tmp = &formats;
95
96 while (*tmp) {
97 if (fmt == *tmp) {
98 *tmp = fmt->next;
99 return 0;
100 }
101 tmp = &(*tmp)->next;
102 }
103 return -EINVAL;
104 }
105
106 int open_inode(struct inode * inode, int mode)
107 {
108 int error, fd;
109 struct file *f, **fpp;
110
111 if (!inode->i_op || !inode->i_op->default_file_ops)
112 return -EINVAL;
113 f = get_empty_filp();
114 if (!f)
115 return -EMFILE;
116 fd = 0;
117 fpp = current->files->fd;
118 for (;;) {
119 if (!*fpp)
120 break;
121 if (++fd > NR_OPEN)
122 return -ENFILE;
123 fpp++;
124 }
125 *fpp = f;
126 f->f_flags = mode;
127 f->f_mode = (mode+1) & O_ACCMODE;
128 f->f_inode = inode;
129 f->f_pos = 0;
130 f->f_reada = 0;
131 f->f_op = inode->i_op->default_file_ops;
132 if (f->f_op->open) {
133 error = f->f_op->open(inode,f);
134 if (error) {
135 *fpp = NULL;
136 f->f_count--;
137 return error;
138 }
139 }
140 inode->i_count++;
141 return fd;
142 }
143
144
145
146
147
148 #define DUMP_WRITE(addr,nr) \
149 while (file.f_op->write(inode,&file,(char *)(addr),(nr)) != (nr)) goto close_coredump
150
151 #define DUMP_SEEK(offset) \
152 if (file.f_op->lseek) { \
153 if (file.f_op->lseek(inode,&file,(offset),0) != (offset)) \
154 goto close_coredump; \
155 } else file.f_pos = (offset)
156
157
158
159
160
161
162
163
164
165
166 static int aout_core_dump(long signr, struct pt_regs * regs)
167 {
168 struct inode * inode = NULL;
169 struct file file;
170 unsigned short fs;
171 int has_dumped = 0;
172 char corefile[6+sizeof(current->comm)];
173 int i;
174 register int dump_start, dump_size;
175 struct user dump;
176
177 if (!current->dumpable)
178 return 0;
179 current->dumpable = 0;
180
181
182 if (current->rlim[RLIMIT_CORE].rlim_cur < PAGE_SIZE)
183 return 0;
184 fs = get_fs();
185 set_fs(KERNEL_DS);
186 memcpy(corefile,"core.",5);
187 #if 0
188 memcpy(corefile+5,current->comm,sizeof(current->comm));
189 #else
190 corefile[4] = '\0';
191 #endif
192 if (open_namei(corefile,O_CREAT | 2 | O_TRUNC,0600,&inode,NULL)) {
193 inode = NULL;
194 goto end_coredump;
195 }
196 if (!S_ISREG(inode->i_mode))
197 goto end_coredump;
198 if (!inode->i_op || !inode->i_op->default_file_ops)
199 goto end_coredump;
200 file.f_mode = 3;
201 file.f_flags = 0;
202 file.f_count = 1;
203 file.f_inode = inode;
204 file.f_pos = 0;
205 file.f_reada = 0;
206 file.f_op = inode->i_op->default_file_ops;
207 if (file.f_op->open)
208 if (file.f_op->open(inode,&file))
209 goto end_coredump;
210 if (!file.f_op->write)
211 goto close_coredump;
212 has_dumped = 1;
213
214 dump.magic = CMAGIC;
215 dump.start_code = 0;
216 dump.start_stack = regs->esp & ~(PAGE_SIZE - 1);
217 dump.u_tsize = ((unsigned long) current->mm->end_code) >> 12;
218 dump.u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1))) >> 12;
219 dump.u_dsize -= dump.u_tsize;
220 dump.u_ssize = 0;
221 for(i=0; i<8; i++) dump.u_debugreg[i] = current->debugreg[i];
222 if (dump.start_stack < TASK_SIZE)
223 dump.u_ssize = ((unsigned long) (TASK_SIZE - dump.start_stack)) >> 12;
224
225
226 if ((dump.u_dsize+dump.u_ssize+1) * PAGE_SIZE >
227 current->rlim[RLIMIT_CORE].rlim_cur)
228 dump.u_dsize = 0;
229
230 if ((dump.u_ssize+1) * PAGE_SIZE >
231 current->rlim[RLIMIT_CORE].rlim_cur)
232 dump.u_ssize = 0;
233 strncpy(dump.u_comm, current->comm, sizeof(current->comm));
234 dump.u_ar0 = (struct pt_regs *)(((int)(&dump.regs)) -((int)(&dump)));
235 dump.signal = signr;
236 dump.regs = *regs;
237
238
239 if (hard_math) {
240 if ((dump.u_fpvalid = current->used_math) != 0) {
241 if (last_task_used_math == current)
242 __asm__("clts ; fnsave %0": :"m" (dump.i387));
243 else
244 memcpy(&dump.i387,¤t->tss.i387.hard,sizeof(dump.i387));
245 }
246 } else {
247
248
249 dump.u_fpvalid = 0;
250 }
251 set_fs(KERNEL_DS);
252
253 DUMP_WRITE(&dump,sizeof(dump));
254
255 DUMP_SEEK(PAGE_SIZE);
256
257 set_fs(USER_DS);
258
259 if (dump.u_dsize != 0) {
260 dump_start = dump.u_tsize << 12;
261 dump_size = dump.u_dsize << 12;
262 DUMP_WRITE(dump_start,dump_size);
263 }
264
265 if (dump.u_ssize != 0) {
266 dump_start = dump.start_stack;
267 dump_size = dump.u_ssize << 12;
268 DUMP_WRITE(dump_start,dump_size);
269 }
270
271 set_fs(KERNEL_DS);
272 DUMP_WRITE(current,sizeof(*current));
273 close_coredump:
274 if (file.f_op->release)
275 file.f_op->release(inode,&file);
276 end_coredump:
277 set_fs(fs);
278 iput(inode);
279 return has_dumped;
280 }
281
282
283
284
285
286
287
288 asmlinkage int sys_uselib(const char * library)
289 {
290 int fd, retval;
291 struct file * file;
292 struct linux_binfmt * fmt;
293
294 fd = sys_open(library, 0, 0);
295 if (fd < 0)
296 return fd;
297 file = current->files->fd[fd];
298 retval = -ENOEXEC;
299 if (file && file->f_inode && file->f_op && file->f_op->read) {
300 for (fmt = formats ; fmt ; fmt = fmt->next) {
301 int (*fn)(int) = fmt->load_shlib;
302 if (!fn)
303 break;
304 retval = fn(fd);
305 if (retval != -ENOEXEC)
306 break;
307 }
308 }
309 sys_close(fd);
310 return retval;
311 }
312
313
314
315
316
317
318 unsigned long * create_tables(char * p,int argc,int envc,int ibcs)
319 {
320 unsigned long *argv,*envp;
321 unsigned long * sp;
322 struct vm_area_struct *mpnt;
323
324 mpnt = (struct vm_area_struct *)kmalloc(sizeof(*mpnt), GFP_KERNEL);
325 if (mpnt) {
326 mpnt->vm_task = current;
327 mpnt->vm_start = PAGE_MASK & (unsigned long) p;
328 mpnt->vm_end = TASK_SIZE;
329 mpnt->vm_page_prot = PAGE_PRIVATE|PAGE_DIRTY;
330 mpnt->vm_flags = VM_STACK_FLAGS;
331 mpnt->vm_share = NULL;
332 mpnt->vm_ops = NULL;
333 mpnt->vm_offset = 0;
334 mpnt->vm_inode = NULL;
335 mpnt->vm_pte = 0;
336 insert_vm_struct(current, mpnt);
337 }
338 sp = (unsigned long *) (0xfffffffc & (unsigned long) p);
339 sp -= envc+1;
340 envp = sp;
341 sp -= argc+1;
342 argv = sp;
343 if (!ibcs) {
344 put_fs_long((unsigned long)envp,--sp);
345 put_fs_long((unsigned long)argv,--sp);
346 }
347 put_fs_long((unsigned long)argc,--sp);
348 current->mm->arg_start = (unsigned long) p;
349 while (argc-->0) {
350 put_fs_long((unsigned long) p,argv++);
351 while (get_fs_byte(p++)) ;
352 }
353 put_fs_long(0,argv);
354 current->mm->arg_end = current->mm->env_start = (unsigned long) p;
355 while (envc-->0) {
356 put_fs_long((unsigned long) p,envp++);
357 while (get_fs_byte(p++)) ;
358 }
359 put_fs_long(0,envp);
360 current->mm->env_end = (unsigned long) p;
361 return sp;
362 }
363
364
365
366
367 static int count(char ** argv)
368 {
369 int i=0;
370 char ** tmp;
371
372 if ((tmp = argv) != 0)
373 while (get_fs_long((unsigned long *) (tmp++)))
374 i++;
375
376 return i;
377 }
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396 unsigned long copy_strings(int argc,char ** argv,unsigned long *page,
397 unsigned long p, int from_kmem)
398 {
399 char *tmp, *pag = NULL;
400 int len, offset = 0;
401 unsigned long old_fs, new_fs;
402
403 if (!p)
404 return 0;
405 new_fs = get_ds();
406 old_fs = get_fs();
407 if (from_kmem==2)
408 set_fs(new_fs);
409 while (argc-- > 0) {
410 if (from_kmem == 1)
411 set_fs(new_fs);
412 if (!(tmp = (char *)get_fs_long(((unsigned long *)argv)+argc)))
413 panic("VFS: argc is wrong");
414 if (from_kmem == 1)
415 set_fs(old_fs);
416 len=0;
417 do {
418 len++;
419 } while (get_fs_byte(tmp++));
420 if (p < len) {
421 set_fs(old_fs);
422 return 0;
423 }
424 while (len) {
425 --p; --tmp; --len;
426 if (--offset < 0) {
427 offset = p % PAGE_SIZE;
428 if (from_kmem==2)
429 set_fs(old_fs);
430 if (!(pag = (char *) page[p/PAGE_SIZE]) &&
431 !(pag = (char *) page[p/PAGE_SIZE] =
432 (unsigned long *) get_free_page(GFP_USER)))
433 return 0;
434 if (from_kmem==2)
435 set_fs(new_fs);
436
437 }
438 *(pag + offset) = get_fs_byte(tmp);
439 }
440 }
441 if (from_kmem==2)
442 set_fs(old_fs);
443 return p;
444 }
445
446 unsigned long change_ldt(unsigned long text_size,unsigned long * page)
447 {
448 unsigned long code_limit,data_limit,code_base,data_base;
449 int i;
450
451 code_limit = TASK_SIZE;
452 data_limit = TASK_SIZE;
453 code_base = data_base = 0;
454 current->mm->start_code = code_base;
455 data_base += data_limit;
456 for (i=MAX_ARG_PAGES-1 ; i>=0 ; i--) {
457 data_base -= PAGE_SIZE;
458 if (page[i]) {
459 current->mm->rss++;
460 put_dirty_page(current,page[i],data_base);
461 }
462 }
463 return data_limit;
464 }
465
466
467
468
469
470
471 int read_exec(struct inode *inode, unsigned long offset,
472 char * addr, unsigned long count)
473 {
474 struct file file;
475 int result = -ENOEXEC;
476
477 if (!inode->i_op || !inode->i_op->default_file_ops)
478 goto end_readexec;
479 file.f_mode = 1;
480 file.f_flags = 0;
481 file.f_count = 1;
482 file.f_inode = inode;
483 file.f_pos = 0;
484 file.f_reada = 0;
485 file.f_op = inode->i_op->default_file_ops;
486 if (file.f_op->open)
487 if (file.f_op->open(inode,&file))
488 goto end_readexec;
489 if (!file.f_op || !file.f_op->read)
490 goto close_readexec;
491 if (file.f_op->lseek) {
492 if (file.f_op->lseek(inode,&file,offset,0) != offset)
493 goto close_readexec;
494 } else
495 file.f_pos = offset;
496 if (get_fs() == USER_DS) {
497 result = verify_area(VERIFY_WRITE, addr, count);
498 if (result)
499 goto close_readexec;
500 }
501 result = file.f_op->read(inode, &file, addr, count);
502 close_readexec:
503 if (file.f_op->release)
504 file.f_op->release(inode,&file);
505 end_readexec:
506 return result;
507 }
508
509
510
511
512
513
514
515 void flush_old_exec(struct linux_binprm * bprm)
516 {
517 int i;
518 int ch;
519 char * name;
520 struct vm_area_struct * mpnt, *mpnt1;
521
522 current->dumpable = 1;
523 name = bprm->filename;
524 for (i=0; (ch = *(name++)) != '\0';) {
525 if (ch == '/')
526 i = 0;
527 else
528 if (i < 15)
529 current->comm[i++] = ch;
530 }
531 current->comm[i] = '\0';
532 if (current->shm)
533 shm_exit();
534
535
536 mpnt = current->mm->mmap;
537 current->mm->mmap = NULL;
538 while (mpnt) {
539 mpnt1 = mpnt->vm_next;
540 if (mpnt->vm_ops && mpnt->vm_ops->close)
541 mpnt->vm_ops->close(mpnt);
542 if (mpnt->vm_inode)
543 iput(mpnt->vm_inode);
544 kfree(mpnt);
545 mpnt = mpnt1;
546 }
547
548
549 if (current->ldt) {
550 free_page((unsigned long) current->ldt);
551 current->ldt = NULL;
552 for (i=1 ; i<NR_TASKS ; i++) {
553 if (task[i] == current) {
554 set_ldt_desc(gdt+(i<<1)+
555 FIRST_LDT_ENTRY,&default_ldt, 1);
556 load_ldt(i);
557 }
558 }
559 }
560
561 for (i=0 ; i<8 ; i++) current->debugreg[i] = 0;
562
563 if (bprm->e_uid != current->euid || bprm->e_gid != current->egid ||
564 !permission(bprm->inode,MAY_READ))
565 current->dumpable = 0;
566 current->signal = 0;
567 for (i=0 ; i<32 ; i++) {
568 current->sigaction[i].sa_mask = 0;
569 current->sigaction[i].sa_flags = 0;
570 if (current->sigaction[i].sa_handler != SIG_IGN)
571 current->sigaction[i].sa_handler = NULL;
572 }
573 for (i=0 ; i<NR_OPEN ; i++)
574 if (FD_ISSET(i,¤t->files->close_on_exec))
575 sys_close(i);
576 FD_ZERO(¤t->files->close_on_exec);
577 clear_page_tables(current);
578 if (last_task_used_math == current)
579 last_task_used_math = NULL;
580 current->used_math = 0;
581 }
582
583
584
585
586 int do_execve(char * filename, char ** argv, char ** envp, struct pt_regs * regs)
587 {
588 struct linux_binprm bprm;
589 struct linux_binfmt * fmt;
590 unsigned long old_fs;
591 int i;
592 int retval;
593 int sh_bang = 0;
594
595 if (regs->cs != USER_CS)
596 return -EINVAL;
597 bprm.p = PAGE_SIZE*MAX_ARG_PAGES-4;
598 for (i=0 ; i<MAX_ARG_PAGES ; i++)
599 bprm.page[i] = 0;
600 retval = open_namei(filename, 0, 0, &bprm.inode, NULL);
601 if (retval)
602 return retval;
603 bprm.filename = filename;
604 bprm.argc = count(argv);
605 bprm.envc = count(envp);
606
607 restart_interp:
608 if (!S_ISREG(bprm.inode->i_mode)) {
609 retval = -EACCES;
610 goto exec_error2;
611 }
612 if (IS_NOEXEC(bprm.inode)) {
613 retval = -EPERM;
614 goto exec_error2;
615 }
616 if (!bprm.inode->i_sb) {
617 retval = -EACCES;
618 goto exec_error2;
619 }
620 i = bprm.inode->i_mode;
621 if (IS_NOSUID(bprm.inode) && (((i & S_ISUID) && bprm.inode->i_uid != current->
622 euid) || ((i & S_ISGID) && !in_group_p(bprm.inode->i_gid))) && !suser()) {
623 retval = -EPERM;
624 goto exec_error2;
625 }
626
627 if (current->flags & PF_PTRACED) {
628 bprm.e_uid = current->euid;
629 bprm.e_gid = current->egid;
630 } else {
631 bprm.e_uid = (i & S_ISUID) ? bprm.inode->i_uid : current->euid;
632 bprm.e_gid = (i & S_ISGID) ? bprm.inode->i_gid : current->egid;
633 }
634 if (current->euid == bprm.inode->i_uid)
635 i >>= 6;
636 else if (in_group_p(bprm.inode->i_gid))
637 i >>= 3;
638 if (!(i & 1) &&
639 !((bprm.inode->i_mode & 0111) && suser())) {
640 retval = -EACCES;
641 goto exec_error2;
642 }
643 memset(bprm.buf,0,sizeof(bprm.buf));
644 old_fs = get_fs();
645 set_fs(get_ds());
646 retval = read_exec(bprm.inode,0,bprm.buf,128);
647 set_fs(old_fs);
648 if (retval < 0)
649 goto exec_error2;
650 if ((bprm.buf[0] == '#') && (bprm.buf[1] == '!') && (!sh_bang)) {
651
652
653
654
655
656 char *cp, *interp, *i_name, *i_arg;
657
658 iput(bprm.inode);
659 bprm.buf[127] = '\0';
660 if ((cp = strchr(bprm.buf, '\n')) == NULL)
661 cp = bprm.buf+127;
662 *cp = '\0';
663 while (cp > bprm.buf) {
664 cp--;
665 if ((*cp == ' ') || (*cp == '\t'))
666 *cp = '\0';
667 else
668 break;
669 }
670 for (cp = bprm.buf+2; (*cp == ' ') || (*cp == '\t'); cp++);
671 if (!cp || *cp == '\0') {
672 retval = -ENOEXEC;
673 goto exec_error1;
674 }
675 interp = i_name = cp;
676 i_arg = 0;
677 for ( ; *cp && (*cp != ' ') && (*cp != '\t'); cp++) {
678 if (*cp == '/')
679 i_name = cp+1;
680 }
681 while ((*cp == ' ') || (*cp == '\t'))
682 *cp++ = '\0';
683 if (*cp)
684 i_arg = cp;
685
686
687
688
689 if (sh_bang++ == 0) {
690 bprm.p = copy_strings(bprm.envc, envp, bprm.page, bprm.p, 0);
691 bprm.p = copy_strings(--bprm.argc, argv+1, bprm.page, bprm.p, 0);
692 }
693
694
695
696
697
698
699
700
701 bprm.p = copy_strings(1, &bprm.filename, bprm.page, bprm.p, 2);
702 bprm.argc++;
703 if (i_arg) {
704 bprm.p = copy_strings(1, &i_arg, bprm.page, bprm.p, 2);
705 bprm.argc++;
706 }
707 bprm.p = copy_strings(1, &i_name, bprm.page, bprm.p, 2);
708 bprm.argc++;
709 if (!bprm.p) {
710 retval = -E2BIG;
711 goto exec_error1;
712 }
713
714
715
716
717
718 retval = open_namei(interp, 0, 0, &bprm.inode, NULL);
719 if (retval)
720 goto exec_error1;
721 goto restart_interp;
722 }
723 if (!sh_bang) {
724 bprm.p = copy_strings(bprm.envc,envp,bprm.page,bprm.p,0);
725 bprm.p = copy_strings(bprm.argc,argv,bprm.page,bprm.p,0);
726 if (!bprm.p) {
727 retval = -E2BIG;
728 goto exec_error2;
729 }
730 }
731
732 bprm.sh_bang = sh_bang;
733 for (fmt = formats ; fmt ; fmt = fmt->next) {
734 int (*fn)(struct linux_binprm *, struct pt_regs *) = fmt->load_binary;
735 if (!fn)
736 break;
737 retval = fn(&bprm, regs);
738 if (retval >= 0) {
739 iput(bprm.inode);
740 current->did_exec = 1;
741 return retval;
742 }
743 if (retval != -ENOEXEC)
744 break;
745 }
746 exec_error2:
747 iput(bprm.inode);
748 exec_error1:
749 for (i=0 ; i<MAX_ARG_PAGES ; i++)
750 free_page(bprm.page[i]);
751 return(retval);
752 }
753
754
755
756
757 asmlinkage int sys_execve(struct pt_regs regs)
758 {
759 int error;
760 char * filename;
761
762 error = getname((char *) regs.ebx, &filename);
763 if (error)
764 return error;
765 error = do_execve(filename, (char **) regs.ecx, (char **) regs.edx, ®s);
766 putname(filename);
767 return error;
768 }
769
770 static void set_brk(unsigned long start, unsigned long end)
771 {
772 start = PAGE_ALIGN(start);
773 end = PAGE_ALIGN(end);
774 if (end <= start)
775 return;
776 do_mmap(NULL, start, end - start,
777 PROT_READ | PROT_WRITE | PROT_EXEC,
778 MAP_FIXED | MAP_PRIVATE, 0);
779 }
780
781
782
783
784
785
786 static int load_aout_binary(struct linux_binprm * bprm, struct pt_regs * regs)
787 {
788 struct exec ex;
789 struct file * file;
790 int fd, error;
791 unsigned long p = bprm->p;
792 unsigned long fd_offset;
793
794 ex = *((struct exec *) bprm->buf);
795 if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != OMAGIC &&
796 N_MAGIC(ex) != QMAGIC) ||
797 ex.a_trsize || ex.a_drsize ||
798 bprm->inode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
799 return -ENOEXEC;
800 }
801
802 current->personality = PER_LINUX;
803 fd_offset = N_TXTOFF(ex);
804 if (N_MAGIC(ex) == ZMAGIC && fd_offset != BLOCK_SIZE) {
805 printk(KERN_NOTICE "N_TXTOFF != BLOCK_SIZE. See a.out.h.\n");
806 return -ENOEXEC;
807 }
808
809 if (N_MAGIC(ex) == ZMAGIC && ex.a_text &&
810 (fd_offset < bprm->inode->i_sb->s_blocksize)) {
811 printk(KERN_NOTICE "N_TXTOFF < BLOCK_SIZE. Please convert binary.\n");
812 return -ENOEXEC;
813 }
814
815
816 flush_old_exec(bprm);
817
818 current->mm->brk = ex.a_bss +
819 (current->mm->start_brk =
820 (current->mm->end_data = ex.a_data +
821 (current->mm->end_code = ex.a_text +
822 (current->mm->start_code = N_TXTADDR(ex)))));
823 current->mm->rss = 0;
824 current->mm->mmap = NULL;
825 current->suid = current->euid = current->fsuid = bprm->e_uid;
826 current->sgid = current->egid = current->fsgid = bprm->e_gid;
827 if (N_MAGIC(ex) == OMAGIC) {
828 do_mmap(NULL, 0, ex.a_text+ex.a_data,
829 PROT_READ|PROT_WRITE|PROT_EXEC,
830 MAP_FIXED|MAP_PRIVATE, 0);
831 read_exec(bprm->inode, 32, (char *) 0, ex.a_text+ex.a_data);
832 } else {
833 if (ex.a_text & 0xfff || ex.a_data & 0xfff)
834 printk(KERN_NOTICE "executable not page aligned\n");
835
836 fd = open_inode(bprm->inode, O_RDONLY);
837
838 if (fd < 0)
839 return fd;
840 file = current->files->fd[fd];
841 if (!file->f_op || !file->f_op->mmap) {
842 sys_close(fd);
843 do_mmap(NULL, 0, ex.a_text+ex.a_data,
844 PROT_READ|PROT_WRITE|PROT_EXEC,
845 MAP_FIXED|MAP_PRIVATE, 0);
846 read_exec(bprm->inode, fd_offset,
847 (char *) N_TXTADDR(ex), ex.a_text+ex.a_data);
848 goto beyond_if;
849 }
850
851 if (ex.a_text) {
852 error = do_mmap(file, N_TXTADDR(ex), ex.a_text,
853 PROT_READ | PROT_EXEC,
854 MAP_FIXED | MAP_SHARED | MAP_DENYWRITE | MAP_EXECUTABLE,
855 fd_offset);
856
857 if (error != N_TXTADDR(ex)) {
858 sys_close(fd);
859 send_sig(SIGSEGV, current, 0);
860 return -EINVAL;
861 }
862 }
863
864 error = do_mmap(file, N_TXTADDR(ex) + ex.a_text, ex.a_data,
865 PROT_READ | PROT_WRITE | PROT_EXEC,
866 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE,
867 fd_offset + ex.a_text);
868 sys_close(fd);
869 if (error != N_TXTADDR(ex) + ex.a_text) {
870 send_sig(SIGSEGV, current, 0);
871 return -EINVAL;
872 }
873 }
874 beyond_if:
875 if (current->exec_domain && current->exec_domain->use_count)
876 (*current->exec_domain->use_count)--;
877 if (current->binfmt && current->binfmt->use_count)
878 (*current->binfmt->use_count)--;
879 current->exec_domain = lookup_exec_domain(current->personality);
880 current->binfmt = &aout_format;
881 if (current->exec_domain && current->exec_domain->use_count)
882 (*current->exec_domain->use_count)++;
883 if (current->binfmt && current->binfmt->use_count)
884 (*current->binfmt->use_count)++;
885
886 set_brk(current->mm->start_brk, current->mm->brk);
887
888 p += change_ldt(ex.a_text,bprm->page);
889 p -= MAX_ARG_PAGES*PAGE_SIZE;
890 p = (unsigned long)create_tables((char *)p,
891 bprm->argc, bprm->envc,
892 current->personality != PER_LINUX);
893 current->mm->start_stack = p;
894 regs->eip = ex.a_entry;
895 regs->esp = p;
896 if (current->flags & PF_PTRACED)
897 send_sig(SIGTRAP, current, 0);
898 return 0;
899 }
900
901
902 static int load_aout_library(int fd)
903 {
904 struct file * file;
905 struct exec ex;
906 struct inode * inode;
907 unsigned int len;
908 unsigned int bss;
909 unsigned int start_addr;
910 int error;
911
912 file = current->files->fd[fd];
913 inode = file->f_inode;
914
915 set_fs(KERNEL_DS);
916 if (file->f_op->read(inode, file, (char *) &ex, sizeof(ex)) != sizeof(ex)) {
917 return -EACCES;
918 }
919 set_fs(USER_DS);
920
921
922 if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != QMAGIC) || ex.a_trsize ||
923 ex.a_drsize || ((ex.a_entry & 0xfff) && N_MAGIC(ex) == ZMAGIC) ||
924 inode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
925 return -ENOEXEC;
926 }
927 if (N_MAGIC(ex) == ZMAGIC && N_TXTOFF(ex) &&
928 (N_TXTOFF(ex) < inode->i_sb->s_blocksize)) {
929 printk("N_TXTOFF < BLOCK_SIZE. Please convert library\n");
930 return -ENOEXEC;
931 }
932
933 if (N_FLAGS(ex)) return -ENOEXEC;
934
935
936
937
938 start_addr = ex.a_entry & 0xfffff000;
939
940
941 error = do_mmap(file, start_addr, ex.a_text + ex.a_data,
942 PROT_READ | PROT_WRITE | PROT_EXEC,
943 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
944 N_TXTOFF(ex));
945 if (error != start_addr)
946 return error;
947 len = PAGE_ALIGN(ex.a_text + ex.a_data);
948 bss = ex.a_text + ex.a_data + ex.a_bss;
949 if (bss > len)
950 do_mmap(NULL, start_addr + len, bss-len,
951 PROT_READ|PROT_WRITE|PROT_EXEC,
952 MAP_PRIVATE|MAP_FIXED, 0);
953 return 0;
954 }