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