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