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