fs/exec.c

Name: Public Git Hosting - davej-history.git/blob - fs/exec.c
Rating: 4.6 (4537 reviews)
 1 /*
 2  * linux/fs/exec.c
 3  *
 4  * Copyright (C) 1991, 1992 Linus Torvalds
 5  */
 6
 7 /*
 8  * #!-checking implemented by tytso.
 9  */
 10 /*
 11  * Demand-loading implemented 01.12.91 - no need to read anything but
 12  * the header into memory. The inode of the executable is put into
 13  * "current->executable", and page faults do the actual loading. Clean.
 14  *
 15  * Once more I can proudly say that linux stood up to being changed: it
 16  * was less than 2 hours work to get demand-loading completely implemented.
 17  *
 18  * Demand loading changed July 1993 by Eric Youngdale. Use mmap instead,
 19  * current->executable is only used by the procfs. This allows a dispatch
 20  * table to check for several different types of binary formats. We keep
 21  * trying until we recognize the file or we run out of supported binary
 22  * formats.
 23  */
 24
 25 #include <linux/config.h>
 26 #include <linux/slab.h>
 27 #include <linux/file.h>
 28 #include <linux/mman.h>
 29 #include <linux/a.out.h>
 30 #include <linux/stat.h>
 31 #include <linux/fcntl.h>
 32 #include <linux/smp_lock.h>
 33 #include <linux/init.h>
 34
 35 #include <asm/uaccess.h>
 36 #include <asm/pgtable.h>
 37 #include <asm/mmu_context.h>
 38
 39 #ifdef CONFIG_KMOD
 40 #include <linux/kmod.h>
 41 #endif
 42
 43 /*
 44  * Here are the actual binaries that will be accepted:
 45  * add more with "register_binfmt()" if using modules...
 46  *
 47  * These are defined again for the 'real' modules if you are using a
 48  * module definition for these routines.
 49  */
 50
 51 static struct linux_binfmt *formats = (struct linux_binfmt *) NULL;
 52
 53 void __init binfmt_setup(void)
 54 {
 55 #ifdef CONFIG_BINFMT_MISC
 56 init_misc_binfmt();
 57 #endif
 58
 59 #ifdef CONFIG_BINFMT_ELF
 60 init_elf_binfmt();
 61 #endif
 62
 63 #ifdef CONFIG_BINFMT_ELF32
 64 init_elf32_binfmt();
 65 #endif
 66
 67 #ifdef CONFIG_BINFMT_AOUT
 68 init_aout_binfmt();
 69 #endif
 70
 71 #ifdef CONFIG_BINFMT_AOUT32
 72 init_aout32_binfmt();
 73 #endif
 74
 75 #ifdef CONFIG_BINFMT_EM86
 76 init_em86_binfmt();
 77 #endif
 78
 79 /* This cannot be configured out of the kernel */
 80 init_script_binfmt();
 81 }
 82
 83 intregister_binfmt(struct linux_binfmt * fmt)
 84 {
 85 struct linux_binfmt ** tmp = &formats;
 86
 87 if(!fmt)
 88 return-EINVAL;
 89 if(fmt->next)
 90 return-EBUSY;
 91 while(*tmp) {
 92 if(fmt == *tmp)
 93 return-EBUSY;
 94  tmp = &(*tmp)->next;
 95 }
 96  fmt->next = formats;
 97  formats = fmt;
 98 return0;
 99 }
 100
 101 #ifdef CONFIG_MODULES
 102 intunregister_binfmt(struct linux_binfmt * fmt)
 103 {
 104 struct linux_binfmt ** tmp = &formats;
 105
 106 while(*tmp) {
 107 if(fmt == *tmp) {
 108 *tmp = fmt->next;
 109 return0;
 110 }
 111  tmp = &(*tmp)->next;
 112 }
 113 return-EINVAL;
 114 }
 115 #endif/* CONFIG_MODULES */
 116
 117 /* N.B. Error returns must be < 0 */
 118 intopen_dentry(struct dentry * dentry,int mode)
 119 {
 120 struct inode * inode = dentry->d_inode;
 121 struct file * f;
 122 struct list_head * l = NULL;
 123 int fd, error;
 124
 125 if(inode->i_sb)
 126  l = &inode->i_sb->s_files;
 127
 128  error = -EINVAL;
 129 if(!inode->i_op || !inode->i_op->default_file_ops)
 130 goto out;
 131  fd =get_unused_fd();
 132 if(fd >=0) {
 133  error = -ENFILE;
 134  f =get_empty_filp();
 135 if(!f)
 136 goto out_fd;
 137  f->f_flags = mode;
 138  f->f_mode = (mode+1) & O_ACCMODE;
 139  f->f_dentry = dentry;
 140  f->f_pos =0;
 141  f->f_reada =0;
 142  f->f_op = inode->i_op->default_file_ops;
 143 if(f->f_op->open) {
 144  error = f->f_op->open(inode,f);
 145 if(error)
 146 goto out_filp;
 147 }
 148 file_move(f, l);
 149 fd_install(fd, f);
 150 dget(dentry);
 151 }
 152 return fd;
 153
 154 out_filp:
 155 if(error >0)
 156  error = -EIO;
 157 put_filp(f);
 158 out_fd:
 159 put_unused_fd(fd);
 160 out:
 161 return error;
 162 }
 163
 164 /*
 165  * Note that a shared library must be both readable and executable due to
 166  * security reasons.
 167  *
 168  * Also note that we take the address to load from from the file itself.
 169  */
 170 asmlinkage intsys_uselib(const char* library)
 171 {
 172 int fd, retval;
 173 struct file * file;
 174 struct linux_binfmt * fmt;
 175
 176 lock_kernel();
 177  fd =sys_open(library,0,0);
 178  retval = fd;
 179 if(fd <0)
 180 goto out;
 181  file =fget(fd);
 182  retval = -ENOEXEC;
 183 if(file && file->f_dentry && file->f_op && file->f_op->read) {
 184 for(fmt = formats ; fmt ; fmt = fmt->next) {
 185 int(*fn)(int) = fmt->load_shlib;
 186 if(!fn)
 187 continue;
 188 /* N.B. Should use file instead of fd */
 189  retval =fn(fd);
 190 if(retval != -ENOEXEC)
 191 break;
 192 }
 193 }
 194 fput(file);
 195 sys_close(fd);
 196 out:
 197 unlock_kernel();
 198 return retval;
 199 }
 200
 201 /*
 202  * count() counts the number of arguments/envelopes
 203  */
 204 static intcount(char** argv)
 205 {
 206 int i =0;
 207
 208 if(argv != NULL) {
 209 for(;;) {
 210 char* p;
 211 int error;
 212
 213  error =get_user(p,argv);
 214 if(error)
 215 return error;
 216 if(!p)
 217 break;
 218  argv++;
 219  i++;
 220 }
 221 }
 222 return i;
 223 }
 224
 225 /*
 226  * 'copy_strings()' copies argument/envelope strings from user
 227  * memory to free pages in kernel mem. These are in a format ready
 228  * to be put directly into the top of new user memory.
 229  */
 230 intcopy_strings(int argc,char** argv,struct linux_binprm *bprm)
 231 {
 232 while(argc-- >0) {
 233 char*str;
 234 int len;
 235 unsigned long pos;
 236
 237 if(get_user(str, argv+argc) || !str || !(len =strlen_user(str)))
 238 return-EFAULT;
 239 if(bprm->p < len)
 240 return-E2BIG;
 241
 242  bprm->p -= len;
 243 /* XXX: add architecture specific overflow check here. */
 244
 245  pos = bprm->p;
 246 while(len) {
 247 char*pag;
 248 int offset, bytes_to_copy;
 249
 250  offset = pos % PAGE_SIZE;
 251 if(!(pag = (char*) bprm->page[pos/PAGE_SIZE]) &&
 252 !(pag = (char*) bprm->page[pos/PAGE_SIZE] =
 253 (unsigned long*)get_free_page(GFP_USER)))
 254 return-ENOMEM;
 255
 256  bytes_to_copy = PAGE_SIZE - offset;
 257 if(bytes_to_copy > len)
 258  bytes_to_copy = len;
 259 if(copy_from_user(pag + offset, str, bytes_to_copy))
 260 return-EFAULT;
 261
 262  pos += bytes_to_copy;
 263  str += bytes_to_copy;
 264  len -= bytes_to_copy;
 265 }
 266 }
 267 return0;
 268 }
 269
 270 /*
 271  * Like copy_strings, but get argv and its values from kernel memory.
 272  */
 273 intcopy_strings_kernel(int argc,char** argv,struct linux_binprm *bprm)
 274 {
 275 int r;
 276  mm_segment_t oldfs =get_fs();
 277 set_fs(KERNEL_DS);
 278  r =copy_strings(argc, argv, bprm);
 279 set_fs(oldfs);
 280 return r;
 281 }
 282
 283 intsetup_arg_pages(struct linux_binprm *bprm)
 284 {
 285 unsigned long stack_base;
 286 struct vm_area_struct *mpnt;
 287 int i;
 288
 289  stack_base = STACK_TOP - MAX_ARG_PAGES*PAGE_SIZE;
 290
 291  bprm->p += stack_base;
 292 if(bprm->loader)
 293  bprm->loader += stack_base;
 294  bprm->exec += stack_base;
 295
 296  mpnt =kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);
 297 if(!mpnt)
 298 return-ENOMEM;
 299
 300 {
 301  mpnt->vm_mm = current->mm;
 302  mpnt->vm_start = PAGE_MASK & (unsigned long) bprm->p;
 303  mpnt->vm_end = STACK_TOP;
 304  mpnt->vm_page_prot = PAGE_COPY;
 305  mpnt->vm_flags = VM_STACK_FLAGS;
 306  mpnt->vm_ops = NULL;
 307  mpnt->vm_offset =0;
 308  mpnt->vm_file = NULL;
 309  mpnt->vm_pte =0;
 310 insert_vm_struct(current->mm, mpnt);
 311  current->mm->total_vm = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;
 312 }
 313
 314 for(i =0; i < MAX_ARG_PAGES ; i++) {
 315 if(bprm->page[i]) {
 316  current->mm->rss++;
 317 put_dirty_page(current,bprm->page[i],stack_base);
 318 }
 319  stack_base += PAGE_SIZE;
 320 }
 321
 322 return0;
 323 }
 324
 325 /*
 326  * Read in the complete executable. This is used for "-N" files
 327  * that aren't on a block boundary, and for files on filesystems
 328  * without get_block support.
 329  */
 330 intread_exec(struct dentry *dentry,unsigned long offset,
 331 char* addr,unsigned long count,int to_kmem)
 332 {
 333 struct file file;
 334 struct inode * inode = dentry->d_inode;
 335 int result = -ENOEXEC;
 336
 337 if(!inode->i_op || !inode->i_op->default_file_ops)
 338 goto end_readexec;
 339 if(init_private_file(&file, dentry,1))
 340 goto end_readexec;
 341 if(!file.f_op->read)
 342 goto close_readexec;
 343 if(file.f_op->llseek) {
 344 if(file.f_op->llseek(&file,offset,0) != offset)
 345 goto close_readexec;
 346 }else
 347  file.f_pos = offset;
 348 if(to_kmem) {
 349  mm_segment_t old_fs =get_fs();
 350 set_fs(get_ds());
 351  result = file.f_op->read(&file, addr, count, &file.f_pos);
 352 set_fs(old_fs);
 353 }else{
 354  result =verify_area(VERIFY_WRITE, addr, count);
 355 if(result)
 356 goto close_readexec;
 357  result = file.f_op->read(&file, addr, count, &file.f_pos);
 358 }
 359 close_readexec:
 360 if(file.f_op->release)
 361  file.f_op->release(inode,&file);
 362 end_readexec:
 363 return result;
 364 }
 365
 366 static intexec_mmap(void)
 367 {
 368 struct mm_struct * mm, * old_mm;
 369
 370  old_mm = current->mm;
 371 if(old_mm &&atomic_read(&old_mm->mm_users) ==1) {
 372 flush_cache_mm(old_mm);
 373 mm_release();
 374 release_segments(old_mm);
 375 exit_mmap(old_mm);
 376 flush_tlb_mm(old_mm);
 377 return0;
 378 }
 379
 380  mm =mm_alloc();
 381 if(mm) {
 382 struct mm_struct *active_mm = current->active_mm;
 383
 384  mm->cpu_vm_mask = (1UL<<smp_processor_id());
 385  current->mm = mm;
 386  current->active_mm = mm;
 387 switch_mm(active_mm, mm);
 388 mm_release();
 389 if(old_mm) {
 390 if(active_mm != old_mm)BUG();
 391 mmput(old_mm);
 392 return0;
 393 }
 394 mmdrop(active_mm);
 395 return0;
 396 }
 397 return-ENOMEM;
 398 }
 399
 400 /*
 401  * This function makes sure the current process has its own signal table,
 402  * so that flush_signal_handlers can later reset the handlers without
 403  * disturbing other processes. (Other processes might share the signal
 404  * table via the CLONE_SIGHAND option to clone().)
 405  */
 406
 407 staticinlineintmake_private_signals(void)
 408 {
 409 struct signal_struct * newsig;
 410
 411 if(atomic_read(&current->sig->count) <=1)
 412 return0;
 413  newsig =kmalloc(sizeof(*newsig), GFP_KERNEL);
 414 if(newsig == NULL)
 415 return-ENOMEM;
 416 spin_lock_init(&newsig->siglock);
 417 atomic_set(&newsig->count,1);
 418 memcpy(newsig->action, current->sig->action,sizeof(newsig->action));
 419  current->sig = newsig;
 420 return0;
 421 }
 422
 423 /*
 424  * If make_private_signals() made a copy of the signal table, decrement the
 425  * refcount of the original table, and free it if necessary.
 426  * We don't do that in make_private_signals() so that we can back off
 427  * in flush_old_exec() if an error occurs after calling make_private_signals().
 428  */
 429
 430 staticinlinevoidrelease_old_signals(struct signal_struct * oldsig)
 431 {
 432 if(current->sig == oldsig)
 433 return;
 434 if(atomic_dec_and_test(&oldsig->count))
 435 kfree(oldsig);
 436 }
 437
 438 /*
 439  * These functions flushes out all traces of the currently running executable
 440  * so that a new one can be started
 441  */
 442
 443 staticinlinevoidflush_old_files(struct files_struct * files)
 444 {
 445 unsigned long j;
 446
 447  j =0;
 448 for(;;) {
 449 unsigned long set, i;
 450
 451  i = j * __NFDBITS;
 452 if(i >= files->max_fds || i >= files->max_fdset)
 453 break;
 454  set =xchg(&files->close_on_exec->fds_bits[j],0);
 455  j++;
 456 for( ; set ; i++,set >>=1) {
 457 if(set &1)
 458 sys_close(i);
 459 }
 460 }
 461 }
 462
 463 intflush_old_exec(struct linux_binprm * bprm)
 464 {
 465 char* name;
 466 int i, ch, retval;
 467 struct signal_struct * oldsig;
 468
 469 /*
 470  * Make sure we have a private signal table
 471  */
 472  oldsig = current->sig;
 473  retval =make_private_signals();
 474 if(retval)goto flush_failed;
 475
 476 /*
 477  * Release all of the old mmap stuff
 478  */
 479  retval =exec_mmap();
 480 if(retval)goto mmap_failed;
 481
 482 /* This is the point of no return */
 483 release_old_signals(oldsig);
 484
 485 if(current->euid == current->uid && current->egid == current->gid)
 486  current->dumpable =1;
 487  name = bprm->filename;
 488 for(i=0; (ch = *(name++)) !='\0';) {
 489 if(ch =='/')
 490  i =0;
 491 else
 492 if(i <15)
 493  current->comm[i++] = ch;
 494 }
 495  current->comm[i] ='\0';
 496
 497 flush_thread();
 498
 499 if(bprm->e_uid != current->euid || bprm->e_gid != current->egid ||
 500 permission(bprm->dentry->d_inode,MAY_READ))
 501  current->dumpable =0;
 502
 503 flush_signal_handlers(current);
 504 flush_old_files(current->files);
 505
 506 return0;
 507
 508 mmap_failed:
 509 if(current->sig != oldsig)
 510 kfree(current->sig);
 511 flush_failed:
 512  current->sig = oldsig;
 513 return retval;
 514 }
 515
 516 /*
 517  * We mustn't allow tracing of suid binaries, unless
 518  * the tracer has the capability to trace anything..
 519  */
 520 staticinlineintmust_not_trace_exec(struct task_struct * p)
 521 {
 522 return(p->flags & PF_PTRACED) && !cap_raised(p->p_pptr->cap_effective, CAP_SYS_PTRACE);
 523 }
 524
 525 /*
 526  * Fill the binprm structure from the inode.
 527  * Check permissions, then read the first 512 bytes
 528  */
 529 intprepare_binprm(struct linux_binprm *bprm)
 530 {
 531 int mode;
 532 int retval,id_change,cap_raised;
 533 struct inode * inode = bprm->dentry->d_inode;
 534
 535  mode = inode->i_mode;
 536 if(!S_ISREG(mode))/* must be regular file */
 537 return-EACCES;
 538 if(!(mode &0111))/* with at least _one_ execute bit set */
 539 return-EACCES;
 540 if(IS_NOEXEC(inode))/* FS mustn't be mounted noexec */
 541 return-EACCES;
 542 if(!inode->i_sb)
 543 return-EACCES;
 544 if((retval =permission(inode, MAY_EXEC)) !=0)
 545 return retval;
 546 /* better not execute files which are being written to */
 547 if(atomic_read(&inode->i_writecount) >0)
 548 return-ETXTBSY;
 549
 550  bprm->e_uid = current->euid;
 551  bprm->e_gid = current->egid;
 552  id_change = cap_raised =0;
 553
 554 /* Set-uid? */
 555 if(mode & S_ISUID) {
 556  bprm->e_uid = inode->i_uid;
 557 if(bprm->e_uid != current->euid)
 558  id_change =1;
 559 }
 560
 561 /* Set-gid? */
 562 /*
 563  * If setgid is set but no group execute bit then this
 564  * is a candidate for mandatory locking, not a setgid
 565  * executable.
 566  */
 567 if((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
 568  bprm->e_gid = inode->i_gid;
 569 if(!in_group_p(bprm->e_gid))
 570  id_change =1;
 571 }
 572
 573 /* We don't have VFS support for capabilities yet */
 574 cap_clear(bprm->cap_inheritable);
 575 cap_clear(bprm->cap_permitted);
 576 cap_clear(bprm->cap_effective);
 577
 578 /* To support inheritance of root-permissions and suid-root
 579  * executables under compatibility mode, we raise the
 580  * effective and inherited bitmasks of the executable file
 581  * (translation: we set the executable "capability dumb" and
 582  * set the allowed set to maximum). We don't set any forced
 583  * bits.
 584  *
 585  * If only the real uid is 0, we only raise the inheritable
 586  * bitmask of the executable file (translation: we set the
 587  * allowed set to maximum and the application to "capability
 588  * smart").
 589  */
 590
 591 if(!issecure(SECURE_NOROOT)) {
 592 if(bprm->e_uid ==0|| current->uid ==0)
 593 cap_set_full(bprm->cap_inheritable);
 594 if(bprm->e_uid ==0)
 595 cap_set_full(bprm->cap_effective);
 596 }
 597
 598 /* Only if pP' is _not_ a subset of pP, do we consider there
 599  * has been a capability related "change of capability". In
 600  * such cases, we need to check that the elevation of
 601  * privilege does not go against other system constraints.
 602  * The new Permitted set is defined below -- see (***). */
 603 {
 604  kernel_cap_t working =
 605 cap_combine(bprm->cap_permitted,
 606 cap_intersect(bprm->cap_inheritable,
 607  current->cap_inheritable));
 608 if(!cap_issubset(working, current->cap_permitted)) {
 609  cap_raised =1;
 610 }
 611 }
 612
 613 if(id_change || cap_raised) {
 614 /* We can't suid-execute if we're sharing parts of the executable */
 615 /* or if we're being traced (or if suid execs are not allowed) */
 616 /* (current->mm->mm_users > 1 is ok, as we'll get a new mm anyway) */
 617 if(IS_NOSUID(inode)
 618 ||must_not_trace_exec(current)
 619 || (atomic_read(&current->fs->count) >1)
 620 || (atomic_read(&current->sig->count) >1)
 621 || (atomic_read(&current->files->count) >1)) {
 622 if(id_change && !capable(CAP_SETUID))
 623 return-EPERM;
 624 if(cap_raised && !capable(CAP_SETPCAP))
 625 return-EPERM;
 626 }
 627 }
 628
 629 memset(bprm->buf,0,sizeof(bprm->buf));
 630 returnread_exec(bprm->dentry,0,bprm->buf,128,1);
 631 }
 632
 633 /*
 634  * This function is used to produce the new IDs and capabilities
 635  * from the old ones and the file's capabilities.
 636  *
 637  * The formula used for evolving capabilities is:
 638  *
 639  * pI' = pI
 640  * (***) pP' = fP | (fI & pI)
 641  * pE' = pP' & fE [NB. fE is 0 or ~0]
 642  *
 643  * I=Inheritable, P=Permitted, E=Effective // p=process, f=file
 644  * ' indicates post-exec().
 645  */
 646
 647 voidcompute_creds(struct linux_binprm *bprm)
 648 {
 649 int new_permitted =cap_t(bprm->cap_permitted) |
 650 (cap_t(bprm->cap_inheritable) &
 651 cap_t(current->cap_inheritable));
 652
 653 /* For init, we want to retain the capabilities set
 654  * in the init_task struct. Thus we skip the usual
 655  * capability rules */
 656 if(current->pid !=1) {
 657 cap_t(current->cap_permitted) = new_permitted;
 658 cap_t(current->cap_effective) = new_permitted &
 659 cap_t(bprm->cap_effective);
 660 }
 661
 662 /* AUD: Audit candidate if current->cap_effective is set */
 663
 664  current->suid = current->euid = current->fsuid = bprm->e_uid;
 665  current->sgid = current->egid = current->fsgid = bprm->e_gid;
 666 if(current->euid != current->uid || current->egid != current->gid ||
 667 !cap_issubset(new_permitted, current->cap_permitted))
 668  current->dumpable =0;
 669 }
 670
 671
 672 voidremove_arg_zero(struct linux_binprm *bprm)
 673 {
 674 if(bprm->argc) {
 675 unsigned long offset;
 676 char* page;
 677  offset = bprm->p % PAGE_SIZE;
 678  page = (char*)bprm->page[bprm->p/PAGE_SIZE];
 679 while(bprm->p++,*(page+offset++))
 680 if(offset==PAGE_SIZE){
 681  offset=0;
 682  page = (char*)bprm->page[bprm->p/PAGE_SIZE];
 683 }
 684  bprm->argc--;
 685 }
 686 }
 687
 688 /*
 689  * cycle the list of binary formats handler, until one recognizes the image
 690  */
 691 intsearch_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
 692 {
 693 inttry,retval=0;
 694 struct linux_binfmt *fmt;
 695 #ifdef __alpha__
 696 /* handle /sbin/loader.. */
 697 {
 698 struct exec * eh = (struct exec *) bprm->buf;
 699 struct linux_binprm bprm_loader;
 700
 701 if(!bprm->loader && eh->fh.f_magic ==0x183&&
 702 (eh->fh.f_flags &0x3000) ==0x3000)
 703 {
 704 int i;
 705 char* dynloader[] = {"/sbin/loader"};
 706 struct dentry * dentry;
 707
 708 dput(bprm->dentry);
 709  bprm->dentry = NULL;
 710
 711  bprm_loader.p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void*);
 712 for(i=0; i<MAX_ARG_PAGES ; i++)/* clear page-table */
 713  bprm_loader.page[i] =0;
 714
 715  dentry =open_namei(dynloader[0],0,0);
 716  retval =PTR_ERR(dentry);
 717 if(IS_ERR(dentry))
 718 return retval;
 719  bprm->dentry = dentry;
 720  bprm->loader = bprm_loader.p;
 721  retval =prepare_binprm(bprm);
 722 if(retval<0)
 723 return retval;
 724 /* should call search_binary_handler recursively here,
 725  but it does not matter */
 726 }
 727 }
 728 #endif
 729 for(try=0;try<2;try++) {
 730 for(fmt = formats ; fmt ; fmt = fmt->next) {
 731 int(*fn)(struct linux_binprm *,struct pt_regs *) = fmt->load_binary;
 732 if(!fn)
 733 continue;
 734  retval =fn(bprm, regs);
 735 if(retval >=0) {
 736 if(bprm->dentry)
 737 dput(bprm->dentry);
 738  bprm->dentry = NULL;
 739  current->did_exec =1;
 740 return retval;
 741 }
 742 if(retval != -ENOEXEC)
 743 break;
 744 if(!bprm->dentry)/* We don't have the dentry anymore */
 745 return retval;
 746 }
 747 if(retval != -ENOEXEC) {
 748 break;
 749 #ifdef CONFIG_KMOD
 750 }else{
 751 #define printable(c) (((c)=='\t') || ((c)=='\n') || (0x20<=(c) && (c)<=0x7e))
 752 char modname[20];
 753 if(printable(bprm->buf[0]) &&
 754 printable(bprm->buf[1]) &&
 755 printable(bprm->buf[2]) &&
 756 printable(bprm->buf[3]))
 757 break;/* -ENOEXEC */
 758 sprintf(modname,"binfmt-%04x", *(unsigned short*)(&bprm->buf[2]));
 759 request_module(modname);
 760 #endif
 761 }
 762 }
 763 return retval;
 764 }
 765
 766
 767 /*
 768  * sys_execve() executes a new program.
 769  */
 770 intdo_execve(char* filename,char** argv,char** envp,struct pt_regs * regs)
 771 {
 772 struct linux_binprm bprm;
 773 struct dentry * dentry;
 774 int retval;
 775 int i;
 776
 777  bprm.p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void*);
 778 memset(bprm.page,0, MAX_ARG_PAGES*sizeof(bprm.page[0]));
 779
 780  dentry =open_namei(filename,0,0);
 781  retval =PTR_ERR(dentry);
 782 if(IS_ERR(dentry))
 783 return retval;
 784
 785  bprm.dentry = dentry;
 786  bprm.filename = filename;
 787  bprm.sh_bang =0;
 788  bprm.loader =0;
 789  bprm.exec =0;
 790 if((bprm.argc =count(argv)) <0) {
 791 dput(dentry);
 792 return bprm.argc;
 793 }
 794
 795 if((bprm.envc =count(envp)) <0) {
 796 dput(dentry);
 797 return bprm.envc;
 798 }
 799
 800  retval =prepare_binprm(&bprm);
 801 if(retval <0)
 802 goto out;
 803
 804  retval =copy_strings_kernel(1, &bprm.filename, &bprm);
 805 if(retval <0)
 806 goto out;
 807
 808  bprm.exec = bprm.p;
 809  retval =copy_strings(bprm.envc, envp, &bprm);
 810 if(retval <0)
 811 goto out;
 812
 813  retval =copy_strings(bprm.argc, argv, &bprm);
 814 if(retval <0)
 815 goto out;
 816
 817  retval =search_binary_handler(&bprm,regs);
 818 if(retval >=0)
 819 /* execve success */
 820 return retval;
 821
 822 out:
 823 /* Something went wrong, return the inode and free the argument pages*/
 824 if(bprm.dentry)
 825 dput(bprm.dentry);
 826
 827 /* Assumes that free_page() can take a NULL argument. */
 828 /* I hope this is ok for all architectures */
 829 for(i=0; i<MAX_ARG_PAGES ; i++)
 830 free_page(bprm.page[i]);
 831
 832 return retval;
 833 }
 834
 835 intdo_coredump(long signr,struct pt_regs * regs)
 836 {
 837 struct linux_binfmt * binfmt;
 838 char corename[6+sizeof(current->comm)];
 839 struct file * file;
 840 struct dentry * dentry;
 841 struct inode * inode;
 842
 843 lock_kernel();
 844  binfmt = current->binfmt;
 845 if(!binfmt || !binfmt->core_dump)
 846 goto fail;
 847 if(!current->dumpable ||atomic_read(&current->mm->mm_users) !=1)
 848  current->dumpable =0;
 849 if(current->rlim[RLIMIT_CORE].rlim_cur < binfmt->min_coredump)
 850 goto fail;
 851
 852 memcpy(corename,"core.",5);
 853 #if 0
 854 memcpy(corename+5,current->comm,sizeof(current->comm));
 855 #else
 856  corename[4] ='\0';
 857 #endif
 858  file =filp_open(corename, O_CREAT |2| O_TRUNC | O_NOFOLLOW,0600);
 859 if(IS_ERR(file))
 860 goto fail;
 861  dentry = file->f_dentry;
 862  inode = dentry->d_inode;
 863 if(inode->i_nlink >1)
 864 goto close_fail;/* multiple links - don't dump */
 865
 866 if(!S_ISREG(inode->i_mode))
 867 goto close_fail;
 868 if(!inode->i_op || !inode->i_op->default_file_ops)
 869 goto close_fail;
 870 if(!file->f_op->write)
 871 goto close_fail;
 872 if(!binfmt->core_dump(signr, regs, file))
 873 goto close_fail;
 874 filp_close(file, NULL);
 875 unlock_kernel();
 876 return1;
 877
 878 close_fail:
 879 filp_close(file, NULL);
 880 fail:
 881 unlock_kernel();
 882 return0;
 883 }