-/* kern_proc.c 3.24 %G% */
+/* kern_proc.c 4.25 82/04/02 */
#include "../h/param.h"
#include "../h/systm.h"
register struct buf *bp;
register struct execa *uap;
int na, ne, ucp, ap, c;
+ int indir, uid, gid;
+ char *sharg;
struct inode *ip;
swblk_t bno;
+ char cfname[DIRSIZ];
+ char cfarg[SHSIZE];
- if ((ip = namei(uchar, 0)) == NULL)
+ if ((ip = namei(uchar, 0, 1)) == NULL)
return;
bno = 0;
bp = 0;
- if(access(ip, IEXEC))
+ indir = 0;
+ uid = u.u_uid;
+ gid = u.u_gid;
+ if (ip->i_mode & ISUID)
+ uid = ip->i_uid;
+ if (ip->i_mode & ISGID)
+ gid = ip->i_gid;
+
+ again:
+ if (access(ip, IEXEC))
goto bad;
- if((ip->i_mode & IFMT) != IFREG ||
+ if ((u.u_procp->p_flag&STRC) && access(ip, IREAD))
+ goto bad;
+ if ((ip->i_mode & IFMT) != IFREG ||
(ip->i_mode & (IEXEC|(IEXEC>>3)|(IEXEC>>6))) == 0) {
u.u_error = EACCES;
goto bad;
}
+
+ /*
+ * Read in first few bytes of file for segment sizes, ux_mag:
+ * 407 = plain executable
+ * 410 = RO text
+ * 413 = demand paged RO text
+ * Also an ASCII line beginning with #! is
+ * the file name of a ``shell'' and arguments may be prepended
+ * to the argument list if given here.
+ *
+ * SHELL NAMES ARE LIMITED IN LENGTH.
+ *
+ * ONLY ONE ARGUMENT MAY BE PASSED TO THE SHELL FROM
+ * THE ASCII LINE.
+ */
+ u.u_base = (caddr_t)&u.u_exdata;
+ u.u_count = sizeof(u.u_exdata);
+ u.u_offset = 0;
+ u.u_segflg = 1;
+ readi(ip);
+ u.u_segflg = 0;
+ if (u.u_error)
+ goto bad;
+ if (u.u_count > sizeof(u.u_exdata) - sizeof(u.u_exdata.Ux_A) &&
+ u.u_exdata.ux_shell[0] != '#') {
+ u.u_error = ENOEXEC;
+ goto bad;
+ }
+ switch (u.u_exdata.ux_mag) {
+
+ case 0407:
+ u.u_exdata.ux_dsize += u.u_exdata.ux_tsize;
+ u.u_exdata.ux_tsize = 0;
+ break;
+
+ case 0413:
+ case 0410:
+ if (u.u_exdata.ux_tsize == 0) {
+ u.u_error = ENOEXEC;
+ goto bad;
+ }
+ break;
+
+ default:
+ if (u.u_exdata.ux_shell[0] != '#' ||
+ u.u_exdata.ux_shell[1] != '!' ||
+ indir) {
+ u.u_error = ENOEXEC;
+ goto bad;
+ }
+ cp = &u.u_exdata.ux_shell[2]; /* skip "#!" */
+ while (cp < &u.u_exdata.ux_shell[SHSIZE]) {
+ if (*cp == '\t')
+ *cp = ' ';
+ else if (*cp == '\n') {
+ *cp = '\0';
+ break;
+ }
+ cp++;
+ }
+ if (*cp != '\0') {
+ u.u_error = ENOEXEC;
+ goto bad;
+ }
+ cp = &u.u_exdata.ux_shell[2];
+ while (*cp == ' ')
+ cp++;
+ u.u_dirp = cp;
+ while (*cp && *cp != ' ')
+ cp++;
+ sharg = NULL;
+ if (*cp) {
+ *cp++ = '\0';
+ while (*cp == ' ')
+ cp++;
+ if (*cp) {
+ bcopy((caddr_t)cp, (caddr_t)cfarg, SHSIZE);
+ sharg = cfarg;
+ }
+ }
+ bcopy((caddr_t)u.u_dbuf, (caddr_t)cfname, DIRSIZ);
+ indir = 1;
+ iput(ip);
+ ip = namei(schar, 0, 1);
+ if (ip == NULL)
+ return;
+ goto again;
+ }
+
/*
* Collect arguments on "file" in swap space.
*/
ne = 0;
nc = 0;
uap = (struct execa *)u.u_ap;
- if ((bno = malloc(argmap, ctod(clrnd((int) btoc(NCARGS))))) == 0) {
+ if ((bno = rmalloc(argmap, ctod(clrnd((int) btoc(NCARGS))))) == 0) {
swkill(u.u_procp, "exece");
goto bad;
}
if (bno % CLSIZE)
- panic("execa malloc");
+ panic("execa rmalloc");
if (uap->argp) for (;;) {
ap = NULL;
- if (uap->argp) {
+ if (indir && (na == 1 || na == 2 && sharg))
+ ap = (int)uap->fname;
+ else if (uap->argp) {
ap = fuword((caddr_t)uap->argp);
uap->argp++;
}
if (ap==NULL)
break;
na++;
- if(ap == -1)
+ if (ap == -1)
u.u_error = EFAULT;
do {
if (nc >= NCARGS-1)
u.u_error = E2BIG;
- if ((c = fubyte((caddr_t)ap++)) < 0)
+ if (indir && na == 2 && sharg != NULL)
+ c = *sharg++ & 0377;
+ else if ((c = fubyte((caddr_t)ap++)) < 0)
u.u_error = EFAULT;
if (u.u_error) {
if (bp)
bdwrite(bp);
bp = 0;
nc = (nc + NBPW-1) & ~(NBPW-1);
- getxfile(ip, nc + (na+4)*NBPW);
+ if (indir)
+ bcopy((caddr_t)cfname, (caddr_t)u.u_dbuf, DIRSIZ);
+ getxfile(ip, nc + (na+4)*NBPW, uid, gid);
if (u.u_error) {
badarg:
for (c = 0; c < nc; c += BSIZE)
/*
* copy back arglist
*/
-
ucp = USRSTACK - nc - NBPW;
ap = ucp - na*NBPW - 3*NBPW;
u.u_ar0[SP] = ap;
if (bp)
brelse(bp);
if (bno)
- mfree(argmap, ctod(clrnd((int) btoc(NCARGS))), bno);
+ rmfree(argmap, ctod(clrnd((int) btoc(NCARGS))), bno);
iput(ip);
}
/*
* Read in and set up memory for executed file.
*/
-getxfile(ip, nargc)
+getxfile(ip, nargc, uid, gid)
register struct inode *ip;
{
register size_t ts, ds, ss;
- int pagi = 0;
-
- /*
- * read in first few bytes
- * of file for segment
- * sizes:
- * ux_mag = 407/410/413
- * 407 is plain executable
- * 410 is RO text
- * 413 is demand paged RO text
- */
+ int pagi;
- u.u_base = (caddr_t)&u.u_exdata;
- u.u_count = sizeof(u.u_exdata);
- u.u_offset = 0;
- u.u_segflg = 1;
- readi(ip);
- u.u_segflg = 0;
- if(u.u_error)
- goto bad;
- if (u.u_count!=0) {
- u.u_error = ENOEXEC;
- goto bad;
- }
- switch (u.u_exdata.ux_mag) {
-
- case 0407:
- u.u_exdata.ux_dsize += u.u_exdata.ux_tsize;
- u.u_exdata.ux_tsize = 0;
- break;
-
- case 0413:
+ if (u.u_exdata.ux_mag == 0413)
pagi = SPAGI;
- /* fall into ... */
-
- case 0410:
- if (u.u_exdata.ux_tsize == 0) {
- u.u_error = ENOEXEC;
- goto bad;
- }
- break;
-
- default:
- u.u_error = ENOEXEC;
- goto bad;
- }
- if(u.u_exdata.ux_tsize!=0 && (ip->i_flag&ITEXT)==0 && ip->i_count!=1) {
+ else
+ pagi = 0;
+ if (u.u_exdata.ux_tsize!=0 && (ip->i_flag&ITEXT)==0 &&
+ ip->i_count!=1) {
register struct file *fp;
- for (fp = file; fp < &file[NFILE]; fp++)
+ for (fp = file; fp < fileNFILE; fp++) {
+ if (fp->f_flag & FSOCKET)
+ continue;
if (fp->f_inode == ip && (fp->f_flag&FWRITE)) {
u.u_error = ETXTBSY;
goto bad;
}
+ }
}
/*
- * find text and data sizes
- * try them out for possible
- * exceed of max sizes
+ * Compute text and data sizes and make sure not too large.
*/
-
ts = clrnd(btoc(u.u_exdata.ux_tsize));
ds = clrnd(btoc((u.u_exdata.ux_dsize+u.u_exdata.ux_bsize)));
ss = clrnd(SSIZE + btoc(nargc));
if (chksize(ts, ds, ss))
goto bad;
+
+ /*
+ * Make sure enough space to start process.
+ */
u.u_cdmap = zdmap;
u.u_csmap = zdmap;
if (swpexpand(ds, ss, &u.u_cdmap, &u.u_csmap) == NULL)
sleep((caddr_t)u.u_procp, PZERO - 1);
u.u_procp->p_flag &= ~(SVFDONE|SKEEP);
}
- u.u_procp->p_flag &= ~(SPAGI|SANOM|SUANOM|SNUSIG);
+ u.u_procp->p_flag &= ~(SPAGI|SSEQL|SUANOM|SNUSIG);
u.u_procp->p_flag |= pagi;
u.u_dmap = u.u_cdmap;
u.u_smap = u.u_csmap;
* set SUID/SGID protections, if no tracing
*/
if ((u.u_procp->p_flag&STRC)==0) {
- if(ip->i_mode&ISUID)
- if(u.u_uid != 0) {
- u.u_uid = ip->i_uid;
- u.u_procp->p_uid = ip->i_uid;
- }
- if(ip->i_mode&ISGID)
- u.u_gid = ip->i_gid;
+ u.u_uid = uid;
+ u.u_procp->p_uid = uid;
+ u.u_gid = gid;
+ u.u_grps[gid/(sizeof(int)*8)] |= 1 << (gid%(sizeof(int)*8));
} else
psignal(u.u_procp, SIGTRAP);
u.u_tsize = ts;
register i;
long sigmask;
- for(rp = &u.u_signal[0], sigmask = 1L; rp < &u.u_signal[NSIG];
+ for (rp = &u.u_signal[1], sigmask = 1L; rp < &u.u_signal[NSIG];
sigmask <<= 1, rp++) {
switch (*rp) {
if ((int)*rp & 1)
u.u_procp->p_siga0 |= sigmask;
else
- u.u_procp->p_siga1 &= ~sigmask;
+ u.u_procp->p_siga0 &= ~sigmask;
if ((int)*rp & 2)
u.u_procp->p_siga1 |= sigmask;
else
}
}
/*
- for(rp = &u.u_ar0[0]; rp < &u.u_ar0[16];)
+ for (rp = &u.u_ar0[0]; rp < &u.u_ar0[16];)
*rp++ = 0;
*/
u.u_ar0[PC] = u.u_exdata.ux_entloc + 2; /* skip over entry mask */
- for(i=0; i<NOFILE; i++) {
+ for (i=0; i<NOFILE; i++) {
if (u.u_pofile[i]&EXCLOSE) {
- closef(u.u_ofile[i]);
+ closef(u.u_ofile[i], 1);
u.u_ofile[i] = NULL;
u.u_pofile[i] &= ~EXCLOSE;
}
}
+
/*
* Remember file name for accounting.
*/
}
/*
- * exit system call:
- * pass back caller's arg
+ * Exit system call: pass back caller's arg
*/
rexit()
{
else
p->p_siga1 = 0;
(void) spl0();
- p->p_aveflt = 0;
- for(i=0; i<NSIG; i++)
+ p->p_cpticks = 0;
+ p->p_pctcpu = 0;
+ for (i=0; i<NSIG; i++)
u.u_signal[i] = SIG_IGN;
/*
* Release virtual memory. If we resulted from
sleep((caddr_t)p, PZERO - 1);
p->p_flag &= ~SVFDONE;
}
- for(i=0; i<NOFILE; i++) {
+ for (i=0; i<NOFILE; i++) {
f = u.u_ofile[i];
u.u_ofile[i] = NULL;
- closef(f);
+ closef(f, 1);
}
- plock(u.u_cdir);
+ ilock(u.u_cdir);
iput(u.u_cdir);
if (u.u_rdir) {
- plock(u.u_rdir);
+ ilock(u.u_rdir);
iput(u.u_rdir);
}
u.u_limit[LIM_FSIZE] = INFINITY;
acct();
vrelpt(u.u_procp);
vrelu(u.u_procp, 0);
+ (void) spl5(); /* hack for mem alloc race XXX */
multprog--;
-/* spl7(); /* clock will get mad because of overlaying */
p->p_stat = SZOMB;
noproc = 1;
i = PIDHASH(p->p_pid);
}
panic("exit");
}
+ if (p->p_pid == 1)
+ panic("init died");
done:
((struct xproc *)p)->xp_xstat = rv; /* overlay */
((struct xproc *)p)->xp_vm = u.u_vm; /* overlay */
vmsadd(&((struct xproc *)p)->xp_vm, &u.u_cvm);
- for(q = &proc[0]; q < &proc[NPROC]; q++)
- if(q->p_pptr == p) {
+ for (q = proc; q < procNPROC; q++)
+ if (q->p_pptr == p) {
q->p_pptr = &proc[1];
q->p_ppid = 1;
wakeup((caddr_t)&proc[1]);
}
/*
* Protect this process from future
- * tty signals, clear TSTP/TTIN/TTOU if pending,
- * and set SDETACH bit on procs.
+ * tty signals, clear TSTP/TTIN/TTOU if pending.
*/
- spgrp(q, -1);
+ (void) spgrp(q, -1);
}
- wakeup((caddr_t)p->p_pptr);
psignal(p->p_pptr, SIGCHLD);
+ wakeup((caddr_t)p->p_pptr);
swtch();
}
f = 0;
loop:
- for(p = &proc[0]; p < &proc[NPROC]; p++)
- if(p->p_pptr == u.u_procp) {
+ for (p = proc; p < procNPROC; p++)
+ if (p->p_pptr == u.u_procp) {
f++;
- if(p->p_stat == SZOMB) {
+ if (p->p_stat == SZOMB) {
u.u_r.r_val1 = p->p_pid;
u.u_r.r_val2 = ((struct xproc *)p)->xp_xstat;
((struct xproc *)p)->xp_xstat = 0;
a = 0;
p2 = NULL;
- for(p1 = &proc[0]; p1 < &proc[NPROC]; p1++) {
+ for (p1 = proc; p1 < procNPROC; p1++) {
if (p1->p_stat==NULL && p2==NULL)
p2 = p1;
else {
* not su and too many procs owned; or
* not su and would take last slot.
*/
- if (p2==NULL || (u.u_uid!=0 && (p2==&proc[NPROC-1] || a>MAXUPRC))) {
+ if (p2==NULL)
+ tablefull("proc");
+ if (p2==NULL || (u.u_uid!=0 && (p2==procNPROC-1 || a>MAXUPRC))) {
u.u_error = EAGAIN;
if (!isvfork) {
(void) vsexpand(0, &u.u_cdmap, 1);
goto out;
}
p1 = u.u_procp;
- if(newproc(isvfork)) {
+ if (newproc(isvfork)) {
u.u_r.r_val1 = p1->p_pid;
u.u_r.r_val2 = 1; /* child */
u.u_start = time;