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