![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_exec.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / kern|
Return to kern_exec.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ ! 23: /* ! 24: * Mach Operating System ! 25: * Copyright (c) 1987 Carnegie-Mellon University ! 26: * All rights reserved. The CMU software License Agreement specifies ! 27: * the terms and conditions for use and redistribution. ! 28: */ ! 29: ! 30: #include <cputypes.h> ! 31: ! 32: /*- ! 33: * Copyright (c) 1982, 1986, 1991, 1993 ! 34: * The Regents of the University of California. All rights reserved. ! 35: * (c) UNIX System Laboratories, Inc. ! 36: * All or some portions of this file are derived from material licensed ! 37: * to the University of California by American Telephone and Telegraph ! 38: * Co. or Unix System Laboratories, Inc. and are reproduced herein with ! 39: * the permission of UNIX System Laboratories, Inc. ! 40: * ! 41: * Redistribution and use in source and binary forms, with or without ! 42: * modification, are permitted provided that the following conditions ! 43: * are met: ! 44: * 1. Redistributions of source code must retain the above copyright ! 45: * notice, this list of conditions and the following disclaimer. ! 46: * 2. Redistributions in binary form must reproduce the above copyright ! 47: * notice, this list of conditions and the following disclaimer in the ! 48: * documentation and/or other materials provided with the distribution. ! 49: * 3. All advertising materials mentioning features or use of this software ! 50: * must display the following acknowledgement: ! 51: * This product includes software developed by the University of ! 52: * California, Berkeley and its contributors. ! 53: * 4. Neither the name of the University nor the names of its contributors ! 54: * may be used to endorse or promote products derived from this software ! 55: * without specific prior written permission. ! 56: * ! 57: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 58: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 59: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 60: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 61: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 62: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 63: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 64: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 65: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 66: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 67: * SUCH DAMAGE. ! 68: * ! 69: * from: @(#)kern_exec.c 8.1 (Berkeley) 6/10/93 ! 70: */ ! 71: #include <mach_nbc.h> ! 72: #include <machine/reg.h> ! 73: ! 74: #include <sys/param.h> ! 75: #include <sys/systm.h> ! 76: #include <sys/filedesc.h> ! 77: #include <sys/kernel.h> ! 78: #include <sys/proc.h> ! 79: #include <sys/user.h> ! 80: #include <sys/buf.h> ! 81: #include <sys/socketvar.h> ! 82: #include <sys/malloc.h> ! 83: #include <sys/namei.h> ! 84: #include <sys/mount.h> ! 85: #include <sys/vnode.h> ! 86: #include <sys/file.h> ! 87: #include <sys/stat.h> ! 88: #include <sys/uio.h> ! 89: #include <sys/acct.h> ! 90: #include <sys/exec.h> ! 91: #include <sys/kdebug.h> ! 92: #include <sys/signal.h> ! 93: ! 94: #include <mach/vm_param.h> ! 95: ! 96: #include <vm/vm_map.h> ! 97: #include <vm/vm_kern.h> ! 98: ! 99: #include <kern/thread.h> ! 100: #include <kern/task.h> ! 101: ! 102: #include <kern/ast.h> ! 103: #include <kern/mach_loader.h> ! 104: #include <mach-o/fat.h> ! 105: #include <mach-o/loader.h> ! 106: #include <machine/vmparam.h> ! 107: ! 108: extern vm_map_t bsd_pageable_map; ! 109: ! 110: #define ROUND_PTR(type, addr) \ ! 111: (type *)( ( (unsigned)(addr) + 16 - 1) \ ! 112: & ~(16 - 1) ) ! 113: ! 114: static int load_return_to_errno(load_return_t lrtn); ! 115: int execve(struct proc *p, struct execve_args *uap, register_t *retval); ! 116: ! 117: int ! 118: execv(p, args, retval) ! 119: struct proc *p; ! 120: void *args; ! 121: int *retval; ! 122: { ! 123: ((struct execve_args *)args)->envp = NULL; ! 124: return (execve(p, args, retval)); ! 125: } ! 126: ! 127: /* ARGSUSED */ ! 128: int ! 129: execve(p, uap, retval) ! 130: register struct proc *p; ! 131: register struct execve_args *uap; ! 132: register_t *retval; ! 133: { ! 134: register struct ucred *cred = p->p_ucred; ! 135: register struct filedesc *fdp = p->p_fd; ! 136: register nc; ! 137: register char *cp; ! 138: int na, ne, ucp, ap, cc; ! 139: unsigned len; ! 140: int indir; ! 141: char *sharg; ! 142: char *execnamep; ! 143: struct vnode *vp; ! 144: struct vattr vattr; ! 145: struct vattr origvattr; ! 146: vm_offset_t execargs; ! 147: struct nameidata nd; ! 148: struct ps_strings ps; ! 149: #define SHSIZE 512 ! 150: char cfarg[SHSIZE]; ! 151: boolean_t is_fat; ! 152: kern_return_t ret; ! 153: struct mach_header *mach_header; ! 154: struct fat_header *fat_header; ! 155: struct fat_arch fat_arch; ! 156: load_return_t lret; ! 157: load_result_t load_result; ! 158: struct uthread *uthread; ! 159: int i; ! 160: union { ! 161: /* #! and name of interpreter */ ! 162: char ex_shell[SHSIZE]; ! 163: /* Mach-O executable */ ! 164: struct mach_header mach_header; ! 165: /* Fat executable */ ! 166: struct fat_header fat_header; ! 167: char pad[512]; ! 168: } exdata; ! 169: int resid, error; ! 170: char *savedpath; ! 171: int savedpathlen = 0; ! 172: vm_offset_t *execargsp; ! 173: char *cpnospace; ! 174: ! 175: ret = kmem_alloc_pageable(bsd_pageable_map, &execargs, NCARGS); ! 176: if (ret != KERN_SUCCESS) ! 177: return(ENOMEM); ! 178: ! 179: uthread = get_bsdthread_info(current_act()); ! 180: ! 181: savedpath = execargs; ! 182: ! 183: /* ! 184: * To support new app package launching for Mac OS X, the dyld ! 185: * needs the first argument to execve() stored on the user stack. ! 186: * Copyin the "path" at the begining of the "execargs" buffer ! 187: * allocated above. ! 188: * ! 189: * We have to do this before namei() because in case of ! 190: * symbolic links, namei() would overwrite the original "path". ! 191: * In case the last symbolic link resolved was a relative pathname ! 192: * we would loose the original "path", which could be an ! 193: * absolute pathname. This might be unacceptable for dyld. ! 194: */ ! 195: /* XXX We could optimize to avoid copyinstr in the namei() */ ! 196: ! 197: error = copyinstr(uap->fname, savedpath, MAXPATHLEN, &savedpathlen); ! 198: if (error) ! 199: return (error); ! 200: /* ! 201: * copyinstr will put in savedpathlen, the count of ! 202: * characters (including NULL) in the path. ! 203: */ ! 204: ! 205: /* Save the name aside for future use */ ! 206: execargsp = (vm_offset_t *)((char *)(execargs) + savedpathlen); ! 207: ! 208: NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | SAVENAME, ! 209: UIO_USERSPACE, uap->fname, p); ! 210: if ((error = namei(&nd))) ! 211: goto bad1; ! 212: vp = nd.ni_vp; ! 213: VOP_LEASE(vp, p, p->p_ucred, LEASE_READ); ! 214: ! 215: if ((error = VOP_GETATTR(vp, &origvattr, p->p_ucred, p))) ! 216: goto bad; ! 217: ! 218: /* Check mount point */ ! 219: if (vp->v_mount->mnt_flag & MNT_NOEXEC) { ! 220: error = EACCES; ! 221: goto bad; ! 222: } ! 223: ! 224: indir = 0; ! 225: if ((vp->v_mount->mnt_flag & MNT_NOSUID) || (p->p_flag & P_TRACED)) ! 226: origvattr.va_mode &= ~(VSUID | VSGID); ! 227: ! 228: *(&vattr) = *(&origvattr); ! 229: ! 230: again: ! 231: error = check_exec_access(p, vp, &vattr); ! 232: if (error) ! 233: goto bad; ! 234: ! 235: /* ! 236: * Read in first few bytes of file for segment sizes, magic number: ! 237: * 407 = plain executable ! 238: * 410 = RO text ! 239: * 413 = demand paged RO text ! 240: * Also an ASCII line beginning with #! is ! 241: * the file name of a ``shell'' and arguments may be prepended ! 242: * to the argument list if given here. ! 243: * ! 244: * SHELL NAMES ARE LIMITED IN LENGTH. ! 245: * ! 246: * ONLY ONE ARGUMENT MAY BE PASSED TO THE SHELL FROM ! 247: * THE ASCII LINE. ! 248: */ ! 249: #if MACH_NBC ! 250: /* ! 251: * Can't hold an excluisve lock that was returned by namei as ! 252: * we depend on pageins to fill the data; there is no need to ! 253: * hold the lock on LEAF anymore ! 254: */ ! 255: VOP_UNLOCK(vp, 0, p); ! 256: #endif /* MACH_NBC */ ! 257: ! 258: exdata.ex_shell[0] = '\0'; /* for zero length files */ ! 259: #if MACH_NBC ! 260: /* Should not pass with IO_NODELOCKED; but ! 261: * the check is ignored in vn_rdwr() if MACH_NBC is on ! 262: * Also if we pass with IO_NODELOCKED turned off ! 263: * vn_rdwr would try to take lock, which is incorrect ! 264: */ ! 265: ! 266: /* ! 267: * because exec doesn't go through open and close ! 268: * we need to map the vnode for proper coherency ! 269: * and then unmap it to release the kernel map ! 270: */ ! 271: map_vnode(vp, p); ! 272: #endif /* MACH_NBC */ ! 273: ! 274: error = vn_rdwr(UIO_READ, vp, (caddr_t)&exdata, sizeof (exdata), 0, ! 275: UIO_SYSSPACE, IO_NODELOCKED, p->p_ucred, &resid, p); ! 276: #if MACH_NBC ! 277: unmap_vnode(vp, p); ! 278: #endif /* MACH_NBC */ ! 279: ! 280: if (error) ! 281: goto bad; ! 282: ! 283: #ifndef lint ! 284: if (resid > sizeof(exdata) - min(sizeof(exdata.mach_header), ! 285: sizeof(exdata.fat_header)) ! 286: && exdata.ex_shell[0] != '#') { ! 287: error = ENOEXEC; ! 288: goto bad; ! 289: } ! 290: #endif /* lint */ ! 291: mach_header = &exdata.mach_header; ! 292: fat_header = &exdata.fat_header; ! 293: if (mach_header->magic == MH_MAGIC) ! 294: is_fat = FALSE; ! 295: else if (fat_header->magic == FAT_MAGIC || ! 296: fat_header->magic == FAT_CIGAM) ! 297: is_fat = TRUE; ! 298: else if (mach_header->magic == MH_CIGAM) { ! 299: error = EBADARCH; ! 300: goto bad; ! 301: } else { ! 302: if (exdata.ex_shell[0] != '#' || ! 303: exdata.ex_shell[1] != '!' || ! 304: indir) { ! 305: error = ENOEXEC; ! 306: goto bad; ! 307: } ! 308: cp = &exdata.ex_shell[2]; /* skip "#!" */ ! 309: while (cp < &exdata.ex_shell[SHSIZE]) { ! 310: if (*cp == '\t') ! 311: *cp = ' '; ! 312: else if (*cp == '\n') { ! 313: *cp = '\0'; ! 314: break; ! 315: } ! 316: cp++; ! 317: } ! 318: if (*cp != '\0') { ! 319: error = ENOEXEC; ! 320: goto bad; ! 321: } ! 322: cp = &exdata.ex_shell[2]; ! 323: while (*cp == ' ') ! 324: cp++; ! 325: execnamep = cp; ! 326: while (*cp && *cp != ' ') ! 327: cp++; ! 328: cfarg[0] = '\0'; ! 329: cpnospace = cp; ! 330: if (*cp) { ! 331: *cp++ = '\0'; ! 332: while (*cp == ' ') ! 333: cp++; ! 334: if (*cp) ! 335: bcopy((caddr_t)cp, (caddr_t)cfarg, SHSIZE); ! 336: } ! 337: ! 338: /* ! 339: * Support for new app package launching for Mac OS X. ! 340: * We are about to retry the execve() by changing the path to the ! 341: * interpreter name. Need to re-initialize the savedpath and ! 342: * savedpathlen. +1 for NULL. ! 343: */ ! 344: savedpathlen = (cpnospace - execnamep + 1); ! 345: error = copystr(execnamep, savedpath, savedpathlen, &savedpathlen); ! 346: if (error) ! 347: goto bad; ! 348: ! 349: /* Save the name aside for future use */ ! 350: execargsp = (vm_offset_t *)((char *)(execargs) + savedpathlen); ! 351: ! 352: indir = 1; ! 353: vput(vp); ! 354: nd.ni_cnd.cn_nameiop = LOOKUP; ! 355: nd.ni_cnd.cn_flags = (nd.ni_cnd.cn_flags & HASBUF) | ! 356: (FOLLOW | LOCKLEAF | SAVENAME); ! 357: nd.ni_segflg = UIO_SYSSPACE; ! 358: nd.ni_dirp = execnamep; ! 359: if ((error = namei(&nd))) ! 360: goto bad1; ! 361: vp = nd.ni_vp; ! 362: VOP_LEASE(vp, p, cred, LEASE_READ); ! 363: if ((error = VOP_GETATTR(vp, &vattr, p->p_ucred, p))) ! 364: goto bad; ! 365: goto again; ! 366: } ! 367: ! 368: /* ! 369: * Collect arguments on "file" in swap space. ! 370: */ ! 371: na = 0; ! 372: ne = 0; ! 373: nc = 0; ! 374: cc = 0; ! 375: /* ! 376: * Support for new app package launching for Mac OS X allocates ! 377: * the "path" at the begining. ! 378: * execargs get allocated after that ! 379: */ ! 380: cp = (char *) execargsp; /* running pointer for copy */ ! 381: /* ! 382: * size of execargs less sizeof "path", ! 383: * a pointer to "path" and a NULL poiter ! 384: */ ! 385: cc = NCARGS - savedpathlen - 2*NBPW; ! 386: /* ! 387: * Copy arguments into file in argdev area. ! 388: */ ! 389: if (uap->argp) for (;;) { ! 390: ap = NULL; ! 391: sharg = NULL; ! 392: if (indir && na == 0) { ! 393: sharg = nd.ni_cnd.cn_nameptr; ! 394: ap = (int)sharg; ! 395: uap->argp++; /* ignore argv[0] */ ! 396: } else if (indir && (na == 1 && cfarg[0])) { ! 397: sharg = cfarg; ! 398: ap = (int)sharg; ! 399: } else if (indir && (na == 1 || (na == 2 && cfarg[0]))) ! 400: ap = (int)uap->fname; ! 401: else if (uap->argp) { ! 402: ap = fuword((caddr_t)uap->argp); ! 403: uap->argp++; ! 404: } ! 405: if (ap == NULL && uap->envp) { ! 406: uap->argp = NULL; ! 407: if ((ap = fuword((caddr_t)uap->envp)) != NULL) ! 408: uap->envp++, ne++; ! 409: } ! 410: if (ap == NULL) ! 411: break; ! 412: na++; ! 413: if (ap == -1) { ! 414: error = EFAULT; ! 415: break; ! 416: } ! 417: do { ! 418: if (nc >= (NCARGS - savedpathlen - 2*NBPW -1)) { ! 419: error = E2BIG; ! 420: break; ! 421: } ! 422: if (sharg) { ! 423: error = copystr(sharg, cp, (unsigned)cc, &len); ! 424: sharg += len; ! 425: } else { ! 426: error = copyinstr((caddr_t)ap, cp, (unsigned)cc, ! 427: &len); ! 428: ap += len; ! 429: } ! 430: cp += len; ! 431: nc += len; ! 432: cc -= len; ! 433: } while (error == ENAMETOOLONG); ! 434: if (error) { ! 435: goto bad; ! 436: } ! 437: } ! 438: nc = (nc + NBPW-1) & ~(NBPW-1); ! 439: ! 440: /* ! 441: * If we have a fat file, find "our" executable. ! 442: */ ! 443: if (is_fat) { ! 444: /* ! 445: * Look up our architecture in the fat file. ! 446: */ ! 447: lret = fatfile_getarch(vp, (vm_offset_t)fat_header, &fat_arch); ! 448: if (lret != LOAD_SUCCESS) { ! 449: error = load_return_to_errno(lret); ! 450: goto bad; ! 451: } ! 452: /* Read the Mach-O header out of it */ ! 453: #if MACH_NBC ! 454: /* ! 455: * because exec doesn't go through open and close ! 456: * we need to map the vnode for proper coherency ! 457: * and then unmap it to release the kernel map ! 458: */ ! 459: map_vnode(vp, p); ! 460: #endif /* MACH_NBC */ ! 461: error = vn_rdwr(UIO_READ, vp, (caddr_t)&exdata.mach_header, ! 462: sizeof (exdata.mach_header), ! 463: fat_arch.offset, ! 464: UIO_SYSSPACE, (IO_UNIT|IO_NODELOCKED), cred, &resid, p); ! 465: #if MACH_NBC ! 466: unmap_vnode(vp, p); ! 467: #endif /* MACH_NBC */ ! 468: ! 469: if (error) { ! 470: goto bad; ! 471: } ! 472: ! 473: /* Did we read a complete header? */ ! 474: if (resid) { ! 475: error = EBADEXEC; ! 476: goto bad; ! 477: } ! 478: ! 479: /* Is what we found a Mach-O executable */ ! 480: if (mach_header->magic != MH_MAGIC) { ! 481: error = ENOEXEC; ! 482: goto bad; ! 483: } ! 484: ! 485: /* ! 486: * Load the Mach-O file. ! 487: */ ! 488: #if !MACH_NBC ! 489: VOP_UNLOCK(vp, 0, p); ! 490: #endif /* !MACH_NBC */ ! 491: lret = load_machfile(vp, mach_header, fat_arch.offset, ! 492: fat_arch.size, &load_result); ! 493: } else { ! 494: /* ! 495: * Load the Mach-O file. ! 496: */ ! 497: #if !MACH_NBC ! 498: VOP_UNLOCK(vp, 0, p); ! 499: #endif /* !MACH_NBC */ ! 500: lret = load_machfile(vp, mach_header, 0, ! 501: (u_long)vattr.va_size, &load_result); ! 502: } ! 503: ! 504: if (lret != LOAD_SUCCESS) { ! 505: error = load_return_to_errno(lret); ! 506: goto bad; ! 507: } ! 508: ! 509: /* ! 510: * deal with set[ug]id. ! 511: */ ! 512: p->p_flag &= ~P_SUGID; ! 513: if (((origvattr.va_mode & VSUID) != 0 && ! 514: p->p_ucred->cr_uid != origvattr.va_uid) ! 515: || (origvattr.va_mode & VSGID) != 0 && ! 516: p->p_ucred->cr_gid != origvattr.va_gid) { ! 517: p->p_ucred = crcopy(cred); ! 518: #if KTRACE ! 519: /* ! 520: * If process is being ktraced, turn off - unless ! 521: * root set it. ! 522: */ ! 523: if (p->p_tracep && !(p->p_traceflag & KTRFAC_ROOT)) { ! 524: vrele(p->p_tracep); ! 525: p->p_tracep = NULL; ! 526: p->p_traceflag = 0; ! 527: } ! 528: #endif ! 529: if (origvattr.va_mode & VSUID) ! 530: p->p_ucred->cr_uid = origvattr.va_uid; ! 531: if (origvattr.va_mode & VSGID) ! 532: p->p_ucred->cr_gid = origvattr.va_gid; ! 533: ! 534: set_security_token(p); ! 535: p->p_flag |= P_SUGID; ! 536: ! 537: /* Radar 2261856; setuid security hole fix */ ! 538: /* Patch from OpenBSD: A. Ramesh */ ! 539: /* ! 540: * XXX For setuid processes, attempt to ensure that ! 541: * stdin, stdout, and stderr are already allocated. ! 542: * We do not want userland to accidentally allocate ! 543: * descriptors in this range which has implied meaning ! 544: * to libc. ! 545: */ ! 546: for (i = 0; i < 3; i++) { ! 547: extern struct fileops vnops; ! 548: struct nameidata nd1; ! 549: struct file *fp; ! 550: int indx; ! 551: ! 552: if (p->p_fd->fd_ofiles[i] == NULL) { ! 553: if ((error = falloc(p, &fp, &indx)) != 0) ! 554: continue; ! 555: NDINIT(&nd1, LOOKUP, FOLLOW, UIO_SYSSPACE, ! 556: "/dev/null", p); ! 557: if ((error = vn_open(&nd1, FREAD, 0)) != 0) { ! 558: ffree(fp); ! 559: p->p_fd->fd_ofiles[indx] = NULL; ! 560: break; ! 561: } ! 562: fp->f_flag = FREAD; ! 563: fp->f_type = DTYPE_VNODE; ! 564: fp->f_ops = &vnops; ! 565: fp->f_data = (caddr_t)nd1.ni_vp; ! 566: VOP_UNLOCK(nd1.ni_vp, 0, p); ! 567: } ! 568: } ! 569: } ! 570: p->p_cred->p_svuid = p->p_ucred->cr_uid; ! 571: p->p_cred->p_svgid = p->p_ucred->cr_gid; ! 572: ! 573: if (p->p_flag & P_TRACED) { ! 574: psignal(p, SIGTRAP); ! 575: #ifdef BSD_USE_APC ! 576: thread_apc_set(current_act(), bsd_ast); ! 577: #else ! 578: ast_on(AST_BSD); ! 579: #endif ! 580: } ! 581: ! 582: if (error) { ! 583: goto bad; ! 584: } ! 585: VOP_LOCK(vp, LK_EXCLUSIVE | LK_RETRY, p); ! 586: vput(vp); ! 587: vp = NULL; ! 588: ! 589: if (load_result.unixproc && ! 590: create_unix_stack(current_map(), ! 591: load_result.user_stack, p)) { ! 592: error = load_return_to_errno(LOAD_NOSPACE); ! 593: goto bad; ! 594: } ! 595: ! 596: /* ! 597: * Copy back arglist if necessary. ! 598: */ ! 599: ! 600: ucp = p->user_stack; ! 601: if (load_result.unixproc) { ! 602: int pathptr; ! 603: ! 604: ucp = ucp - nc - NBPW; /* begining of the STRING AREA */ ! 605: ! 606: /* ! 607: * Support for new app package launching for Mac OS X allocates ! 608: * the "path" at the begining of the execargs buffer. ! 609: * copy it just before the string area. ! 610: */ ! 611: len = 0; ! 612: pathptr = ucp - savedpathlen; ! 613: error = copyoutstr(savedpath, (caddr_t)pathptr, ! 614: (unsigned)savedpathlen, &len); ! 615: if (error) ! 616: goto bad; ! 617: ! 618: /* Save a NULL pointer below it */ ! 619: (void) suword((caddr_t)(pathptr - NBPW), 0); ! 620: ! 621: /* Save the pointer to "path" just below it */ ! 622: (void) suword((caddr_t)(pathptr - 2*NBPW), pathptr); ! 623: ! 624: /* ! 625: * na includes arg[] and env[]. ! 626: * NBPW for 2 NULL one each ofter arg[argc -1] and env[n] ! 627: * NBPW for argc ! 628: * skip over saved path, NBPW for pointer to path, ! 629: * and NBPW for the NULL after pointer to path. ! 630: */ ! 631: ap = ucp - na*NBPW - 3*NBPW - savedpathlen - 2*NBPW; ! 632: uthread->uu_ar0[SP] = ap; ! 633: (void) suword((caddr_t)ap, na-ne); /* argc */ ! 634: nc = 0; ! 635: cc = 0; ! 636: ! 637: cp = (char *) execargsp; ! 638: cc = NCARGS - savedpathlen - 2*NBPW; ! 639: ps.ps_argvstr = (char *)ucp; /* first argv string */ ! 640: ps.ps_nargvstr = na - ne; /* argc */ ! 641: for (;;) { ! 642: ap += NBPW; ! 643: if (na == ne) { ! 644: (void) suword((caddr_t)ap, 0); ! 645: ap += NBPW; ! 646: ps.ps_envstr = (char *)ucp; ! 647: ps.ps_nenvstr = ne; ! 648: } ! 649: if (--na < 0) ! 650: break; ! 651: (void) suword((caddr_t)ap, ucp); ! 652: do { ! 653: error = copyoutstr(cp, (caddr_t)ucp, ! 654: (unsigned)cc, &len); ! 655: ucp += len; ! 656: cp += len; ! 657: nc += len; ! 658: cc -= len; ! 659: } while (error == ENAMETOOLONG); ! 660: if (error == EFAULT) ! 661: break; /* bad stack - user's problem */ ! 662: } ! 663: (void) suword((caddr_t)ap, 0); ! 664: } ! 665: ! 666: if (load_result.dynlinker) { ! 667: ap = uthread->uu_ar0[SP] -= 4; ! 668: (void) suword((caddr_t)ap, load_result.mach_header); ! 669: } ! 670: ! 671: #if defined(i386) || defined(ppc) ! 672: uthread->uu_ar0[PC] = load_result.entry_point; ! 673: #else ! 674: #error architecture not implemented! ! 675: #endif ! 676: ! 677: /* ! 678: * Reset signal state. ! 679: */ ! 680: execsigs(p); ! 681: ! 682: /* ! 683: * Close file descriptors ! 684: * which specify close-on-exec. ! 685: */ ! 686: fdexec(p); ! 687: /* FIXME: Till vmspace inherit is fixed: */ ! 688: if (p->vm_shm) ! 689: shmexit(p); ! 690: ! 691: /* ! 692: * Remember file name for accounting. ! 693: */ ! 694: p->p_acflag &= ~AFORK; ! 695: if (nd.ni_cnd.cn_namelen > MAXCOMLEN) ! 696: nd.ni_cnd.cn_namelen = MAXCOMLEN; ! 697: bcopy((caddr_t)nd.ni_cnd.cn_nameptr, (caddr_t)p->p_comm, ! 698: (unsigned)nd.ni_cnd.cn_namelen); ! 699: p->p_comm[nd.ni_cnd.cn_namelen] = '\0'; ! 700: ! 701: { ! 702: /* This is for kdebug */ ! 703: long dbg_arg1, dbg_arg2, dbg_arg3, dbg_arg4; ! 704: ! 705: /* Collect the pathname for tracing */ ! 706: kdbg_trace_string(p, &dbg_arg1, &dbg_arg2, &dbg_arg3, &dbg_arg4); ! 707: KERNEL_DEBUG_CONSTANT((TRACEDBG_CODE(DBG_TRACE_STRING, 2)) | DBG_FUNC_NONE, ! 708: dbg_arg1, dbg_arg2, dbg_arg3, dbg_arg4, 0); ! 709: } ! 710: ! 711: /* ! 712: * mark as execed, wakeup the process that vforked (if any) and tell ! 713: * it that it now has it's own resources back ! 714: */ ! 715: p->p_flag |= P_EXEC; ! 716: if (p->p_pptr && (p->p_flag & P_PPWAIT)) { ! 717: p->p_flag &= ~P_PPWAIT; ! 718: wakeup((caddr_t)p->p_pptr); ! 719: } ! 720: ! 721: bad: ! 722: FREE_ZONE(nd.ni_cnd.cn_pnbuf, nd.ni_cnd.cn_pnlen, M_NAMEI); ! 723: if (vp) ! 724: vput(vp); ! 725: bad1: ! 726: #if FIXME /* [ */ ! 727: if (execargs) ! 728: kmem_free_wakeup(bsd_pageable_map, execargs, NCARGS); ! 729: #else /* FIXME ][ */ ! 730: if (execargs) ! 731: kmem_free(bsd_pageable_map, execargs, NCARGS); ! 732: #endif /* FIXME ] */ ! 733: return(error); ! 734: } ! 735: ! 736: ! 737: #define unix_stack_size(p) (p->p_rlimit[RLIMIT_STACK].rlim_cur) ! 738: ! 739: kern_return_t ! 740: create_unix_stack(map, user_stack, p) ! 741: vm_map_t map; ! 742: vm_offset_t user_stack; ! 743: struct proc *p; ! 744: { ! 745: vm_size_t size; ! 746: vm_offset_t addr; ! 747: ! 748: p->user_stack = user_stack; ! 749: size = round_page(unix_stack_size(p)); ! 750: #if STACK_GROWTH_UP ! 751: /* stack always points to first address for stacks */ ! 752: addr = user_stack; ! 753: #else STACK_GROWTH_UP ! 754: addr = trunc_page(user_stack - size); ! 755: #endif /* STACK_GROWTH_UP */ ! 756: return (vm_allocate(map,&addr, size, FALSE)); ! 757: } ! 758: ! 759: #include <sys/reboot.h> ! 760: ! 761: char init_program_name[128] = "/sbin/mach_init\0"; ! 762: ! 763: char init_args[128] = ""; ! 764: ! 765: struct execve_args init_exec_args; ! 766: int init_attempts = 0; ! 767: ! 768: ! 769: void ! 770: load_init_program(p) ! 771: struct proc *p; ! 772: { ! 773: vm_offset_t init_addr; ! 774: int *old_ap; ! 775: char *argv[3]; ! 776: int error; ! 777: register_t retval[2]; ! 778: struct uthread * ut; ! 779: ! 780: unix_master(); ! 781: ! 782: error = 0; ! 783: ! 784: /* init_args are copied in string form directly from bootstrap */ ! 785: ! 786: do { ! 787: if (boothowto & RB_INITNAME) { ! 788: printf("init program? "); ! 789: #if FIXME /* [ */ ! 790: gets(init_program_name, init_program_name); ! 791: #endif /* FIXME ] */ ! 792: } ! 793: ! 794: if (error && ((boothowto & RB_INITNAME) == 0) && ! 795: (init_attempts == 1)) { ! 796: static char other_init[] = "/etc/mach_init"; ! 797: printf("Load of %s, errno %d, trying %s\n", ! 798: init_program_name, error, other_init); ! 799: error = 0; ! 800: bcopy(other_init, init_program_name, ! 801: sizeof(other_init)); ! 802: } ! 803: ! 804: init_attempts++; ! 805: ! 806: if (error) { ! 807: printf("Load of %s failed, errno %d\n", ! 808: init_program_name, error); ! 809: error = 0; ! 810: boothowto |= RB_INITNAME; ! 811: continue; ! 812: } ! 813: ! 814: /* ! 815: * Copy out program name. ! 816: */ ! 817: ! 818: init_addr = VM_MIN_ADDRESS; ! 819: (void) vm_allocate(current_map(), &init_addr, ! 820: PAGE_SIZE, TRUE); ! 821: if (init_addr == 0) ! 822: init_addr++; ! 823: (void) copyout((caddr_t) init_program_name, ! 824: (caddr_t) (init_addr), ! 825: (unsigned) sizeof(init_program_name)+1); ! 826: ! 827: argv[0] = (char *) init_addr; ! 828: init_addr += sizeof(init_program_name); ! 829: init_addr = (vm_offset_t)ROUND_PTR(char, init_addr); ! 830: ! 831: /* ! 832: * Put out first (and only) argument, similarly. ! 833: * Assumes everything fits in a page as allocated ! 834: * above. ! 835: */ ! 836: ! 837: (void) copyout((caddr_t) init_args, ! 838: (caddr_t) (init_addr), ! 839: (unsigned) sizeof(init_args)); ! 840: ! 841: argv[1] = (char *) init_addr; ! 842: init_addr += sizeof(init_args); ! 843: init_addr = (vm_offset_t)ROUND_PTR(char, init_addr); ! 844: ! 845: /* ! 846: * Null-end the argument list ! 847: */ ! 848: ! 849: argv[2] = (char *) 0; ! 850: ! 851: /* ! 852: * Copy out the argument list. ! 853: */ ! 854: ! 855: (void) copyout((caddr_t) argv, ! 856: (caddr_t) (init_addr), ! 857: (unsigned) sizeof(argv)); ! 858: ! 859: /* ! 860: * Set up argument block for fake call to execve. ! 861: */ ! 862: ! 863: init_exec_args.fname = argv[0]; ! 864: init_exec_args.argp = (char **) init_addr; ! 865: init_exec_args.envp = 0; ! 866: ! 867: error = execve(p,&init_exec_args,retval); ! 868: } while (error); ! 869: ! 870: unix_release(); ! 871: } ! 872: ! 873: /* ! 874: * Convert a load_return_t to an errno. ! 875: */ ! 876: static int ! 877: load_return_to_errno(load_return_t lrtn) ! 878: { ! 879: switch (lrtn) { ! 880: case LOAD_SUCCESS: ! 881: return 0; ! 882: case LOAD_BADARCH: ! 883: return EBADARCH; ! 884: case LOAD_BADMACHO: ! 885: return EBADMACHO; ! 886: case LOAD_SHLIB: ! 887: return ESHLIBVERS; ! 888: case LOAD_NOSPACE: ! 889: return ENOMEM; ! 890: case LOAD_PROTECT: ! 891: return EACCES; ! 892: case LOAD_RESOURCE: ! 893: case LOAD_FAILURE: ! 894: default: ! 895: return EBADEXEC; ! 896: } ! 897: } ! 898: ! 899: /* ! 900: * exec_check_access() ! 901: */ ! 902: int ! 903: check_exec_access(p, vp, vap) ! 904: struct proc *p; ! 905: struct vnode *vp; ! 906: struct vattr *vap; ! 907: { ! 908: int flag; ! 909: int error; ! 910: ! 911: if (error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p)) ! 912: return (error); ! 913: flag = p->p_flag; ! 914: if (flag & P_TRACED) { ! 915: if (error = VOP_ACCESS(vp, VREAD, p->p_ucred, p)) ! 916: return (error); ! 917: } ! 918: if (vp->v_type != VREG || ! 919: (vap->va_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) == 0) ! 920: return (EACCES); ! 921: return (0); ! 922: } ! 923:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.