1 /* $OpenBSD: jobs.c,v 1.39 2009/12/13 04:36:48 deraadt Exp $ */ 2 3 /*- 4 * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011, 5 * 2012, 2013 6 * Thorsten Glaser <tg (at) mirbsd.org> 7 * 8 * Provided that these terms and disclaimer and all copyright notices 9 * are retained or reproduced in an accompanying document, permission 10 * is granted to deal in this work without restriction, including un- 11 * limited rights to use, publicly perform, distribute, sell, modify, 12 * merge, give away, or sublicence. 13 * 14 * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to 15 * the utmost extent permitted by applicable law, neither express nor 16 * implied; without malicious intent or gross negligence. In no event 17 * may a licensor, author or contributor be held liable for indirect, 18 * direct, other damage, loss, or other issues arising in any way out 19 * of dealing in the work, even if advised of the possibility of such 20 * damage or existence of a defect, except proven that it results out 21 * of said person's immediate fault when using the work as intended. 22 */ 23 24 #include "sh.h" 25 26 __RCSID("$MirOS: src/bin/mksh/jobs.c,v 1.100 2013/07/26 20:33:23 tg Exp $"); 27 28 #if HAVE_KILLPG 29 #define mksh_killpg killpg 30 #else 31 /* cross fingers and hope kill is killpg-endowed */ 32 #define mksh_killpg(p,s) kill(-(p), (s)) 33 #endif 34 35 /* Order important! */ 36 #define PRUNNING 0 37 #define PEXITED 1 38 #define PSIGNALLED 2 39 #define PSTOPPED 3 40 41 typedef struct proc Proc; 42 struct proc { 43 Proc *next; /* next process in pipeline (if any) */ 44 pid_t pid; /* process id */ 45 int state; 46 int status; /* wait status */ 47 /* process command string from vistree */ 48 char command[256 - (ALLOC_SIZE + sizeof(Proc *) + sizeof(pid_t) + 49 2 * sizeof(int))]; 50 }; 51 52 /* Notify/print flag - j_print() argument */ 53 #define JP_SHORT 1 /* print signals processes were killed by */ 54 #define JP_MEDIUM 2 /* print [job-num] -/+ command */ 55 #define JP_LONG 3 /* print [job-num] -/+ pid command */ 56 #define JP_PGRP 4 /* print pgrp */ 57 58 /* put_job() flags */ 59 #define PJ_ON_FRONT 0 /* at very front */ 60 #define PJ_PAST_STOPPED 1 /* just past any stopped jobs */ 61 62 /* Job.flags values */ 63 #define JF_STARTED 0x001 /* set when all processes in job are started */ 64 #define JF_WAITING 0x002 /* set if j_waitj() is waiting on job */ 65 #define JF_W_ASYNCNOTIFY 0x004 /* set if waiting and async notification ok */ 66 #define JF_XXCOM 0x008 /* set for $(command) jobs */ 67 #define JF_FG 0x010 /* running in foreground (also has tty pgrp) */ 68 #define JF_SAVEDTTY 0x020 /* j->ttystat is valid */ 69 #define JF_CHANGED 0x040 /* process has changed state */ 70 #define JF_KNOWN 0x080 /* $! referenced */ 71 #define JF_ZOMBIE 0x100 /* known, unwaited process */ 72 #define JF_REMOVE 0x200 /* flagged for removal (j_jobs()/j_noityf()) */ 73 #define JF_USETTYMODE 0x400 /* tty mode saved if process exits normally */ 74 #define JF_SAVEDTTYPGRP 0x800 /* j->saved_ttypgrp is valid */ 75 76 typedef struct job Job; 77 struct job { 78 Job *next; /* next job in list */ 79 Proc *proc_list; /* process list */ 80 Proc *last_proc; /* last process in list */ 81 struct timeval systime; /* system time used by job */ 82 struct timeval usrtime; /* user time used by job */ 83 pid_t pgrp; /* process group of job */ 84 pid_t ppid; /* pid of process that forked job */ 85 int job; /* job number: %n */ 86 int flags; /* see JF_* */ 87 volatile int state; /* job state */ 88 int status; /* exit status of last process */ 89 int32_t age; /* number of jobs started */ 90 Coproc_id coproc_id; /* 0 or id of coprocess output pipe */ 91 #ifndef MKSH_UNEMPLOYED 92 mksh_ttyst ttystat; /* saved tty state for stopped jobs */ 93 pid_t saved_ttypgrp; /* saved tty process group for stopped jobs */ 94 #endif 95 }; 96 97 /* Flags for j_waitj() */ 98 #define JW_NONE 0x00 99 #define JW_INTERRUPT 0x01 /* ^C will stop the wait */ 100 #define JW_ASYNCNOTIFY 0x02 /* asynchronous notification during wait ok */ 101 #define JW_STOPPEDWAIT 0x04 /* wait even if job stopped */ 102 #define JW_PIPEST 0x08 /* want PIPESTATUS */ 103 104 /* Error codes for j_lookup() */ 105 #define JL_NOSUCH 0 /* no such job */ 106 #define JL_AMBIG 1 /* %foo or %?foo is ambiguous */ 107 #define JL_INVALID 2 /* non-pid, non-% job id */ 108 109 static const char * const lookup_msgs[] = { 110 "no such job", 111 "ambiguous", 112 "argument must be %job or process id" 113 }; 114 115 static Job *job_list; /* job list */ 116 static Job *last_job; 117 static Job *async_job; 118 static pid_t async_pid; 119 120 static int nzombie; /* # of zombies owned by this process */ 121 static int32_t njobs; /* # of jobs started */ 122 123 #ifndef CHILD_MAX 124 #define CHILD_MAX 25 125 #endif 126 127 #ifndef MKSH_NOPROSPECTOFWORK 128 /* held_sigchld is set if sigchld occurs before a job is completely started */ 129 static volatile sig_atomic_t held_sigchld; 130 #endif 131 132 #ifndef MKSH_UNEMPLOYED 133 static struct shf *shl_j; 134 static bool ttypgrp_ok; /* set if can use tty pgrps */ 135 static pid_t restore_ttypgrp = -1; 136 static int const tt_sigs[] = { SIGTSTP, SIGTTIN, SIGTTOU }; 137 #endif 138 139 static void j_set_async(Job *); 140 static void j_startjob(Job *); 141 static int j_waitj(Job *, int, const char *); 142 static void j_sigchld(int); 143 static void j_print(Job *, int, struct shf *); 144 static Job *j_lookup(const char *, int *); 145 static Job *new_job(void); 146 static Proc *new_proc(void); 147 static void check_job(Job *); 148 static void put_job(Job *, int); 149 static void remove_job(Job *, const char *); 150 static int kill_job(Job *, int); 151 152 static void tty_init_talking(void); 153 static void tty_init_state(void); 154 155 /* initialise job control */ 156 void 157 j_init(void) 158 { 159 #ifndef MKSH_UNEMPLOYED 160 bool mflagset = Flag(FMONITOR) != 127; 161 162 Flag(FMONITOR) = 0; 163 #endif 164 165 #ifndef MKSH_NOPROSPECTOFWORK 166 (void)sigemptyset(&sm_default); 167 sigprocmask(SIG_SETMASK, &sm_default, NULL); 168 169 (void)sigemptyset(&sm_sigchld); 170 (void)sigaddset(&sm_sigchld, SIGCHLD); 171 172 setsig(&sigtraps[SIGCHLD], j_sigchld, 173 SS_RESTORE_ORIG|SS_FORCE|SS_SHTRAP); 174 #else 175 /* Make sure SIGCHLD isn't ignored - can do odd things under SYSV */ 176 setsig(&sigtraps[SIGCHLD], SIG_DFL, SS_RESTORE_ORIG|SS_FORCE); 177 #endif 178 179 #ifndef MKSH_UNEMPLOYED 180 if (!mflagset && Flag(FTALKING)) 181 Flag(FMONITOR) = 1; 182 183 /* 184 * shl_j is used to do asynchronous notification (used in 185 * an interrupt handler, so need a distinct shf) 186 */ 187 shl_j = shf_fdopen(2, SHF_WR, NULL); 188 189 if (Flag(FMONITOR) || Flag(FTALKING)) { 190 int i; 191 192 /* 193 * the TF_SHELL_USES test is a kludge that lets us know if 194 * if the signals have been changed by the shell. 195 */ 196 for (i = NELEM(tt_sigs); --i >= 0; ) { 197 sigtraps[tt_sigs[i]].flags |= TF_SHELL_USES; 198 /* j_change() sets this to SS_RESTORE_DFL if FMONITOR */ 199 setsig(&sigtraps[tt_sigs[i]], SIG_IGN, 200 SS_RESTORE_IGN|SS_FORCE); 201 } 202 } 203 204 /* j_change() calls tty_init_talking() and tty_init_state() */ 205 if (Flag(FMONITOR)) 206 j_change(); 207 else 208 #endif 209 if (Flag(FTALKING)) { 210 tty_init_talking(); 211 tty_init_state(); 212 } 213 } 214 215 static int 216 proc_errorlevel(Proc *p) 217 { 218 switch (p->state) { 219 case PEXITED: 220 return (WEXITSTATUS(p->status)); 221 case PSIGNALLED: 222 return (128 + WTERMSIG(p->status)); 223 default: 224 return (0); 225 } 226 } 227 228 /* job cleanup before shell exit */ 229 void 230 j_exit(void) 231 { 232 /* kill stopped, and possibly running, jobs */ 233 Job *j; 234 bool killed = false; 235 236 for (j = job_list; j != NULL; j = j->next) { 237 if (j->ppid == procpid && 238 (j->state == PSTOPPED || 239 (j->state == PRUNNING && 240 ((j->flags & JF_FG) || 241 (Flag(FLOGIN) && !Flag(FNOHUP) && procpid == kshpid))))) { 242 killed = true; 243 if (j->pgrp == 0) 244 kill_job(j, SIGHUP); 245 else 246 mksh_killpg(j->pgrp, SIGHUP); 247 #ifndef MKSH_UNEMPLOYED 248 if (j->state == PSTOPPED) { 249 if (j->pgrp == 0) 250 kill_job(j, SIGCONT); 251 else 252 mksh_killpg(j->pgrp, SIGCONT); 253 } 254 #endif 255 } 256 } 257 if (killed) 258 sleep(1); 259 j_notify(); 260 261 #ifndef MKSH_UNEMPLOYED 262 if (kshpid == procpid && restore_ttypgrp >= 0) { 263 /* 264 * Need to restore the tty pgrp to what it was when the 265 * shell started up, so that the process that started us 266 * will be able to access the tty when we are done. 267 * Also need to restore our process group in case we are 268 * about to do an exec so that both our parent and the 269 * process we are to become will be able to access the tty. 270 */ 271 tcsetpgrp(tty_fd, restore_ttypgrp); 272 setpgid(0, restore_ttypgrp); 273 } 274 if (Flag(FMONITOR)) { 275 Flag(FMONITOR) = 0; 276 j_change(); 277 } 278 #endif 279 } 280 281 #ifndef MKSH_UNEMPLOYED 282 /* turn job control on or off according to Flag(FMONITOR) */ 283 void 284 j_change(void) 285 { 286 int i; 287 288 if (Flag(FMONITOR)) { 289 bool use_tty = Flag(FTALKING); 290 291 /* don't call mksh_tcget until we own the tty process group */ 292 if (use_tty) 293 tty_init_talking(); 294 295 /* no controlling tty, no SIGT* */ 296 if ((ttypgrp_ok = (use_tty && tty_fd >= 0 && tty_devtty))) { 297 setsig(&sigtraps[SIGTTIN], SIG_DFL, 298 SS_RESTORE_ORIG|SS_FORCE); 299 /* wait to be given tty (POSIX.1, B.2, job control) */ 300 while (/* CONSTCOND */ 1) { 301 pid_t ttypgrp; 302 303 if ((ttypgrp = tcgetpgrp(tty_fd)) < 0) { 304 warningf(false, "%s: %s %s: %s", 305 "j_init", "tcgetpgrp", "failed", 306 cstrerror(errno)); 307 ttypgrp_ok = false; 308 break; 309 } 310 if (ttypgrp == kshpgrp) 311 break; 312 kill(0, SIGTTIN); 313 } 314 } 315 for (i = NELEM(tt_sigs); --i >= 0; ) 316 setsig(&sigtraps[tt_sigs[i]], SIG_IGN, 317 SS_RESTORE_DFL|SS_FORCE); 318 if (ttypgrp_ok && kshpgrp != kshpid) { 319 if (setpgid(0, kshpid) < 0) { 320 warningf(false, "%s: %s %s: %s", "j_init", 321 "setpgid", "failed", cstrerror(errno)); 322 ttypgrp_ok = false; 323 } else { 324 if (tcsetpgrp(tty_fd, kshpid) < 0) { 325 warningf(false, "%s: %s %s: %s", 326 "j_init", "tcsetpgrp", "failed", 327 cstrerror(errno)); 328 ttypgrp_ok = false; 329 } else 330 restore_ttypgrp = kshpgrp; 331 kshpgrp = kshpid; 332 } 333 } 334 #ifndef MKSH_DISABLE_TTY_WARNING 335 if (use_tty && !ttypgrp_ok) 336 warningf(false, "%s: %s", "warning", 337 "won't have full job control"); 338 #endif 339 } else { 340 ttypgrp_ok = false; 341 if (Flag(FTALKING)) 342 for (i = NELEM(tt_sigs); --i >= 0; ) 343 setsig(&sigtraps[tt_sigs[i]], SIG_IGN, 344 SS_RESTORE_IGN|SS_FORCE); 345 else 346 for (i = NELEM(tt_sigs); --i >= 0; ) { 347 if (sigtraps[tt_sigs[i]].flags & 348 (TF_ORIG_IGN | TF_ORIG_DFL)) 349 setsig(&sigtraps[tt_sigs[i]], 350 (sigtraps[tt_sigs[i]].flags & TF_ORIG_IGN) ? 351 SIG_IGN : SIG_DFL, 352 SS_RESTORE_ORIG|SS_FORCE); 353 } 354 } 355 tty_init_state(); 356 } 357 #endif 358 359 #if HAVE_NICE 360 /* run nice(3) and ignore the result */ 361 static void 362 ksh_nice(int ness) 363 { 364 #if defined(__USE_FORTIFY_LEVEL) && (__USE_FORTIFY_LEVEL > 0) 365 int eno; 366 367 errno = 0; 368 /* this is gonna annoy users; complain to your distro, people! */ 369 if (nice(ness) == -1 && (eno = errno) != 0) 370 warningf(false, "%s: %s", "bgnice", cstrerror(eno)); 371 #else 372 (void)nice(ness); 373 #endif 374 } 375 #endif 376 377 /* execute tree in child subprocess */ 378 int 379 exchild(struct op *t, int flags, 380 volatile int *xerrok, 381 /* used if XPCLOSE or XCCLOSE */ 382 int close_fd) 383 { 384 /* for pipelines */ 385 static Proc *last_proc; 386 387 int rv = 0, forksleep, jwflags = JW_NONE; 388 #ifndef MKSH_NOPROSPECTOFWORK 389 sigset_t omask; 390 #endif 391 Proc *p; 392 Job *j; 393 pid_t cldpid; 394 395 if (flags & XPIPEST) { 396 flags &= ~XPIPEST; 397 jwflags |= JW_PIPEST; 398 } 399 400 if (flags & XEXEC) 401 /* 402 * Clear XFORK|XPCLOSE|XCCLOSE|XCOPROC|XPIPEO|XPIPEI|XXCOM|XBGND 403 * (also done in another execute() below) 404 */ 405 return (execute(t, flags & (XEXEC | XERROK), xerrok)); 406 407 #ifndef MKSH_NOPROSPECTOFWORK 408 /* no SIGCHLDs while messing with job and process lists */ 409 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); 410 #endif 411 412 p = new_proc(); 413 p->next = NULL; 414 p->state = PRUNNING; 415 p->status = 0; 416 p->pid = 0; 417 418 /* link process into jobs list */ 419 if (flags & XPIPEI) { 420 /* continuing with a pipe */ 421 if (!last_job) 422 internal_errorf("%s %d", 423 "exchild: XPIPEI and no last_job - pid", 424 (int)procpid); 425 j = last_job; 426 if (last_proc) 427 last_proc->next = p; 428 last_proc = p; 429 } else { 430 /* fills in j->job */ 431 j = new_job(); 432 /* 433 * we don't consider XXCOMs foreground since they don't get 434 * tty process group and we don't save or restore tty modes. 435 */ 436 j->flags = (flags & XXCOM) ? JF_XXCOM : 437 ((flags & XBGND) ? 0 : (JF_FG|JF_USETTYMODE)); 438 timerclear(&j->usrtime); 439 timerclear(&j->systime); 440 j->state = PRUNNING; 441 j->pgrp = 0; 442 j->ppid = procpid; 443 j->age = ++njobs; 444 j->proc_list = p; 445 j->coproc_id = 0; 446 last_job = j; 447 last_proc = p; 448 put_job(j, PJ_PAST_STOPPED); 449 } 450 451 vistree(p->command, sizeof(p->command), t); 452 453 /* create child process */ 454 forksleep = 1; 455 while ((cldpid = fork()) < 0 && errno == EAGAIN && forksleep < 32) { 456 if (intrsig) 457 /* allow user to ^C out... */ 458 break; 459 sleep(forksleep); 460 forksleep <<= 1; 461 } 462 /* ensure $RANDOM changes between parent and child */ 463 rndset((unsigned long)cldpid); 464 /* fork failed? */ 465 if (cldpid < 0) { 466 kill_job(j, SIGKILL); 467 remove_job(j, "fork failed"); 468 #ifndef MKSH_NOPROSPECTOFWORK 469 sigprocmask(SIG_SETMASK, &omask, NULL); 470 #endif 471 errorf("can't fork - try again"); 472 } 473 p->pid = cldpid ? cldpid : (procpid = getpid()); 474 475 #ifndef MKSH_UNEMPLOYED 476 /* job control set up */ 477 if (Flag(FMONITOR) && !(flags&XXCOM)) { 478 bool dotty = false; 479 480 if (j->pgrp == 0) { 481 /* First process */ 482 j->pgrp = p->pid; 483 dotty = true; 484 } 485 486 /* 487 * set pgrp in both parent and child to deal with race 488 * condition 489 */ 490 setpgid(p->pid, j->pgrp); 491 if (ttypgrp_ok && dotty && !(flags & XBGND)) 492 tcsetpgrp(tty_fd, j->pgrp); 493 } 494 #endif 495 496 /* used to close pipe input fd */ 497 if (close_fd >= 0 && (((flags & XPCLOSE) && cldpid) || 498 ((flags & XCCLOSE) && !cldpid))) 499 close(close_fd); 500 if (!cldpid) { 501 /* child */ 502 503 /* Do this before restoring signal */ 504 if (flags & XCOPROC) 505 coproc_cleanup(false); 506 cleanup_parents_env(); 507 #ifndef MKSH_UNEMPLOYED 508 /* 509 * If FMONITOR or FTALKING is set, these signals are ignored, 510 * if neither FMONITOR nor FTALKING are set, the signals have 511 * their inherited values. 512 */ 513 if (Flag(FMONITOR) && !(flags & XXCOM)) { 514 for (forksleep = NELEM(tt_sigs); --forksleep >= 0; ) 515 setsig(&sigtraps[tt_sigs[forksleep]], SIG_DFL, 516 SS_RESTORE_DFL|SS_FORCE); 517 } 518 #endif 519 #if HAVE_NICE 520 if (Flag(FBGNICE) && (flags & XBGND)) 521 ksh_nice(4); 522 #endif 523 if ((flags & XBGND) 524 #ifndef MKSH_UNEMPLOYED 525 && !Flag(FMONITOR) 526 #endif 527 ) { 528 setsig(&sigtraps[SIGINT], SIG_IGN, 529 SS_RESTORE_IGN|SS_FORCE); 530 setsig(&sigtraps[SIGQUIT], SIG_IGN, 531 SS_RESTORE_IGN|SS_FORCE); 532 if ((!(flags & (XPIPEI | XCOPROC))) && 533 ((forksleep = open("/dev/null", 0)) > 0)) { 534 (void)ksh_dup2(forksleep, 0, true); 535 close(forksleep); 536 } 537 } 538 /* in case of $(jobs) command */ 539 remove_job(j, "child"); 540 #ifndef MKSH_NOPROSPECTOFWORK 541 /* remove_job needs SIGCHLD blocked still */ 542 sigprocmask(SIG_SETMASK, &omask, NULL); 543 #endif 544 nzombie = 0; 545 #ifndef MKSH_UNEMPLOYED 546 ttypgrp_ok = false; 547 Flag(FMONITOR) = 0; 548 #endif 549 Flag(FTALKING) = 0; 550 cleartraps(); 551 /* no return */ 552 execute(t, (flags & XERROK) | XEXEC, NULL); 553 #ifndef MKSH_SMALL 554 if (t->type == TPIPE) 555 unwind(LLEAVE); 556 internal_warningf("%s: %s", "exchild", "execute() returned"); 557 fptreef(shl_out, 8, "%s: tried to execute {\n\t%T\n}\n", 558 "exchild", t); 559 shf_flush(shl_out); 560 #endif 561 unwind(LLEAVE); 562 /* NOTREACHED */ 563 } 564 565 /* shell (parent) stuff */ 566 if (!(flags & XPIPEO)) { 567 /* last process in a job */ 568 j_startjob(j); 569 if (flags & XCOPROC) { 570 j->coproc_id = coproc.id; 571 /* n jobs using co-process output */ 572 coproc.njobs++; 573 /* j using co-process input */ 574 coproc.job = (void *)j; 575 } 576 if (flags & XBGND) { 577 j_set_async(j); 578 if (Flag(FTALKING)) { 579 shf_fprintf(shl_out, "[%d]", j->job); 580 for (p = j->proc_list; p; p = p->next) 581 shf_fprintf(shl_out, " %d", 582 (int)p->pid); 583 shf_putchar('\n', shl_out); 584 shf_flush(shl_out); 585 } 586 } else 587 rv = j_waitj(j, jwflags, "jw:last proc"); 588 } 589 590 #ifndef MKSH_NOPROSPECTOFWORK 591 sigprocmask(SIG_SETMASK, &omask, NULL); 592 #endif 593 594 return (rv); 595 } 596 597 /* start the last job: only used for $(command) jobs */ 598 void 599 startlast(void) 600 { 601 #ifndef MKSH_NOPROSPECTOFWORK 602 sigset_t omask; 603 604 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); 605 #endif 606 607 /* no need to report error - waitlast() will do it */ 608 if (last_job) { 609 /* ensure it isn't removed by check_job() */ 610 last_job->flags |= JF_WAITING; 611 j_startjob(last_job); 612 } 613 #ifndef MKSH_NOPROSPECTOFWORK 614 sigprocmask(SIG_SETMASK, &omask, NULL); 615 #endif 616 } 617 618 /* wait for last job: only used for $(command) jobs */ 619 int 620 waitlast(void) 621 { 622 int rv; 623 Job *j; 624 #ifndef MKSH_NOPROSPECTOFWORK 625 sigset_t omask; 626 627 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); 628 #endif 629 630 j = last_job; 631 if (!j || !(j->flags & JF_STARTED)) { 632 if (!j) 633 warningf(true, "%s: %s", "waitlast", "no last job"); 634 else 635 internal_warningf("%s: %s", "waitlast", "not started"); 636 #ifndef MKSH_NOPROSPECTOFWORK 637 sigprocmask(SIG_SETMASK, &omask, NULL); 638 #endif 639 /* not so arbitrary, non-zero value */ 640 return (125); 641 } 642 643 rv = j_waitj(j, JW_NONE, "waitlast"); 644 645 #ifndef MKSH_NOPROSPECTOFWORK 646 sigprocmask(SIG_SETMASK, &omask, NULL); 647 #endif 648 649 return (rv); 650 } 651 652 /* wait for child, interruptable. */ 653 int 654 waitfor(const char *cp, int *sigp) 655 { 656 int rv, ecode, flags = JW_INTERRUPT|JW_ASYNCNOTIFY; 657 Job *j; 658 #ifndef MKSH_NOPROSPECTOFWORK 659 sigset_t omask; 660 661 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); 662 #endif 663 664 *sigp = 0; 665 666 if (cp == NULL) { 667 /* 668 * wait for an unspecified job - always returns 0, so 669 * don't have to worry about exited/signaled jobs 670 */ 671 for (j = job_list; j; j = j->next) 672 /* AT&T ksh will wait for stopped jobs - we don't */ 673 if (j->ppid == procpid && j->state == PRUNNING) 674 break; 675 if (!j) { 676 #ifndef MKSH_NOPROSPECTOFWORK 677 sigprocmask(SIG_SETMASK, &omask, NULL); 678 #endif 679 return (-1); 680 } 681 } else if ((j = j_lookup(cp, &ecode))) { 682 /* don't report normal job completion */ 683 flags &= ~JW_ASYNCNOTIFY; 684 if (j->ppid != procpid) { 685 #ifndef MKSH_NOPROSPECTOFWORK 686 sigprocmask(SIG_SETMASK, &omask, NULL); 687 #endif 688 return (-1); 689 } 690 } else { 691 #ifndef MKSH_NOPROSPECTOFWORK 692 sigprocmask(SIG_SETMASK, &omask, NULL); 693 #endif 694 if (ecode != JL_NOSUCH) 695 bi_errorf("%s: %s", cp, lookup_msgs[ecode]); 696 return (-1); 697 } 698 699 /* AT&T ksh will wait for stopped jobs - we don't */ 700 rv = j_waitj(j, flags, "jw:waitfor"); 701 702 #ifndef MKSH_NOPROSPECTOFWORK 703 sigprocmask(SIG_SETMASK, &omask, NULL); 704 #endif 705 706 if (rv < 0) 707 /* we were interrupted */ 708 *sigp = 128 + -rv; 709 710 return (rv); 711 } 712 713 /* kill (built-in) a job */ 714 int 715 j_kill(const char *cp, int sig) 716 { 717 Job *j; 718 int rv = 0, ecode; 719 #ifndef MKSH_NOPROSPECTOFWORK 720 sigset_t omask; 721 722 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); 723 #endif 724 725 if ((j = j_lookup(cp, &ecode)) == NULL) { 726 #ifndef MKSH_NOPROSPECTOFWORK 727 sigprocmask(SIG_SETMASK, &omask, NULL); 728 #endif 729 bi_errorf("%s: %s", cp, lookup_msgs[ecode]); 730 return (1); 731 } 732 733 if (j->pgrp == 0) { 734 /* started when !Flag(FMONITOR) */ 735 if (kill_job(j, sig) < 0) { 736 bi_errorf("%s: %s", cp, cstrerror(errno)); 737 rv = 1; 738 } 739 } else { 740 #ifndef MKSH_UNEMPLOYED 741 if (j->state == PSTOPPED && (sig == SIGTERM || sig == SIGHUP)) 742 mksh_killpg(j->pgrp, SIGCONT); 743 #endif 744 if (mksh_killpg(j->pgrp, sig) < 0) { 745 bi_errorf("%s: %s", cp, cstrerror(errno)); 746 rv = 1; 747 } 748 } 749 750 #ifndef MKSH_NOPROSPECTOFWORK 751 sigprocmask(SIG_SETMASK, &omask, NULL); 752 #endif 753 754 return (rv); 755 } 756 757 #ifndef MKSH_UNEMPLOYED 758 /* fg and bg built-ins: called only if Flag(FMONITOR) set */ 759 int 760 j_resume(const char *cp, int bg) 761 { 762 Job *j; 763 Proc *p; 764 int ecode, rv = 0; 765 bool running; 766 sigset_t omask; 767 768 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); 769 770 if ((j = j_lookup(cp, &ecode)) == NULL) { 771 sigprocmask(SIG_SETMASK, &omask, NULL); 772 bi_errorf("%s: %s", cp, lookup_msgs[ecode]); 773 return (1); 774 } 775 776 if (j->pgrp == 0) { 777 sigprocmask(SIG_SETMASK, &omask, NULL); 778 bi_errorf("job not job-controlled"); 779 return (1); 780 } 781 782 if (bg) 783 shprintf("[%d] ", j->job); 784 785 running = false; 786 for (p = j->proc_list; p != NULL; p = p->next) { 787 if (p->state == PSTOPPED) { 788 p->state = PRUNNING; 789 p->status = 0; 790 running = true; 791 } 792 shf_puts(p->command, shl_stdout); 793 if (p->next) 794 shf_puts("| ", shl_stdout); 795 } 796 shf_putc('\n', shl_stdout); 797 shf_flush(shl_stdout); 798 if (running) 799 j->state = PRUNNING; 800 801 put_job(j, PJ_PAST_STOPPED); 802 if (bg) 803 j_set_async(j); 804 else { 805 /* attach tty to job */ 806 if (j->state == PRUNNING) { 807 if (ttypgrp_ok && (j->flags & JF_SAVEDTTY)) 808 mksh_tcset(tty_fd, &j->ttystat); 809 /* See comment in j_waitj regarding saved_ttypgrp. */ 810 if (ttypgrp_ok && 811 tcsetpgrp(tty_fd, (j->flags & JF_SAVEDTTYPGRP) ? 812 j->saved_ttypgrp : j->pgrp) < 0) { 813 rv = errno; 814 if (j->flags & JF_SAVEDTTY) 815 mksh_tcset(tty_fd, &tty_state); 816 sigprocmask(SIG_SETMASK, &omask, NULL); 817 bi_errorf("%s %s(%d, %ld) %s: %s", 818 "1st", "tcsetpgrp", tty_fd, 819 (long)((j->flags & JF_SAVEDTTYPGRP) ? 820 j->saved_ttypgrp : j->pgrp), "failed", 821 cstrerror(rv)); 822 return (1); 823 } 824 } 825 j->flags |= JF_FG; 826 j->flags &= ~JF_KNOWN; 827 if (j == async_job) 828 async_job = NULL; 829 } 830 831 if (j->state == PRUNNING && mksh_killpg(j->pgrp, SIGCONT) < 0) { 832 int eno = errno; 833 834 if (!bg) { 835 j->flags &= ~JF_FG; 836 if (ttypgrp_ok && (j->flags & JF_SAVEDTTY)) 837 mksh_tcset(tty_fd, &tty_state); 838 if (ttypgrp_ok && tcsetpgrp(tty_fd, kshpgrp) < 0) 839 warningf(true, "%s %s(%d, %ld) %s: %s", 840 "fg: 2nd", "tcsetpgrp", tty_fd, 841 (long)kshpgrp, "failed", cstrerror(errno)); 842 } 843 sigprocmask(SIG_SETMASK, &omask, NULL); 844 bi_errorf("%s %s %s", "can't continue job", 845 cp, cstrerror(eno)); 846 return (1); 847 } 848 if (!bg) { 849 if (ttypgrp_ok) { 850 j->flags &= ~(JF_SAVEDTTY | JF_SAVEDTTYPGRP); 851 } 852 rv = j_waitj(j, JW_NONE, "jw:resume"); 853 } 854 sigprocmask(SIG_SETMASK, &omask, NULL); 855 return (rv); 856 } 857 #endif 858 859 /* are there any running or stopped jobs ? */ 860 int 861 j_stopped_running(void) 862 { 863 Job *j; 864 int which = 0; 865 866 for (j = job_list; j != NULL; j = j->next) { 867 #ifndef MKSH_UNEMPLOYED 868 if (j->ppid == procpid && j->state == PSTOPPED) 869 which |= 1; 870 #endif 871 if (Flag(FLOGIN) && !Flag(FNOHUP) && procpid == kshpid && 872 j->ppid == procpid && j->state == PRUNNING) 873 which |= 2; 874 } 875 if (which) { 876 shellf("You have %s%s%s jobs\n", 877 which & 1 ? "stopped" : "", 878 which == 3 ? " and " : "", 879 which & 2 ? "running" : ""); 880 return (1); 881 } 882 883 return (0); 884 } 885 886 887 /* list jobs for jobs built-in */ 888 int 889 j_jobs(const char *cp, int slp, 890 /* 0: short, 1: long, 2: pgrp */ 891 int nflag) 892 { 893 Job *j, *tmp; 894 int how, zflag = 0; 895 #ifndef MKSH_NOPROSPECTOFWORK 896 sigset_t omask; 897 898 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); 899 #endif 900 901 if (nflag < 0) { 902 /* kludge: print zombies */ 903 nflag = 0; 904 zflag = 1; 905 } 906 if (cp) { 907 int ecode; 908 909 if ((j = j_lookup(cp, &ecode)) == NULL) { 910 #ifndef MKSH_NOPROSPECTOFWORK 911 sigprocmask(SIG_SETMASK, &omask, NULL); 912 #endif 913 bi_errorf("%s: %s", cp, lookup_msgs[ecode]); 914 return (1); 915 } 916 } else 917 j = job_list; 918 how = slp == 0 ? JP_MEDIUM : (slp == 1 ? JP_LONG : JP_PGRP); 919 for (; j; j = j->next) { 920 if ((!(j->flags & JF_ZOMBIE) || zflag) && 921 (!nflag || (j->flags & JF_CHANGED))) { 922 j_print(j, how, shl_stdout); 923 if (j->state == PEXITED || j->state == PSIGNALLED) 924 j->flags |= JF_REMOVE; 925 } 926 if (cp) 927 break; 928 } 929 /* Remove jobs after printing so there won't be multiple + or - jobs */ 930 for (j = job_list; j; j = tmp) { 931 tmp = j->next; 932 if (j->flags & JF_REMOVE) 933 remove_job(j, "jobs"); 934 } 935 #ifndef MKSH_NOPROSPECTOFWORK 936 sigprocmask(SIG_SETMASK, &omask, NULL); 937 #endif 938 return (0); 939 } 940 941 /* list jobs for top-level notification */ 942 void 943 j_notify(void) 944 { 945 Job *j, *tmp; 946 #ifndef MKSH_NOPROSPECTOFWORK 947 sigset_t omask; 948 949 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); 950 #endif 951 for (j = job_list; j; j = j->next) { 952 #ifndef MKSH_UNEMPLOYED 953 if (Flag(FMONITOR) && (j->flags & JF_CHANGED)) 954 j_print(j, JP_MEDIUM, shl_out); 955 #endif 956 /* 957 * Remove job after doing reports so there aren't 958 * multiple +/- jobs. 959 */ 960 if (j->state == PEXITED || j->state == PSIGNALLED) 961 j->flags |= JF_REMOVE; 962 } 963 for (j = job_list; j; j = tmp) { 964 tmp = j->next; 965 if (j->flags & JF_REMOVE) 966 remove_job(j, "notify"); 967 } 968 shf_flush(shl_out); 969 #ifndef MKSH_NOPROSPECTOFWORK 970 sigprocmask(SIG_SETMASK, &omask, NULL); 971 #endif 972 } 973 974 /* Return pid of last process in last asynchronous job */ 975 pid_t 976 j_async(void) 977 { 978 #ifndef MKSH_NOPROSPECTOFWORK 979 sigset_t omask; 980 981 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); 982 #endif 983 984 if (async_job) 985 async_job->flags |= JF_KNOWN; 986 987 #ifndef MKSH_NOPROSPECTOFWORK 988 sigprocmask(SIG_SETMASK, &omask, NULL); 989 #endif 990 991 return (async_pid); 992 } 993 994 /* 995 * Make j the last async process 996 * 997 * If jobs are compiled in then this routine expects sigchld to be blocked. 998 */ 999 static void 1000 j_set_async(Job *j) 1001 { 1002 Job *jl, *oldest; 1003 1004 if (async_job && (async_job->flags & (JF_KNOWN|JF_ZOMBIE)) == JF_ZOMBIE) 1005 remove_job(async_job, "async"); 1006 if (!(j->flags & JF_STARTED)) { 1007 internal_warningf("%s: %s", "j_async", "job not started"); 1008 return; 1009 } 1010 async_job = j; 1011 async_pid = j->last_proc->pid; 1012 while (nzombie > CHILD_MAX) { 1013 oldest = NULL; 1014 for (jl = job_list; jl; jl = jl->next) 1015 if (jl != async_job && (jl->flags & JF_ZOMBIE) && 1016 (!oldest || jl->age < oldest->age)) 1017 oldest = jl; 1018 if (!oldest) { 1019 /* XXX debugging */ 1020 if (!(async_job->flags & JF_ZOMBIE) || nzombie != 1) { 1021 internal_warningf("%s: bad nzombie (%d)", 1022 "j_async", nzombie); 1023 nzombie = 0; 1024 } 1025 break; 1026 } 1027 remove_job(oldest, "zombie"); 1028 } 1029 } 1030 1031 /* 1032 * Start a job: set STARTED, check for held signals and set j->last_proc 1033 * 1034 * If jobs are compiled in then this routine expects sigchld to be blocked. 1035 */ 1036 static void 1037 j_startjob(Job *j) 1038 { 1039 Proc *p; 1040 1041 j->flags |= JF_STARTED; 1042 for (p = j->proc_list; p->next; p = p->next) 1043 ; 1044 j->last_proc = p; 1045 1046 #ifndef MKSH_NOPROSPECTOFWORK 1047 if (held_sigchld) { 1048 held_sigchld = 0; 1049 /* Don't call j_sigchld() as it may remove job... */ 1050 kill(procpid, SIGCHLD); 1051 } 1052 #endif 1053 } 1054 1055 /* 1056 * wait for job to complete or change state 1057 * 1058 * If jobs are compiled in then this routine expects sigchld to be blocked. 1059 */ 1060 static int 1061 j_waitj(Job *j, 1062 /* see JW_* */ 1063 int flags, 1064 const char *where) 1065 { 1066 int rv; 1067 #ifdef MKSH_NO_SIGSUSPEND 1068 sigset_t omask; 1069 #endif 1070 1071 /* 1072 * No auto-notify on the job we are waiting on. 1073 */ 1074 j->flags |= JF_WAITING; 1075 if (flags & JW_ASYNCNOTIFY) 1076 j->flags |= JF_W_ASYNCNOTIFY; 1077 1078 #ifndef MKSH_UNEMPLOYED 1079 if (!Flag(FMONITOR)) 1080 #endif 1081 flags |= JW_STOPPEDWAIT; 1082 1083 while (j->state == PRUNNING || 1084 ((flags & JW_STOPPEDWAIT) && j->state == PSTOPPED)) { 1085 #ifndef MKSH_NOPROSPECTOFWORK 1086 #ifdef MKSH_NO_SIGSUSPEND 1087 sigprocmask(SIG_SETMASK, &sm_default, &omask); 1088 pause(); 1089 /* note that handlers may run here so they need to know */ 1090 sigprocmask(SIG_SETMASK, &omask, NULL); 1091 #else 1092 sigsuspend(&sm_default); 1093 #endif 1094 #else 1095 j_sigchld(SIGCHLD); 1096 #endif 1097 if (fatal_trap) { 1098 int oldf = j->flags & (JF_WAITING|JF_W_ASYNCNOTIFY); 1099 j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY); 1100 runtraps(TF_FATAL); 1101 /* not reached... */ 1102 j->flags |= oldf; 1103 } 1104 if ((flags & JW_INTERRUPT) && (rv = trap_pending())) { 1105 j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY); 1106 return (-rv); 1107 } 1108 } 1109 j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY); 1110 1111 if (j->flags & JF_FG) { 1112 j->flags &= ~JF_FG; 1113 #ifndef MKSH_UNEMPLOYED 1114 if (Flag(FMONITOR) && ttypgrp_ok && j->pgrp) { 1115 /* 1116 * Save the tty's current pgrp so it can be restored 1117 * when the job is foregrounded. This is to 1118 * deal with things like the GNU su which does 1119 * a fork/exec instead of an exec (the fork means 1120 * the execed shell gets a different pid from its 1121 * pgrp, so naturally it sets its pgrp and gets hosed 1122 * when it gets foregrounded by the parent shell which 1123 * has restored the tty's pgrp to that of the su 1124 * process). 1125 */ 1126 if (j->state == PSTOPPED && 1127 (j->saved_ttypgrp = tcgetpgrp(tty_fd)) >= 0) 1128 j->flags |= JF_SAVEDTTYPGRP; 1129 if (tcsetpgrp(tty_fd, kshpgrp) < 0) 1130 warningf(true, "%s %s(%d, %ld) %s: %s", 1131 "j_waitj:", "tcsetpgrp", tty_fd, 1132 (long)kshpgrp, "failed", cstrerror(errno)); 1133 if (j->state == PSTOPPED) { 1134 j->flags |= JF_SAVEDTTY; 1135 mksh_tcget(tty_fd, &j->ttystat); 1136 } 1137 } 1138 #endif 1139 if (tty_hasstate) { 1140 /* 1141 * Only restore tty settings if job was originally 1142 * started in the foreground. Problems can be 1143 * caused by things like 'more foobar &' which will 1144 * typically get and save the shell's vi/emacs tty 1145 * settings before setting up the tty for itself; 1146 * when more exits, it restores the 'original' 1147 * settings, and things go down hill from there... 1148 */ 1149 if (j->state == PEXITED && j->status == 0 && 1150 (j->flags & JF_USETTYMODE)) { 1151 mksh_tcget(tty_fd, &tty_state); 1152 } else { 1153 mksh_tcset(tty_fd, &tty_state); 1154 /*- 1155 * Don't use tty mode if job is stopped and 1156 * later restarted and exits. Consider 1157 * the sequence: 1158 * vi foo (stopped) 1159 * ... 1160 * stty something 1161 * ... 1162 * fg (vi; ZZ) 1163 * mode should be that of the stty, not what 1164 * was before the vi started. 1165 */ 1166 if (j->state == PSTOPPED) 1167 j->flags &= ~JF_USETTYMODE; 1168 } 1169 } 1170 #ifndef MKSH_UNEMPLOYED 1171 /* 1172 * If it looks like user hit ^C to kill a job, pretend we got 1173 * one too to break out of for loops, etc. (AT&T ksh does this 1174 * even when not monitoring, but this doesn't make sense since 1175 * a tty generated ^C goes to the whole process group) 1176 */ 1177 { 1178 int status; 1179 1180 status = j->last_proc->status; 1181 if (Flag(FMONITOR) && j->state == PSIGNALLED && 1182 WIFSIGNALED(status) && 1183 (sigtraps[WTERMSIG(status)].flags & TF_TTY_INTR)) 1184 trapsig(WTERMSIG(status)); 1185 } 1186 #endif 1187 } 1188 1189 j_usrtime = j->usrtime; 1190 j_systime = j->systime; 1191 rv = j->status; 1192 1193 if ((flags & JW_PIPEST) && (j->proc_list != NULL)) { 1194 uint32_t num = 0; 1195 Proc *p = j->proc_list; 1196 struct tbl *vp; 1197 1198 unset(vp_pipest, 1); 1199 vp = vp_pipest; 1200 vp->flag = DEFINED | ISSET | INTEGER | RDONLY | ARRAY | INT_U; 1201 goto got_array; 1202 1203 while (p != NULL) { 1204 { 1205 struct tbl *vq; 1206 1207 /* strlen(vp_pipest->name) == 10 */ 1208 vq = alloc(offsetof(struct tbl, name[0]) + 11, 1209 vp_pipest->areap); 1210 memset(vq, 0, offsetof(struct tbl, name[0])); 1211 memcpy(vq->name, vp_pipest->name, 11); 1212 vp->u.array = vq; 1213 vp = vq; 1214 } 1215 vp->areap = vp_pipest->areap; 1216 vp->ua.index = ++num; 1217 vp->flag = DEFINED | ISSET | INTEGER | RDONLY | 1218 ARRAY | INT_U | AINDEX; 1219 got_array: 1220 vp->val.i = proc_errorlevel(p); 1221 if (Flag(FPIPEFAIL) && vp->val.i) 1222 rv = vp->val.i; 1223 p = p->next; 1224 } 1225 } 1226 1227 if (!(flags & JW_ASYNCNOTIFY) 1228 #ifndef MKSH_UNEMPLOYED 1229 && (!Flag(FMONITOR) || j->state != PSTOPPED) 1230 #endif 1231 ) { 1232 j_print(j, JP_SHORT, shl_out); 1233 shf_flush(shl_out); 1234 } 1235 if (j->state != PSTOPPED 1236 #ifndef MKSH_UNEMPLOYED 1237 && (!Flag(FMONITOR) || !(flags & JW_ASYNCNOTIFY)) 1238 #endif 1239 ) 1240 remove_job(j, where); 1241 1242 return (rv); 1243 } 1244 1245 /* 1246 * SIGCHLD handler to reap children and update job states 1247 * 1248 * If jobs are compiled in then this routine expects sigchld to be blocked. 1249 */ 1250 /* ARGSUSED */ 1251 static void 1252 j_sigchld(int sig MKSH_A_UNUSED) 1253 { 1254 int saved_errno = errno; 1255 Job *j; 1256 Proc *p = NULL; 1257 pid_t pid; 1258 int status; 1259 struct rusage ru0, ru1; 1260 #ifdef MKSH_NO_SIGSUSPEND 1261 sigset_t omask; 1262 1263 /* this handler can run while SIGCHLD is not blocked, so block it now */ 1264 sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); 1265 #endif 1266 1267 #ifndef MKSH_NOPROSPECTOFWORK 1268 /* 1269 * Don't wait for any processes if a job is partially started. 1270 * This is so we don't do away with the process group leader 1271 * before all the processes in a pipe line are started (so the 1272 * setpgid() won't fail) 1273 */ 1274 for (j = job_list; j; j = j->next) 1275 if (j->ppid == procpid && !(j->flags & JF_STARTED)) { 1276 held_sigchld = 1; 1277 goto j_sigchld_out; 1278 } 1279 #endif 1280 1281 getrusage(RUSAGE_CHILDREN, &ru0); 1282 do { 1283 #ifndef MKSH_NOPROSPECTOFWORK 1284 pid = waitpid(-1, &status, (WNOHANG|WUNTRACED)); 1285 #else 1286 pid = wait(&status); 1287 #endif 1288 1289 /* 1290 * return if this would block (0) or no children 1291 * or interrupted (-1) 1292 */ 1293 if (pid <= 0) 1294 goto j_sigchld_out; 1295 1296 getrusage(RUSAGE_CHILDREN, &ru1); 1297 1298 /* find job and process structures for this pid */ 1299 for (j = job_list; j != NULL; j = j->next) 1300 for (p = j->proc_list; p != NULL; p = p->next) 1301 if (p->pid == pid) 1302 goto found; 1303 found: 1304 if (j == NULL) { 1305 /* Can occur if process has kids, then execs shell 1306 warningf(true, "bad process waited for (pid = %d)", 1307 pid); 1308 */ 1309 ru0 = ru1; 1310 continue; 1311 } 1312 1313 timeradd(&j->usrtime, &ru1.ru_utime, &j->usrtime); 1314 timersub(&j->usrtime, &ru0.ru_utime, &j->usrtime); 1315 timeradd(&j->systime, &ru1.ru_stime, &j->systime); 1316 timersub(&j->systime, &ru0.ru_stime, &j->systime); 1317 ru0 = ru1; 1318 p->status = status; 1319 #ifndef MKSH_UNEMPLOYED 1320 if (WIFSTOPPED(status)) 1321 p->state = PSTOPPED; 1322 else 1323 #endif 1324 if (WIFSIGNALED(status)) 1325 p->state = PSIGNALLED; 1326 else 1327 p->state = PEXITED; 1328 1329 /* check to see if entire job is done */ 1330 check_job(j); 1331 } 1332 #ifndef MKSH_NOPROSPECTOFWORK 1333 while (/* CONSTCOND */ 1); 1334 #else 1335 while (/* CONSTCOND */ 0); 1336 #endif 1337 1338 j_sigchld_out: 1339 #ifdef MKSH_NO_SIGSUSPEND 1340 sigprocmask(SIG_SETMASK, &omask, NULL); 1341 #endif 1342 errno = saved_errno; 1343 } 1344 1345 /* 1346 * Called only when a process in j has exited/stopped (ie, called only 1347 * from j_sigchld()). If no processes are running, the job status 1348 * and state are updated, asynchronous job notification is done and, 1349 * if unneeded, the job is removed. 1350 * 1351 * If jobs are compiled in then this routine expects sigchld to be blocked. 1352 */ 1353 static void 1354 check_job(Job *j) 1355 { 1356 int jstate; 1357 Proc *p; 1358 1359 /* XXX debugging (nasty - interrupt routine using shl_out) */ 1360 if (!(j->flags & JF_STARTED)) { 1361 internal_warningf("check_job: job started (flags 0x%x)", 1362 j->flags); 1363 return; 1364 } 1365 1366 jstate = PRUNNING; 1367 for (p=j->proc_list; p != NULL; p = p->next) { 1368 if (p->state == PRUNNING) 1369 /* some processes still running */ 1370 return; 1371 if (p->state > jstate) 1372 jstate = p->state; 1373 } 1374 j->state = jstate; 1375 j->status = proc_errorlevel(j->last_proc); 1376 1377 /* 1378 * Note when co-process dies: can't be done in j_wait() nor 1379 * remove_job() since neither may be called for non-interactive 1380 * shells. 1381 */ 1382 if (j->state == PEXITED || j->state == PSIGNALLED) { 1383 /* 1384 * No need to keep co-process input any more 1385 * (at least, this is what ksh93d thinks) 1386 */ 1387 if (coproc.job == j) { 1388 coproc.job = NULL; 1389 /* 1390 * XXX would be nice to get the closes out of here 1391 * so they aren't done in the signal handler. 1392 * Would mean a check in coproc_getfd() to 1393 * do "if job == 0 && write >= 0, close write". 1394 */ 1395 coproc_write_close(coproc.write); 1396 } 1397 /* Do we need to keep the output? */ 1398 if (j->coproc_id && j->coproc_id == coproc.id && 1399 --coproc.njobs == 0) 1400 coproc_readw_close(coproc.read); 1401 } 1402 1403 j->flags |= JF_CHANGED; 1404 #ifndef MKSH_UNEMPLOYED 1405 if (Flag(FMONITOR) && !(j->flags & JF_XXCOM)) { 1406 /* 1407 * Only put stopped jobs at the front to avoid confusing 1408 * the user (don't want finished jobs effecting %+ or %-) 1409 */ 1410 if (j->state == PSTOPPED) 1411 put_job(j, PJ_ON_FRONT); 1412 if (Flag(FNOTIFY) && 1413 (j->flags & (JF_WAITING|JF_W_ASYNCNOTIFY)) != JF_WAITING) { 1414 /* Look for the real file descriptor 2 */ 1415 { 1416 struct env *ep; 1417 int fd = 2; 1418 1419 for (ep = e; ep; ep = ep->oenv) 1420 if (ep->savefd && ep->savefd[2]) 1421 fd = ep->savefd[2]; 1422 shf_reopen(fd, SHF_WR, shl_j); 1423 } 1424 /* 1425 * Can't call j_notify() as it removes jobs. The job 1426 * must stay in the job list as j_waitj() may be 1427 * running with this job. 1428 */ 1429 j_print(j, JP_MEDIUM, shl_j); 1430 shf_flush(shl_j); 1431 if (!(j->flags & JF_WAITING) && j->state != PSTOPPED) 1432 remove_job(j, "notify"); 1433 } 1434 } 1435 #endif 1436 if ( 1437 #ifndef MKSH_UNEMPLOYED 1438 !Flag(FMONITOR) && 1439 #endif 1440 !(j->flags & (JF_WAITING|JF_FG)) && 1441 j->state != PSTOPPED) { 1442 if (j == async_job || (j->flags & JF_KNOWN)) { 1443 j->flags |= JF_ZOMBIE; 1444 j->job = -1; 1445 nzombie++; 1446 } else 1447 remove_job(j, "checkjob"); 1448 } 1449 } 1450 1451 /* 1452 * Print job status in either short, medium or long format. 1453 * 1454 * If jobs are compiled in then this routine expects sigchld to be blocked. 1455 */ 1456 static void 1457 j_print(Job *j, int how, struct shf *shf) 1458 { 1459 Proc *p; 1460 int state; 1461 int status; 1462 int coredumped; 1463 char jobchar = ' '; 1464 char buf[64]; 1465 const char *filler; 1466 int output = 0; 1467 1468 if (how == JP_PGRP) { 1469 /* 1470 * POSIX doesn't say what to do it there is no process 1471 * group leader (ie, !FMONITOR). We arbitrarily return 1472 * last pid (which is what $! returns). 1473 */ 1474 shf_fprintf(shf, "%d\n", (int)(j->pgrp ? j->pgrp : 1475 (j->last_proc ? j->last_proc->pid : 0))); 1476 return; 1477 } 1478 j->flags &= ~JF_CHANGED; 1479 filler = j->job > 10 ? "\n " : "\n "; 1480 if (j == job_list) 1481 jobchar = '+'; 1482 else if (j == job_list->next) 1483 jobchar = '-'; 1484 1485 for (p = j->proc_list; p != NULL;) { 1486 coredumped = 0; 1487 switch (p->state) { 1488 case PRUNNING: 1489 memcpy(buf, "Running", 8); 1490 break; 1491 case PSTOPPED: 1492 strlcpy(buf, sigtraps[WSTOPSIG(p->status)].mess, 1493 sizeof(buf)); 1494 break; 1495 case PEXITED: 1496 if (how == JP_SHORT) 1497 buf[0] = '\0'; 1498 else if (WEXITSTATUS(p->status) == 0) 1499 memcpy(buf, "Done", 5); 1500 else 1501 shf_snprintf(buf, sizeof(buf), "Done (%d)", 1502 WEXITSTATUS(p->status)); 1503 break; 1504 case PSIGNALLED: 1505 #ifdef WCOREDUMP 1506 if (WCOREDUMP(p->status)) 1507 coredumped = 1; 1508 #endif 1509 /* 1510 * kludge for not reporting 'normal termination 1511 * signals' (i.e. SIGINT, SIGPIPE) 1512 */ 1513 if (how == JP_SHORT && !coredumped && 1514 (WTERMSIG(p->status) == SIGINT || 1515 WTERMSIG(p->status) == SIGPIPE)) { 1516 buf[0] = '\0'; 1517 } else 1518 strlcpy(buf, sigtraps[WTERMSIG(p->status)].mess, 1519 sizeof(buf)); 1520 break; 1521 default: 1522 buf[0] = '\0'; 1523 } 1524 1525 if (how != JP_SHORT) { 1526 if (p == j->proc_list) 1527 shf_fprintf(shf, "[%d] %c ", j->job, jobchar); 1528 else 1529 shf_puts(filler, shf); 1530 } 1531 1532 if (how == JP_LONG) 1533 shf_fprintf(shf, "%5d ", (int)p->pid); 1534 1535 if (how == JP_SHORT) { 1536 if (buf[0]) { 1537 output = 1; 1538 shf_fprintf(shf, "%s%s ", 1539 buf, coredumped ? " (core dumped)" : null); 1540 } 1541 } else { 1542 output = 1; 1543 shf_fprintf(shf, "%-20s %s%s%s", buf, p->command, 1544 p->next ? "|" : null, 1545 coredumped ? " (core dumped)" : null); 1546 } 1547 1548 state = p->state; 1549 status = p->status; 1550 p = p->next; 1551 while (p && p->state == state && p->status == status) { 1552 if (how == JP_LONG) 1553 shf_fprintf(shf, "%s%5d %-20s %s%s", filler, 1554 (int)p->pid, " ", p->command, 1555 p->next ? "|" : null); 1556 else if (how == JP_MEDIUM) 1557 shf_fprintf(shf, " %s%s", p->command, 1558 p->next ? "|" : null); 1559 p = p->next; 1560 } 1561 } 1562 if (output) 1563 shf_putc('\n', shf); 1564 } 1565 1566 /* 1567 * Convert % sequence to job 1568 * 1569 * If jobs are compiled in then this routine expects sigchld to be blocked. 1570 */ 1571 static Job * 1572 j_lookup(const char *cp, int *ecodep) 1573 { 1574 Job *j, *last_match; 1575 Proc *p; 1576 size_t len; 1577 int job = 0; 1578 1579 if (ksh_isdigit(*cp)) { 1580 getn(cp, &job); 1581 /* Look for last_proc->pid (what $! returns) first... */ 1582 for (j = job_list; j != NULL; j = j->next) 1583 if (j->last_proc && j->last_proc->pid == job) 1584 return (j); 1585 /* 1586 * ...then look for process group (this is non-POSIX, 1587 * but should not break anything 1588 */ 1589 for (j = job_list; j != NULL; j = j->next) 1590 if (j->pgrp && j->pgrp == job) 1591 return (j); 1592 if (ecodep) 1593 *ecodep = JL_NOSUCH; 1594 return (NULL); 1595 } 1596 if (*cp != '%') { 1597 if (ecodep) 1598 *ecodep = JL_INVALID; 1599 return (NULL); 1600 } 1601 switch (*++cp) { 1602 case '\0': /* non-standard */ 1603 case '+': 1604 case '%': 1605 if (job_list != NULL) 1606 return (job_list); 1607 break; 1608 1609 case '-': 1610 if (job_list != NULL && job_list->next) 1611 return (job_list->next); 1612 break; 1613 1614 case '0': case '1': case '2': case '3': case '4': 1615 case '5': case '6': case '7': case '8': case '9': 1616 getn(cp, &job); 1617 for (j = job_list; j != NULL; j = j->next) 1618 if (j->job == job) 1619 return (j); 1620 break; 1621 1622 /* %?string */ 1623 case '?': 1624 last_match = NULL; 1625 for (j = job_list; j != NULL; j = j->next) 1626 for (p = j->proc_list; p != NULL; p = p->next) 1627 if (strstr(p->command, cp+1) != NULL) { 1628 if (last_match) { 1629 if (ecodep) 1630 *ecodep = JL_AMBIG; 1631 return (NULL); 1632 } 1633 last_match = j; 1634 } 1635 if (last_match) 1636 return (last_match); 1637 break; 1638 1639 /* %string */ 1640 default: 1641 len = strlen(cp); 1642 last_match = NULL; 1643 for (j = job_list; j != NULL; j = j->next) 1644 if (strncmp(cp, j->proc_list->command, len) == 0) { 1645 if (last_match) { 1646 if (ecodep) 1647 *ecodep = JL_AMBIG; 1648 return (NULL); 1649 } 1650 last_match = j; 1651 } 1652 if (last_match) 1653 return (last_match); 1654 break; 1655 } 1656 if (ecodep) 1657 *ecodep = JL_NOSUCH; 1658 return (NULL); 1659 } 1660 1661 static Job *free_jobs; 1662 static Proc *free_procs; 1663 1664 /* 1665 * allocate a new job and fill in the job number. 1666 * 1667 * If jobs are compiled in then this routine expects sigchld to be blocked. 1668 */ 1669 static Job * 1670 new_job(void) 1671 { 1672 int i; 1673 Job *newj, *j; 1674 1675 if (free_jobs != NULL) { 1676 newj = free_jobs; 1677 free_jobs = free_jobs->next; 1678 } else 1679 newj = alloc(sizeof(Job), APERM); 1680 1681 /* brute force method */ 1682 for (i = 1; ; i++) { 1683 for (j = job_list; j && j->job != i; j = j->next) 1684 ; 1685 if (j == NULL) 1686 break; 1687 } 1688 newj->job = i; 1689 1690 return (newj); 1691 } 1692 1693 /* 1694 * Allocate new process struct 1695 * 1696 * If jobs are compiled in then this routine expects sigchld to be blocked. 1697 */ 1698 static Proc * 1699 new_proc(void) 1700 { 1701 Proc *p; 1702 1703 if (free_procs != NULL) { 1704 p = free_procs; 1705 free_procs = free_procs->next; 1706 } else 1707 p = alloc(sizeof(Proc), APERM); 1708 1709 return (p); 1710 } 1711 1712 /* 1713 * Take job out of job_list and put old structures into free list. 1714 * Keeps nzombies, last_job and async_job up to date. 1715 * 1716 * If jobs are compiled in then this routine expects sigchld to be blocked. 1717 */ 1718 static void 1719 remove_job(Job *j, const char *where) 1720 { 1721 Proc *p, *tmp; 1722 Job **prev, *curr; 1723 1724 mkssert(j != NULL); 1725 prev = &job_list; 1726 curr = job_list; 1727 while (curr && curr != j) { 1728 prev = &curr->next; 1729 curr = *prev; 1730 } 1731 if (curr != j) { 1732 internal_warningf("remove_job: job %s (%s)", "not found", where); 1733 return; 1734 } 1735 *prev = curr->next; 1736 1737 /* free up proc structures */ 1738 for (p = j->proc_list; p != NULL; ) { 1739 tmp = p; 1740 p = p->next; 1741 tmp->next = free_procs; 1742 free_procs = tmp; 1743 } 1744 1745 if ((j->flags & JF_ZOMBIE) && j->ppid == procpid) 1746 --nzombie; 1747 j->next = free_jobs; 1748 free_jobs = j; 1749 1750 if (j == last_job) 1751 last_job = NULL; 1752 if (j == async_job) 1753 async_job = NULL; 1754 } 1755 1756 /* 1757 * put j in a particular location (taking it out job_list if it is there 1758 * already) 1759 * 1760 * If jobs are compiled in then this routine expects sigchld to be blocked. 1761 */ 1762 static void 1763 put_job(Job *j, int where) 1764 { 1765 Job **prev, *curr; 1766 1767 mkssert(j != NULL); 1768 /* Remove job from list (if there) */ 1769 prev = &job_list; 1770 curr = job_list; 1771 while (curr && curr != j) { 1772 prev = &curr->next; 1773 curr = *prev; 1774 } 1775 if (curr == j) 1776 *prev = curr->next; 1777 1778 switch (where) { 1779 case PJ_ON_FRONT: 1780 j->next = job_list; 1781 job_list = j; 1782 break; 1783 1784 case PJ_PAST_STOPPED: 1785 prev = &job_list; 1786 curr = job_list; 1787 for (; curr && curr->state == PSTOPPED; prev = &curr->next, 1788 curr = *prev) 1789 ; 1790 j->next = curr; 1791 *prev = j; 1792 break; 1793 } 1794 } 1795 1796 /* 1797 * nuke a job (called when unable to start full job). 1798 * 1799 * If jobs are compiled in then this routine expects sigchld to be blocked. 1800 */ 1801 static int 1802 kill_job(Job *j, int sig) 1803 { 1804 Proc *p; 1805 int rval = 0; 1806 1807 for (p = j->proc_list; p != NULL; p = p->next) 1808 if (p->pid != 0) 1809 if (kill(p->pid, sig) < 0) 1810 rval = -1; 1811 return (rval); 1812 } 1813 1814 static void 1815 tty_init_talking(void) 1816 { 1817 switch (tty_init_fd()) { 1818 case 0: 1819 break; 1820 case 1: 1821 #ifndef MKSH_DISABLE_TTY_WARNING 1822 warningf(false, "%s: %s %s: %s", 1823 "No controlling tty", "open", "/dev/tty", 1824 cstrerror(errno)); 1825 #endif 1826 break; 1827 case 2: 1828 #ifndef MKSH_DISABLE_TTY_WARNING 1829 warningf(false, "%s: %s", "can't find tty fd", cstrerror(errno)); 1830 #endif 1831 break; 1832 case 3: 1833 warningf(false, "%s: %s %s: %s", "j_ttyinit", 1834 "dup of tty fd", "failed", cstrerror(errno)); 1835 break; 1836 case 4: 1837 warningf(false, "%s: %s: %s", "j_ttyinit", 1838 "can't set close-on-exec flag", cstrerror(errno)); 1839 break; 1840 } 1841 } 1842 1843 static void 1844 tty_init_state(void) 1845 { 1846 if (tty_fd >= 0) { 1847 mksh_tcget(tty_fd, &tty_state); 1848 tty_hasstate = true; 1849 } 1850 } 1851
