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 static int load_aout_binary(struct linux_binprm *, struct pt_regs * regs);
54 static int load_aout_library(int fd);
55 static int aout_core_dump(long signr, struct pt_regs * regs);
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 int i;
172 register int dump_start, dump_size;
173 struct user dump;
174
175 if (!current->dumpable)
176 return 0;
177 current->dumpable = 0;
178
179
180 if (current->rlim[RLIMIT_CORE].rlim_cur < PAGE_SIZE)
181 return 0;
182 fs = get_fs();
183 set_fs(KERNEL_DS);
184 memcpy(corefile,"core.",5);
185 #if 0
186 memcpy(corefile+5,current->comm,sizeof(current->comm));
187 #else
188 corefile[4] = '\0';
189 #endif
190 if (open_namei(corefile,O_CREAT | 2 | O_TRUNC,0600,&inode,NULL)) {
191 inode = NULL;
192 goto end_coredump;
193 }
194 if (!S_ISREG(inode->i_mode))
195 goto end_coredump;
196 if (!inode->i_op || !inode->i_op->default_file_ops)
197 goto end_coredump;
198 if (get_write_access(inode))
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 done_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 done_coredump:
277 put_write_access(inode);
278 end_coredump:
279 set_fs(fs);
280 iput(inode);
281 return has_dumped;
282 }
283
284
285
286
287
288
289
290 asmlinkage int sys_uselib(const char * library)
291 {
292 int fd, retval;
293 struct file * file;
294 struct linux_binfmt * fmt;
295
296 fd = sys_open(library, 0, 0);
297 if (fd < 0)
298 return fd;
299 file = current->files->fd[fd];
300 retval = -ENOEXEC;
301 if (file && file->f_inode && file->f_op && file->f_op->read) {
302 for (fmt = formats ; fmt ; fmt = fmt->next) {
303 int (*fn)(int) = fmt->load_shlib;
304 if (!fn)
305 break;
306 retval = fn(fd);
307 if (retval != -ENOEXEC)
308 break;
309 }
310 }
311 sys_close(fd);
312 return retval;
313 }
314
315
316
317
318
319
320 unsigned long * create_tables(char * p,int argc,int envc,int ibcs)
321 {
322 unsigned long *argv,*envp;
323 unsigned long * sp;
324 struct vm_area_struct *mpnt;
325
326 mpnt = (struct vm_area_struct *)kmalloc(sizeof(*mpnt), GFP_KERNEL);
327 if (mpnt) {
328 mpnt->vm_task = current;
329 mpnt->vm_start = PAGE_MASK & (unsigned long) p;
330 mpnt->vm_end = TASK_SIZE;
331 mpnt->vm_page_prot = PAGE_PRIVATE|PAGE_DIRTY;
332 mpnt->vm_flags = VM_STACK_FLAGS;
333 mpnt->vm_share = NULL;
334 mpnt->vm_ops = NULL;
335 mpnt->vm_offset = 0;
336 mpnt->vm_inode = NULL;
337 mpnt->vm_pte = 0;
338 insert_vm_struct(current, mpnt);
339 }
340 sp = (unsigned long *) (0xfffffffc & (unsigned long) p);
341 sp -= envc+1;
342 envp = sp;
343 sp -= argc+1;
344 argv = sp;
345 if (!ibcs) {
346 put_fs_long((unsigned long)envp,--sp);
347 put_fs_long((unsigned long)argv,--sp);
348 }
349 put_fs_long((unsigned long)argc,--sp);
350 current->mm->arg_start = (unsigned long) p;
351 while (argc-->0) {
352 put_fs_long((unsigned long) p,argv++);
353 while (get_fs_byte(p++)) ;
354 }
355 put_fs_long(0,argv);
356 current->mm->arg_end = current->mm->env_start = (unsigned long) p;
357 while (envc-->0) {
358 put_fs_long((unsigned long) p,envp++);
359 while (get_fs_byte(p++)) ;
360 }
361 put_fs_long(0,envp);
362 current->mm->env_end = (unsigned long) p;
363 return sp;
364 }
365
366
367
368
369 static int count(char ** argv)
370 {
371 int i=0;
372 char ** tmp;
373
374 if ((tmp = argv) != 0)
375 while (get_fs_long((unsigned long *) (tmp++)))
376 i++;
377
378 return i;
379 }
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398 unsigned long copy_strings(int argc,char ** argv,unsigned long *page,
399 unsigned long p, int from_kmem)
400 {
401 char *tmp, *pag = NULL;
402 int len, offset = 0;
403 unsigned long old_fs, new_fs;
404
405 if (!p)
406 return 0;
407 new_fs = get_ds();
408 old_fs = get_fs();
409 if (from_kmem==2)
410 set_fs(new_fs);
411 while (argc-- > 0) {
412 if (from_kmem == 1)
413 set_fs(new_fs);
414 if (!(tmp = (char *)get_fs_long(((unsigned long *)argv)+argc)))
415 panic("VFS: argc is wrong");
416 if (from_kmem == 1)
417 set_fs(old_fs);
418 len=0;
419 do {
420 len++;
421 } while (get_fs_byte(tmp++));
422 if (p < len) {
423 set_fs(old_fs);
424 return 0;
425 }
426 while (len) {
427 --p; --tmp; --len;
428 if (--offset < 0) {
429 offset = p % PAGE_SIZE;
430 if (from_kmem==2)
431 set_fs(old_fs);
432 if (!(pag = (char *) page[p/PAGE_SIZE]) &&
433 !(pag = (char *) page[p/PAGE_SIZE] =
434 (unsigned long *) get_free_page(GFP_USER)))
435 return 0;
436 if (from_kmem==2)
437 set_fs(new_fs);
438
439 }
440 *(pag + offset) = get_fs_byte(tmp);
441 }
442 }
443 if (from_kmem==2)
444 set_fs(old_fs);
445 return p;
446 }
447
448 unsigned long change_ldt(unsigned long text_size,unsigned long * page)
449 {
450 unsigned long code_limit,data_limit,code_base,data_base;
451 int i;
452
453 code_limit = TASK_SIZE;
454 data_limit = TASK_SIZE;
455 code_base = data_base = 0;
456 current->mm->start_code = code_base;
457 data_base += data_limit;
458 for (i=MAX_ARG_PAGES-1 ; i>=0 ; i--) {
459 data_base -= PAGE_SIZE;
460 if (page[i]) {
461 current->mm->rss++;
462 put_dirty_page(current,page[i],data_base);
463 }
464 }
465 return data_limit;
466 }
467
468
469
470
471
472
473 int read_exec(struct inode *inode, unsigned long offset,
474 char * addr, unsigned long count)
475 {
476 struct file file;
477 int result = -ENOEXEC;
478
479 if (!inode->i_op || !inode->i_op->default_file_ops)
480 goto end_readexec;
481 file.f_mode = 1;
482 file.f_flags = 0;
483 file.f_count = 1;
484 file.f_inode = inode;
485 file.f_pos = 0;
486 file.f_reada = 0;
487 file.f_op = inode->i_op->default_file_ops;
488 if (file.f_op->open)
489 if (file.f_op->open(inode,&file))
490 goto end_readexec;
491 if (!file.f_op || !file.f_op->read)
492 goto close_readexec;
493 if (file.f_op->lseek) {
494 if (file.f_op->lseek(inode,&file,offset,0) != offset)
495 goto close_readexec;
496 } else
497 file.f_pos = offset;
498 if (get_fs() == USER_DS) {
499 result = verify_area(VERIFY_WRITE, addr, count);
500 if (result)
501 goto close_readexec;
502 }
503 result = file.f_op->read(inode, &file, addr, count);
504 close_readexec:
505 if (file.f_op->release)
506 file.f_op->release(inode,&file);
507 end_readexec:
508 return result;
509 }
510
511
512
513
514
515
516
517 void flush_old_exec(struct linux_binprm * bprm)
518 {
519 int i;
520 int ch;
521 char * name;
522 struct vm_area_struct * mpnt, *mpnt1;
523
524 current->dumpable = 1;
525 name = bprm->filename;
526 for (i=0; (ch = *(name++)) != '\0';) {
527 if (ch == '/')
528 i = 0;
529 else
530 if (i < 15)
531 current->comm[i++] = ch;
532 }
533 current->comm[i] = '\0';
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
640 if (bprm.inode->i_wcount > 0) {
641 retval = -ETXTBSY;
642 goto exec_error2;
643 }
644 memset(bprm.buf,0,sizeof(bprm.buf));
645 old_fs = get_fs();
646 set_fs(get_ds());
647 retval = read_exec(bprm.inode,0,bprm.buf,128);
648 set_fs(old_fs);
649 if (retval < 0)
650 goto exec_error2;
651 if ((bprm.buf[0] == '#') && (bprm.buf[1] == '!') && (!sh_bang)) {
652
653
654
655
656
657 char *cp, *interp, *i_name, *i_arg;
658
659 iput(bprm.inode);
660 bprm.buf[127] = '\0';
661 if ((cp = strchr(bprm.buf, '\n')) == NULL)
662 cp = bprm.buf+127;
663 *cp = '\0';
664 while (cp > bprm.buf) {
665 cp--;
666 if ((*cp == ' ') || (*cp == '\t'))
667 *cp = '\0';
668 else
669 break;
670 }
671 for (cp = bprm.buf+2; (*cp == ' ') || (*cp == '\t'); cp++);
672 if (!cp || *cp == '\0') {
673 retval = -ENOEXEC;
674 goto exec_error1;
675 }
676 interp = i_name = cp;
677 i_arg = 0;
678 for ( ; *cp && (*cp != ' ') && (*cp != '\t'); cp++) {
679 if (*cp == '/')
680 i_name = cp+1;
681 }
682 while ((*cp == ' ') || (*cp == '\t'))
683 *cp++ = '\0';
684 if (*cp)
685 i_arg = cp;
686
687
688
689
690 if (sh_bang++ == 0) {
691 bprm.p = copy_strings(bprm.envc, envp, bprm.page, bprm.p, 0);
692 bprm.p = copy_strings(--bprm.argc, argv+1, bprm.page, bprm.p, 0);
693 }
694
695
696
697
698
699
700
701
702 bprm.p = copy_strings(1, &bprm.filename, bprm.page, bprm.p, 2);
703 bprm.argc++;
704 if (i_arg) {
705 bprm.p = copy_strings(1, &i_arg, bprm.page, bprm.p, 2);
706 bprm.argc++;
707 }
708 bprm.p = copy_strings(1, &i_name, bprm.page, bprm.p, 2);
709 bprm.argc++;
710 if (!bprm.p) {
711 retval = -E2BIG;
712 goto exec_error1;
713 }
714
715
716
717
718
719 retval = open_namei(interp, 0, 0, &bprm.inode, NULL);
720 if (retval)
721 goto exec_error1;
722 goto restart_interp;
723 }
724 if (!sh_bang) {
725 bprm.p = copy_strings(bprm.envc,envp,bprm.page,bprm.p,0);
726 bprm.p = copy_strings(bprm.argc,argv,bprm.page,bprm.p,0);
727 if (!bprm.p) {
728 retval = -E2BIG;
729 goto exec_error2;
730 }
731 }
732
733 bprm.sh_bang = sh_bang;
734 for (fmt = formats ; fmt ; fmt = fmt->next) {
735 int (*fn)(struct linux_binprm *, struct pt_regs *) = fmt->load_binary;
736 if (!fn)
737 break;
738 retval = fn(&bprm, regs);
739 if (retval >= 0) {
740 iput(bprm.inode);
741 current->did_exec = 1;
742 return retval;
743 }
744 if (retval != -ENOEXEC)
745 break;
746 }
747 exec_error2:
748 iput(bprm.inode);
749 exec_error1:
750 for (i=0 ; i<MAX_ARG_PAGES ; i++)
751 free_page(bprm.page[i]);
752 return(retval);
753 }
754
755
756
757
758 asmlinkage int sys_execve(struct pt_regs regs)
759 {
760 int error;
761 char * filename;
762
763 error = getname((char *) regs.ebx, &filename);
764 if (error)
765 return error;
766 error = do_execve(filename, (char **) regs.ecx, (char **) regs.edx, ®s);
767 putname(filename);
768 return error;
769 }
770
771 static void set_brk(unsigned long start, unsigned long end)
772 {
773 start = PAGE_ALIGN(start);
774 end = PAGE_ALIGN(end);
775 if (end <= start)
776 return;
777 do_mmap(NULL, start, end - start,
778 PROT_READ | PROT_WRITE | PROT_EXEC,
779 MAP_FIXED | MAP_PRIVATE, 0);
780 }
781
782
783
784
785
786
787 static int load_aout_binary(struct linux_binprm * bprm, struct pt_regs * regs)
788 {
789 struct exec ex;
790 struct file * file;
791 int fd, error;
792 unsigned long p = bprm->p;
793 unsigned long fd_offset;
794
795 ex = *((struct exec *) bprm->buf);
796 if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != OMAGIC &&
797 N_MAGIC(ex) != QMAGIC) ||
798 ex.a_trsize || ex.a_drsize ||
799 bprm->inode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
800 return -ENOEXEC;
801 }
802
803 current->personality = PER_LINUX;
804 fd_offset = N_TXTOFF(ex);
805 if (N_MAGIC(ex) == ZMAGIC && fd_offset != BLOCK_SIZE) {
806 printk(KERN_NOTICE "N_TXTOFF != BLOCK_SIZE. See a.out.h.\n");
807 return -ENOEXEC;
808 }
809
810 if (N_MAGIC(ex) == ZMAGIC && ex.a_text &&
811 (fd_offset < bprm->inode->i_sb->s_blocksize)) {
812 printk(KERN_NOTICE "N_TXTOFF < BLOCK_SIZE. Please convert binary.\n");
813 return -ENOEXEC;
814 }
815
816
817 flush_old_exec(bprm);
818
819 current->mm->brk = ex.a_bss +
820 (current->mm->start_brk =
821 (current->mm->end_data = ex.a_data +
822 (current->mm->end_code = ex.a_text +
823 (current->mm->start_code = N_TXTADDR(ex)))));
824 current->mm->rss = 0;
825 current->mm->mmap = NULL;
826 current->suid = current->euid = current->fsuid = bprm->e_uid;
827 current->sgid = current->egid = current->fsgid = bprm->e_gid;
828 if (N_MAGIC(ex) == OMAGIC) {
829 do_mmap(NULL, 0, ex.a_text+ex.a_data,
830 PROT_READ|PROT_WRITE|PROT_EXEC,
831 MAP_FIXED|MAP_PRIVATE, 0);
832 read_exec(bprm->inode, 32, (char *) 0, ex.a_text+ex.a_data);
833 } else {
834 if (ex.a_text & 0xfff || ex.a_data & 0xfff)
835 printk(KERN_NOTICE "executable not page aligned\n");
836
837 fd = open_inode(bprm->inode, O_RDONLY);
838
839 if (fd < 0)
840 return fd;
841 file = current->files->fd[fd];
842 if (!file->f_op || !file->f_op->mmap) {
843 sys_close(fd);
844 do_mmap(NULL, 0, ex.a_text+ex.a_data,
845 PROT_READ|PROT_WRITE|PROT_EXEC,
846 MAP_FIXED|MAP_PRIVATE, 0);
847 read_exec(bprm->inode, fd_offset,
848 (char *) N_TXTADDR(ex), ex.a_text+ex.a_data);
849 goto beyond_if;
850 }
851
852 error = do_mmap(file, N_TXTADDR(ex), ex.a_text,
853 PROT_READ | PROT_EXEC,
854 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE,
855 fd_offset);
856
857 if (error != N_TXTADDR(ex)) {
858 sys_close(fd);
859 send_sig(SIGKILL, current, 0);
860 return error;
861 }
862
863 error = do_mmap(file, N_TXTADDR(ex) + ex.a_text, ex.a_data,
864 PROT_READ | PROT_WRITE | PROT_EXEC,
865 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE,
866 fd_offset + ex.a_text);
867 sys_close(fd);
868 if (error != N_TXTADDR(ex) + ex.a_text) {
869 send_sig(SIGKILL, current, 0);
870 return error;
871 }
872 }
873 beyond_if:
874 if (current->exec_domain && current->exec_domain->use_count)
875 (*current->exec_domain->use_count)--;
876 if (current->binfmt && current->binfmt->use_count)
877 (*current->binfmt->use_count)--;
878 current->exec_domain = lookup_exec_domain(current->personality);
879 current->binfmt = &aout_format;
880 if (current->exec_domain && current->exec_domain->use_count)
881 (*current->exec_domain->use_count)++;
882 if (current->binfmt && current->binfmt->use_count)
883 (*current->binfmt->use_count)++;
884
885 set_brk(current->mm->start_brk, current->mm->brk);
886
887 p += change_ldt(ex.a_text,bprm->page);
888 p -= MAX_ARG_PAGES*PAGE_SIZE;
889 p = (unsigned long)create_tables((char *)p,
890 bprm->argc, bprm->envc,
891 current->personality != PER_LINUX);
892 current->mm->start_stack = p;
893 regs->eip = ex.a_entry;
894 regs->esp = p;
895 if (current->flags & PF_PTRACED)
896 send_sig(SIGTRAP, current, 0);
897 return 0;
898 }
899
900
901 static int load_aout_library(int fd)
902 {
903 struct file * file;
904 struct exec ex;
905 struct inode * inode;
906 unsigned int len;
907 unsigned int bss;
908 unsigned int start_addr;
909 int error;
910
911 file = current->files->fd[fd];
912 inode = file->f_inode;
913
914 set_fs(KERNEL_DS);
915 if (file->f_op->read(inode, file, (char *) &ex, sizeof(ex)) != sizeof(ex)) {
916 return -EACCES;
917 }
918 set_fs(USER_DS);
919
920
921 if ((N_MAGIC(ex) != ZMAGIC && N_MAGIC(ex) != QMAGIC) || ex.a_trsize ||
922 ex.a_drsize || ((ex.a_entry & 0xfff) && N_MAGIC(ex) == ZMAGIC) ||
923 inode->i_size < ex.a_text+ex.a_data+ex.a_syms+N_TXTOFF(ex)) {
924 return -ENOEXEC;
925 }
926 if (N_MAGIC(ex) == ZMAGIC && N_TXTOFF(ex) &&
927 (N_TXTOFF(ex) < inode->i_sb->s_blocksize)) {
928 printk("N_TXTOFF < BLOCK_SIZE. Please convert library\n");
929 return -ENOEXEC;
930 }
931
932 if (N_FLAGS(ex)) return -ENOEXEC;
933
934
935
936
937 start_addr = ex.a_entry & 0xfffff000;
938
939
940 error = do_mmap(file, start_addr, ex.a_text + ex.a_data,
941 PROT_READ | PROT_WRITE | PROT_EXEC,
942 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
943 N_TXTOFF(ex));
944 if (error != start_addr)
945 return error;
946 len = PAGE_ALIGN(ex.a_text + ex.a_data);
947 bss = ex.a_text + ex.a_data + ex.a_bss;
948 if (bss > len)
949 do_mmap(NULL, start_addr + len, bss-len,
950 PROT_READ|PROT_WRITE|PROT_EXEC,
951 MAP_PRIVATE|MAP_FIXED, 0);
952 return 0;
953 }