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 (!permission(bprm.inode, MAY_EXEC) ||
635 (!(bprm.inode->i_mode & 0111) && fsuser())) {
636 retval = -EACCES;
637 goto exec_error2;
638 }
639 memset(bprm.buf,0,sizeof(bprm.buf));
640 old_fs = get_fs();
641 set_fs(get_ds());
642 retval = read_exec(bprm.inode,0,bprm.buf,128);
643 set_fs(old_fs);
644 if (retval < 0)
645 goto exec_error2;
646 if ((bprm.buf[0] == '#') && (bprm.buf[1] == '!') && (!sh_bang)) {
647
648
649
650
651
652 char *cp, *interp, *i_name, *i_arg;
653
654 iput(bprm.inode);
655 bprm.buf[127] = '\0';
656 if ((cp = strchr(bprm.buf, '\n')) == NULL)
657 cp = bprm.buf+127;
658 *cp = '\0';
659 while (cp > bprm.buf) {
660 cp--;
661 if ((*cp == ' ') || (*cp == '\t'))
662 *cp = '\0';
663 else
664 break;
665 }
666 for (cp = bprm.buf+2; (*cp == ' ') || (*cp == '\t'); cp++);
667 if (!cp || *cp == '\0') {
668 retval = -ENOEXEC;
669 goto exec_error1;
670 }
671 interp = i_name = cp;
672 i_arg = 0;
673 for ( ; *cp && (*cp != ' ') && (*cp != '\t'); cp++) {
674 if (*cp == '/')
675 i_name = cp+1;
676 }
677 while ((*cp == ' ') || (*cp == '\t'))
678 *cp++ = '\0';
679 if (*cp)
680 i_arg = cp;
681
682
683
684
685 if (sh_bang++ == 0) {
686 bprm.p = copy_strings(bprm.envc, envp, bprm.page, bprm.p, 0);
687 bprm.p = copy_strings(--bprm.argc, argv+1, bprm.page, bprm.p, 0);
688 }
689
690
691
692
693
694
695
696
697 bprm.p = copy_strings(1, &bprm.filename, bprm.page, bprm.p, 2);
698 bprm.argc++;
699 if (i_arg) {
700 bprm.p = copy_strings(1, &i_arg, bprm.page, bprm.p, 2);
701 bprm.argc++;
702 }
703 bprm.p = copy_strings(1, &i_name, bprm.page, bprm.p, 2);
704 bprm.argc++;
705 if (!bprm.p) {
706 retval = -E2BIG;
707 goto exec_error1;
708 }
709
710
711
712
713
714 retval = open_namei(interp, 0, 0, &bprm.inode, NULL);
715 if (retval)
716 goto exec_error1;
717 goto restart_interp;
718 }
719 if (!sh_bang) {
720 bprm.p = copy_strings(bprm.envc,envp,bprm.page,bprm.p,0);
721 bprm.p = copy_strings(bprm.argc,argv,bprm.page,bprm.p,0);
722 if (!bprm.p) {
723 retval = -E2BIG;
724 goto exec_error2;
725 }
726 }
727
728 bprm.sh_bang = sh_bang;
729 for (fmt = formats ; fmt ; fmt = fmt->next) {
730 int (*fn)(struct linux_binprm *, struct pt_regs *) = fmt->load_binary;
731 if (!fn)
732 break;
733 retval = fn(&bprm, regs);
734 if (retval >= 0) {
735 iput(bprm.inode);
736 current->did_exec = 1;
737 return retval;
738 }
739 if (retval != -ENOEXEC)
740 break;
741 }
742 exec_error2:
743 iput(bprm.inode);
744 exec_error1:
745 for (i=0 ; i<MAX_ARG_PAGES ; i++)
746 free_page(bprm.page[i]);
747 return(retval);
748 }
749
750
751
752
753 asmlinkage int sys_execve(struct pt_regs regs)
754 {
755 int error;
756 char * filename;
757
758 error = getname((char *) regs.ebx, &filename);
759 if (error)
760 return error;
761 error = do_execve(filename, (char **) regs.ecx, (char **) regs.edx, ®s);
762 putname(filename);
763 return error;
764 }
765
766 static void set_brk(unsigned long start, unsigned long end)
767 {
768 start = PAGE_ALIGN(start);
769 end = PAGE_ALIGN(end);
770 if (end <= start)
771 return;
772 do_mmap(NULL, start, end - start,
773 PROT_READ | PROT_WRITE | PROT_EXEC,
774 MAP_FIXED | MAP_PRIVATE, 0);
775 }
776
777
778
779
780
781
782 static int load_aout_binary(struct linux_binprm * bprm, struct pt_regs * regs)
783 {
784 struct exec ex;
785 struct file * file;
786 int fd, error;
787 unsigned long p = bprm->p;
788 unsigned long fd_offset;
789
790 ex = *((struct exec *) bprm->buf);
791 if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != OMAGIC &&
792 N_MAGIC(ex) != QMAGIC) ||
793 ex.a_trsize || ex.a_drsize ||
794 bprm->inode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
795 return -ENOEXEC;
796 }
797
798 current->personality = PER_LINUX;
799 fd_offset = N_TXTOFF(ex);
800 if (N_MAGIC(ex) == ZMAGIC && fd_offset != BLOCK_SIZE) {
801 printk(KERN_NOTICE "N_TXTOFF != BLOCK_SIZE. See a.out.h.\n");
802 return -ENOEXEC;
803 }
804
805 if (N_MAGIC(ex) == ZMAGIC && ex.a_text &&
806 (fd_offset < bprm->inode->i_sb->s_blocksize)) {
807 printk(KERN_NOTICE "N_TXTOFF < BLOCK_SIZE. Please convert binary.\n");
808 return -ENOEXEC;
809 }
810
811
812 flush_old_exec(bprm);
813
814 current->mm->brk = ex.a_bss +
815 (current->mm->start_brk =
816 (current->mm->end_data = ex.a_data +
817 (current->mm->end_code = ex.a_text +
818 (current->mm->start_code = N_TXTADDR(ex)))));
819 current->mm->rss = 0;
820 current->mm->mmap = NULL;
821 current->suid = current->euid = current->fsuid = bprm->e_uid;
822 current->sgid = current->egid = current->fsgid = bprm->e_gid;
823 if (N_MAGIC(ex) == OMAGIC) {
824 do_mmap(NULL, 0, ex.a_text+ex.a_data,
825 PROT_READ|PROT_WRITE|PROT_EXEC,
826 MAP_FIXED|MAP_PRIVATE, 0);
827 read_exec(bprm->inode, 32, (char *) 0, ex.a_text+ex.a_data);
828 } else {
829 if (ex.a_text & 0xfff || ex.a_data & 0xfff)
830 printk(KERN_NOTICE "executable not page aligned\n");
831
832 fd = open_inode(bprm->inode, O_RDONLY);
833
834 if (fd < 0)
835 return fd;
836 file = current->files->fd[fd];
837 if (!file->f_op || !file->f_op->mmap) {
838 sys_close(fd);
839 do_mmap(NULL, 0, ex.a_text+ex.a_data,
840 PROT_READ|PROT_WRITE|PROT_EXEC,
841 MAP_FIXED|MAP_PRIVATE, 0);
842 read_exec(bprm->inode, fd_offset,
843 (char *) N_TXTADDR(ex), ex.a_text+ex.a_data);
844 goto beyond_if;
845 }
846
847 if (ex.a_text) {
848 error = do_mmap(file, N_TXTADDR(ex), ex.a_text,
849 PROT_READ | PROT_EXEC,
850 MAP_FIXED | MAP_SHARED | MAP_DENYWRITE | MAP_EXECUTABLE,
851 fd_offset);
852
853 if (error != N_TXTADDR(ex)) {
854 sys_close(fd);
855 send_sig(SIGSEGV, current, 0);
856 return -EINVAL;
857 }
858 }
859
860 error = do_mmap(file, N_TXTADDR(ex) + ex.a_text, ex.a_data,
861 PROT_READ | PROT_WRITE | PROT_EXEC,
862 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE,
863 fd_offset + ex.a_text);
864 sys_close(fd);
865 if (error != N_TXTADDR(ex) + ex.a_text) {
866 send_sig(SIGSEGV, current, 0);
867 return -EINVAL;
868 }
869 }
870 beyond_if:
871 if (current->exec_domain && current->exec_domain->use_count)
872 (*current->exec_domain->use_count)--;
873 if (current->binfmt && current->binfmt->use_count)
874 (*current->binfmt->use_count)--;
875 current->exec_domain = lookup_exec_domain(current->personality);
876 current->binfmt = &aout_format;
877 if (current->exec_domain && current->exec_domain->use_count)
878 (*current->exec_domain->use_count)++;
879 if (current->binfmt && current->binfmt->use_count)
880 (*current->binfmt->use_count)++;
881
882 set_brk(current->mm->start_brk, current->mm->brk);
883
884 p += change_ldt(ex.a_text,bprm->page);
885 p -= MAX_ARG_PAGES*PAGE_SIZE;
886 p = (unsigned long)create_tables((char *)p,
887 bprm->argc, bprm->envc,
888 current->personality != PER_LINUX);
889 current->mm->start_stack = p;
890 regs->eip = ex.a_entry;
891 regs->esp = p;
892 if (current->flags & PF_PTRACED)
893 send_sig(SIGTRAP, current, 0);
894 return 0;
895 }
896
897
898 static int load_aout_library(int fd)
899 {
900 struct file * file;
901 struct exec ex;
902 struct inode * inode;
903 unsigned int len;
904 unsigned int bss;
905 unsigned int start_addr;
906 int error;
907
908 file = current->files->fd[fd];
909 inode = file->f_inode;
910
911 set_fs(KERNEL_DS);
912 if (file->f_op->read(inode, file, (char *) &ex, sizeof(ex)) != sizeof(ex)) {
913 return -EACCES;
914 }
915 set_fs(USER_DS);
916
917
918 if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != QMAGIC) || ex.a_trsize ||
919 ex.a_drsize || ((ex.a_entry & 0xfff) && N_MAGIC(ex) == ZMAGIC) ||
920 inode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
921 return -ENOEXEC;
922 }
923 if (N_MAGIC(ex) == ZMAGIC && N_TXTOFF(ex) &&
924 (N_TXTOFF(ex) < inode->i_sb->s_blocksize)) {
925 printk("N_TXTOFF < BLOCK_SIZE. Please convert library\n");
926 return -ENOEXEC;
927 }
928
929 if (N_FLAGS(ex)) return -ENOEXEC;
930
931
932
933
934 start_addr = ex.a_entry & 0xfffff000;
935
936
937 error = do_mmap(file, start_addr, ex.a_text + ex.a_data,
938 PROT_READ | PROT_WRITE | PROT_EXEC,
939 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
940 N_TXTOFF(ex));
941 if (error != start_addr)
942 return error;
943 len = PAGE_ALIGN(ex.a_text + ex.a_data);
944 bss = ex.a_text + ex.a_data + ex.a_bss;
945 if (bss > len)
946 do_mmap(NULL, start_addr + len, bss-len,
947 PROT_READ|PROT_WRITE|PROT_EXEC,
948 MAP_PRIVATE|MAP_FIXED, 0);
949 return 0;
950 }