proc.c revision 1.44
1 /* $NetBSD: proc.c,v 1.44 2025/07/05 06:41:09 mlelstv Exp $ */ 2 3 /*- 4 * Copyright (c) 1980, 1991, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 #if 0 35 static char sccsid[] = "@(#)proc.c 8.1 (Berkeley) 5/31/93"; 36 #else 37 __RCSID("$NetBSD: proc.c,v 1.44 2025/07/05 06:41:09 mlelstv Exp $"); 38 #endif 39 #endif /* not lint */ 40 41 #include <sys/types.h> 42 #include <sys/wait.h> 43 44 #include <errno.h> 45 #include <stdarg.h> 46 #include <stdlib.h> 47 #include <string.h> 48 #include <unistd.h> 49 50 #include "csh.h" 51 #include "dir.h" 52 #include "extern.h" 53 #include "proc.h" 54 55 #define BIGINDEX 9 /* largest desirable job index */ 56 57 extern int insource; 58 59 struct process proclist; 60 int pnoprocesses; 61 62 struct process *pholdjob; 63 64 struct process *pcurrjob; 65 struct process *pcurrent; 66 struct process *pprevious; 67 68 int pmaxindex; 69 70 static void pflushall(void); 71 static void pflush(struct process *); 72 static void pclrcurr(struct process *); 73 static void padd(struct command *); 74 static int pprint(struct process *, int); 75 static void ptprint(struct process *); 76 static void pads(Char *); 77 static void pkill(Char **v, int); 78 static struct process *pgetcurr(struct process *); 79 static void okpcntl(void); 80 81 /* 82 * pchild - called at interrupt level by the SIGCHLD signal 83 * indicating that at least one child has terminated or stopped 84 * thus at least one wait system call will definitely return a 85 * childs status. Top level routines (like pwait) must be sure 86 * to mask interrupts when playing with the proclist data structures! 87 */ 88 /* ARGSUSED */ 89 void 90 pchild(int notused) 91 { 92 struct rusage ru; 93 struct process *fp, *pp; 94 int jobflags, pid, w; 95 96 loop: 97 errno = 0; /* reset, just in case */ 98 pid = wait3(&w, 99 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), &ru); 100 101 if (pid <= 0) { 102 if (errno == EINTR) { 103 errno = 0; 104 goto loop; 105 } 106 pnoprocesses = pid == -1; 107 return; 108 } 109 for (pp = proclist.p_next; pp != NULL; pp = pp->p_next) 110 if (pid == pp->p_pid) 111 goto found; 112 goto loop; 113 found: 114 if (pid == atoi(short2str(value(STRchild)))) 115 unsetv(STRchild); 116 pp->p_flags &= ~(PRUNNING | PSTOPPED | PREPORTED); 117 if (WIFSTOPPED(w)) { 118 pp->p_flags |= PSTOPPED; 119 pp->p_reason = WSTOPSIG(w); 120 } 121 else { 122 if (pp->p_flags & (PTIME | PPTIME) || adrof(STRtime)) 123 (void)clock_gettime(CLOCK_MONOTONIC, &pp->p_etime); 124 125 pp->p_rusage = ru; 126 if (WIFSIGNALED(w)) { 127 if (WTERMSIG(w) == SIGINT) 128 pp->p_flags |= PINTERRUPTED; 129 else 130 pp->p_flags |= PSIGNALED; 131 if (WCOREDUMP(w)) 132 pp->p_flags |= PDUMPED; 133 pp->p_reason = WTERMSIG(w); 134 } 135 else { 136 pp->p_reason = WEXITSTATUS(w); 137 if (pp->p_reason != 0) 138 pp->p_flags |= PAEXITED; 139 else 140 pp->p_flags |= PNEXITED; 141 } 142 } 143 jobflags = 0; 144 fp = pp; 145 do { 146 if ((fp->p_flags & (PPTIME | PRUNNING | PSTOPPED)) == 0 && 147 !child && adrof(STRtime) && 148 fp->p_rusage.ru_utime.tv_sec + fp->p_rusage.ru_stime.tv_sec 149 >= atoi(short2str(value(STRtime)))) 150 fp->p_flags |= PTIME; 151 jobflags |= fp->p_flags; 152 } while ((fp = fp->p_friends) != pp); 153 pp->p_flags &= ~PFOREGND; 154 if (pp == pp->p_friends && (pp->p_flags & PPTIME)) { 155 pp->p_flags &= ~PPTIME; 156 pp->p_flags |= PTIME; 157 } 158 if ((jobflags & (PRUNNING | PREPORTED)) == 0) { 159 fp = pp; 160 do { 161 if (fp->p_flags & PSTOPPED) 162 fp->p_flags |= PREPORTED; 163 } while ((fp = fp->p_friends) != pp); 164 while (fp->p_pid != fp->p_jobid) 165 fp = fp->p_friends; 166 if (jobflags & PSTOPPED) { 167 if (pcurrent && pcurrent != fp) 168 pprevious = pcurrent; 169 pcurrent = fp; 170 } 171 else 172 pclrcurr(fp); 173 if (jobflags & PFOREGND) { 174 if (jobflags & (PSIGNALED | PSTOPPED | PPTIME) || 175 #ifdef IIASA 176 jobflags & PAEXITED || 177 #endif 178 !eq(dcwd->di_name, fp->p_cwd->di_name)) { 179 ; /* print in pjwait */ 180 } 181 /* PWP: print a newline after ^C */ 182 else if (jobflags & PINTERRUPTED) { 183 (void)vis_fputc('\r' | QUOTE, cshout); 184 (void)fputc('\n', cshout); 185 } 186 } 187 else { 188 if (jobflags & PNOTIFY || adrof(STRnotify)) { 189 (void)vis_fputc('\r' | QUOTE, cshout); 190 (void)fputc('\n', cshout); 191 (void)pprint(pp, NUMBER | NAME | REASON); 192 if ((jobflags & PSTOPPED) == 0) 193 pflush(pp); 194 } 195 else { 196 fp->p_flags |= PNEEDNOTE; 197 neednote++; 198 } 199 } 200 } 201 goto loop; 202 } 203 204 void 205 pnote(void) 206 { 207 struct process *pp; 208 sigset_t osigset, nsigset; 209 int flags; 210 211 neednote = 0; 212 sigemptyset(&nsigset); 213 (void)sigaddset(&nsigset, SIGCHLD); 214 for (pp = proclist.p_next; pp != NULL; pp = pp->p_next) { 215 if (pp->p_flags & PNEEDNOTE) { 216 (void)sigprocmask(SIG_BLOCK, &nsigset, &osigset); 217 pp->p_flags &= ~PNEEDNOTE; 218 flags = pprint(pp, NUMBER | NAME | REASON); 219 if ((flags & (PRUNNING | PSTOPPED)) == 0) 220 pflush(pp); 221 (void)sigprocmask(SIG_SETMASK, &osigset, NULL); 222 } 223 } 224 } 225 226 /* 227 * pwait - wait for current job to terminate, maintaining integrity 228 * of current and previous job indicators. 229 */ 230 void 231 pwait(void) 232 { 233 struct process *fp, *pp; 234 sigset_t osigset, nsigset; 235 236 /* 237 * Here's where dead procs get flushed. 238 */ 239 sigemptyset(&nsigset); 240 (void)sigaddset(&nsigset, SIGCHLD); 241 (void)sigprocmask(SIG_BLOCK, &nsigset, &osigset); 242 for (pp = (fp = &proclist)->p_next; pp != NULL; pp = (fp = pp)->p_next) 243 if (pp->p_pid == 0) { 244 fp->p_next = pp->p_next; 245 free(pp->p_command); 246 if (pp->p_cwd && --pp->p_cwd->di_count == 0) 247 if (pp->p_cwd->di_next == 0) 248 dfree(pp->p_cwd); 249 free(pp); 250 pp = fp; 251 } 252 (void)sigprocmask(SIG_SETMASK, &osigset, NULL); 253 pjwait(pcurrjob); 254 } 255 256 257 /* 258 * pjwait - wait for a job to finish or become stopped 259 * It is assumed to be in the foreground state (PFOREGND) 260 */ 261 void 262 pjwait(struct process *pp) 263 { 264 struct process *fp; 265 sigset_t osigset, nsigset; 266 int jobflags, reason; 267 268 while (pp->p_pid != pp->p_jobid) 269 pp = pp->p_friends; 270 fp = pp; 271 272 do { 273 if ((fp->p_flags & (PFOREGND | PRUNNING)) == PRUNNING) 274 (void)fprintf(csherr, "BUG: waiting for background job!\n"); 275 } while ((fp = fp->p_friends) != pp); 276 /* 277 * Now keep pausing as long as we are not interrupted (SIGINT), and the 278 * target process, or any of its friends, are running 279 */ 280 fp = pp; 281 sigemptyset(&nsigset); 282 (void)sigaddset(&nsigset, SIGCHLD); 283 (void)sigprocmask(SIG_BLOCK, &nsigset, &osigset); 284 for (;;) { 285 sigemptyset(&nsigset); 286 (void)sigaddset(&nsigset, SIGCHLD); 287 (void)sigprocmask(SIG_BLOCK, &nsigset, NULL); 288 jobflags = 0; 289 do 290 jobflags |= fp->p_flags; 291 while ((fp = (fp->p_friends)) != pp); 292 if ((jobflags & PRUNNING) == 0) 293 break; 294 #ifdef JOBDEBUG 295 (void)fprintf(csherr, "starting to sigsuspend for SIGCHLD on %d\n", 296 fp->p_pid); 297 #endif /* JOBDEBUG */ 298 nsigset = osigset; 299 (void)sigdelset(&nsigset, SIGCHLD); 300 (void)sigsuspend(&nsigset); 301 } 302 (void)sigprocmask(SIG_SETMASK, &osigset, NULL); 303 if (tpgrp > 0) /* get tty back */ 304 (void)tcsetpgrp(FSHTTY, tpgrp); 305 if ((jobflags & (PSIGNALED | PSTOPPED | PTIME)) || 306 !eq(dcwd->di_name, fp->p_cwd->di_name)) { 307 if (jobflags & PSTOPPED) { 308 (void) fputc('\n', cshout); 309 if (adrof(STRlistjobs)) { 310 Char *jobcommand[3]; 311 312 jobcommand[0] = STRjobs; 313 if (eq(value(STRlistjobs), STRlong)) 314 jobcommand[1] = STRml; 315 else 316 jobcommand[1] = NULL; 317 jobcommand[2] = NULL; 318 319 dojobs(jobcommand, NULL); 320 (void)pprint(pp, SHELLDIR); 321 } 322 else 323 (void)pprint(pp, AREASON | SHELLDIR); 324 } 325 else 326 (void)pprint(pp, AREASON | SHELLDIR); 327 } 328 if ((jobflags & (PINTERRUPTED | PSTOPPED)) && setintr && 329 (!gointr || !eq(gointr, STRminus))) { 330 if ((jobflags & PSTOPPED) == 0) 331 pflush(pp); 332 pintr1(0); 333 } 334 reason = 0; 335 fp = pp; 336 do { 337 if (fp->p_reason) 338 reason = fp->p_flags & (PSIGNALED | PINTERRUPTED) ? 339 fp->p_reason | META : fp->p_reason; 340 } while ((fp = fp->p_friends) != pp); 341 if ((reason != 0) && (adrof(STRprintexitvalue))) { 342 (void)fprintf(cshout, "Exit %d\n", reason); 343 } 344 set(STRstatus, putn(reason)); 345 if (reason && exiterr) 346 exitstat(); 347 pflush(pp); 348 } 349 350 /* 351 * dowait - wait for all processes to finish 352 */ 353 void 354 /*ARGSUSED*/ 355 dowait(Char **v, struct command *t) 356 { 357 struct process *pp; 358 sigset_t osigset, nsigset; 359 360 pjobs++; 361 sigemptyset(&nsigset); 362 (void)sigaddset(&nsigset, SIGCHLD); 363 (void)sigprocmask(SIG_BLOCK, &nsigset, &osigset); 364 loop: 365 for (pp = proclist.p_next; pp; pp = pp->p_next) 366 if (pp->p_pid && /* pp->p_pid == pp->p_jobid && */ 367 pp->p_flags & PRUNNING) { 368 sigemptyset(&nsigset); 369 (void)sigsuspend(&nsigset); 370 goto loop; 371 } 372 (void)sigprocmask(SIG_SETMASK, &osigset, NULL); 373 pjobs = 0; 374 } 375 376 /* 377 * pflushall - flush all jobs from list (e.g. at fork()) 378 */ 379 static void 380 pflushall(void) 381 { 382 struct process *pp; 383 384 for (pp = proclist.p_next; pp != NULL; pp = pp->p_next) 385 if (pp->p_pid) 386 pflush(pp); 387 } 388 389 /* 390 * pflush - flag all process structures in the same job as the 391 * the argument process for deletion. The actual free of the 392 * space is not done here since pflush is called at interrupt level. 393 */ 394 static void 395 pflush(struct process *pp) 396 { 397 struct process *np; 398 int idx; 399 400 if (pp->p_pid == 0) { 401 (void)fprintf(csherr, "BUG: process flushed twice"); 402 return; 403 } 404 while (pp->p_pid != pp->p_jobid) 405 pp = pp->p_friends; 406 pclrcurr(pp); 407 if (pp == pcurrjob) 408 pcurrjob = 0; 409 idx = pp->p_index; 410 np = pp; 411 do { 412 np->p_index = np->p_pid = 0; 413 np->p_flags &= ~PNEEDNOTE; 414 } while ((np = np->p_friends) != pp); 415 if (idx == pmaxindex) { 416 for (np = proclist.p_next, idx = 0; np; np = np->p_next) 417 if (np->p_index > idx) 418 idx = np->p_index; 419 pmaxindex = idx; 420 } 421 } 422 423 /* 424 * pclrcurr - make sure the given job is not the current or previous job; 425 * pp MUST be the job leader 426 */ 427 static void 428 pclrcurr(struct process *pp) 429 { 430 if (pp == pcurrent) { 431 if (pprevious != NULL) { 432 pcurrent = pprevious; 433 pprevious = pgetcurr(pp); 434 } 435 else { 436 pcurrent = pgetcurr(pp); 437 pprevious = pgetcurr(pp); 438 } 439 } else if (pp == pprevious) 440 pprevious = pgetcurr(pp); 441 } 442 443 /* +4 here is 1 for '\0', 1 ea for << >& >> */ 444 static Char command[PMAXLEN + 4]; 445 static size_t cmdlen; 446 static Char *cmdp; 447 448 /* 449 * palloc - allocate a process structure and fill it up. 450 * an important assumption is made that the process is running. 451 */ 452 void 453 palloc(int pid, struct command *t) 454 { 455 struct process *pp; 456 int i; 457 458 pp = xcalloc(1, sizeof(*pp)); 459 pp->p_pid = pid; 460 pp->p_flags = t->t_dflg & F_AMPERSAND ? PRUNNING : PRUNNING | PFOREGND; 461 if (t->t_dflg & F_TIME) 462 pp->p_flags |= PPTIME; 463 cmdp = command; 464 cmdlen = 0; 465 padd(t); 466 *cmdp++ = 0; 467 if (t->t_dflg & F_PIPEOUT) { 468 pp->p_flags |= PPOU; 469 if (t->t_dflg & F_STDERR) 470 pp->p_flags |= PERR; 471 } 472 pp->p_command = Strsave(command); 473 if (pcurrjob) { 474 struct process *fp; 475 476 /* careful here with interrupt level */ 477 pp->p_cwd = 0; 478 pp->p_index = pcurrjob->p_index; 479 pp->p_friends = pcurrjob; 480 pp->p_jobid = pcurrjob->p_pid; 481 for (fp = pcurrjob; fp->p_friends != pcurrjob; fp = fp->p_friends) 482 continue; 483 fp->p_friends = pp; 484 } 485 else { 486 pcurrjob = pp; 487 pp->p_jobid = pid; 488 pp->p_friends = pp; 489 pp->p_cwd = dcwd; 490 dcwd->di_count++; 491 if (pmaxindex < BIGINDEX) 492 pp->p_index = ++pmaxindex; 493 else { 494 struct process *np; 495 496 for (i = 1;; i++) { 497 for (np = proclist.p_next; np; np = np->p_next) 498 if (np->p_index == i) 499 goto tryagain; 500 pp->p_index = i; 501 if (i > pmaxindex) 502 pmaxindex = i; 503 break; 504 tryagain:; 505 } 506 } 507 if (pcurrent == NULL) 508 pcurrent = pp; 509 else if (pprevious == NULL) 510 pprevious = pp; 511 } 512 pp->p_next = proclist.p_next; 513 proclist.p_next = pp; 514 (void)clock_gettime(CLOCK_MONOTONIC, &pp->p_btime); 515 } 516 517 static void 518 padd(struct command *t) 519 { 520 Char **argp; 521 522 if (t == 0) 523 return; 524 switch (t->t_dtyp) { 525 case NODE_PAREN: 526 pads(STRLparensp); 527 padd(t->t_dspr); 528 pads(STRspRparen); 529 break; 530 case NODE_COMMAND: 531 for (argp = t->t_dcom; *argp; argp++) { 532 pads(*argp); 533 if (argp[1]) 534 pads(STRspace); 535 } 536 break; 537 case NODE_OR: 538 case NODE_AND: 539 case NODE_PIPE: 540 case NODE_LIST: 541 padd(t->t_dcar); 542 switch (t->t_dtyp) { 543 case NODE_OR: 544 pads(STRspor2sp); 545 break; 546 case NODE_AND: 547 pads(STRspand2sp); 548 break; 549 case NODE_PIPE: 550 pads(STRsporsp); 551 break; 552 case NODE_LIST: 553 pads(STRsemisp); 554 break; 555 } 556 padd(t->t_dcdr); 557 return; 558 } 559 if ((t->t_dflg & F_PIPEIN) == 0 && t->t_dlef) { 560 pads((t->t_dflg & F_READ) ? STRspLarrow2sp : STRspLarrowsp); 561 pads(t->t_dlef); 562 } 563 if ((t->t_dflg & F_PIPEOUT) == 0 && t->t_drit) { 564 pads((t->t_dflg & F_APPEND) ? STRspRarrow2 : STRspRarrow); 565 if (t->t_dflg & F_STDERR) 566 pads(STRand); 567 pads(STRspace); 568 pads(t->t_drit); 569 } 570 } 571 572 static void 573 pads(Char *cp) 574 { 575 size_t i; 576 577 /* 578 * Avoid the Quoted Space alias hack! Reported by: 579 * sam (at) john-bigboote.ICS.UCI.EDU (Sam Horrocks) 580 */ 581 if (cp[0] == STRQNULL[0]) 582 cp++; 583 584 i = Strlen(cp); 585 586 if (cmdlen >= PMAXLEN) 587 return; 588 if (cmdlen + i >= PMAXLEN) { 589 (void)Strcpy(cmdp, STRsp3dots); 590 cmdlen = PMAXLEN; 591 cmdp += 4; 592 return; 593 } 594 (void)Strcpy(cmdp, cp); 595 cmdp += i; 596 cmdlen += i; 597 } 598 599 /* 600 * psavejob - temporarily save the current job on a one level stack 601 * so another job can be created. Used for { } in exp6 602 * and `` in globbing. 603 */ 604 void 605 psavejob(void) 606 { 607 pholdjob = pcurrjob; 608 pcurrjob = NULL; 609 } 610 611 /* 612 * prestjob - opposite of psavejob. This may be missed if we are interrupted 613 * somewhere, but pendjob cleans up anyway. 614 */ 615 void 616 prestjob(void) 617 { 618 pcurrjob = pholdjob; 619 pholdjob = NULL; 620 } 621 622 /* 623 * pendjob - indicate that a job (set of commands) has been completed 624 * or is about to begin. 625 */ 626 void 627 pendjob(void) 628 { 629 struct process *pp, *tp; 630 631 if (pcurrjob && (pcurrjob->p_flags & (PFOREGND | PSTOPPED)) == 0) { 632 pp = pcurrjob; 633 while (pp->p_pid != pp->p_jobid) 634 pp = pp->p_friends; 635 (void)fprintf(cshout, "[%d]", pp->p_index); 636 tp = pp; 637 do { 638 (void)fprintf(cshout, " %ld", (long)pp->p_pid); 639 pp = pp->p_friends; 640 } while (pp != tp); 641 (void)fputc('\n', cshout); 642 } 643 pholdjob = pcurrjob = 0; 644 } 645 646 /* 647 * pprint - print a job 648 */ 649 static int 650 pprint(struct process *pp, int flag) 651 { 652 static struct rusage zru; 653 struct process *tp; 654 const char *format; 655 int jobflags, pstatus, reason, status; 656 int hadnl; 657 658 hadnl = 1; /* did we just have a newline */ 659 (void)fpurge(cshout); 660 661 while (pp->p_pid != pp->p_jobid) 662 pp = pp->p_friends; 663 if (pp == pp->p_friends && (pp->p_flags & PPTIME)) { 664 pp->p_flags &= ~PPTIME; 665 pp->p_flags |= PTIME; 666 } 667 tp = pp; 668 status = reason = -1; 669 jobflags = 0; 670 do { 671 jobflags |= pp->p_flags; 672 pstatus = pp->p_flags & PALLSTATES; 673 if (tp != pp && !hadnl && !(flag & FANCY) && 674 ((pstatus == status && pp->p_reason == reason) || 675 !(flag & REASON))) { 676 (void)fputc(' ', cshout); 677 hadnl = 0; 678 } 679 else { 680 if (tp != pp && !hadnl) { 681 (void)fputc('\n', cshout); 682 hadnl = 1; 683 } 684 if (flag & NUMBER) { 685 if (pp == tp) 686 (void)fprintf(cshout, "[%d]%s %c ", pp->p_index, 687 pp->p_index < 10 ? " " : "", 688 pp == pcurrent ? '+' : 689 (pp == pprevious ? '-' : ' ')); 690 else 691 (void)fprintf(cshout, " "); 692 hadnl = 0; 693 } 694 if (flag & FANCY) { 695 (void)fprintf(cshout, "%5ld ", (long)pp->p_pid); 696 hadnl = 0; 697 } 698 if (flag & (REASON | AREASON)) { 699 if (flag & NAME) 700 format = "%-23s"; 701 else 702 format = "%s"; 703 if (pstatus == status) { 704 if (pp->p_reason == reason) { 705 (void)fprintf(cshout, format, ""); 706 hadnl = 0; 707 goto prcomd; 708 } 709 else 710 reason = pp->p_reason; 711 } else { 712 status = pstatus; 713 reason = pp->p_reason; 714 } 715 switch (status) { 716 case PRUNNING: 717 (void)fprintf(cshout, format, "Running "); 718 hadnl = 0; 719 break; 720 case PINTERRUPTED: 721 case PSTOPPED: 722 case PSIGNALED: 723 /* 724 * tell what happened to the background job 725 * From: Michael Schroeder 726 * <mlschroe (at) immd4.informatik.uni-erlangen.de> 727 */ 728 if ((flag & REASON) 729 || ((flag & AREASON) 730 && reason != SIGINT 731 && (reason != SIGPIPE 732 || (pp->p_flags & PPOU) == 0))) { 733 (void)fprintf(cshout, format, 734 sys_siglist[(unsigned char) 735 pp->p_reason]); 736 hadnl = 0; 737 } 738 break; 739 case PNEXITED: 740 case PAEXITED: 741 if (flag & REASON) { 742 if (pp->p_reason) 743 (void)fprintf(cshout, "Exit %-18d", pp->p_reason); 744 else 745 (void)fprintf(cshout, format, "Done"); 746 hadnl = 0; 747 } 748 break; 749 default: 750 (void)fprintf(csherr, "BUG: status=%-9o", status); 751 } 752 } 753 } 754 prcomd: 755 if (flag & NAME) { 756 (void)fprintf(cshout, "%s", vis_str(pp->p_command)); 757 if (pp->p_flags & PPOU) 758 (void)fprintf(cshout, " |"); 759 if (pp->p_flags & PERR) 760 (void)fputc('&', cshout); 761 hadnl = 0; 762 } 763 if (flag & (REASON | AREASON) && pp->p_flags & PDUMPED) { 764 (void)fprintf(cshout, " (core dumped)"); 765 hadnl = 0; 766 } 767 if (tp == pp->p_friends) { 768 if (flag & AMPERSAND) { 769 (void)fprintf(cshout, " &"); 770 hadnl = 0; 771 } 772 if (flag & JOBDIR && 773 !eq(tp->p_cwd->di_name, dcwd->di_name)) { 774 (void)fprintf(cshout, " (wd: "); 775 dtildepr(value(STRhome), tp->p_cwd->di_name); 776 (void)fputc(')', cshout); 777 hadnl = 0; 778 } 779 } 780 if (pp->p_flags & PPTIME && !(status & (PSTOPPED | PRUNNING))) { 781 if (!hadnl) 782 (void)fprintf(cshout, "\n\t"); 783 prusage(cshout, &zru, &pp->p_rusage, &pp->p_etime, 784 &pp->p_btime); 785 hadnl = 1; 786 } 787 if (tp == pp->p_friends) { 788 if (!hadnl) { 789 (void)fputc('\n', cshout); 790 hadnl = 1; 791 } 792 if (flag & SHELLDIR && !eq(tp->p_cwd->di_name, dcwd->di_name)) { 793 (void)fprintf(cshout, "(wd now: "); 794 dtildepr(value(STRhome), dcwd->di_name); 795 (void)fprintf(cshout, ")\n"); 796 hadnl = 1; 797 } 798 } 799 } while ((pp = pp->p_friends) != tp); 800 if (jobflags & PTIME && (jobflags & (PSTOPPED | PRUNNING)) == 0) { 801 if (jobflags & NUMBER) 802 (void)fprintf(cshout, " "); 803 ptprint(tp); 804 hadnl = 1; 805 } 806 (void)fflush(cshout); 807 return (jobflags); 808 } 809 810 static void 811 ptprint(struct process *tp) 812 { 813 static struct rusage zru; 814 static struct timespec ztime; 815 struct rusage ru; 816 struct timespec tetime, diff; 817 struct process *pp; 818 819 pp = tp; 820 ru = zru; 821 tetime = ztime; 822 do { 823 ruadd(&ru, &pp->p_rusage); 824 timespecsub(&pp->p_etime, &pp->p_btime, &diff); 825 if (timespeccmp(&diff, &tetime, >)) 826 tetime = diff; 827 } while ((pp = pp->p_friends) != tp); 828 prusage(cshout, &zru, &ru, &tetime, &ztime); 829 } 830 831 /* 832 * dojobs - print all jobs 833 */ 834 void 835 /*ARGSUSED*/ 836 dojobs(Char **v, struct command *t) 837 { 838 struct process *pp; 839 int flag, i; 840 841 flag = NUMBER | NAME | REASON; 842 if (chkstop) 843 chkstop = 2; 844 if (*++v) { 845 if (eq(*v, STRml) && !v[1]) { 846 flag |= FANCY | JOBDIR; 847 } else if (eq(*v, STRmZ)) { 848 if (v[1] && v[1][0]) { 849 setproctitle("%s", short2str(v[1])); 850 } else { 851 setproctitle(NULL); 852 } 853 return; 854 } else { 855 stderror(ERR_JOBS); 856 } 857 } 858 for (i = 1; i <= pmaxindex; i++) 859 for (pp = proclist.p_next; pp; pp = pp->p_next) 860 if (pp->p_index == i && pp->p_pid == pp->p_jobid) { 861 pp->p_flags &= ~PNEEDNOTE; 862 if (!(pprint(pp, flag) & (PRUNNING | PSTOPPED))) 863 pflush(pp); 864 break; 865 } 866 } 867 868 /* 869 * dofg - builtin - put the job into the foreground 870 */ 871 void 872 /*ARGSUSED*/ 873 dofg(Char **v, struct command *t) 874 { 875 struct process *pp; 876 877 okpcntl(); 878 ++v; 879 do { 880 pp = pfind(*v); 881 pstart(pp, 1); 882 pjwait(pp); 883 } while (*v && *++v); 884 } 885 886 /* 887 * %... - builtin - put the job into the foreground 888 */ 889 void 890 /*ARGSUSED*/ 891 dofg1(Char **v, struct command *t) 892 { 893 struct process *pp; 894 895 okpcntl(); 896 pp = pfind(v[0]); 897 pstart(pp, 1); 898 pjwait(pp); 899 } 900 901 /* 902 * dobg - builtin - put the job into the background 903 */ 904 void 905 /*ARGSUSED*/ 906 dobg(Char **v, struct command *t) 907 { 908 struct process *pp; 909 910 okpcntl(); 911 ++v; 912 do { 913 pp = pfind(*v); 914 pstart(pp, 0); 915 } while (*v && *++v); 916 } 917 918 /* 919 * %... & - builtin - put the job into the background 920 */ 921 void 922 /*ARGSUSED*/ 923 dobg1(Char **v, struct command *t) 924 { 925 struct process *pp; 926 927 pp = pfind(v[0]); 928 pstart(pp, 0); 929 } 930 931 /* 932 * dostop - builtin - stop the job 933 */ 934 void 935 /*ARGSUSED*/ 936 dostop(Char **v, struct command *t) 937 { 938 pkill(++v, SIGSTOP); 939 } 940 941 /* 942 * dokill - builtin - superset of kill (1) 943 */ 944 void 945 /*ARGSUSED*/ 946 dokill(Char **v, struct command *t) 947 { 948 Char *signame; 949 char *name; 950 long signum; 951 char *ep; 952 953 signum = SIGTERM; 954 v++; 955 if (v[0] && v[0][0] == '-') { 956 if (v[0][1] == 'l') { 957 if (v[1]) { 958 if (!Isdigit(v[1][0])) 959 stderror(ERR_NAME | ERR_BADSIG); 960 961 signum = strtol(short2str(v[1]), &ep, 10); 962 if (signum < 0 || signum >= NSIG) 963 stderror(ERR_NAME | ERR_BADSIG); 964 else if (signum == 0) 965 (void)fputc('0', cshout); /* 0's symbolic name is '0' */ 966 else 967 (void)fprintf(cshout, "%s ", sys_signame[signum]); 968 } else { 969 for (signum = 1; signum < NSIG; signum++) { 970 (void)fprintf(cshout, "%s ", sys_signame[signum]); 971 if (signum == NSIG / 2) 972 (void)fputc('\n', cshout); 973 } 974 } 975 (void)fputc('\n', cshout); 976 return; 977 } 978 if (Isdigit(v[0][1])) { 979 signum = strtol(short2str(v[0] + 1), &ep, 10); 980 if (signum < 0 || signum >= NSIG || *ep) 981 stderror(ERR_NAME | ERR_BADSIG); 982 } 983 else { 984 if (v[0][1] == 's' && v[0][2] == '\0') 985 signame = *(++v); 986 else 987 signame = &v[0][1]; 988 989 if (signame == NULL || v[1] == NULL) 990 stderror(ERR_NAME | ERR_TOOFEW); 991 992 name = short2str(signame); 993 for (signum = 1; signum < NSIG; signum++) 994 if (!strcasecmp(sys_signame[signum], name) || 995 (!strncasecmp("SIG", name, 3) && /* skip "SIG" prefix */ 996 !strcasecmp(sys_signame[signum], name + 3))) 997 break; 998 999 if (signum == NSIG) { 1000 if (signame[0] == '0') 1001 signum = 0; 1002 else { 1003 setname(vis_str(signame)); 1004 stderror(ERR_NAME | ERR_UNKSIG); 1005 } 1006 } 1007 } 1008 v++; 1009 } 1010 pkill(v, (int)signum); 1011 } 1012 1013 static void 1014 pkill(Char **v, int signum) 1015 { 1016 struct process *pp, *np; 1017 Char *cp; 1018 sigset_t nsigset; 1019 int err1, jobflags, pid; 1020 char *ep; 1021 1022 jobflags = 0; 1023 err1 = 0; 1024 sigemptyset(&nsigset); 1025 (void)sigaddset(&nsigset, SIGCHLD); 1026 if (setintr) 1027 (void)sigaddset(&nsigset, SIGINT); 1028 (void)sigprocmask(SIG_BLOCK, &nsigset, NULL); 1029 gflag = 0, tglob(v); 1030 if (gflag) { 1031 v = globall(v); 1032 if (v == 0) 1033 stderror(ERR_NAME | ERR_NOMATCH); 1034 } 1035 else { 1036 v = gargv = saveblk(v); 1037 trim(v); 1038 } 1039 1040 while (v && (cp = *v)) { 1041 if (*cp == '%') { 1042 np = pp = pfind(cp); 1043 do 1044 jobflags |= np->p_flags; 1045 while ((np = np->p_friends) != pp); 1046 switch (signum) { 1047 case SIGSTOP: 1048 case SIGTSTP: 1049 case SIGTTIN: 1050 case SIGTTOU: 1051 if ((jobflags & PRUNNING) == 0) { 1052 (void)fprintf(csherr, "%s: Already suspended\n", 1053 vis_str(cp)); 1054 err1++; 1055 goto cont; 1056 } 1057 break; 1058 /* 1059 * suspend a process, kill -CONT %, then type jobs; the shell 1060 * says it is suspended, but it is running; thanks jaap.. 1061 */ 1062 case SIGCONT: 1063 pstart(pp, 0); 1064 goto cont; 1065 } 1066 if (kill(-pp->p_jobid, signum) < 0) { 1067 (void)fprintf(csherr, "%s: %s\n", vis_str(cp), 1068 strerror(errno)); 1069 err1++; 1070 } 1071 if (signum == SIGTERM || signum == SIGHUP) 1072 (void)kill(-pp->p_jobid, SIGCONT); 1073 } 1074 else if (!(Isdigit(*cp) || *cp == '-')) 1075 stderror(ERR_NAME | ERR_JOBARGS); 1076 else { 1077 pid = (pid_t)strtoul(short2str(cp), &ep, 0); 1078 if (*ep) { 1079 (void)fprintf(csherr, "%s: Badly formed number\n", 1080 short2str(cp)); 1081 err1++; 1082 goto cont; 1083 } else if (kill(pid, signum) < 0) { 1084 (void)fprintf(csherr, "%d: %s\n", pid, strerror(errno)); 1085 err1++; 1086 goto cont; 1087 } 1088 if (signum == SIGTERM || signum == SIGHUP) 1089 (void)kill((pid_t) pid, SIGCONT); 1090 } 1091 cont: 1092 v++; 1093 } 1094 if (gargv) 1095 blkfree(gargv), gargv = 0; 1096 (void)sigprocmask(SIG_UNBLOCK, &nsigset, NULL); 1097 if (err1) 1098 stderror(ERR_SILENT); 1099 } 1100 1101 /* 1102 * pstart - start the job in foreground/background 1103 */ 1104 void 1105 pstart(struct process *pp, int foregnd) 1106 { 1107 struct process *np; 1108 sigset_t osigset, nsigset; 1109 long jobflags; 1110 1111 jobflags = 0; 1112 sigemptyset(&nsigset); 1113 (void)sigaddset(&nsigset, SIGCHLD); 1114 (void)sigprocmask(SIG_BLOCK, &nsigset, &osigset); 1115 np = pp; 1116 do { 1117 jobflags |= np->p_flags; 1118 if (np->p_flags & (PRUNNING | PSTOPPED)) { 1119 np->p_flags |= PRUNNING; 1120 np->p_flags &= ~PSTOPPED; 1121 if (foregnd) 1122 np->p_flags |= PFOREGND; 1123 else 1124 np->p_flags &= ~PFOREGND; 1125 } 1126 } while ((np = np->p_friends) != pp); 1127 if (!foregnd) 1128 pclrcurr(pp); 1129 (void)pprint(pp, foregnd ? NAME | JOBDIR : NUMBER | NAME | AMPERSAND); 1130 if (foregnd) 1131 (void)tcsetpgrp(FSHTTY, pp->p_jobid); 1132 if (jobflags & PSTOPPED) 1133 (void)kill(-pp->p_jobid, SIGCONT); 1134 (void)sigprocmask(SIG_SETMASK, &osigset, NULL); 1135 } 1136 1137 void 1138 panystop(int neednl) 1139 { 1140 struct process *pp; 1141 1142 chkstop = 2; 1143 for (pp = proclist.p_next; pp; pp = pp->p_next) 1144 if (pp->p_flags & PSTOPPED) 1145 stderror(ERR_STOPPED, neednl ? "\n" : ""); 1146 } 1147 1148 struct process * 1149 pfind(Char *cp) 1150 { 1151 struct process *pp, *np; 1152 1153 if (cp == 0 || cp[1] == 0 || eq(cp, STRcent2) || eq(cp, STRcentplus)) { 1154 if (pcurrent == NULL) 1155 stderror(ERR_NAME | ERR_JOBCUR); 1156 return (pcurrent); 1157 } 1158 if (eq(cp, STRcentminus) || eq(cp, STRcenthash)) { 1159 if (pprevious == NULL) 1160 stderror(ERR_NAME | ERR_JOBPREV); 1161 return (pprevious); 1162 } 1163 if (Isdigit(cp[1])) { 1164 int idx = atoi(short2str(cp + 1)); 1165 1166 for (pp = proclist.p_next; pp; pp = pp->p_next) 1167 if (pp->p_index == idx && pp->p_pid == pp->p_jobid) 1168 return (pp); 1169 stderror(ERR_NAME | ERR_NOSUCHJOB); 1170 } 1171 np = NULL; 1172 for (pp = proclist.p_next; pp; pp = pp->p_next) 1173 if (pp->p_pid == pp->p_jobid) { 1174 if (cp[1] == '?') { 1175 Char *dp; 1176 1177 for (dp = pp->p_command; *dp; dp++) { 1178 if (*dp != cp[2]) 1179 continue; 1180 if (prefix(cp + 2, dp)) 1181 goto match; 1182 } 1183 } 1184 else if (prefix(cp + 1, pp->p_command)) { 1185 match: 1186 if (np) 1187 stderror(ERR_NAME | ERR_AMBIG); 1188 np = pp; 1189 } 1190 } 1191 if (np) 1192 return (np); 1193 stderror(ERR_NAME | (cp[1] == '?' ? ERR_JOBPAT : ERR_NOSUCHJOB)); 1194 /* NOTREACHED */ 1195 } 1196 1197 /* 1198 * pgetcurr - find most recent job that is not pp, preferably stopped 1199 */ 1200 static struct process * 1201 pgetcurr(struct process *pp) 1202 { 1203 struct process *np, *xp; 1204 1205 xp = NULL; 1206 for (np = proclist.p_next; np; np = np->p_next) 1207 if (np != pcurrent && np != pp && np->p_pid && 1208 np->p_pid == np->p_jobid) { 1209 if (np->p_flags & PSTOPPED) 1210 return (np); 1211 if (xp == NULL) 1212 xp = np; 1213 } 1214 return (xp); 1215 } 1216 1217 /* 1218 * donotify - flag the job so as to report termination asynchronously 1219 */ 1220 void 1221 /*ARGSUSED*/ 1222 donotify(Char **v, struct command *t) 1223 { 1224 struct process *pp; 1225 1226 pp = pfind(*++v); 1227 pp->p_flags |= PNOTIFY; 1228 } 1229 1230 /* 1231 * Do the fork and whatever should be done in the child side that 1232 * should not be done if we are not forking at all (like for simple builtin's) 1233 * Also do everything that needs any signals fiddled with in the parent side 1234 * 1235 * Wanttty tells whether process and/or tty pgrps are to be manipulated: 1236 * -1: leave tty alone; inherit pgrp from parent 1237 * 0: already have tty; manipulate process pgrps only 1238 * 1: want to claim tty; manipulate process and tty pgrps 1239 * It is usually just the value of tpgrp. 1240 */ 1241 1242 int 1243 pfork(struct command *t /* command we are forking for */, int wanttty) 1244 { 1245 int pgrp, pid; 1246 sigset_t osigset, nsigset; 1247 int ignint; 1248 1249 ignint = 0; 1250 /* 1251 * A child will be uninterruptible only under very special conditions. 1252 * Remember that the semantics of '&' is implemented by disconnecting the 1253 * process from the tty so signals do not need to ignored just for '&'. 1254 * Thus signals are set to default action for children unless: we have had 1255 * an "onintr -" (then specifically ignored) we are not playing with 1256 * signals (inherit action) 1257 */ 1258 if (setintr) 1259 ignint = (tpgrp == -1 && (t->t_dflg & F_NOINTERRUPT)) 1260 || (gointr && eq(gointr, STRminus)); 1261 /* 1262 * Check for maximum nesting of 16 processes to avoid Forking loops 1263 */ 1264 if (child == 16) 1265 stderror(ERR_NESTING, 16); 1266 /* 1267 * Hold SIGCHLD until we have the process installed in our table. 1268 */ 1269 sigemptyset(&nsigset); 1270 (void)sigaddset(&nsigset, SIGCHLD); 1271 (void)sigprocmask(SIG_BLOCK, &nsigset, &osigset); 1272 while ((pid = fork()) < 0) 1273 if (setintr == 0) 1274 (void)sleep(FORKSLEEP); 1275 else { 1276 (void)sigprocmask(SIG_SETMASK, &osigset, NULL); 1277 stderror(ERR_NOPROC); 1278 } 1279 if (pid == 0) { 1280 settimes(); 1281 pgrp = pcurrjob ? pcurrjob->p_jobid : getpid(); 1282 pflushall(); 1283 pcurrjob = NULL; 1284 child++; 1285 if (setintr) { 1286 setintr = 0; /* until I think otherwise */ 1287 /* 1288 * Children just get blown away on SIGINT, SIGQUIT unless "onintr 1289 * -" seen. 1290 */ 1291 (void)signal(SIGINT, ignint ? SIG_IGN : SIG_DFL); 1292 (void)signal(SIGQUIT, ignint ? SIG_IGN : SIG_DFL); 1293 if (wanttty >= 0) { 1294 /* make stoppable */ 1295 (void)signal(SIGTSTP, SIG_DFL); 1296 (void)signal(SIGTTIN, SIG_DFL); 1297 (void)signal(SIGTTOU, SIG_DFL); 1298 } 1299 (void)signal(SIGTERM, parterm); 1300 } 1301 else if (tpgrp == -1 && (t->t_dflg & F_NOINTERRUPT)) { 1302 (void)signal(SIGINT, SIG_IGN); 1303 (void)signal(SIGQUIT, SIG_IGN); 1304 } 1305 pgetty(wanttty, pgrp); 1306 /* 1307 * Nohup and nice apply only to NODE_COMMAND's but it would be nice 1308 * (?!?) if you could say "nohup (foo;bar)" Then the parser would have 1309 * to know about nice/nohup/time 1310 */ 1311 if (t->t_dflg & F_NOHUP) 1312 (void)signal(SIGHUP, SIG_IGN); 1313 if (t->t_dflg & F_NICE) 1314 (void)setpriority(PRIO_PROCESS, 0, t->t_nice); 1315 } 1316 else { 1317 if (wanttty >= 0) 1318 (void)setpgid(pid, pcurrjob ? pcurrjob->p_jobid : pid); 1319 palloc(pid, t); 1320 (void)sigprocmask(SIG_SETMASK, &osigset, NULL); 1321 } 1322 1323 return (pid); 1324 } 1325 1326 static void 1327 okpcntl(void) 1328 { 1329 if (tpgrp == -1) 1330 stderror(ERR_JOBCONTROL); 1331 if (tpgrp == 0) 1332 stderror(ERR_JOBCTRLSUB); 1333 /* NOTREACHED */ 1334 } 1335 1336 /* 1337 * if we don't have vfork(), things can still go in the wrong order 1338 * resulting in the famous 'Stopped (tty output)'. But some systems 1339 * don't permit the setpgid() call, (these are more recent secure 1340 * systems such as ibm's aix). Then we'd rather print an error message 1341 * than hang the shell! 1342 * I am open to suggestions how to fix that. 1343 */ 1344 void 1345 pgetty(int wanttty, int pgrp) 1346 { 1347 sigset_t osigset, nsigset; 1348 1349 /* 1350 * christos: I am blocking the tty signals till I've set things 1351 * correctly.... 1352 */ 1353 if (wanttty > 0) { 1354 sigemptyset(&nsigset); 1355 (void)sigaddset(&nsigset, SIGTSTP); 1356 (void)sigaddset(&nsigset, SIGTTIN); 1357 (void)sigaddset(&nsigset, SIGTTOU); 1358 (void)sigprocmask(SIG_BLOCK, &nsigset, &osigset); 1359 } 1360 /* 1361 * From: Michael Schroeder <mlschroe (at) immd4.informatik.uni-erlangen.de> 1362 * Don't check for tpgrp >= 0 so even non-interactive shells give 1363 * background jobs process groups Same for the comparison in the other part 1364 * of the #ifdef 1365 */ 1366 if (wanttty >= 0) 1367 if (setpgid(0, pgrp) == -1) { 1368 (void)fprintf(csherr, "csh: setpgid error.\n"); 1369 xexit(0); 1370 } 1371 1372 if (wanttty > 0) { 1373 (void)tcsetpgrp(FSHTTY, pgrp); 1374 (void)sigprocmask(SIG_SETMASK, &osigset, NULL); 1375 } 1376 1377 if (tpgrp > 0) 1378 tpgrp = 0; /* gave tty away */ 1379 } 1380
Indexes created Mon Sep 22 10:09:38 GMT 2025