![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sh.proc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / bin / csh|
Return to sh.proc.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / bin / csh |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley Software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char *sccsid = "@(#)sh.proc.c 5.10 (Berkeley) 5/19/88";
9: #endif
10:
11: #include "sh.h"
12: #include "sh.dir.h"
13: #include "sh.proc.h"
14: #include <sys/wait.h>
15: #include <sys/ioctl.h>
16:
17: /*
18: * C Shell - functions that manage processes, handling hanging, termination
19: */
20:
21: #define BIGINDEX 9 /* largest desirable job index */
22:
23: /*
24: * pchild - called at interrupt level by the SIGCHLD signal
25: * indicating that at least one child has terminated or stopped
26: * thus at least one wait system call will definitely return a
27: * childs status. Top level routines (like pwait) must be sure
28: * to mask interrupts when playing with the proclist data structures!
29: */
30: pchild()
31: {
32: register struct process *pp;
33: register struct process *fp;
34: register int pid;
35: union wait w;
36: int jobflags;
37: struct rusage ru;
38: extern int insource;
39:
40: loop:
41: pid = wait3(&w, (setintr && (intty || insource) ? WNOHANG|WUNTRACED:WNOHANG), &ru);
42: if (pid <= 0) {
43: if (errno == EINTR) {
44: errno = 0;
45: goto loop;
46: }
47: pnoprocesses = pid == -1;
48: return;
49: }
50: for (pp = proclist.p_next; pp != PNULL; pp = pp->p_next)
51: if (pid == pp->p_pid)
52: goto found;
53: goto loop;
54: found:
55: if (pid == atoi(value("child")))
56: unsetv("child");
57: pp->p_flags &= ~(PRUNNING|PSTOPPED|PREPORTED);
58: if (WIFSTOPPED(w)) {
59: pp->p_flags |= PSTOPPED;
60: pp->p_reason = w.w_stopsig;
61: } else {
62: if (pp->p_flags & (PTIME|PPTIME) || adrof("time"))
63: (void) gettimeofday(&pp->p_etime, (struct timezone *)0);
64: pp->p_rusage = ru;
65: if (WIFSIGNALED(w)) {
66: if (w.w_termsig == SIGINT)
67: pp->p_flags |= PINTERRUPTED;
68: else
69: pp->p_flags |= PSIGNALED;
70: if (w.w_coredump)
71: pp->p_flags |= PDUMPED;
72: pp->p_reason = w.w_termsig;
73: } else {
74: pp->p_reason = w.w_retcode;
75: if (pp->p_reason != 0)
76: pp->p_flags |= PAEXITED;
77: else
78: pp->p_flags |= PNEXITED;
79: }
80: }
81: jobflags = 0;
82: fp = pp;
83: do {
84: if ((fp->p_flags & (PPTIME|PRUNNING|PSTOPPED)) == 0 &&
85: !child && adrof("time") &&
86: fp->p_rusage.ru_utime.tv_sec+fp->p_rusage.ru_stime.tv_sec >=
87: atoi(value("time")))
88: fp->p_flags |= PTIME;
89: jobflags |= fp->p_flags;
90: } while ((fp = fp->p_friends) != pp);
91: pp->p_flags &= ~PFOREGND;
92: if (pp == pp->p_friends && (pp->p_flags & PPTIME)) {
93: pp->p_flags &= ~PPTIME;
94: pp->p_flags |= PTIME;
95: }
96: if ((jobflags & (PRUNNING|PREPORTED)) == 0) {
97: fp = pp;
98: do {
99: if (fp->p_flags&PSTOPPED)
100: fp->p_flags |= PREPORTED;
101: } while((fp = fp->p_friends) != pp);
102: while(fp->p_pid != fp->p_jobid)
103: fp = fp->p_friends;
104: if (jobflags&PSTOPPED) {
105: if (pcurrent && pcurrent != fp)
106: pprevious = pcurrent;
107: pcurrent = fp;
108: } else
109: pclrcurr(fp);
110: if (jobflags&PFOREGND) {
111: if (jobflags & (PSIGNALED|PSTOPPED|PPTIME) ||
112: #ifdef IIASA
113: jobflags & PAEXITED ||
114: #endif
115: !eq(dcwd->di_name, fp->p_cwd->di_name)) {
116: ; /* print in pjwait */
117: }
118: /*
119: else if ((jobflags & (PTIME|PSTOPPED)) == PTIME)
120: ptprint(fp);
121: */
122: } else {
123: if (jobflags&PNOTIFY || adrof("notify")) {
124: printf("\215\n");
125: (void) pprint(pp, NUMBER|NAME|REASON);
126: if ((jobflags&PSTOPPED) == 0)
127: pflush(pp);
128: } else {
129: fp->p_flags |= PNEEDNOTE;
130: neednote++;
131: }
132: }
133: }
134: goto loop;
135: }
136:
137: pnote()
138: {
139: register struct process *pp;
140: int flags;
141: long omask;
142:
143: neednote = 0;
144: for (pp = proclist.p_next; pp != PNULL; pp = pp->p_next) {
145: if (pp->p_flags & PNEEDNOTE) {
146: omask = sigblock(sigmask(SIGCHLD));
147: pp->p_flags &= ~PNEEDNOTE;
148: flags = pprint(pp, NUMBER|NAME|REASON);
149: if ((flags&(PRUNNING|PSTOPPED)) == 0)
150: pflush(pp);
151: (void) sigsetmask(omask);
152: }
153: }
154: }
155:
156: /*
157: * pwait - wait for current job to terminate, maintaining integrity
158: * of current and previous job indicators.
159: */
160: pwait()
161: {
162: register struct process *fp, *pp;
163: long omask;
164:
165: /*
166: * Here's where dead procs get flushed.
167: */
168: omask = sigblock(sigmask(SIGCHLD));
169: for (pp = (fp = &proclist)->p_next; pp != PNULL; pp = (fp = pp)->p_next)
170: if (pp->p_pid == 0) {
171: fp->p_next = pp->p_next;
172: xfree(pp->p_command);
173: if (pp->p_cwd && --pp->p_cwd->di_count == 0)
174: if (pp->p_cwd->di_next == 0)
175: dfree(pp->p_cwd);
176: xfree((char *)pp);
177: pp = fp;
178: }
179: (void) sigsetmask(omask);
180: pjwait(pcurrjob);
181: }
182:
183: /*
184: * pjwait - wait for a job to finish or become stopped
185: * It is assumed to be in the foreground state (PFOREGND)
186: */
187: pjwait(pp)
188: register struct process *pp;
189: {
190: register struct process *fp;
191: int jobflags, reason;
192: long omask;
193:
194: while (pp->p_pid != pp->p_jobid)
195: pp = pp->p_friends;
196: fp = pp;
197: do {
198: if ((fp->p_flags&(PFOREGND|PRUNNING)) == PRUNNING)
199: printf("BUG: waiting for background job!\n");
200: } while ((fp = fp->p_friends) != pp);
201: /*
202: * Now keep pausing as long as we are not interrupted (SIGINT),
203: * and the target process, or any of its friends, are running
204: */
205: fp = pp;
206: omask = sigblock(sigmask(SIGCHLD));
207: for (;;) {
208: jobflags = 0;
209: do
210: jobflags |= fp->p_flags;
211: while ((fp = (fp->p_friends)) != pp);
212: if ((jobflags & PRUNNING) == 0)
213: break;
214: sigpause(sigblock(0L) &~ sigmask(SIGCHLD));
215: }
216: (void) sigsetmask(omask);
217: if (tpgrp > 0) /* get tty back */
218: (void) ioctl(FSHTTY, TIOCSPGRP, (char *)&tpgrp);
219: if ((jobflags&(PSIGNALED|PSTOPPED|PTIME)) ||
220: !eq(dcwd->di_name, fp->p_cwd->di_name)) {
221: if (jobflags&PSTOPPED)
222: printf("\n");
223: (void) pprint(pp, AREASON|SHELLDIR);
224: }
225: if ((jobflags&(PINTERRUPTED|PSTOPPED)) && setintr &&
226: (!gointr || !eq(gointr, "-"))) {
227: if ((jobflags & PSTOPPED) == 0)
228: pflush(pp);
229: pintr1(0);
230: /*NOTREACHED*/
231: }
232: reason = 0;
233: fp = pp;
234: do {
235: if (fp->p_reason)
236: reason = fp->p_flags & (PSIGNALED|PINTERRUPTED) ?
237: fp->p_reason | QUOTE : fp->p_reason;
238: } while ((fp = fp->p_friends) != pp);
239: set("status", putn(reason));
240: if (reason && exiterr)
241: exitstat();
242: pflush(pp);
243: }
244:
245: /*
246: * dowait - wait for all processes to finish
247: */
248: dowait()
249: {
250: register struct process *pp;
251: long omask;
252:
253: pjobs++;
254: omask = sigblock(sigmask(SIGCHLD));
255: loop:
256: for (pp = proclist.p_next; pp; pp = pp->p_next)
257: if (pp->p_pid && /* pp->p_pid == pp->p_jobid && */
258: pp->p_flags&PRUNNING) {
259: sigpause(0L);
260: goto loop;
261: }
262: (void) sigsetmask(omask);
263: pjobs = 0;
264: }
265:
266: /*
267: * pflushall - flush all jobs from list (e.g. at fork())
268: */
269: pflushall()
270: {
271: register struct process *pp;
272:
273: for (pp = proclist.p_next; pp != PNULL; pp = pp->p_next)
274: if (pp->p_pid)
275: pflush(pp);
276: }
277:
278: /*
279: * pflush - flag all process structures in the same job as the
280: * the argument process for deletion. The actual free of the
281: * space is not done here since pflush is called at interrupt level.
282: */
283: pflush(pp)
284: register struct process *pp;
285: {
286: register struct process *np;
287: register int index;
288:
289: if (pp->p_pid == 0) {
290: printf("BUG: process flushed twice");
291: return;
292: }
293: while (pp->p_pid != pp->p_jobid)
294: pp = pp->p_friends;
295: pclrcurr(pp);
296: if (pp == pcurrjob)
297: pcurrjob = 0;
298: index = pp->p_index;
299: np = pp;
300: do {
301: np->p_index = np->p_pid = 0;
302: np->p_flags &= ~PNEEDNOTE;
303: } while ((np = np->p_friends) != pp);
304: if (index == pmaxindex) {
305: for (np = proclist.p_next, index = 0; np; np = np->p_next)
306: if (np->p_index > index)
307: index = np->p_index;
308: pmaxindex = index;
309: }
310: }
311:
312: /*
313: * pclrcurr - make sure the given job is not the current or previous job;
314: * pp MUST be the job leader
315: */
316: pclrcurr(pp)
317: register struct process *pp;
318: {
319:
320: if (pp == pcurrent)
321: if (pprevious != PNULL) {
322: pcurrent = pprevious;
323: pprevious = pgetcurr(pp);
324: } else {
325: pcurrent = pgetcurr(pp);
326: pprevious = pgetcurr(pp);
327: }
328: else if (pp == pprevious)
329: pprevious = pgetcurr(pp);
330: }
331:
332: /* +4 here is 1 for '\0', 1 ea for << >& >> */
333: char command[PMAXLEN+4];
334: int cmdlen;
335: char *cmdp;
336: /*
337: * palloc - allocate a process structure and fill it up.
338: * an important assumption is made that the process is running.
339: */
340: palloc(pid, t)
341: int pid;
342: register struct command *t;
343: {
344: register struct process *pp;
345: int i;
346:
347: pp = (struct process *)calloc(1, sizeof(struct process));
348: pp->p_pid = pid;
349: pp->p_flags = t->t_dflg & FAND ? PRUNNING : PRUNNING|PFOREGND;
350: if (t->t_dflg & FTIME)
351: pp->p_flags |= PPTIME;
352: cmdp = command;
353: cmdlen = 0;
354: padd(t);
355: *cmdp++ = 0;
356: if (t->t_dflg & FPOU) {
357: pp->p_flags |= PPOU;
358: if (t->t_dflg & FDIAG)
359: pp->p_flags |= PDIAG;
360: }
361: pp->p_command = savestr(command);
362: if (pcurrjob) {
363: struct process *fp;
364: /* careful here with interrupt level */
365: pp->p_cwd = 0;
366: pp->p_index = pcurrjob->p_index;
367: pp->p_friends = pcurrjob;
368: pp->p_jobid = pcurrjob->p_pid;
369: for (fp = pcurrjob; fp->p_friends != pcurrjob; fp = fp->p_friends)
370: ;
371: fp->p_friends = pp;
372: } else {
373: pcurrjob = pp;
374: pp->p_jobid = pid;
375: pp->p_friends = pp;
376: pp->p_cwd = dcwd;
377: dcwd->di_count++;
378: if (pmaxindex < BIGINDEX)
379: pp->p_index = ++pmaxindex;
380: else {
381: struct process *np;
382:
383: for (i = 1; ; i++) {
384: for (np = proclist.p_next; np; np = np->p_next)
385: if (np->p_index == i)
386: goto tryagain;
387: pp->p_index = i;
388: if (i > pmaxindex)
389: pmaxindex = i;
390: break;
391: tryagain:;
392: }
393: }
394: if (pcurrent == PNULL)
395: pcurrent = pp;
396: else if (pprevious == PNULL)
397: pprevious = pp;
398: }
399: pp->p_next = proclist.p_next;
400: proclist.p_next = pp;
401: (void) gettimeofday(&pp->p_btime, (struct timezone *)0);
402: }
403:
404: padd(t)
405: register struct command *t;
406: {
407: char **argp;
408:
409: if (t == 0)
410: return;
411: switch (t->t_dtyp) {
412:
413: case TPAR:
414: pads("( ");
415: padd(t->t_dspr);
416: pads(" )");
417: break;
418:
419: case TCOM:
420: for (argp = t->t_dcom; *argp; argp++) {
421: pads(*argp);
422: if (argp[1])
423: pads(" ");
424: }
425: break;
426:
427: case TOR:
428: case TAND:
429: case TFIL:
430: case TLST:
431: padd(t->t_dcar);
432: switch (t->t_dtyp) {
433: case TOR:
434: pads(" || ");
435: break;
436: case TAND:
437: pads(" && ");
438: break;
439: case TFIL:
440: pads(" | ");
441: break;
442: case TLST:
443: pads("; ");
444: break;
445: }
446: padd(t->t_dcdr);
447: return;
448: }
449: if ((t->t_dflg & FPIN) == 0 && t->t_dlef) {
450: pads((t->t_dflg & FHERE) ? " << " : " < ");
451: pads(t->t_dlef);
452: }
453: if ((t->t_dflg & FPOU) == 0 && t->t_drit) {
454: pads((t->t_dflg & FCAT) ? " >>" : " >");
455: if (t->t_dflg & FDIAG)
456: pads("&");
457: pads(" ");
458: pads(t->t_drit);
459: }
460: }
461:
462: pads(cp)
463: char *cp;
464: {
465: register int i = strlen(cp);
466:
467: if (cmdlen >= PMAXLEN)
468: return;
469: if (cmdlen + i >= PMAXLEN) {
470: (void) strcpy(cmdp, " ...");
471: cmdlen = PMAXLEN;
472: cmdp += 4;
473: return;
474: }
475: (void) strcpy(cmdp, cp);
476: cmdp += i;
477: cmdlen += i;
478: }
479:
480: /*
481: * psavejob - temporarily save the current job on a one level stack
482: * so another job can be created. Used for { } in exp6
483: * and `` in globbing.
484: */
485: psavejob()
486: {
487:
488: pholdjob = pcurrjob;
489: pcurrjob = PNULL;
490: }
491:
492: /*
493: * prestjob - opposite of psavejob. This may be missed if we are interrupted
494: * somewhere, but pendjob cleans up anyway.
495: */
496: prestjob()
497: {
498:
499: pcurrjob = pholdjob;
500: pholdjob = PNULL;
501: }
502:
503: /*
504: * pendjob - indicate that a job (set of commands) has been completed
505: * or is about to begin.
506: */
507: pendjob()
508: {
509: register struct process *pp, *tp;
510:
511: if (pcurrjob && (pcurrjob->p_flags&(PFOREGND|PSTOPPED)) == 0) {
512: pp = pcurrjob;
513: while (pp->p_pid != pp->p_jobid)
514: pp = pp->p_friends;
515: printf("[%d]", pp->p_index);
516: tp = pp;
517: do {
518: printf(" %d", pp->p_pid);
519: pp = pp->p_friends;
520: } while (pp != tp);
521: printf("\n");
522: }
523: pholdjob = pcurrjob = 0;
524: }
525:
526: /*
527: * pprint - print a job
528: */
529: pprint(pp, flag)
530: register struct process *pp;
531: {
532: register status, reason;
533: struct process *tp;
534: extern char *linp, linbuf[];
535: int jobflags, pstatus;
536: char *format;
537:
538: while (pp->p_pid != pp->p_jobid)
539: pp = pp->p_friends;
540: if (pp == pp->p_friends && (pp->p_flags & PPTIME)) {
541: pp->p_flags &= ~PPTIME;
542: pp->p_flags |= PTIME;
543: }
544: tp = pp;
545: status = reason = -1;
546: jobflags = 0;
547: do {
548: jobflags |= pp->p_flags;
549: pstatus = pp->p_flags & PALLSTATES;
550: if (tp != pp && linp != linbuf && !(flag&FANCY) &&
551: (pstatus == status && pp->p_reason == reason ||
552: !(flag&REASON)))
553: printf(" ");
554: else {
555: if (tp != pp && linp != linbuf)
556: printf("\n");
557: if(flag&NUMBER)
558: if (pp == tp)
559: printf("[%d]%s %c ", pp->p_index,
560: pp->p_index < 10 ? " " : "",
561: pp==pcurrent ? '+' :
562: (pp == pprevious ? '-' : ' '));
563: else
564: printf(" ");
565: if (flag&FANCY)
566: printf("%5d ", pp->p_pid);
567: if (flag&(REASON|AREASON)) {
568: if (flag&NAME)
569: format = "%-23s";
570: else
571: format = "%s";
572: if (pstatus == status)
573: if (pp->p_reason == reason) {
574: printf(format, "");
575: goto prcomd;
576: } else
577: reason = pp->p_reason;
578: else {
579: status = pstatus;
580: reason = pp->p_reason;
581: }
582: switch (status) {
583:
584: case PRUNNING:
585: printf(format, "Running ");
586: break;
587:
588: case PINTERRUPTED:
589: case PSTOPPED:
590: case PSIGNALED:
591: if ((flag&(REASON|AREASON))
592: && reason != SIGINT
593: && reason != SIGPIPE)
594: printf(format, mesg[pp->p_reason].pname);
595: break;
596:
597: case PNEXITED:
598: case PAEXITED:
599: if (flag & REASON)
600: if (pp->p_reason)
601: printf("Exit %-16d", pp->p_reason);
602: else
603: printf(format, "Done");
604: break;
605:
606: default:
607: printf("BUG: status=%-9o", status);
608: }
609: }
610: }
611: prcomd:
612: if (flag&NAME) {
613: printf("%s", pp->p_command);
614: if (pp->p_flags & PPOU)
615: printf(" |");
616: if (pp->p_flags & PDIAG)
617: printf("&");
618: }
619: if (flag&(REASON|AREASON) && pp->p_flags&PDUMPED)
620: printf(" (core dumped)");
621: if (tp == pp->p_friends) {
622: if (flag&ERSAND)
623: printf(" &");
624: if (flag&JOBDIR &&
625: !eq(tp->p_cwd->di_name, dcwd->di_name)) {
626: printf(" (wd: ");
627: dtildepr(value("home"), tp->p_cwd->di_name);
628: printf(")");
629: }
630: }
631: if (pp->p_flags&PPTIME && !(status&(PSTOPPED|PRUNNING))) {
632: if (linp != linbuf)
633: printf("\n\t");
634: { static struct rusage zru;
635: prusage(&zru, &pp->p_rusage, &pp->p_etime,
636: &pp->p_btime);
637: }
638: }
639: if (tp == pp->p_friends) {
640: if (linp != linbuf)
641: printf("\n");
642: if (flag&SHELLDIR && !eq(tp->p_cwd->di_name, dcwd->di_name)) {
643: printf("(wd now: ");
644: dtildepr(value("home"), dcwd->di_name);
645: printf(")\n");
646: }
647: }
648: } while ((pp = pp->p_friends) != tp);
649: if (jobflags&PTIME && (jobflags&(PSTOPPED|PRUNNING)) == 0) {
650: if (jobflags & NUMBER)
651: printf(" ");
652: ptprint(tp);
653: }
654: return (jobflags);
655: }
656:
657: ptprint(tp)
658: register struct process *tp;
659: {
660: struct timeval tetime, diff;
661: static struct timeval ztime;
662: struct rusage ru;
663: static struct rusage zru;
664: register struct process *pp = tp;
665:
666: ru = zru;
667: tetime = ztime;
668: do {
669: ruadd(&ru, &pp->p_rusage);
670: tvsub(&diff, &pp->p_etime, &pp->p_btime);
671: if (timercmp(&diff, &tetime, >))
672: tetime = diff;
673: } while ((pp = pp->p_friends) != tp);
674: prusage(&zru, &ru, &tetime, &ztime);
675: }
676:
677: /*
678: * dojobs - print all jobs
679: */
680: dojobs(v)
681: char **v;
682: {
683: register struct process *pp;
684: register int flag = NUMBER|NAME|REASON;
685: int i;
686:
687: if (chkstop)
688: chkstop = 2;
689: if (*++v) {
690: if (v[1] || !eq(*v, "-l"))
691: error("Usage: jobs [ -l ]");
692: flag |= FANCY|JOBDIR;
693: }
694: for (i = 1; i <= pmaxindex; i++)
695: for (pp = proclist.p_next; pp; pp = pp->p_next)
696: if (pp->p_index == i && pp->p_pid == pp->p_jobid) {
697: pp->p_flags &= ~PNEEDNOTE;
698: if (!(pprint(pp, flag) & (PRUNNING|PSTOPPED)))
699: pflush(pp);
700: break;
701: }
702: }
703:
704: /*
705: * dofg - builtin - put the job into the foreground
706: */
707: dofg(v)
708: char **v;
709: {
710: register struct process *pp;
711:
712: okpcntl();
713: ++v;
714: do {
715: pp = pfind(*v);
716: pstart(pp, 1);
717: pjwait(pp);
718: } while (*v && *++v);
719: }
720:
721: /*
722: * %... - builtin - put the job into the foreground
723: */
724: dofg1(v)
725: char **v;
726: {
727: register struct process *pp;
728:
729: okpcntl();
730: pp = pfind(v[0]);
731: pstart(pp, 1);
732: pjwait(pp);
733: }
734:
735: /*
736: * dobg - builtin - put the job into the background
737: */
738: dobg(v)
739: char **v;
740: {
741: register struct process *pp;
742:
743: okpcntl();
744: ++v;
745: do {
746: pp = pfind(*v);
747: pstart(pp, 0);
748: } while (*v && *++v);
749: }
750:
751: /*
752: * %... & - builtin - put the job into the background
753: */
754: dobg1(v)
755: char **v;
756: {
757: register struct process *pp;
758:
759: pp = pfind(v[0]);
760: pstart(pp, 0);
761: }
762:
763: /*
764: * dostop - builtin - stop the job
765: */
766: dostop(v)
767: char **v;
768: {
769:
770: pkill(++v, SIGSTOP);
771: }
772:
773: /*
774: * dokill - builtin - superset of kill (1)
775: */
776: dokill(v)
777: char **v;
778: {
779: register int signum;
780: register char *name;
781:
782: v++;
783: if (v[0] && v[0][0] == '-') {
784: if (v[0][1] == 'l') {
785: for (signum = 1; signum <= NSIG; signum++) {
786: if (name = mesg[signum].iname)
787: printf("%s ", name);
788: if (signum == 16)
789: cshputchar('\n');
790: }
791: cshputchar('\n');
792: return;
793: }
794: if (digit(v[0][1])) {
795: signum = atoi(v[0]+1);
796: if (signum < 0 || signum > NSIG)
797: bferr("Bad signal number");
798: } else {
799: name = &v[0][1];
800: for (signum = 1; signum <= NSIG; signum++)
801: if (mesg[signum].iname &&
802: eq(name, mesg[signum].iname))
803: goto gotsig;
804: setname(name);
805: bferr("Unknown signal; kill -l lists signals");
806: }
807: gotsig:
808: v++;
809: } else
810: signum = SIGTERM;
811: pkill(v, signum);
812: }
813:
814: pkill(v, signum)
815: char **v;
816: int signum;
817: {
818: register struct process *pp, *np;
819: register int jobflags = 0;
820: int pid, err = 0;
821: long omask;
822: char *cp;
823: extern char *sys_errlist[];
824:
825: omask = sigmask(SIGCHLD);
826: if (setintr)
827: omask |= sigmask(SIGINT);
828: omask = sigblock(omask) & ~omask;
829: while (*v) {
830: cp = globone(*v);
831: if (*cp == '%') {
832: np = pp = pfind(cp);
833: do
834: jobflags |= np->p_flags;
835: while ((np = np->p_friends) != pp);
836: switch (signum) {
837:
838: case SIGSTOP:
839: case SIGTSTP:
840: case SIGTTIN:
841: case SIGTTOU:
842: if ((jobflags & PRUNNING) == 0) {
843: printf("%s: Already suspended\n", cp);
844: err++;
845: goto cont;
846: }
847: }
848: if (killpg(pp->p_jobid, signum) < 0) {
849: printf("%s: ", cp);
850: printf("%s\n", sys_errlist[errno]);
851: err++;
852: }
853: if (signum == SIGTERM || signum == SIGHUP)
854: (void) killpg(pp->p_jobid, SIGCONT);
855: } else if (!(digit(*cp) || *cp == '-'))
856: bferr("Arguments should be jobs or process id's");
857: else {
858: pid = atoi(cp);
859: if (kill(pid, signum) < 0) {
860: printf("%d: ", pid);
861: printf("%s\n", sys_errlist[errno]);
862: err++;
863: goto cont;
864: }
865: if (signum == SIGTERM || signum == SIGHUP)
866: (void) kill(pid, SIGCONT);
867: }
868: cont:
869: xfree(cp);
870: v++;
871: }
872: (void) sigsetmask(omask);
873: if (err)
874: error(NOSTR);
875: }
876:
877: /*
878: * pstart - start the job in foreground/background
879: */
880: pstart(pp, foregnd)
881: register struct process *pp;
882: int foregnd;
883: {
884: register struct process *np;
885: int jobflags = 0;
886: long omask;
887:
888: omask = sigblock(sigmask(SIGCHLD));
889: np = pp;
890: do {
891: jobflags |= np->p_flags;
892: if (np->p_flags&(PRUNNING|PSTOPPED)) {
893: np->p_flags |= PRUNNING;
894: np->p_flags &= ~PSTOPPED;
895: if (foregnd)
896: np->p_flags |= PFOREGND;
897: else
898: np->p_flags &= ~PFOREGND;
899: }
900: } while((np = np->p_friends) != pp);
901: if (!foregnd)
902: pclrcurr(pp);
903: (void) pprint(pp, foregnd ? NAME|JOBDIR : NUMBER|NAME|AMPERSAND);
904: if (foregnd)
905: (void) ioctl(FSHTTY, TIOCSPGRP, (char *)&pp->p_jobid);
906: if (jobflags&PSTOPPED)
907: (void) killpg(pp->p_jobid, SIGCONT);
908: (void) sigsetmask(omask);
909: }
910:
911: panystop(neednl)
912: {
913: register struct process *pp;
914:
915: chkstop = 2;
916: for (pp = proclist.p_next; pp; pp = pp->p_next)
917: if (pp->p_flags & PSTOPPED)
918: error("\nThere are suspended jobs" + 1 - neednl);
919: }
920:
921: struct process *
922: pfind(cp)
923: char *cp;
924: {
925: register struct process *pp, *np;
926:
927: if (cp == 0 || cp[1] == 0 || eq(cp, "%%") || eq(cp, "%+")) {
928: if (pcurrent == PNULL)
929: bferr("No current job");
930: return (pcurrent);
931: }
932: if (eq(cp, "%-") || eq(cp, "%#")) {
933: if (pprevious == PNULL)
934: bferr("No previous job");
935: return (pprevious);
936: }
937: if (digit(cp[1])) {
938: int index = atoi(cp+1);
939: for (pp = proclist.p_next; pp; pp = pp->p_next)
940: if (pp->p_index == index && pp->p_pid == pp->p_jobid)
941: return (pp);
942: bferr("No such job");
943: }
944: np = PNULL;
945: for (pp = proclist.p_next; pp; pp = pp->p_next)
946: if (pp->p_pid == pp->p_jobid) {
947: if (cp[1] == '?') {
948: register char *dp;
949: for (dp = pp->p_command; *dp; dp++) {
950: if (*dp != cp[2])
951: continue;
952: if (prefix(cp+2, dp))
953: goto match;
954: }
955: } else if (prefix(cp+1, pp->p_command)) {
956: match:
957: if (np)
958: bferr("Ambiguous");
959: np = pp;
960: }
961: }
962: if (np)
963: return (np);
964: if (cp[1] == '?')
965: bferr("No job matches pattern");
966: else
967: bferr("No such job");
968: /*NOTREACHED*/
969: }
970:
971: /*
972: * pgetcurr - find most recent job that is not pp, preferably stopped
973: */
974: struct process *
975: pgetcurr(pp)
976: register struct process *pp;
977: {
978: register struct process *np;
979: register struct process *xp = PNULL;
980:
981: for (np = proclist.p_next; np; np = np->p_next)
982: if (np != pcurrent && np != pp && np->p_pid &&
983: np->p_pid == np->p_jobid) {
984: if (np->p_flags & PSTOPPED)
985: return (np);
986: if (xp == PNULL)
987: xp = np;
988: }
989: return (xp);
990: }
991:
992: /*
993: * donotify - flag the job so as to report termination asynchronously
994: */
995: donotify(v)
996: char **v;
997: {
998: register struct process *pp;
999:
1000: pp = pfind(*++v);
1001: pp->p_flags |= PNOTIFY;
1002: }
1003:
1004: /*
1005: * Do the fork and whatever should be done in the child side that
1006: * should not be done if we are not forking at all (like for simple builtin's)
1007: * Also do everything that needs any signals fiddled with in the parent side
1008: *
1009: * Wanttty tells whether process and/or tty pgrps are to be manipulated:
1010: * -1: leave tty alone; inherit pgrp from parent
1011: * 0: already have tty; manipulate process pgrps only
1012: * 1: want to claim tty; manipulate process and tty pgrps
1013: * It is usually just the value of tpgrp.
1014: */
1015: pfork(t, wanttty)
1016: struct command *t; /* command we are forking for */
1017: int wanttty;
1018: {
1019: register int pid;
1020: bool ignint = 0;
1021: int pgrp;
1022: long omask;
1023:
1024: /*
1025: * A child will be uninterruptible only under very special
1026: * conditions. Remember that the semantics of '&' is
1027: * implemented by disconnecting the process from the tty so
1028: * signals do not need to ignored just for '&'.
1029: * Thus signals are set to default action for children unless:
1030: * we have had an "onintr -" (then specifically ignored)
1031: * we are not playing with signals (inherit action)
1032: */
1033: if (setintr)
1034: ignint = (tpgrp == -1 && (t->t_dflg&FINT))
1035: || (gointr && eq(gointr, "-"));
1036: /*
1037: * Hold SIGCHLD until we have the process installed in our table.
1038: */
1039: omask = sigblock(sigmask(SIGCHLD));
1040: while ((pid = fork()) < 0)
1041: if (setintr == 0)
1042: sleep(FORKSLEEP);
1043: else {
1044: (void) sigsetmask(omask);
1045: error("No more processes");
1046: }
1047: if (pid == 0) {
1048: settimes();
1049: pgrp = pcurrjob ? pcurrjob->p_jobid : getpid();
1050: pflushall();
1051: pcurrjob = PNULL;
1052: child++;
1053: if (setintr) {
1054: setintr = 0; /* until I think otherwise */
1055: /*
1056: * Children just get blown away on SIGINT, SIGQUIT
1057: * unless "onintr -" seen.
1058: */
1059: (void) signal(SIGINT, ignint ? SIG_IGN : SIG_DFL);
1060: (void) signal(SIGQUIT, ignint ? SIG_IGN : SIG_DFL);
1061: if (wanttty >= 0) {
1062: /* make stoppable */
1063: (void) signal(SIGTSTP, SIG_DFL);
1064: (void) signal(SIGTTIN, SIG_DFL);
1065: (void) signal(SIGTTOU, SIG_DFL);
1066: }
1067: (void) signal(SIGTERM, parterm);
1068: } else if (tpgrp == -1 && (t->t_dflg&FINT)) {
1069: (void) signal(SIGINT, SIG_IGN);
1070: (void) signal(SIGQUIT, SIG_IGN);
1071: }
1072: if (wanttty > 0)
1073: (void) ioctl(FSHTTY, TIOCSPGRP, (char *)&pgrp);
1074: if (wanttty >= 0 && tpgrp >= 0)
1075: (void) setpgrp(0, pgrp);
1076: if (tpgrp > 0)
1077: tpgrp = 0; /* gave tty away */
1078: /*
1079: * Nohup and nice apply only to TCOM's but it would be
1080: * nice (?!?) if you could say "nohup (foo;bar)"
1081: * Then the parser would have to know about nice/nohup/time
1082: */
1083: if (t->t_dflg & FNOHUP)
1084: (void) signal(SIGHUP, SIG_IGN);
1085: if (t->t_dflg & FNICE)
1086: (void) setpriority(PRIO_PROCESS, 0, t->t_nice);
1087: } else {
1088: palloc(pid, t);
1089: (void) sigsetmask(omask);
1090: }
1091:
1092: return (pid);
1093: }
1094:
1095: okpcntl()
1096: {
1097:
1098: if (tpgrp == -1)
1099: error("No job control in this shell");
1100: if (tpgrp == 0)
1101: error("No job control in subshells");
1102: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.