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