![[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 [CSRG BSD Unix] / 43BSDReno / sys / kern|
Return to kern_exec.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / kern |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution is only permitted until one year after the first shipment
6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
7: * binary forms are permitted provided that: (1) source distributions retain
8: * this entire copyright notice and comment, and (2) distributions including
9: * binaries display the following acknowledgement: This product includes
10: * software developed by the University of California, Berkeley and its
11: * contributors'' in the documentation or other materials provided with the
12: * distribution and in all advertising materials mentioning features or use
13: * of this software. Neither the name of the University nor the names of
14: * its contributors may be used to endorse or promote products derived from
15: * this software without specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: *
20: * @(#)kern_exec.c 7.30 (Berkeley) 6/30/90
21: */
22:
23: #include "param.h"
24: #include "systm.h"
25: #include "map.h"
26: #include "user.h"
27: #include "kernel.h"
28: #include "proc.h"
29: #include "mount.h"
30: #include "ucred.h"
31: #include "malloc.h"
32: #include "buf.h"
33: #include "vnode.h"
34: #include "seg.h"
35: #include "vm.h"
36: #include "text.h"
37: #include "file.h"
38: #include "uio.h"
39: #include "acct.h"
40: #include "exec.h"
41:
42: #include "machine/reg.h"
43: #include "machine/pte.h"
44: #include "machine/psl.h"
45: #include "machine/mtpr.h"
46:
47: #ifdef HPUXCOMPAT
48: #include "../hpux/hpux_exec.h"
49: #endif
50:
51: /*
52: * exec system call, with and without environments.
53: */
54: execv(p, uap, retval)
55: struct proc *p;
56: struct args {
57: char *fname;
58: char **argp;
59: char **envp;
60: } *uap;
61: int *retval;
62: {
63:
64: uap->envp = NULL;
65: return (execve(p, uap, retval));
66: }
67:
68: /* ARGSUSED */
69: execve(p, uap, retval)
70: register struct proc *p;
71: register struct args {
72: char *fname;
73: char **argp;
74: char **envp;
75: } *uap;
76: int *retval;
77: {
78: register nc;
79: register char *cp;
80: register struct buf *bp;
81: struct buf *tbp;
82: int na, ne, ucp, ap, cc;
83: unsigned len;
84: int indir, uid, gid;
85: char *sharg;
86: struct vnode *vp;
87: swblk_t bno;
88: struct vattr vattr;
89: char cfname[MAXCOMLEN + 1];
90: char cfarg[MAXINTERP];
91: union {
92: char ex_shell[MAXINTERP]; /* #! and interpreter name */
93: struct exec ex_exec;
94: #ifdef HPUXCOMPAT
95: struct hpux_exec ex_hexec;
96: #endif
97: } exdata;
98: #ifdef HPUXCOMPAT
99: struct hpux_exec hhead;
100: #endif
101: register struct ucred *cred = u.u_cred;
102: register struct nameidata *ndp = &u.u_nd;
103: int resid, error, flags = 0;
104:
105: start:
106: ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
107: ndp->ni_segflg = UIO_USERSPACE;
108: ndp->ni_dirp = uap->fname;
109: if (error = namei(ndp))
110: return (error);
111: vp = ndp->ni_vp;
112: bno = 0;
113: bp = 0;
114: indir = 0;
115: uid = cred->cr_uid;
116: gid = cred->cr_gid;
117: if (error = VOP_GETATTR(vp, &vattr, cred))
118: goto bad;
119: if (vp->v_mount->mnt_flag & MNT_NOEXEC) {
120: error = EACCES;
121: goto bad;
122: }
123: if ((vp->v_mount->mnt_flag & MNT_NOSUID) == 0) {
124: if (vattr.va_mode & VSUID)
125: uid = vattr.va_uid;
126: if (vattr.va_mode & VSGID)
127: gid = vattr.va_gid;
128: }
129:
130: again:
131: if (error = VOP_ACCESS(vp, VEXEC, cred))
132: goto bad;
133: if ((p->p_flag & STRC) && (error = VOP_ACCESS(vp, VREAD, cred)))
134: goto bad;
135: if (vp->v_type != VREG ||
136: (vattr.va_mode & (VEXEC|(VEXEC>>3)|(VEXEC>>6))) == 0) {
137: error = EACCES;
138: goto bad;
139: }
140:
141: /*
142: * Read in first few bytes of file for segment sizes, magic number:
143: * OMAGIC = plain executable
144: * NMAGIC = RO text
145: * ZMAGIC = demand paged RO text
146: * Also an ASCII line beginning with #! is
147: * the file name of a ``shell'' and arguments may be prepended
148: * to the argument list if given here.
149: *
150: * SHELL NAMES ARE LIMITED IN LENGTH.
151: *
152: * ONLY ONE ARGUMENT MAY BE PASSED TO THE SHELL FROM
153: * THE ASCII LINE.
154: */
155: exdata.ex_shell[0] = '\0'; /* for zero length files */
156: error = vn_rdwr(UIO_READ, vp, (caddr_t)&exdata, sizeof (exdata),
157: (off_t)0, UIO_SYSSPACE, (IO_UNIT|IO_NODELOCKED), cred, &resid);
158: if (error)
159: goto bad;
160: #ifndef lint
161: if (resid > sizeof(exdata) - sizeof(exdata.ex_exec) &&
162: exdata.ex_shell[0] != '#') {
163: error = ENOEXEC;
164: goto bad;
165: }
166: #endif
167: #if defined(hp300)
168: switch ((int)exdata.ex_exec.a_mid) {
169:
170: /*
171: * An ancient hp200 or hp300 binary, shouldn't happen anymore.
172: * Mark as invalid.
173: */
174: case MID_ZERO:
175: exdata.ex_exec.a_magic = 0;
176: break;
177:
178: /*
179: * HP200 series has a smaller page size so we cannot
180: * demand-load or even write protect text, so we just
181: * treat as OMAGIC.
182: */
183: case MID_HP200:
184: exdata.ex_exec.a_magic = OMAGIC;
185: break;
186:
187: case MID_HP300:
188: break;
189:
190: #ifdef HPUXCOMPAT
191: case MID_HPUX:
192: /*
193: * Save a.out header. This is eventually saved in the pcb,
194: * but we cannot do that yet in case the exec fails before
195: * the image is overlayed.
196: */
197: bcopy((caddr_t)&exdata.ex_hexec,
198: (caddr_t)&hhead, sizeof hhead);
199: /*
200: * If version number is 0x2bad this is a native BSD
201: * binary created via the HPUX SGS. Should not be
202: * treated as an HPUX binary.
203: */
204: if (exdata.ex_hexec.ha_version != BSDVNUM)
205: flags |= SHPUX;
206: /*
207: * Shuffle important fields to their BSD locations.
208: * Note that the order in which this is done is important.
209: */
210: exdata.ex_exec.a_text = exdata.ex_hexec.ha_text;
211: exdata.ex_exec.a_data = exdata.ex_hexec.ha_data;
212: exdata.ex_exec.a_bss = exdata.ex_hexec.ha_bss;
213: exdata.ex_exec.a_entry = exdata.ex_hexec.ha_entry;
214: /*
215: * For ZMAGIC files, make sizes consistant with those
216: * generated by BSD ld.
217: */
218: if (exdata.ex_exec.a_magic == ZMAGIC) {
219: exdata.ex_exec.a_text =
220: ctob(btoc(exdata.ex_exec.a_text));
221: nc = exdata.ex_exec.a_data + exdata.ex_exec.a_bss;
222: exdata.ex_exec.a_data =
223: ctob(btoc(exdata.ex_exec.a_data));
224: nc -= (int)exdata.ex_exec.a_data;
225: exdata.ex_exec.a_bss = (nc < 0) ? 0 : nc;
226: }
227: break;
228: #endif
229: }
230: #endif
231: switch ((int)exdata.ex_exec.a_magic) {
232:
233: case OMAGIC:
234: exdata.ex_exec.a_data += exdata.ex_exec.a_text;
235: exdata.ex_exec.a_text = 0;
236: break;
237:
238: case ZMAGIC:
239: flags |= SPAGV;
240: case NMAGIC:
241: if (exdata.ex_exec.a_text == 0) {
242: error = ENOEXEC;
243: goto bad;
244: }
245: break;
246:
247: default:
248: if (exdata.ex_shell[0] != '#' ||
249: exdata.ex_shell[1] != '!' ||
250: indir) {
251: error = ENOEXEC;
252: goto bad;
253: }
254: for (cp = &exdata.ex_shell[2];; ++cp) {
255: if (cp >= &exdata.ex_shell[MAXINTERP]) {
256: error = ENOEXEC;
257: goto bad;
258: }
259: if (*cp == '\n') {
260: *cp = '\0';
261: break;
262: }
263: if (*cp == '\t')
264: *cp = ' ';
265: }
266: cp = &exdata.ex_shell[2];
267: while (*cp == ' ')
268: cp++;
269: ndp->ni_dirp = cp;
270: while (*cp && *cp != ' ')
271: cp++;
272: cfarg[0] = '\0';
273: if (*cp) {
274: *cp++ = '\0';
275: while (*cp == ' ')
276: cp++;
277: if (*cp)
278: bcopy((caddr_t)cp, (caddr_t)cfarg, MAXINTERP);
279: }
280: indir = 1;
281: vput(vp);
282: ndp->ni_nameiop = LOOKUP | FOLLOW | LOCKLEAF;
283: ndp->ni_segflg = UIO_SYSSPACE;
284: if (error = namei(ndp))
285: return (error);
286: vp = ndp->ni_vp;
287: if (error = VOP_GETATTR(vp, &vattr, cred))
288: goto bad;
289: bcopy((caddr_t)ndp->ni_dent.d_name, (caddr_t)cfname,
290: MAXCOMLEN);
291: cfname[MAXCOMLEN] = '\0';
292: uid = cred->cr_uid; /* shell scripts can't be setuid */
293: gid = cred->cr_gid;
294: goto again;
295: }
296: /*
297: * If the vnode has been modified since we last used it,
298: * then throw away all its pages and its text table entry.
299: */
300: if (vp->v_text && vp->v_text->x_mtime != vattr.va_mtime.tv_sec) {
301: /*
302: * Try once to release, if it is still busy
303: * take more drastic action.
304: */
305: xrele(vp);
306: if (vp->v_flag & VTEXT) {
307: vput(vp);
308: vgone(vp);
309: goto start;
310: }
311: }
312:
313: /*
314: * Collect arguments on "file" in swap space.
315: */
316: na = 0;
317: ne = 0;
318: nc = 0;
319: cc = 0;
320: bno = rmalloc(argmap, (long)ctod(clrnd((int)btoc(NCARGS))));
321: if (bno == 0) {
322: swkill(p, "exec: no swap space");
323: goto bad;
324: }
325: if (bno % CLSIZE)
326: panic("execa rmalloc");
327: #ifdef GENERIC
328: if (rootdev == dumpdev)
329: bno += 4096;
330: #endif
331: /*
332: * Copy arguments into file in argdev area.
333: */
334: if (uap->argp) for (;;) {
335: ap = NULL;
336: sharg = NULL;
337: if (indir && na == 0) {
338: sharg = cfname;
339: ap = (int)sharg;
340: uap->argp++; /* ignore argv[0] */
341: } else if (indir && (na == 1 && cfarg[0])) {
342: sharg = cfarg;
343: ap = (int)sharg;
344: } else if (indir && (na == 1 || na == 2 && cfarg[0]))
345: ap = (int)uap->fname;
346: else if (uap->argp) {
347: ap = fuword((caddr_t)uap->argp);
348: uap->argp++;
349: }
350: if (ap == NULL && uap->envp) {
351: uap->argp = NULL;
352: if ((ap = fuword((caddr_t)uap->envp)) != NULL)
353: uap->envp++, ne++;
354: }
355: if (ap == NULL)
356: break;
357: na++;
358: if (ap == -1) {
359: error = EFAULT;
360: if (bp) {
361: brelse(bp);
362: bp = 0;
363: }
364: goto badarg;
365: }
366: do {
367: if (cc <= 0) {
368: /*
369: * We depend on NCARGS being a multiple of
370: * CLBYTES. This way we need only check
371: * overflow before each buffer allocation.
372: */
373: if (nc >= NCARGS-1) {
374: error = E2BIG;
375: break;
376: }
377: if (bp)
378: bdwrite(bp);
379: cc = CLBYTES;
380: bp = getblk(argdev_vp, bno + ctod(nc/NBPG), cc);
381: cp = bp->b_un.b_addr;
382: }
383: if (sharg) {
384: error = copystr(sharg, cp, (unsigned)cc, &len);
385: sharg += len;
386: } else {
387: error = copyinstr((caddr_t)ap, cp, (unsigned)cc,
388: &len);
389: ap += len;
390: }
391: cp += len;
392: nc += len;
393: cc -= len;
394: } while (error == ENOENT);
395: if (error) {
396: if (bp)
397: brelse(bp);
398: bp = 0;
399: goto badarg;
400: }
401: }
402: if (bp)
403: bdwrite(bp);
404: bp = 0;
405: nc = (nc + NBPW-1) & ~(NBPW-1);
406: error = getxfile(p, vp, &exdata.ex_exec, flags, nc + (na+4)*NBPW,
407: uid, gid);
408: if (error) {
409: badarg:
410: for (cc = 0; cc < nc; cc += CLBYTES) {
411: (void) baddr(argdev_vp, bno + ctod(cc/NBPG),
412: CLBYTES, NOCRED, &tbp);
413: bp = tbp;
414: if (bp) {
415: bp->b_flags |= B_INVAL; /* throw away */
416: brelse(bp);
417: bp = 0;
418: }
419: }
420: goto bad;
421: }
422: if (vp->v_text)
423: vp->v_text->x_mtime = vattr.va_mtime.tv_sec;
424: vput(vp);
425: vp = NULL;
426:
427: #ifdef HPUXCOMPAT
428: /*
429: * We are now committed to the exec so we can save the exec
430: * header in the pcb where we can dump it if necessary in core()
431: */
432: if (u.u_pcb.pcb_flags & PCB_HPUXBIN)
433: bcopy((caddr_t)&hhead,
434: (caddr_t)u.u_pcb.pcb_exec, sizeof hhead);
435: #endif
436:
437: /*
438: * Copy back arglist.
439: */
440: ucp = USRSTACK - nc - NBPW;
441: ap = ucp - na*NBPW - 3*NBPW;
442: u.u_ar0[SP] = ap;
443: (void) suword((caddr_t)ap, na-ne);
444: nc = 0;
445: cc = 0;
446: for (;;) {
447: ap += NBPW;
448: if (na == ne) {
449: (void) suword((caddr_t)ap, 0);
450: ap += NBPW;
451: }
452: if (--na < 0)
453: break;
454: (void) suword((caddr_t)ap, ucp);
455: do {
456: if (cc <= 0) {
457: if (bp)
458: brelse(bp);
459: cc = CLBYTES;
460: error = bread(argdev_vp,
461: (daddr_t)(bno + ctod(nc / NBPG)), cc,
462: NOCRED, &tbp);
463: bp = tbp;
464: bp->b_flags |= B_INVAL; /* throw away */
465: cp = bp->b_un.b_addr;
466: }
467: error = copyoutstr(cp, (caddr_t)ucp, (unsigned)cc,
468: &len);
469: ucp += len;
470: cp += len;
471: nc += len;
472: cc -= len;
473: } while (error == ENOENT);
474: if (error == EFAULT)
475: panic("exec: EFAULT");
476: }
477: (void) suword((caddr_t)ap, 0);
478:
479: execsigs(p);
480:
481: for (nc = u.u_lastfile; nc >= 0; --nc) {
482: if (u.u_pofile[nc] & UF_EXCLOSE) {
483: (void) closef(u.u_ofile[nc]);
484: u.u_ofile[nc] = NULL;
485: u.u_pofile[nc] = 0;
486: }
487: u.u_pofile[nc] &= ~UF_MAPPED;
488: }
489: while (u.u_lastfile >= 0 && u.u_ofile[u.u_lastfile] == NULL)
490: u.u_lastfile--;
491: setregs(exdata.ex_exec.a_entry, retval);
492: /*
493: * Remember file name for accounting.
494: */
495: u.u_acflag &= ~AFORK;
496: if (indir)
497: bcopy((caddr_t)cfname, (caddr_t)p->p_comm, MAXCOMLEN);
498: else {
499: if (ndp->ni_dent.d_namlen > MAXCOMLEN)
500: ndp->ni_dent.d_namlen = MAXCOMLEN;
501: bcopy((caddr_t)ndp->ni_dent.d_name, (caddr_t)p->p_comm,
502: (unsigned)(ndp->ni_dent.d_namlen + 1));
503: }
504: bad:
505: if (bp)
506: brelse(bp);
507: if (bno)
508: rmfree(argmap, (long)ctod(clrnd((int) btoc(NCARGS))), bno);
509: if (vp)
510: vput(vp);
511: return (error);
512: }
513:
514: /*
515: * Read in and set up memory for executed file.
516: */
517: getxfile(p, vp, ep, flags, nargc, uid, gid)
518: register struct proc *p;
519: register struct vnode *vp;
520: register struct exec *ep;
521: int flags, nargc, uid, gid;
522: {
523: segsz_t ts, ds, ids, uds, ss;
524: register struct ucred *cred = u.u_cred;
525: off_t toff;
526: int error;
527:
528: #ifdef HPUXCOMPAT
529: if (ep->a_mid == MID_HPUX)
530: toff = sizeof (struct hpux_exec);
531: else
532: #endif
533: toff = sizeof (struct exec);
534: if (vp->v_text && (vp->v_text->x_flag & XTRC))
535: return (ETXTBSY);
536: if (ep->a_text != 0 && (vp->v_flag & VTEXT) == 0 &&
537: vp->v_usecount != 1) {
538: register struct file *fp;
539:
540: for (fp = file; fp < fileNFILE; fp++) {
541: if (fp->f_type == DTYPE_VNODE &&
542: fp->f_count > 0 &&
543: (struct vnode *)fp->f_data == vp &&
544: (fp->f_flag & FWRITE)) {
545: return (ETXTBSY);
546: }
547: }
548: }
549:
550: /*
551: * Compute text and data sizes and make sure not too large.
552: * NB - Check data and bss separately as they may overflow
553: * when summed together.
554: */
555: ts = clrnd(btoc(ep->a_text));
556: ids = clrnd(btoc(ep->a_data));
557: uds = clrnd(btoc(ep->a_bss));
558: ds = clrnd(btoc(ep->a_data + ep->a_bss));
559: ss = clrnd(SSIZE + btoc(nargc));
560: if (error =
561: chksize((unsigned)ts, (unsigned)ids, (unsigned)uds, (unsigned)ss))
562: return (error);
563:
564: /*
565: * Make sure enough space to start process.
566: */
567: u.u_cdmap = zdmap;
568: u.u_csmap = zdmap;
569: if (error = swpexpand(ds, ss, &u.u_cdmap, &u.u_csmap))
570: return (error);
571:
572: /*
573: * At this point, we are committed to the new image!
574: * Release virtual memory resources of old process, and
575: * initialize the virtual memory of the new process.
576: * If we resulted from vfork(), instead wakeup our
577: * parent who will set SVFDONE when he has taken back
578: * our resources.
579: */
580: if ((p->p_flag & SVFORK) == 0) {
581: #ifdef MAPMEM
582: if (u.u_mmap && (error = mmexec(p)))
583: return (error);
584: #endif
585: vrelvm();
586: } else {
587: p->p_flag &= ~SVFORK;
588: p->p_flag |= SKEEP;
589: wakeup((caddr_t)p);
590: while ((p->p_flag & SVFDONE) == 0)
591: sleep((caddr_t)p, PZERO - 1);
592: p->p_flag &= ~(SVFDONE|SKEEP);
593: }
594: #ifdef hp300
595: u.u_pcb.pcb_flags &= ~(PCB_AST|PCB_HPUXMMAP|PCB_HPUXBIN);
596: #ifdef HPUXCOMPAT
597: /* remember that we were loaded from an HPUX format file */
598: if (ep->a_mid == MID_HPUX)
599: u.u_pcb.pcb_flags |= PCB_HPUXBIN;
600: #endif
601: #endif
602: p->p_flag &= ~(SPAGV|SSEQL|SUANOM|SHPUX);
603: p->p_flag |= flags | SEXEC;
604: u.u_dmap = u.u_cdmap;
605: u.u_smap = u.u_csmap;
606: vgetvm(ts, ds, ss);
607:
608: if ((flags & SPAGV) == 0)
609: (void) vn_rdwr(UIO_READ, vp,
610: (char *)ctob(dptov(p, 0)),
611: (int)ep->a_data,
612: (off_t)(toff + ep->a_text),
613: UIO_USERSPACE, (IO_UNIT|IO_NODELOCKED), cred, (int *)0);
614: xalloc(vp, ep, toff, cred);
615: #if defined(tahoe)
616: /*
617: * Define new keys.
618: */
619: if (p->p_textp == 0) { /* use existing code key if shared */
620: ckeyrelease(p->p_ckey);
621: p->p_ckey = getcodekey();
622: }
623: mtpr(CCK, p->p_ckey);
624: dkeyrelease(p->p_dkey);
625: p->p_dkey = getdatakey();
626: mtpr(DCK, p->p_dkey);
627: #endif
628: if ((flags & SPAGV) && p->p_textp)
629: vinifod(p, (struct fpte *)dptopte(p, 0),
630: PG_FTEXT, p->p_textp->x_vptr,
631: (long)(1 + ts/CLSIZE), (segsz_t)btoc(ep->a_data));
632:
633: #if defined(vax) || defined(tahoe)
634: /* THIS SHOULD BE DONE AT A LOWER LEVEL, IF AT ALL */
635: mtpr(TBIA, 0);
636: #endif
637: #ifdef hp300
638: TBIAU();
639: #endif
640: #if defined(i386)
641: tlbflush();
642: #endif
643:
644: /*
645: * set SUID/SGID protections, if no tracing
646: */
647: if ((p->p_flag&STRC)==0) {
648: if (uid != cred->cr_uid || gid != cred->cr_gid)
649: u.u_cred = cred = crcopy(cred);
650: cred->cr_uid = uid;
651: cred->cr_gid = gid;
652: p->p_uid = uid;
653: } else
654: psignal(p, SIGTRAP);
655: p->p_svuid = p->p_uid;
656: p->p_svgid = cred->cr_gid;
657: u.u_tsize = ts;
658: u.u_dsize = ds;
659: u.u_ssize = ss;
660: u.u_prof.pr_scale = 0;
661: #if defined(tahoe)
662: u.u_pcb.pcb_savacc.faddr = (float *)NULL;
663: #endif
664: return (0);
665: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.