add cpio to subdirectory list

[unix-history] / usr / src / bin / csh / proc.c

diff --git a/usr/src/bin/csh/proc.c b/usr/src/bin/csh/proc.c
index 3ad725f..0140cd4 100644 (file)
--- a/usr/src/bin/csh/proc.c
+++ b/usr/src/bin/csh/proc.c
@@ -1,9 +1,17 @@
-static char *sccsid = "@(#)proc.c      4.10 (Berkeley) 83/06/11";
+/*
+ * Copyright (c) 1980 Regents of the University of California.
+ * All rights reserved.  The Berkeley Software License Agreement
+ * specifies the terms and conditions for redistribution.
+ */
+
+#ifndef lint
+static char *sccsid = "@(#)proc.c      5.10 (Berkeley) %G%";
+#endif

 
 #include "sh.h"
 #include "sh.dir.h"
 #include "sh.proc.h"
 
 #include "sh.h"
 #include "sh.dir.h"
 #include "sh.proc.h"

-#include <wait.h>
+#include <sys/wait.h>

 #include <sys/ioctl.h>
 
 /*
 #include <sys/ioctl.h>
 
 /*


@@ -27,12 +35,10 @@ pchild()
        union wait w;
        int jobflags;
        struct rusage ru;
        union wait w;
        int jobflags;
        struct rusage ru;

+       extern int insource;

 
 

-       if (!timesdone)
-               timesdone++, times(&shtimes);

 loop:
 loop:

-       pid = wait3(&w.w_status, (setintr ? WNOHANG|WUNTRACED:WNOHANG),
-           &ru);
+       pid = wait3(&w, (setintr && (intty || insource) ? WNOHANG|WUNTRACED:WNOHANG), &ru);

        if (pid <= 0) {
                if (errno == EINTR) {
                        errno = 0;
        if (pid <= 0) {
                if (errno == EINTR) {
                        errno = 0;


@@ -53,16 +59,8 @@ found:
                pp->p_flags |= PSTOPPED;
                pp->p_reason = w.w_stopsig;
        } else {
                pp->p_flags |= PSTOPPED;
                pp->p_reason = w.w_stopsig;
        } else {

-               if (pp->p_flags & (PTIME|PPTIME) || adrof("time")) {
-                       time_t oldcutimes, oldcstimes;
-                       oldcutimes = shtimes.tms_cutime;
-                       oldcstimes = shtimes.tms_cstime;
-                       gettimeofday(&pp->p_etime, (struct timezone *)0);
-                       times(&shtimes);
-                       pp->p_utime = shtimes.tms_cutime - oldcutimes;
-                       pp->p_stime = shtimes.tms_cstime - oldcstimes;
-               } else
-                       times(&shtimes);
+               if (pp->p_flags & (PTIME|PPTIME) || adrof("time"))
+                       (void) gettimeofday(&pp->p_etime, (struct timezone *)0);

                pp->p_rusage = ru;
                if (WIFSIGNALED(w)) {
                        if (w.w_termsig == SIGINT)
                pp->p_rusage = ru;
                if (WIFSIGNALED(w)) {
                        if (w.w_termsig == SIGINT)


@@ -85,7 +83,7 @@ found:
        do {
                if ((fp->p_flags & (PPTIME|PRUNNING|PSTOPPED)) == 0 &&
                    !child && adrof("time") &&
        do {
                if ((fp->p_flags & (PPTIME|PRUNNING|PSTOPPED)) == 0 &&
                    !child && adrof("time") &&

-                   (fp->p_utime + fp->p_stime) / HZ >=
+                   fp->p_rusage.ru_utime.tv_sec+fp->p_rusage.ru_stime.tv_sec >=

                     atoi(value("time")))
                        fp->p_flags |= PTIME;
                jobflags |= fp->p_flags;
                     atoi(value("time")))
                        fp->p_flags |= PTIME;
                jobflags |= fp->p_flags;


@@ -124,7 +122,7 @@ found:
                } else {
                        if (jobflags&PNOTIFY || adrof("notify")) {
                                printf("\215\n");
                } else {
                        if (jobflags&PNOTIFY || adrof("notify")) {
                                printf("\215\n");

-                               pprint(pp, NUMBER|NAME|REASON);
+                               (void) pprint(pp, NUMBER|NAME|REASON);

                                if ((jobflags&PSTOPPED) == 0)
                                        pflush(pp);
                        } else {
                                if ((jobflags&PSTOPPED) == 0)
                                        pflush(pp);
                        } else {


@@ -140,16 +138,17 @@ pnote()
 {
        register struct process *pp;
        int flags;
 {
        register struct process *pp;
        int flags;

+       long omask;

 
        neednote = 0;
        for (pp = proclist.p_next; pp != PNULL; pp = pp->p_next) {
                if (pp->p_flags & PNEEDNOTE) {
 
        neednote = 0;
        for (pp = proclist.p_next; pp != PNULL; pp = pp->p_next) {
                if (pp->p_flags & PNEEDNOTE) {

-                       sighold(SIGCHLD);
+                       omask = sigblock(sigmask(SIGCHLD));

                        pp->p_flags &= ~PNEEDNOTE;
                        flags = pprint(pp, NUMBER|NAME|REASON);
                        if ((flags&(PRUNNING|PSTOPPED)) == 0)
                                pflush(pp);
                        pp->p_flags &= ~PNEEDNOTE;
                        flags = pprint(pp, NUMBER|NAME|REASON);
                        if ((flags&(PRUNNING|PSTOPPED)) == 0)
                                pflush(pp);

-                       sigrelse(SIGCHLD);
+                       (void) sigsetmask(omask);

                }
        }
 }
                }
        }
 }


@@ -161,11 +160,12 @@ pnote()
 pwait()
 {
        register struct process *fp, *pp;
 pwait()
 {
        register struct process *fp, *pp;

+       long omask;

 
        /*
         * Here's where dead procs get flushed.
         */
 
        /*
         * Here's where dead procs get flushed.
         */

-       sighold(SIGCHLD);
+       omask = sigblock(sigmask(SIGCHLD));

        for (pp = (fp = &proclist)->p_next; pp != PNULL; pp = (fp = pp)->p_next)
                if (pp->p_pid == 0) {
                        fp->p_next = pp->p_next;
        for (pp = (fp = &proclist)->p_next; pp != PNULL; pp = (fp = pp)->p_next)
                if (pp->p_pid == 0) {
                        fp->p_next = pp->p_next;


@@ -176,9 +176,7 @@ pwait()
                        xfree((char *)pp);
                        pp = fp;
                }
                        xfree((char *)pp);
                        pp = fp;
                }

-       sigrelse(SIGCHLD);
-       if (setintr)
-               sigignore(SIGINT);
+       (void) sigsetmask(omask);

        pjwait(pcurrjob);
 }
 
        pjwait(pcurrjob);
 }
 


@@ -191,7 +189,10 @@ pjwait(pp)
 {
        register struct process *fp;
        int jobflags, reason;
 {
        register struct process *fp;
        int jobflags, reason;

+       long omask;

 
 

+       while (pp->p_pid != pp->p_jobid)
+               pp = pp->p_friends;

        fp = pp;
        do {
                if ((fp->p_flags&(PFOREGND|PRUNNING)) == PRUNNING)
        fp = pp;
        do {
                if ((fp->p_flags&(PFOREGND|PRUNNING)) == PRUNNING)


@@ -202,24 +203,24 @@ pjwait(pp)
         * and the target process, or any of its friends, are running
         */
        fp = pp;
         * and the target process, or any of its friends, are running
         */
        fp = pp;

+       omask = sigblock(sigmask(SIGCHLD));

        for (;;) {
        for (;;) {

-               sighold(SIGCHLD);

                jobflags = 0;
                do
                        jobflags |= fp->p_flags;
                jobflags = 0;
                do
                        jobflags |= fp->p_flags;

-               while((fp = (fp->p_friends)) != pp);
+               while ((fp = (fp->p_friends)) != pp);

                if ((jobflags & PRUNNING) == 0)
                        break;
                if ((jobflags & PRUNNING) == 0)
                        break;

-               sigpause(sigblock(0) &~ mask(SIGCHLD));
+               sigpause(sigblock(0L) &~ sigmask(SIGCHLD));

        }
        }

-       sigrelse(SIGCHLD);
-       if (tpgrp > 0)
-               ioctl(FSHTTY, TIOCSPGRP, &tpgrp);       /* get tty back */
+       (void) sigsetmask(omask);
+       if (tpgrp > 0)                  /* get tty back */
+               (void) ioctl(FSHTTY, TIOCSPGRP, (char *)&tpgrp);

        if ((jobflags&(PSIGNALED|PSTOPPED|PTIME)) ||
             !eq(dcwd->di_name, fp->p_cwd->di_name)) {
                if (jobflags&PSTOPPED)
                        printf("\n");
        if ((jobflags&(PSIGNALED|PSTOPPED|PTIME)) ||
             !eq(dcwd->di_name, fp->p_cwd->di_name)) {
                if (jobflags&PSTOPPED)
                        printf("\n");

-               pprint(pp, AREASON|SHELLDIR);
+               (void) pprint(pp, AREASON|SHELLDIR);

        }
        if ((jobflags&(PINTERRUPTED|PSTOPPED)) && setintr &&
            (!gointr || !eq(gointr, "-"))) {
        }
        if ((jobflags&(PINTERRUPTED|PSTOPPED)) && setintr &&
            (!gointr || !eq(gointr, "-"))) {


@@ -247,19 +248,18 @@ pjwait(pp)
 dowait()
 {
        register struct process *pp;
 dowait()
 {
        register struct process *pp;

+       long omask;

 
        pjobs++;
 
        pjobs++;

-       if (setintr)
-               sigrelse(SIGINT);
+       omask = sigblock(sigmask(SIGCHLD));

 loop:
 loop:

-       sighold(SIGCHLD);

        for (pp = proclist.p_next; pp; pp = pp->p_next)
        for (pp = proclist.p_next; pp; pp = pp->p_next)

-               if (pp->p_pid && pp->p_pid == pp->p_jobid &&
+               if (pp->p_pid && /* pp->p_pid == pp->p_jobid && */

                    pp->p_flags&PRUNNING) {
                    pp->p_flags&PRUNNING) {

-                       sigpause(sigblock(0) &~ mask(SIGCHLD));
+                       sigpause(0L);

                        goto loop;
                }
                        goto loop;
                }

-       sigrelse(SIGCHLD);
+       (void) sigsetmask(omask);

        pjobs = 0;
 }
 
        pjobs = 0;
 }
 


@@ -398,7 +398,7 @@ palloc(pid, t)
        }
        pp->p_next = proclist.p_next;
        proclist.p_next = pp;
        }
        pp->p_next = proclist.p_next;
        proclist.p_next = pp;

-       gettimeofday(&pp->p_btime, (struct timezone *)0);
+       (void) gettimeofday(&pp->p_btime, (struct timezone *)0);

 }
 
 padd(t)
 }
 
 padd(t)


@@ -424,15 +424,25 @@ padd(t)
                }
                break;
 
                }
                break;
 

+       case TOR:
+       case TAND:

        case TFIL:
        case TFIL:

-               padd(t->t_dcar);
-               pads(" | ");
-               padd(t->t_dcdr);
-               return;
-

        case TLST:
                padd(t->t_dcar);
        case TLST:
                padd(t->t_dcar);

-               pads("; ");
+               switch (t->t_dtyp) {
+               case TOR:
+                       pads(" || ");
+                       break;
+               case TAND:
+                       pads(" && ");
+                       break;
+               case TFIL:
+                       pads(" | ");
+                       break;
+               case TLST:
+                       pads("; ");
+                       break;
+               }

                padd(t->t_dcdr);
                return;
        }
                padd(t->t_dcdr);
                return;
        }


@@ -457,12 +467,12 @@ pads(cp)
        if (cmdlen >= PMAXLEN)
                return;
        if (cmdlen + i >= PMAXLEN) {
        if (cmdlen >= PMAXLEN)
                return;
        if (cmdlen + i >= PMAXLEN) {

-               strcpy(cmdp, " ...");
+               (void) strcpy(cmdp, " ...");

                cmdlen = PMAXLEN;
                cmdp += 4;
                return;
        }
                cmdlen = PMAXLEN;
                cmdp += 4;
                return;
        }

-       strcpy(cmdp, cp);
+       (void) strcpy(cmdp, cp);

        cmdp += i;
        cmdlen += i;
 }
        cmdp += i;
        cmdlen += i;
 }


@@ -556,7 +566,7 @@ pprint(pp, flag)
                                printf("%5d ", pp->p_pid);
                        if (flag&(REASON|AREASON)) {
                                if (flag&NAME)
                                printf("%5d ", pp->p_pid);
                        if (flag&(REASON|AREASON)) {
                                if (flag&NAME)

-                                       format = "%-21s";
+                                       format = "%-23s";

                                else
                                        format = "%s";
                                if (pstatus == status)
                                else
                                        format = "%s";
                                if (pstatus == status)


@@ -578,8 +588,9 @@ pprint(pp, flag)
                                case PINTERRUPTED:
                                case PSTOPPED:
                                case PSIGNALED:
                                case PINTERRUPTED:
                                case PSTOPPED:
                                case PSIGNALED:

-                                       if (flag&REASON || reason != SIGINT ||
-                                           reason != SIGPIPE)
+                                       if ((flag&(REASON|AREASON))
+                                           && reason != SIGINT
+                                           && reason != SIGPIPE)

                                                printf(format, mesg[pp->p_reason].pname);
                                        break;
 
                                                printf(format, mesg[pp->p_reason].pname);
                                        break;
 


@@ -703,8 +714,6 @@ dofg(v)
        do {
                pp = pfind(*v);
                pstart(pp, 1);
        do {
                pp = pfind(*v);
                pstart(pp, 1);

-               if (setintr)
-                       sigignore(SIGINT);

                pjwait(pp);
        } while (*v && *++v);
 }
                pjwait(pp);
        } while (*v && *++v);
 }


@@ -720,8 +729,6 @@ dofg1(v)
        okpcntl();
        pp = pfind(v[0]);
        pstart(pp, 1);
        okpcntl();
        pp = pfind(v[0]);
        pstart(pp, 1);

-       if (setintr)
-               sigignore(SIGINT);

        pjwait(pp);
 }
 
        pjwait(pp);
 }
 


@@ -779,14 +786,14 @@ dokill(v)
                                if (name = mesg[signum].iname)
                                        printf("%s ", name);
                                if (signum == 16)
                                if (name = mesg[signum].iname)
                                        printf("%s ", name);
                                if (signum == 16)

-                                       printf("\n");
+                                       cshputchar('\n');

                        }
                        }

-                       printf("\n");
+                       cshputchar('\n');

                        return;
                }
                if (digit(v[0][1])) {
                        signum = atoi(v[0]+1);
                        return;
                }
                if (digit(v[0][1])) {
                        signum = atoi(v[0]+1);

-                       if (signum < 1 || signum > NSIG)
+                       if (signum < 0 || signum > NSIG)

                                bferr("Bad signal number");
                } else {
                        name = &v[0][1];
                                bferr("Bad signal number");
                } else {
                        name = &v[0][1];


@@ -810,16 +817,19 @@ pkill(v, signum)
 {
        register struct process *pp, *np;
        register int jobflags = 0;
 {
        register struct process *pp, *np;
        register int jobflags = 0;

-       int pid;
+       int pid, err = 0;
+       long omask;
+       char *cp;

        extern char *sys_errlist[];
        extern char *sys_errlist[];

-       int err = 0;

 
 

+       omask = sigmask(SIGCHLD);

        if (setintr)
        if (setintr)

-               sighold(SIGINT);
-       sighold(SIGCHLD);
+               omask |= sigmask(SIGINT);
+       omask = sigblock(omask) & ~omask;

        while (*v) {
        while (*v) {

-               if (**v == '%') {
-                       np = pp = pfind(*v);
+               cp = globone(*v);
+               if (*cp == '%') {
+                       np = pp = pfind(cp);

                        do
                                jobflags |= np->p_flags;
                        while ((np = np->p_friends) != pp);
                        do
                                jobflags |= np->p_flags;
                        while ((np = np->p_friends) != pp);


@@ -830,18 +840,22 @@ pkill(v, signum)
                        case SIGTTIN:
                        case SIGTTOU:
                                if ((jobflags & PRUNNING) == 0) {
                        case SIGTTIN:
                        case SIGTTOU:
                                if ((jobflags & PRUNNING) == 0) {

-                                       printf("%s: Already stopped\n", *v);
+                                       printf("%s: Already suspended\n", cp);

                                        err++;
                                        goto cont;
                                }
                        }
                                        err++;
                                        goto cont;
                                }
                        }

-                       killpg(pp->p_jobid, signum);
+                       if (killpg(pp->p_jobid, signum) < 0) {
+                               printf("%s: ", cp);
+                               printf("%s\n", sys_errlist[errno]);
+                               err++;
+                       }

                        if (signum == SIGTERM || signum == SIGHUP)
                        if (signum == SIGTERM || signum == SIGHUP)

-                               killpg(pp->p_jobid, SIGCONT);
-               } else if (!digit(**v))
+                               (void) killpg(pp->p_jobid, SIGCONT);
+               } else if (!(digit(*cp) || *cp == '-'))

                        bferr("Arguments should be jobs or process id's");
                else {
                        bferr("Arguments should be jobs or process id's");
                else {

-                       pid = atoi(*v);
+                       pid = atoi(cp);

                        if (kill(pid, signum) < 0) {
                                printf("%d: ", pid);
                                printf("%s\n", sys_errlist[errno]);
                        if (kill(pid, signum) < 0) {
                                printf("%d: ", pid);
                                printf("%s\n", sys_errlist[errno]);


@@ -849,14 +863,13 @@ pkill(v, signum)
                                goto cont;
                        }
                        if (signum == SIGTERM || signum == SIGHUP)
                                goto cont;
                        }
                        if (signum == SIGTERM || signum == SIGHUP)

-                               kill(pid, SIGCONT);
+                               (void) kill(pid, SIGCONT);

                }
 cont:
                }
 cont:

+               xfree(cp);

                v++;
        }
                v++;
        }

-       sigrelse(SIGCHLD);
-       if (setintr)
-               sigrelse(SIGINT);
+       (void) sigsetmask(omask);

        if (err)
                error(NOSTR);
 }
        if (err)
                error(NOSTR);
 }


@@ -870,8 +883,9 @@ pstart(pp, foregnd)
 {
        register struct process *np;
        int jobflags = 0;
 {
        register struct process *np;
        int jobflags = 0;

+       long omask;

 
 

-       sighold(SIGCHLD);
+       omask = sigblock(sigmask(SIGCHLD));

        np = pp;
        do {
                jobflags |= np->p_flags;
        np = pp;
        do {
                jobflags |= np->p_flags;


@@ -886,12 +900,12 @@ pstart(pp, foregnd)
        } while((np = np->p_friends) != pp);
        if (!foregnd)
                pclrcurr(pp);
        } while((np = np->p_friends) != pp);
        if (!foregnd)
                pclrcurr(pp);

-       pprint(pp, foregnd ? NAME|JOBDIR : NUMBER|NAME|AMPERSAND);
+       (void) pprint(pp, foregnd ? NAME|JOBDIR : NUMBER|NAME|AMPERSAND);

        if (foregnd)
        if (foregnd)

-               ioctl(FSHTTY, TIOCSPGRP, &pp->p_jobid);
+               (void) ioctl(FSHTTY, TIOCSPGRP, (char *)&pp->p_jobid);

        if (jobflags&PSTOPPED)
        if (jobflags&PSTOPPED)

-               killpg(pp->p_jobid, SIGCONT);
-       sigrelse(SIGCHLD);
+               (void) killpg(pp->p_jobid, SIGCONT);
+       (void) sigsetmask(omask);

 }
 
 panystop(neednl)
 }
 
 panystop(neednl)


@@ -901,7 +915,7 @@ panystop(neednl)
        chkstop = 2;
        for (pp = proclist.p_next; pp; pp = pp->p_next)
                if (pp->p_flags & PSTOPPED)
        chkstop = 2;
        for (pp = proclist.p_next; pp; pp = pp->p_next)
                if (pp->p_flags & PSTOPPED)

-                       error("\nThere are stopped jobs" + 1 - neednl);
+                       error("\nThere are suspended jobs" + 1 - neednl);

 }
 
 struct process *
 }
 
 struct process *


@@ -951,6 +965,7 @@ match:
                bferr("No job matches pattern");
        else
                bferr("No such job");
                bferr("No job matches pattern");
        else
                bferr("No such job");

+       /*NOTREACHED*/

 }
 
 /*
 }
 
 /*


@@ -1004,6 +1019,7 @@ pfork(t, wanttty)
        register int pid;
        bool ignint = 0;
        int pgrp;
        register int pid;
        bool ignint = 0;
        int pgrp;

+       long omask;

 
        /*
         * A child will be uninterruptible only under very special
 
        /*
         * A child will be uninterruptible only under very special


@@ -1020,13 +1036,12 @@ pfork(t, wanttty)
        /*
         * Hold SIGCHLD until we have the process installed in our table.
         */
        /*
         * Hold SIGCHLD until we have the process installed in our table.
         */

-       sighold(SIGCHLD);
+       omask = sigblock(sigmask(SIGCHLD));

        while ((pid = fork()) < 0)
                if (setintr == 0)
                        sleep(FORKSLEEP);
                else {
        while ((pid = fork()) < 0)
                if (setintr == 0)
                        sleep(FORKSLEEP);
                else {

-                       sigrelse(SIGINT);
-                       sigrelse(SIGCHLD);
+                       (void) sigsetmask(omask);

                        error("No more processes");
                }
        if (pid == 0) {
                        error("No more processes");
                }
        if (pid == 0) {


@@ -1034,32 +1049,30 @@ pfork(t, wanttty)
                pgrp = pcurrjob ? pcurrjob->p_jobid : getpid();
                pflushall();
                pcurrjob = PNULL;
                pgrp = pcurrjob ? pcurrjob->p_jobid : getpid();
                pflushall();
                pcurrjob = PNULL;

-               timesdone = 0;

                child++;
                if (setintr) {
                        setintr = 0;            /* until I think otherwise */
                child++;
                if (setintr) {
                        setintr = 0;            /* until I think otherwise */

-                       sigrelse(SIGCHLD);

                        /*
                         * Children just get blown away on SIGINT, SIGQUIT
                         * unless "onintr -" seen.
                         */
                        /*
                         * Children just get blown away on SIGINT, SIGQUIT
                         * unless "onintr -" seen.
                         */

-                       signal(SIGINT, ignint ? SIG_IGN : SIG_DFL);
-                       signal(SIGQUIT, ignint ? SIG_IGN : SIG_DFL);
+                       (void) signal(SIGINT, ignint ? SIG_IGN : SIG_DFL);
+                       (void) signal(SIGQUIT, ignint ? SIG_IGN : SIG_DFL);

                        if (wanttty >= 0) {
                                /* make stoppable */
                        if (wanttty >= 0) {
                                /* make stoppable */

-                               signal(SIGTSTP, SIG_DFL);
-                               signal(SIGTTIN, SIG_DFL);
-                               signal(SIGTTOU, SIG_DFL);
+                               (void) signal(SIGTSTP, SIG_DFL);
+                               (void) signal(SIGTTIN, SIG_DFL);
+                               (void) signal(SIGTTOU, SIG_DFL);

                        }
                        }

-                       signal(SIGTERM, parterm);
+                       (void) signal(SIGTERM, parterm);

                } else if (tpgrp == -1 && (t->t_dflg&FINT)) {
                } else if (tpgrp == -1 && (t->t_dflg&FINT)) {

-                       signal(SIGINT, SIG_IGN);
-                       signal(SIGQUIT, SIG_IGN);
+                       (void) signal(SIGINT, SIG_IGN);
+                       (void) signal(SIGQUIT, SIG_IGN);

                }
                if (wanttty > 0)
                }
                if (wanttty > 0)

-                       ioctl(FSHTTY, TIOCSPGRP, &pgrp);
+                       (void) ioctl(FSHTTY, TIOCSPGRP, (char *)&pgrp);

                if (wanttty >= 0 && tpgrp >= 0)
                if (wanttty >= 0 && tpgrp >= 0)

-                       setpgrp(0, pgrp);
+                       (void) setpgrp(0, pgrp);

                if (tpgrp > 0)
                        tpgrp = 0;              /* gave tty away */
                /*
                if (tpgrp > 0)
                        tpgrp = 0;              /* gave tty away */
                /*


@@ -1068,18 +1081,12 @@ pfork(t, wanttty)
                 * Then the parser would have to know about nice/nohup/time
                 */
                if (t->t_dflg & FNOHUP)
                 * Then the parser would have to know about nice/nohup/time
                 */
                if (t->t_dflg & FNOHUP)

-                       signal(SIGHUP, SIG_IGN);
-               if (t->t_dflg & FNICE) {
-/* sigh...
-                       nice(20);
-                       nice(-10);
-*/
-                       nice(t->t_nice);
-               }
-
+                       (void) signal(SIGHUP, SIG_IGN);
+               if (t->t_dflg & FNICE)
+                       (void) setpriority(PRIO_PROCESS, 0, t->t_nice);

        } else {
                palloc(pid, t);
        } else {
                palloc(pid, t);

-               sigrelse(SIGCHLD);
+               (void) sigsetmask(omask);

        }
 
        return (pid);
        }
 
        return (pid);