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