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