![[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 Darwin 0.x] / kernel / bsd / kern|
Return to kern_exec.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Mach Operating System
28: * Copyright (c) 1987 Carnegie-Mellon University
29: * All rights reserved. The CMU software License Agreement specifies
30: * the terms and conditions for use and redistribution.
31: */
32: /*
33: * HISTORY
34: * 11 Dec 1997 Umesh Vaishampayan ([email protected])
35: * Modified execve() to do the allocation for arguments before locking the inode. Cleaned up
36: * warnings.
37: *
38: * 20 Jun 1995 Mac Gillon (mgillon) at NeXT
39: * 4.4 based version
40: *
41: * 18 May 1992 ? at NeXT
42: * Expanded fat file support to handle little endian machines.
43: *
44: * 6-Dec-91 Peter King (king) at NeXT
45: * NeXT: Fat file support.
46: *
47: * 7-Nov-90 Gregg Kellogg (gk) at NeXT
48: * NeXT: reset signal interrupt bits on exec.
49: *
50: * 25-Sep-89 Morris Meyer (mmeyer) at NeXT
51: * NFS 4.0 Changes: Changed SPAGI to SPAGV. Removed #include dir.h.
52: *
53: * 24-Oct-88 Steve Stone (steve) at NeXT
54: * Added Attach trace support.
55: *
56: * 22-Jul-88 Avadis Tevanian, Jr. (avie) at NeXT
57: * Support for Mach-O files.
58: *
59: * 19-Apr-88 Avadis Tevanian, Jr. (avie) at NeXT
60: * Removed old history, purged lots of dead code.
61: */
62:
63: #include <cputypes.h>
64:
65: /*-
66: * Copyright (c) 1982, 1986, 1991, 1993
67: * The Regents of the University of California. All rights reserved.
68: * (c) UNIX System Laboratories, Inc.
69: * All or some portions of this file are derived from material licensed
70: * to the University of California by American Telephone and Telegraph
71: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
72: * the permission of UNIX System Laboratories, Inc.
73: *
74: * Redistribution and use in source and binary forms, with or without
75: * modification, are permitted provided that the following conditions
76: * are met:
77: * 1. Redistributions of source code must retain the above copyright
78: * notice, this list of conditions and the following disclaimer.
79: * 2. Redistributions in binary form must reproduce the above copyright
80: * notice, this list of conditions and the following disclaimer in the
81: * documentation and/or other materials provided with the distribution.
82: * 3. All advertising materials mentioning features or use of this software
83: * must display the following acknowledgement:
84: * This product includes software developed by the University of
85: * California, Berkeley and its contributors.
86: * 4. Neither the name of the University nor the names of its contributors
87: * may be used to endorse or promote products derived from this software
88: * without specific prior written permission.
89: *
90: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
91: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
92: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
93: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
94: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
95: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
96: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
97: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
98: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
99: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
100: * SUCH DAMAGE.
101: *
102: * from: @(#)kern_exec.c 8.1 (Berkeley) 6/10/93
103: */
104: #include <mach_nbc.h>
105: #include <machine/reg.h>
106:
107: #include <sys/param.h>
108: #include <sys/systm.h>
109: #include <sys/filedesc.h>
110: #include <sys/kernel.h>
111: #include <sys/proc.h>
112: #include <sys/user.h>
113: #include <sys/buf.h>
114: #include <sys/socketvar.h>
115: #include <sys/malloc.h>
116: #include <sys/namei.h>
117: #include <sys/mount.h>
118: #include <sys/vnode.h>
119: #include <sys/file.h>
120: #include <sys/stat.h>
121: #include <sys/uio.h>
122: #include <sys/acct.h>
123: #include <sys/exec.h>
124: #include <mach/exception.h>
125:
126: #include <sys/signal.h>
127: #include <kern/task.h>
128: #include <kern/thread.h>
129:
130: #include <mach/vm_param.h>
131: #include <vm/vm_map.h>
132: #include <vm/vm_object.h>
133: #include <vm/vnode_pager.h>
134: #include <vm/vm_kern.h>
135: #include <vm/vm_user.h>
136: #include <kern/mapfs.h>
137: #include <kern/zalloc.h>
138:
139: #include <kern/parallel.h>
140: #include <kern/mach_loader.h>
141:
142: #include <mach-o/fat.h>
143: #include <mach-o/loader.h>
144:
145: #include <machine/vmparam.h>
146: #include <kernserv/c_utils.h>
147:
148: static int load_return_to_errno(load_return_t lrtn);
149: int execve(struct proc *p, struct execve_args *uap, register_t *retval);
150:
151: int
152: execv(p, args, retval)
153: struct proc *p;
154: void *args;
155: int *retval;
156: {
157: ((struct execve_args *)args)->envp = NULL;
158: return (execve(p, args, retval));
159: }
160:
161: /* ARGSUSED */
162: int
163: execve(p, uap, retval)
164: register struct proc *p;
165: register struct execve_args *uap;
166: register_t *retval;
167: {
168: register struct ucred *cred = p->p_ucred;
169: register struct filedesc *fdp = p->p_fd;
170: register nc;
171: register char *cp;
172: int na, ne, ucp, ap, cc;
173: unsigned len;
174: int indir;
175: char *sharg;
176: char *execnamep;
177: struct vnode *vp;
178: struct vattr vattr;
179: struct vattr origvattr;
180: vm_offset_t execargs;
181: struct nameidata nd;
182: struct ps_strings ps;
183: #define SHSIZE 512
184: char cfarg[SHSIZE];
185: boolean_t is_fat;
186: struct mach_header *mach_header;
187: struct fat_header *fat_header;
188: struct fat_arch fat_arch;
189: load_return_t lret;
190: load_result_t load_result;
191: struct uthread *uthread;
192: int i;
193: union {
194: /* #! and name of interpreter */
195: char ex_shell[SHSIZE];
196: /* Mach-O executable */
197: struct mach_header mach_header;
198: /* Fat executable */
199: struct fat_header fat_header;
200: char pad[512];
201: } exdata;
202: int resid, error;
203:
204: /* Start with an allocation */
205: execargs = kmem_alloc_wait(kernel_pageable_map, NCARGS);
206:
207: uthread = current_thread()->_uthread;
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: if (*cp) {
330: *cp++ = '\0';
331: while (*cp == ' ')
332: cp++;
333: if (*cp)
334: bcopy((caddr_t)cp, (caddr_t)cfarg, SHSIZE);
335: }
336: indir = 1;
337: vput(vp);
338: nd.ni_cnd.cn_nameiop = LOOKUP;
339: nd.ni_cnd.cn_flags = (nd.ni_cnd.cn_flags & HASBUF) |
340: (FOLLOW | LOCKLEAF | SAVENAME);
341: nd.ni_segflg = UIO_SYSSPACE;
342: nd.ni_dirp = execnamep;
343: if ((error = namei(&nd)))
344: goto bad1;
345: vp = nd.ni_vp;
346: VOP_LEASE(vp, p, cred, LEASE_READ);
347: if ((error = VOP_GETATTR(vp, &vattr, p->p_ucred, p)))
348: goto bad;
349: goto again;
350: }
351:
352: /*
353: * Collect arguments on "file" in swap space.
354: */
355: na = 0;
356: ne = 0;
357: nc = 0;
358: cc = 0;
359: /* execargs gets allocated at the begining */
360: cp = (char *) execargs; /* running pointer for copy */
361: cc = NCARGS; /* size of execargs */
362: /*
363: * Copy arguments into file in argdev area.
364: */
365: if (uap->argp) for (;;) {
366: ap = NULL;
367: sharg = NULL;
368: if (indir && na == 0) {
369: sharg = nd.ni_cnd.cn_nameptr;
370: ap = (int)sharg;
371: uap->argp++; /* ignore argv[0] */
372: } else if (indir && (na == 1 && cfarg[0])) {
373: sharg = cfarg;
374: ap = (int)sharg;
375: } else if (indir && (na == 1 || (na == 2 && cfarg[0])))
376: ap = (int)uap->fname;
377: else if (uap->argp) {
378: ap = fuword((caddr_t)uap->argp);
379: uap->argp++;
380: }
381: if (ap == NULL && uap->envp) {
382: uap->argp = NULL;
383: if ((ap = fuword((caddr_t)uap->envp)) != NULL)
384: uap->envp++, ne++;
385: }
386: if (ap == NULL)
387: break;
388: na++;
389: if (ap == -1) {
390: error = EFAULT;
391: break;
392: }
393: do {
394: if (nc >= NCARGS-1) {
395: error = E2BIG;
396: break;
397: }
398: if (sharg) {
399: error = copystr(sharg, cp, (unsigned)cc, &len);
400: sharg += len;
401: } else {
402: error = copyinstr((caddr_t)ap, cp, (unsigned)cc,
403: &len);
404: ap += len;
405: }
406: cp += len;
407: nc += len;
408: cc -= len;
409: } while (error == ENAMETOOLONG);
410: if (error) {
411: goto bad;
412: }
413: }
414: nc = (nc + NBPW-1) & ~(NBPW-1);
415:
416: /*
417: * If we have a fat file, find "our" executable.
418: */
419: if (is_fat) {
420: /*
421: * Look up our architecture in the fat file.
422: */
423: lret = fatfile_getarch(vp, (vm_offset_t)fat_header, &fat_arch);
424: if (lret != LOAD_SUCCESS) {
425: error = load_return_to_errno(lret);
426: goto bad;
427: }
428: /* Read the Mach-O header out of it */
429: #if MACH_NBC
430: /*
431: * because exec doesn't go through open and close
432: * we need to map the vnode for proper coherency
433: * and then unmap it to release the kernel map
434: */
435: map_vnode(vp, p);
436: #endif /* MACH_NBC */
437: error = vn_rdwr(UIO_READ, vp, (caddr_t)&exdata.mach_header,
438: sizeof (exdata.mach_header),
439: fat_arch.offset,
440: UIO_SYSSPACE, (IO_UNIT|IO_NODELOCKED), cred, &resid, p);
441: #if MACH_NBC
442: unmap_vnode(vp, p);
443: #endif /* MACH_NBC */
444:
445: if (error) {
446: goto bad;
447: }
448:
449: /* Did we read a complete header? */
450: if (resid) {
451: error = EBADEXEC;
452: goto bad;
453: }
454:
455: /* Is what we found a Mach-O executable */
456: if (mach_header->magic != MH_MAGIC) {
457: error = ENOEXEC;
458: goto bad;
459: }
460:
461: /*
462: * Load the Mach-O file.
463: */
464: #if !MACH_NBC
465: VOP_UNLOCK(vp, 0, p);
466: #endif /* !MACH_NBC */
467: lret = load_machfile(vp, mach_header, fat_arch.offset,
468: fat_arch.size, &load_result);
469: } else {
470: /*
471: * Load the Mach-O file.
472: */
473: #if !MACH_NBC
474: VOP_UNLOCK(vp, 0, p);
475: #endif /* !MACH_NBC */
476: lret = load_machfile(vp, mach_header, 0,
477: (u_long)vattr.va_size, &load_result);
478: }
479:
480: if (lret != LOAD_SUCCESS) {
481: error = load_return_to_errno(lret);
482: goto bad;
483: }
484:
485: /*
486: * deal with set[ug]id.
487: */
488: p->p_flag &= ~P_SUGID;
489: if (((origvattr.va_mode & VSUID) != 0 &&
490: p->p_ucred->cr_uid != origvattr.va_uid)
491: || (origvattr.va_mode & VSGID) != 0 &&
492: p->p_ucred->cr_gid != origvattr.va_gid) {
493: p->p_ucred = crcopy(cred);
494: #if KTRACE
495: /*
496: * If process is being ktraced, turn off - unless
497: * root set it.
498: */
499: if (p->p_tracep && !(p->p_traceflag & KTRFAC_ROOT)) {
500: vrele(p->p_tracep);
501: p->p_tracep = NULL;
502: p->p_traceflag = 0;
503: }
504: #endif
505: if (origvattr.va_mode & VSUID)
506: p->p_ucred->cr_uid = origvattr.va_uid;
507: if (origvattr.va_mode & VSGID)
508: p->p_ucred->cr_gid = origvattr.va_gid;
509: p->p_flag |= P_SUGID;
510: /* Radar 2261856; setuid security hole fix */
511: /* Patch from OpenBSD: A. Ramesh */
512: /*
513: * XXX For setuid processes, attempt to ensure that
514: * stdin, stdout, and stderr are already allocated.
515: * We do not want userland to accidentally allocate
516: * descriptors in this range which has implied meaning
517: * to libc.
518: */
519: for (i = 0; i < 3; i++) {
520: extern struct fileops vnops;
521: struct nameidata nd1;
522: struct file *fp;
523: int indx;
524:
525: if (p->p_fd->fd_ofiles[i] == NULL) {
526: if ((error = falloc(p, &fp, &indx)) != 0)
527: continue;
528: NDINIT(&nd1, LOOKUP, FOLLOW, UIO_SYSSPACE,
529: "/dev/null", p);
530: if ((error = vn_open(&nd1, FREAD, 0)) != 0) {
531: ffree(fp);
532: p->p_fd->fd_ofiles[indx] = NULL;
533: break;
534: }
535: fp->f_flag = FREAD;
536: fp->f_type = DTYPE_VNODE;
537: fp->f_ops = &vnops;
538: fp->f_data = (caddr_t)nd1.ni_vp;
539: VOP_UNLOCK(nd1.ni_vp, 0, p);
540: }
541: }
542:
543:
544:
545: }
546: p->p_cred->p_svuid = p->p_ucred->cr_uid;
547: p->p_cred->p_svgid = p->p_ucred->cr_gid;
548:
549: if (p->p_flag & P_TRACED)
550: exception_from_kernel(EXC_BREAKPOINT, 0, 0);
551:
552: /*
553: * Temp hack until ld changes... allocate page 0 if its not
554: * already allocated.
555: *
556: * FIXME: ld has changed, can we remove this yet? -PK
557: */
558: {
559: vm_offset_t addr = 0;
560: kern_return_t ret;
561:
562: ret = vm_allocate(current_task()->map, &addr, PAGE_SIZE,
563: FALSE);
564: if (ret == KERN_SUCCESS) {
565: (void)vm_protect(current_task()->map, 0, PAGE_SIZE,
566: FALSE, VM_PROT_NONE);
567: }
568: }
569: if (error) {
570: /*
571: * NOTE: to prevent a race condition, getxfile had
572: * to temporarily unlock the inode. If new code needs to
573: * be inserted here before the iput below, and it needs
574: * to deal with the inode, keep this in mind.
575: */
576: goto bad;
577: }
578: VOP_LOCK(vp, LK_EXCLUSIVE | LK_RETRY, p);
579: vput(vp);
580: vp = NULL;
581:
582: if (load_result.unixproc &&
583: create_unix_stack(current_task()->map,
584: load_result.user_stack, p)) {
585: error = load_return_to_errno(LOAD_NOSPACE);
586: goto bad;
587: }
588:
589: /*
590: * Copy back arglist if necessary.
591: */
592:
593: ucp = p->user_stack;
594: if (load_result.unixproc) {
595: #if STACK_GROWTH_UP
596: /* for stacks that grow up we:
597: * place storage for the ps_strings stuff
598: * put a pointer to the end of the string area at
599: * the beginning of the stack (used by table()),
600: * put a pointer to the arg area where we start the
601: * process stack pointer.
602: */
603: ap = ucp + NBPW; // leave word for string ptr
604: (void) suword((caddr_t)ap, load_result.mach_header); // dyld
605: ap += NBPW;
606: ucp = ap + na*NBPW + 3*NBPW;
607: (void) suword((caddr_t)(ap - 2 * NBPW), ucp + nc);
608: uthread->uu_ar0[SP] = ucp + nc;
609: (void) suword((caddr_t)uthread->uu_ar0[SP], 0);
610: uthread->uu_ar0[SP] += NBPW;
611: (void) suword((caddr_t)uthread->uu_ar0[SP], ap);
612: #else STACK_GROWTH_UP
613: ucp = ucp - nc - NBPW;
614: ap = ucp - na*NBPW - 3*NBPW;
615: uthread->uu_ar0[SP] = ap;
616: #endif /* STACK_GROWTH_UP */
617: (void) suword((caddr_t)ap, na-ne);
618: nc = 0;
619: cc = 0;
620: cp = (char *) execargs;
621: cc = NCARGS;
622: ps.ps_argvstr = (char *)ucp; /* first argv string */
623: ps.ps_nargvstr = na - ne; /* argc */
624: for (;;) {
625: ap += NBPW;
626: if (na == ne) {
627: (void) suword((caddr_t)ap, 0);
628: ap += NBPW;
629: ps.ps_envstr = (char *)ucp;
630: ps.ps_nenvstr = ne;
631: }
632: if (--na < 0)
633: break;
634: (void) suword((caddr_t)ap, ucp);
635: do {
636: error = copyoutstr(cp, (caddr_t)ucp,
637: (unsigned)cc, &len);
638: ucp += len;
639: cp += len;
640: nc += len;
641: cc -= len;
642: } while (error == ENOENT);
643: if (error == EFAULT)
644: break; /* bad stack - user's problem */
645: }
646: (void) suword((caddr_t)ap, 0);
647: // (void) copyout((caddr_t)&ps, (caddr_t)PS_STRINGS, sizeof(ps));
648: }
649:
650: #if STACK_GROWTH_UP
651: #else STACK_GROWTH_UP
652: if (load_result.dynlinker) {
653: ap = uthread->uu_ar0[SP] -= 4;
654: (void) suword((caddr_t)ap, load_result.mach_header);
655: }
656: #endif /* STACK_GROWTH_UP */
657:
658: /*
659: * This is GROSS XXX FIXME
660: */
661: #if defined(i386) || defined(ppc)
662: uthread->uu_ar0[PC] = load_result.entry_point;
663: #else
664: #error architecture not implemented!
665: #endif
666:
667: /*
668: * Reset signal state.
669: */
670: execsigs(p);
671:
672: /*
673: * Close file descriptors
674: * which specify close-on-exec.
675: */
676: fdexec(p);
677:
678: /*
679: * Remember file name for accounting.
680: */
681: p->p_acflag &= ~AFORK;
682: if (nd.ni_cnd.cn_namelen > MAXCOMLEN)
683: nd.ni_cnd.cn_namelen = MAXCOMLEN;
684: bcopy((caddr_t)nd.ni_cnd.cn_nameptr, (caddr_t)p->p_comm,
685: (unsigned)nd.ni_cnd.cn_namelen);
686: p->p_comm[nd.ni_cnd.cn_namelen] = '\0';
687:
688: /*
689: * mark as execed, wakeup the process that vforked (if any) and tell
690: * it that it now has it's own resources back
691: */
692: p->p_flag |= P_EXEC;
693: if (p->p_pptr && (p->p_flag & P_PPWAIT)) {
694: p->p_flag &= ~P_PPWAIT;
695: wakeup((caddr_t)p->p_pptr);
696: }
697:
698: bad:
699: FREE_ZONE(nd.ni_cnd.cn_pnbuf, nd.ni_cnd.cn_pnlen, M_NAMEI);
700: if (vp)
701: vput(vp);
702: bad1:
703: if (execargs)
704: kmem_free_wakeup(kernel_pageable_map, execargs, NCARGS);
705: return(error);
706: }
707:
708:
709: #define unix_stack_size(p) (p->p_rlimit[RLIMIT_STACK].rlim_cur)
710:
711: kern_return_t create_unix_stack(map, user_stack, p)
712: vm_map_t map;
713: vm_offset_t user_stack;
714: struct proc *p;
715: {
716: vm_size_t size;
717: vm_offset_t addr;
718:
719: p->user_stack = user_stack;
720: size = round_page(unix_stack_size(p));
721: #if STACK_GROWTH_UP
722: // stack always points to first address for stacks
723: addr = user_stack;
724: #else STACK_GROWTH_UP
725: addr = trunc_page(user_stack - size);
726: #endif /* STACK_GROWTH_UP */
727: return(vm_map_find(map, VM_OBJECT_NULL, (vm_offset_t) 0,
728: &addr, size, FALSE));
729: }
730:
731: #include <sys/reboot.h>
732:
733: char init_program_name[128] = "/sbin/mach_init\0";
734:
735: char init_args[128] = "-D\0";
736:
737: struct execve_args init_exec_args;
738: int init_attempts = 0;
739:
740:
741: void load_init_program(p)
742: struct proc *p;
743: {
744: vm_offset_t init_addr;
745: int *old_ap;
746: char *argv[3];
747: int error;
748: register_t retval[2];
749:
750:
751: unix_master();
752:
753: error = 0;
754:
755: /* init_args are copied in string form directly from bootstrap */
756:
757: do {
758: if (boothowto & RB_INITNAME) {
759: printf("init program? ");
760: gets(init_program_name, init_program_name);
761: }
762:
763: if (error && ((boothowto & RB_INITNAME) == 0) &&
764: (init_attempts == 1)) {
765: static char other_init[] = "/etc/mach_init";
766: printf("Load of %s, errno %d, trying %s\n",
767: init_program_name, error, other_init);
768: error = 0;
769: bcopy(other_init, init_program_name,
770: sizeof(other_init));
771: }
772:
773: init_attempts++;
774:
775: if (error) {
776: printf("Load of %s failed, errno %d\n",
777: init_program_name, error);
778: error = 0;
779: boothowto |= RB_INITNAME;
780: continue;
781: }
782:
783: /*
784: * Copy out program name.
785: */
786:
787: init_addr = VM_MIN_ADDRESS;
788: (void) vm_allocate(current_task()->map, &init_addr,
789: PAGE_SIZE, TRUE);
790: if (init_addr == 0)
791: init_addr++;
792: (void) copyout((caddr_t) init_program_name,
793: (caddr_t) (init_addr),
794: (unsigned) sizeof(init_program_name)+1);
795:
796: argv[0] = (char *) init_addr;
797: init_addr += sizeof(init_program_name);
798: init_addr = (vm_offset_t)ROUND_PTR(char, init_addr);
799:
800: /*
801: * Put out first (and only) argument, similarly.
802: * Assumes everything fits in a page as allocated
803: * above.
804: */
805:
806: (void) copyout((caddr_t) init_args,
807: (caddr_t) (init_addr),
808: (unsigned) sizeof(init_args));
809:
810: argv[1] = (char *) init_addr;
811: init_addr += sizeof(init_args);
812: init_addr = (vm_offset_t)ROUND_PTR(char, init_addr);
813:
814: /*
815: * Null-end the argument list
816: */
817:
818: argv[2] = (char *) 0;
819:
820: /*
821: * Copy out the argument list.
822: */
823:
824: (void) copyout((caddr_t) argv,
825: (caddr_t) (init_addr),
826: (unsigned) sizeof(argv));
827:
828: /*
829: * Set up argument block for fake call to execve.
830: */
831:
832: init_exec_args.fname = argv[0];
833: init_exec_args.argp = (char **) init_addr;
834: init_exec_args.envp = 0;
835:
836: old_ap = current_thread()->_uthread->uu_ap;
837: current_thread()->_uthread->uu_ap = (int *) &init_exec_args;
838: error = execve(p,&init_exec_args,retval);
839: current_thread()->_uthread->uu_ap = old_ap;
840: } while (error);
841:
842: unix_release();
843: }
844:
845: /*
846: * Convert a load_return_t to an errno.
847: */
848: static int load_return_to_errno(load_return_t lrtn)
849: {
850: switch (lrtn) {
851: case LOAD_SUCCESS:
852: return 0;
853: case LOAD_BADARCH:
854: return EBADARCH;
855: case LOAD_BADMACHO:
856: return EBADMACHO;
857: case LOAD_SHLIB:
858: return ESHLIBVERS;
859: case LOAD_NOSPACE:
860: return ENOMEM;
861: case LOAD_PROTECT:
862: return EACCES;
863: case LOAD_RESOURCE:
864: case LOAD_FAILURE:
865: default:
866: return EBADEXEC;
867: }
868: }
869:
870: /*
871: * exec_check_access()
872: */
873: int
874: check_exec_access(p, vp, vap)
875: struct proc *p;
876: struct vnode *vp;
877: struct vattr *vap;
878: {
879: int flag;
880: int error;
881:
882: if (error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p))
883: return (error);
884: flag = p->p_flag;
885: if (flag & P_TRACED) {
886: if (error = VOP_ACCESS(vp, VREAD, p->p_ucred, p))
887: return (error);
888: }
889: if (vp->v_type != VREG ||
890: (vap->va_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) == 0)
891: return (EACCES);
892: return (0);
893: }
894:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.