(no message)

[unix-history] / usr / src / sys / kern / kern_proc.c

diff --git a/usr/src/sys/kern/kern_proc.c b/usr/src/sys/kern/kern_proc.c
index 8af1856..1c72a95 100644 (file)
--- a/usr/src/sys/kern/kern_proc.c
+++ b/usr/src/sys/kern/kern_proc.c
@@ -1,4 +1,4 @@
-/*     kern_proc.c     3.1     %H%     */
+/*     kern_proc.c     3.14    %G%     */

 
 #include "../h/param.h"
 #include "../h/systm.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"


@@ -12,9 +12,11 @@
 #include "../h/inode.h"
 #include "../h/seg.h"
 #include "../h/acct.h"
 #include "../h/inode.h"
 #include "../h/seg.h"
 #include "../h/acct.h"

+#include "/usr/include/wait.h"

 #include "../h/pte.h"
 #include "../h/vm.h"
 #include "../h/text.h"
 #include "../h/pte.h"
 #include "../h/vm.h"
 #include "../h/text.h"

+#include "../h/psl.h"

 
 /*
  * exec system call, with and without environments.
 
 /*
  * exec system call, with and without environments.


@@ -59,7 +61,7 @@ exece()
        ne = 0;
        nc = 0;
        uap = (struct execa *)u.u_ap;
        ne = 0;
        nc = 0;
        uap = (struct execa *)u.u_ap;

-       if ((bno = malloc(swapmap, ctod(clrnd((int) btoc(NCARGS))))) == 0) {
+       if ((bno = malloc(argmap, ctod(clrnd((int) btoc(NCARGS))))) == 0) {

                swkill(u.u_procp, "exece");
                goto bad;
        }
                swkill(u.u_procp, "exece");
                goto bad;
        }


@@ -88,12 +90,17 @@ exece()
                                u.u_error = E2BIG;
                        if ((c = fubyte((caddr_t)ap++)) < 0)
                                u.u_error = EFAULT;
                                u.u_error = E2BIG;
                        if ((c = fubyte((caddr_t)ap++)) < 0)
                                u.u_error = EFAULT;

-                       if (u.u_error)
+                       if (u.u_error) {
+                               if (bp)
+                                       brelse(bp);
+                               bp = 0;

                                goto badarg;
                                goto badarg;

+                       }

                        if ((nc&BMASK) == 0) {
                                if (bp)
                                        bdwrite(bp);
                        if ((nc&BMASK) == 0) {
                                if (bp)
                                        bdwrite(bp);

-                               bp = getblk(swapdev, (daddr_t)(dbtofsb(swplo+bno)+(nc>>BSHIFT)));
+                               bp = getblk(argdev,
+                                   (daddr_t)(dbtofsb(bno)+(nc>>BSHIFT)));

                                cp = bp->b_un.b_addr;
                        }
                        nc++;
                                cp = bp->b_un.b_addr;
                        }
                        nc++;


@@ -107,7 +114,7 @@ exece()
        if (getxfile(ip, nc) || u.u_error) {
 badarg:
                for (c = 0; c < nc; c += BSIZE)
        if (getxfile(ip, nc) || u.u_error) {
 badarg:
                for (c = 0; c < nc; c += BSIZE)

-                       if (bp = baddr(swapdev, dbtofsb(swplo+bno)+(c>>BSHIFT))) {
+                       if (bp = baddr(argdev, dbtofsb(bno)+(c>>BSHIFT))) {

                                bp->b_flags |= B_AGE;           /* throw away */
                                bp->b_flags &= ~B_DELWRI;       /* cancel io */
                                brelse(bp);
                                bp->b_flags |= B_AGE;           /* throw away */
                                bp->b_flags &= ~B_DELWRI;       /* cancel io */
                                brelse(bp);


@@ -123,38 +130,39 @@ badarg:
        ucp = USRSTACK - nc - NBPW;
        ap = ucp - na*NBPW - 3*NBPW;
        u.u_ar0[SP] = ap;
        ucp = USRSTACK - nc - NBPW;
        ap = ucp - na*NBPW - 3*NBPW;
        u.u_ar0[SP] = ap;

-       VOID suword((caddr_t)ap, na-ne);
+       (void) suword((caddr_t)ap, na-ne);

        nc = 0;
        for (;;) {
                ap += NBPW;
                if (na==ne) {
        nc = 0;
        for (;;) {
                ap += NBPW;
                if (na==ne) {

-                       VOID suword((caddr_t)ap, 0);
+                       (void) suword((caddr_t)ap, 0);

                        ap += NBPW;
                }
                if (--na < 0)
                        break;
                        ap += NBPW;
                }
                if (--na < 0)
                        break;

-               VOID suword((caddr_t)ap, ucp);
+               (void) suword((caddr_t)ap, ucp);

                do {
                        if ((nc&BMASK) == 0) {
                                if (bp)
                                        brelse(bp);
                do {
                        if ((nc&BMASK) == 0) {
                                if (bp)
                                        brelse(bp);

-                               bp = bread(swapdev, (daddr_t)(dbtofsb(swplo+bno)+(nc>>BSHIFT)));
+                               bp = bread(argdev,
+                                   (daddr_t)(dbtofsb(bno)+(nc>>BSHIFT)));

                                bp->b_flags |= B_AGE;           /* throw away */
                                bp->b_flags &= ~B_DELWRI;       /* cancel io */
                                cp = bp->b_un.b_addr;
                        }
                                bp->b_flags |= B_AGE;           /* throw away */
                                bp->b_flags &= ~B_DELWRI;       /* cancel io */
                                cp = bp->b_un.b_addr;
                        }

-                       VOID subyte((caddr_t)ucp++, (c = *cp++));
+                       (void) subyte((caddr_t)ucp++, (c = *cp++));

                        nc++;
                } while(c&0377);
        }
                        nc++;
                } while(c&0377);
        }

-       VOID suword((caddr_t)ap, 0);
-       VOID suword((caddr_t)ucp, 0);
+       (void) suword((caddr_t)ap, 0);
+       (void) suword((caddr_t)ucp, 0);

        setregs();
 bad:
        if (bp)
                brelse(bp);
        if (bno)
        setregs();
 bad:
        if (bp)
                brelse(bp);
        if (bno)

-               mfree(swapmap, ctod(clrnd((int) btoc(NCARGS))), bno);
+               mfree(argmap, ctod(clrnd((int) btoc(NCARGS))), bno);

        iput(ip);
 }
 
        iput(ip);
 }
 


@@ -247,7 +255,8 @@ register struct inode *ip;
        ds = clrnd(btoc((u.u_exdata.ux_dsize+u.u_exdata.ux_bsize)));
        ss = clrnd(SSIZE + btoc(nargc));
        if (overlay) {
        ds = clrnd(btoc((u.u_exdata.ux_dsize+u.u_exdata.ux_bsize)));
        ss = clrnd(SSIZE + btoc(nargc));
        if (overlay) {

-               if ((u.u_procp->p_flag & SPAGI) || u.u_sep==0 && ctos(ts) != ctos(u.u_tsize) || nargc) {
+               if ((u.u_procp->p_flag & SPAGI) ||
+                   u.u_sep==0 && ctos(ts) != ctos(u.u_tsize) || nargc) {

                        u.u_error = ENOMEM;
                        goto bad;
                }
                        u.u_error = ENOMEM;
                        goto bad;
                }


@@ -306,7 +315,7 @@ register struct inode *ip;
                            1 + ts/CLSIZE, (int)btoc(u.u_exdata.ux_dsize));
 
                /* THIS SHOULD BE DONE AT A LOWER LEVEL, IF AT ALL */
                            1 + ts/CLSIZE, (int)btoc(u.u_exdata.ux_dsize));
 
                /* THIS SHOULD BE DONE AT A LOWER LEVEL, IF AT ALL */

-               mtpr(TBIA,1);
+               mtpr(TBIA, 0);

 
                /*
                 * set SUID/SGID protections, if no tracing
 
                /*
                 * set SUID/SGID protections, if no tracing


@@ -320,7 +329,7 @@ register struct inode *ip;
                        if(ip->i_mode&ISGID)
                                u.u_gid = ip->i_gid;
                } else
                        if(ip->i_mode&ISGID)
                                u.u_gid = ip->i_gid;
                } else

-                       psignal(u.u_procp, SIGTRC);
+                       psignal(u.u_procp, SIGTRAP);

        }
        u.u_tsize = ts;
        u.u_dsize = ds;
        }
        u.u_tsize = ts;
        u.u_dsize = ds;


@@ -335,12 +344,37 @@ bad:
  */
 setregs()
 {
  */
 setregs()
 {

-       register int *rp;
+       register int (**rp)();

        register i;
        register i;

+       long sigmask;
+
+       for(rp = &u.u_signal[0], sigmask = 1L; rp < &u.u_signal[NSIG];
+           sigmask <<= 1, rp++) {
+               switch (*rp) {

 
 

-       for(rp = &u.u_signal[0]; rp < &u.u_signal[NSIG]; rp++)
-               if((*rp & 1) == 0)
-                       *rp = 0;
+               case SIG_IGN:
+               case SIG_DFL:
+               case SIG_HOLD:
+                       continue;
+
+               default:
+                       /*
+                        * Normal or deferring catch; revert to default.
+                        */
+                       (void) spl6();
+                       *rp = SIG_DFL;
+                       if ((int)*rp & 1)
+                               u.u_procp->p_siga0 |= sigmask;
+                       else
+                               u.u_procp->p_siga1 &= ~sigmask;
+                       if ((int)*rp & 2)
+                               u.u_procp->p_siga1 |= sigmask;
+                       else
+                               u.u_procp->p_siga1 &= ~sigmask;
+                       (void) spl0();
+                       continue;
+               }
+       }

 /*
        for(rp = &u.u_ar0[0]; rp < &u.u_ar0[16];)
                *rp++ = 0;
 /*
        for(rp = &u.u_ar0[0]; rp < &u.u_ar0[16];)
                *rp++ = 0;


@@ -350,8 +384,8 @@ setregs()
                if (u.u_pofile[i]&EXCLOSE) {
                        closef(u.u_ofile[i]);
                        u.u_ofile[i] = NULL;
                if (u.u_pofile[i]&EXCLOSE) {
                        closef(u.u_ofile[i]);
                        u.u_ofile[i] = NULL;

+                       u.u_pofile[i] &= ~EXCLOSE;

                }
                }

-               u.u_pofile[i] &= ~EXCLOSE;

        }
        /*
         * Remember file name for accounting.
        }
        /*
         * Remember file name for accounting.


@@ -395,10 +429,19 @@ exit(rv)
        p->p_flag &= ~(STRC|SULOCK);
        p->p_flag |= SWEXIT;
        p->p_clktim = 0;
        p->p_flag &= ~(STRC|SULOCK);
        p->p_flag |= SWEXIT;
        p->p_clktim = 0;

-       rate.v_pgin -= p->p_aveflt;
+       (void) spl6();
+       if ((int)SIG_IGN & 1)
+               p->p_siga0 = ~0;
+       else
+               p->p_siga0 = 0;
+       if ((int)SIG_IGN & 2)
+               p->p_siga1 = ~0;
+       else
+               p->p_siga1 = 0;
+       (void) spl0();

        p->p_aveflt = 0;
        for(i=0; i<NSIG; i++)
        p->p_aveflt = 0;
        for(i=0; i<NSIG; i++)

-               u.u_signal[i] = 1;
+               u.u_signal[i] = SIG_IGN;

        /*
         * Release virtual memory.  If we resulted from
         * a vfork(), instead give the resources back to
        /*
         * Release virtual memory.  If we resulted from
         * a vfork(), instead give the resources back to


@@ -428,7 +471,8 @@ exit(rv)
        vrelpt(u.u_procp);
        vrelu(u.u_procp, 0);
        multprog--;
        vrelpt(u.u_procp);
        vrelu(u.u_procp, 0);
        multprog--;

-       spl7();                 /* clock will get mad because of overlaying */
+/*     spl7();                 /* clock will get mad because of overlaying */
+       noproc = 1;

        p->p_stat = SZOMB;
        i = PIDHASH(p->p_pid);
        x = p - proc;
        p->p_stat = SZOMB;
        i = PIDHASH(p->p_pid);
        x = p - proc;


@@ -447,22 +491,51 @@ done:
        ((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++)
        ((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_ppid == p->p_pid) {
-                       wakeup((caddr_t)&proc[1]);
+               if(q->p_pptr == p) {
+                       q->p_pptr = &proc[1];

                        q->p_ppid = 1;
                        q->p_ppid = 1;

-                       if (q->p_stat==SSTOP)
-                               setrun(q);
+                       q->p_flag |= SDETACH;
+                       wakeup((caddr_t)&proc[1]);
+                       /*
+                        * Traced processes are killed
+                        * since their existence means someone is screwing up.
+                        * Traced processes are sent a hangup and a continue.
+                        * This is designed to be ``safe'' for setuid
+                        * processes since they must be willing to tolerate
+                        * hangups anyways.
+                        */
+                       if (q->p_flag&STRC) {
+                               q->p_flag &= ~STRC;
+                               psignal(q, SIGKILL);
+                       } else if (q->p_stat == SSTOP) {
+                               psignal(q, SIGHUP);
+                               psignal(q, SIGCONT);
+                       }
+                       /*
+                        * Protect this process from future
+                        * tty signals, and clear TSTP/TTIN/TTOU if pending.
+                        */
+                       spgrp(q, -1);

                }
                }

-       q = pfind(p->p_ppid);
-       if (q)
-               wakeup((caddr_t)q);
+       wakeup((caddr_t)p->p_pptr);
+       psignal(p->p_pptr, SIGCHLD);

        swtch();
 }
 
 wait()
 {
        swtch();
 }
 
 wait()
 {

+       struct vtimes vm;
+       struct vtimes *vp;

 
 

-       wait1((struct vtimes *)0);
+       if ((u.u_ar0[PS] & PSL_ALLCC) != PSL_ALLCC) {
+               wait1(0, (struct vtimes *)0);
+               return;
+       }
+       vp = (struct vtimes *)u.u_ar0[R1];
+       wait1(u.u_ar0[R0], &vm);
+       if (u.u_error)
+               return;
+       (void) copyout((caddr_t)&vm, (caddr_t)vp, sizeof (struct vtimes));

 }
 
 /*
 }
 
 /*


@@ -472,17 +545,17 @@ wait()
  * Look also for stopped (traced) children,
  * and pass back status from them.
  */
  * Look also for stopped (traced) children,
  * and pass back status from them.
  */

-wait1(vp)
+wait1(options, vp)
+       register options;

        struct vtimes *vp;
 {
        register f;
        register struct proc *p;
 
        f = 0;
        struct vtimes *vp;
 {
        register f;
        register struct proc *p;
 
        f = 0;

-

 loop:
        for(p = &proc[0]; p < &proc[NPROC]; p++)
 loop:
        for(p = &proc[0]; p < &proc[NPROC]; p++)

-       if(p->p_ppid == u.u_procp->p_pid) {
+       if(p->p_pptr == u.u_procp) {

                f++;
                if(p->p_stat == SZOMB) {
                        u.u_r.r_val1 = p->p_pid;
                f++;
                if(p->p_stat == SZOMB) {
                        u.u_r.r_val1 = p->p_pid;


@@ -495,27 +568,40 @@ loop:
                        p->p_stat = NULL;
                        p->p_pid = 0;
                        p->p_ppid = 0;
                        p->p_stat = NULL;
                        p->p_pid = 0;
                        p->p_ppid = 0;

+                       p->p_pptr = 0;

                        p->p_sig = 0;
                        p->p_sig = 0;

+                       p->p_siga0 = 0;
+                       p->p_siga1 = 0;

                        p->p_pgrp = 0;
                        p->p_flag = 0;
                        p->p_wchan = 0;
                        p->p_pgrp = 0;
                        p->p_flag = 0;
                        p->p_wchan = 0;

+                       p->p_cursig = 0;

                        return;
                }
                        return;
                }

-               if(p->p_stat == SSTOP) {
-                       if((p->p_flag&SWTED) == 0) {
-                               p->p_flag |= SWTED;
-                               u.u_r.r_val1 = p->p_pid;
-                               u.u_r.r_val2 = (fsig(p)<<8) | 0177;
-                               return;
-                       }
-                       continue;
+               if (p->p_stat == SSTOP && (p->p_flag&SWTED)==0 &&
+                   (p->p_flag&STRC || options&WUNTRACED)) {
+                       p->p_flag |= SWTED;
+                       u.u_r.r_val1 = p->p_pid;
+                       u.u_r.r_val2 = (p->p_cursig<<8) | WSTOPPED;
+                       return;

                }
        }
                }
        }

-       if(f) {
-               sleep((caddr_t)u.u_procp, PWAIT);
-               goto loop;
+       if (f==0) {
+               u.u_error = ECHILD;
+               return;
+       }
+       if (options&WNOHANG) {
+               u.u_r.r_val1 = 0;
+               return;
+       }
+/*
+       if (setjmp(u.u_qsav)) {
+               u.u_eosys = RESTARTSYS;
+               return;

        }
        }

-       u.u_error = ECHILD;
+*/
+       sleep((caddr_t)u.u_procp, PWAIT);
+       goto loop;

 }
 
 /*
 }
 
 /*


@@ -557,8 +643,8 @@ fork1(isvfork)
        if (p2==NULL || (u.u_uid!=0 && (p2==&proc[NPROC-1] || a>MAXUPRC))) {
                u.u_error = EAGAIN;
                if (!isvfork) {
        if (p2==NULL || (u.u_uid!=0 && (p2==&proc[NPROC-1] || a>MAXUPRC))) {
                u.u_error = EAGAIN;
                if (!isvfork) {

-                       VOID vsexpand(0, &u.u_cdmap, 1);
-                       VOID vsexpand(0, &u.u_csmap, 1);
+                       (void) vsexpand(0, &u.u_cdmap, 1);
+                       (void) vsexpand(0, &u.u_csmap, 1);

                }
                goto out;
        }
                }
                goto out;
        }