usr/src/sys/kern/kern_exit.c

/*      kern_exit.c     4.6     83/07/01        */

#include "../machine/reg.h"
#include "../machine/psl.h"

#include "../h/param.h"
#include "../h/systm.h"
#include "../h/map.h"
#include "../h/dir.h"
#include "../h/user.h"
#include "../h/kernel.h"
#include "../h/proc.h"
#include "../h/buf.h"
#include "../h/wait.h"
#include "../h/vm.h"
#include "../h/file.h"
#include "../h/mbuf.h"
#include "../h/inode.h"

/*
 * Exit system call: pass back caller's arg
 */
rexit()
{
        register struct a {
                int     rval;
        } *uap;

        uap = (struct a *)u.u_ap;
        exit((uap->rval & 0377) << 8);
}

/*
 * Release resources.
 * Save u. area for parent to look at.
 * Enter zombie state.
 * Wake up parent and init processes,
 * and dispose of children.
 */
exit(rv)
        int rv;
{
        register int i;
        register struct proc *p, *q;
        register int x;
        struct mbuf *m = m_getclr(M_WAIT, MT_ZOMBIE);

#ifdef PGINPROF
        vmsizmon();
#endif
        p = u.u_procp;
        p->p_flag &= ~(STRC|SULOCK);
        p->p_flag |= SWEXIT;
        p->p_sigignore = ~0;
        p->p_cpticks = 0;
        p->p_pctcpu = 0;
        for (i = 0; i < NSIG; i++)
                u.u_signal[i] = SIG_IGN;
        untimeout(realitexpire, (caddr_t)p);
        /*
         * Release virtual memory.  If we resulted from
         * a vfork(), instead give the resources back to
         * the parent.
         */
        if ((p->p_flag & SVFORK) == 0)
                vrelvm();
        else {
                p->p_flag &= ~SVFORK;
                wakeup((caddr_t)p);
                while ((p->p_flag & SVFDONE) == 0)
                        sleep((caddr_t)p, PZERO - 1);
                p->p_flag &= ~SVFDONE;
        }
        for (i = 0; i < NOFILE; i++) {
                struct file *f;

                f = u.u_ofile[i];
                u.u_ofile[i] = NULL;
                u.u_pofile[i] = 0;
                closef(f);
        }
        ilock(u.u_cdir);
        iput(u.u_cdir);
        if (u.u_rdir) {
                ilock(u.u_rdir);
                iput(u.u_rdir);
        }
        u.u_rlimit[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
        acct();
#ifdef QUOTA
        qclean();
#endif
        vrelpt(u.u_procp);
        vrelu(u.u_procp, 0);
        (void) spl5();          /* hack for mem alloc race XXX */
        multprog--;
        p->p_stat = SZOMB;
        noproc = 1;
        i = PIDHASH(p->p_pid);
        x = p - proc;
        if (pidhash[i] == x)
                pidhash[i] = p->p_idhash;
        else {
                for (i = pidhash[i]; i != 0; i = proc[i].p_idhash)
                        if (proc[i].p_idhash == x) {
                                proc[i].p_idhash = p->p_idhash;
                                goto done;
                        }
                panic("exit");
        }
        if (p->p_pid == 1)
                panic("init died");
done:
        p->p_xstat = rv;
if (m == 0)
panic("exit: m_getclr");
        p->p_ru = mtod(m, struct rusage *);
        *p->p_ru = u.u_ru;
        ruadd(p->p_ru, &u.u_cru);
        for (q = proc; q < procNPROC; q++)
                if (q->p_pptr == p) {
                        if (q->p_osptr)
                                q->p_osptr->p_ysptr = q->p_ysptr;
                        if (q->p_ysptr)
                                q->p_ysptr->p_osptr = q->p_osptr;
                        if (proc[1].p_cptr)
                                proc[1].p_cptr->p_ysptr = q;
                        q->p_osptr = proc[1].p_cptr;
                        q->p_ysptr = NULL;
                        proc[1].p_cptr = q;

                        q->p_pptr = &proc[1];
                        q->p_ppid = 1;
                        wakeup((caddr_t)&proc[1]);
                        /*
                         * Traced processes are killed
                         * since their existence means someone is screwing up.
                         * Stopped 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, clear TSTP/TTIN/TTOU if pending.
                         */
                        (void) spgrp(q, -1);
                }
        psignal(p->p_pptr, SIGCHLD);
        wakeup((caddr_t)p->p_pptr);
        swtch();
}

wait()
{
        struct rusage ru, *rup;

        if ((u.u_ar0[PS] & PSL_ALLCC) != PSL_ALLCC) {
                u.u_error = wait1(0, (struct rusage *)0);
                return;
        }
        rup = (struct rusage *)u.u_ar0[R1];
        u.u_error = wait1(u.u_ar0[R0], &ru);
        if (u.u_error)
                return;
        (void) copyout((caddr_t)&ru, (caddr_t)rup, sizeof (struct rusage));
}

/*
 * Wait system call.
 * Search for a terminated (zombie) child,
 * finally lay it to rest, and collect its status.
 * Look also for stopped (traced) children,
 * and pass back status from them.
 */
wait1(options, ru)
        register int options;
        struct rusage *ru;
{
        register f;
        register struct proc *p, *q;

        f = 0;
loop:
        for (p = proc; p < procNPROC; p++)
        if (p->p_pptr == u.u_procp) {
                f++;
                if (p->p_stat == SZOMB) {
                        u.u_r.r_val1 = p->p_pid;
                        u.u_r.r_val2 = p->p_xstat;
                        p->p_xstat = 0;
                        if (ru)
                                *ru = *p->p_ru;
                        ruadd(&u.u_cru, p->p_ru);
                        (void) m_free(dtom(p->p_ru));
                        p->p_ru = 0;
                        p->p_stat = NULL;
                        p->p_pid = 0;
                        p->p_ppid = 0;
                        if (q = p->p_ysptr)
                                q->p_osptr = p->p_osptr;
                        if (q = p->p_osptr)
                                q->p_ysptr = p->p_ysptr;
                        if ((q = p->p_pptr)->p_cptr == p)
                                q->p_cptr = p->p_osptr;
                        p->p_pptr = 0;
                        p->p_ysptr = 0;
                        p->p_osptr = 0;
                        p->p_cptr = 0;
                        p->p_sig = 0;
                        p->p_sigcatch = 0;
                        p->p_sigignore = 0;
                        p->p_sigmask = 0;
                        p->p_pgrp = 0;
                        p->p_flag = 0;
                        p->p_wchan = 0;
                        p->p_cursig = 0;
                        return (0);
                }
                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 (0);
                }
        }
        if (f == 0)
                return (ECHILD);
        if (options&WNOHANG) {
                u.u_r.r_val1 = 0;
                return (0);
        }
        if ((u.u_procp->p_flag&SOUSIG) == 0 && setjmp(&u.u_qsave)) {
                u.u_eosys = RESTARTSYS;
                return (0);
        }
        sleep((caddr_t)u.u_procp, PWAIT);
        goto loop;
}