/* $OpenBSD: jobs.c,v 1.43 2015/09/10 22:48:58 nicm Exp $ */ /*- * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2011, * 2012, 2013, 2014, 2015, 2016, 2018, 2019 * mirabilos * * Provided that these terms and disclaimer and all copyright notices * are retained or reproduced in an accompanying document, permission * is granted to deal in this work without restriction, including un- * limited rights to use, publicly perform, distribute, sell, modify, * merge, give away, or sublicence. * * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to * the utmost extent permitted by applicable law, neither express nor * implied; without malicious intent or gross negligence. In no event * may a licensor, author or contributor be held liable for indirect, * direct, other damage, loss, or other issues arising in any way out * of dealing in the work, even if advised of the possibility of such * damage or existence of a defect, except proven that it results out * of said person's immediate fault when using the work as intended. */ #include "sh.h" __RCSID("$MirOS: src/bin/mksh/jobs.c,v 1.128 2019/12/11 19:46:20 tg Exp $"); #if HAVE_KILLPG #define mksh_killpg killpg #else /* cross fingers and hope kill is killpg-endowed */ #define mksh_killpg(p,s) kill(-(p), (s)) #endif /* Order important! */ #define PRUNNING 0 #define PEXITED 1 #define PSIGNALLED 2 #define PSTOPPED 3 typedef struct proc Proc; /* to take alignment into consideration */ struct proc_dummy { Proc *next; pid_t pid; int state; int status; char command[128]; }; /* real structure */ struct proc { /* next process in pipeline (if any) */ Proc *next; /* process id of this Unix process in the job */ pid_t pid; /* one of the four P… above */ int state; /* wait status */ int status; /* process command string from vistree */ char command[256 - (ALLOC_OVERHEAD + offsetof(struct proc_dummy, command[0]))]; }; /* Notify/print flag - j_print() argument */ #define JP_SHORT 1 /* print signals processes were killed by */ #define JP_MEDIUM 2 /* print [job-num] -/+ command */ #define JP_LONG 3 /* print [job-num] -/+ pid command */ #define JP_PGRP 4 /* print pgrp */ /* put_job() flags */ #define PJ_ON_FRONT 0 /* at very front */ #define PJ_PAST_STOPPED 1 /* just past any stopped jobs */ /* Job.flags values */ #define JF_STARTED 0x001 /* set when all processes in job are started */ #define JF_WAITING 0x002 /* set if j_waitj() is waiting on job */ #define JF_W_ASYNCNOTIFY 0x004 /* set if waiting and async notification ok */ #define JF_XXCOM 0x008 /* set for $(command) jobs */ #define JF_FG 0x010 /* running in foreground (also has tty pgrp) */ #define JF_SAVEDTTY 0x020 /* j->ttystat is valid */ #define JF_CHANGED 0x040 /* process has changed state */ #define JF_KNOWN 0x080 /* $! referenced */ #define JF_ZOMBIE 0x100 /* known, unwaited process */ #define JF_REMOVE 0x200 /* flagged for removal (j_jobs()/j_noityf()) */ #define JF_USETTYMODE 0x400 /* tty mode saved if process exits normally */ #define JF_SAVEDTTYPGRP 0x800 /* j->saved_ttypgrp is valid */ typedef struct job Job; struct job { ALLOC_ITEM alloc_INT; /* internal, do not touch */ Job *next; /* next job in list */ Proc *proc_list; /* process list */ Proc *last_proc; /* last process in list */ struct timeval systime; /* system time used by job */ struct timeval usrtime; /* user time used by job */ pid_t pgrp; /* process group of job */ pid_t ppid; /* pid of process that forked job */ int job; /* job number: %n */ int flags; /* see JF_* */ volatile int state; /* job state */ int status; /* exit status of last process */ int age; /* number of jobs started */ Coproc_id coproc_id; /* 0 or id of coprocess output pipe */ #ifndef MKSH_UNEMPLOYED mksh_ttyst ttystat; /* saved tty state for stopped jobs */ pid_t saved_ttypgrp; /* saved tty process group for stopped jobs */ #endif }; /* Flags for j_waitj() */ #define JW_NONE 0x00 #define JW_INTERRUPT 0x01 /* ^C will stop the wait */ #define JW_ASYNCNOTIFY 0x02 /* asynchronous notification during wait ok */ #define JW_STOPPEDWAIT 0x04 /* wait even if job stopped */ #define JW_PIPEST 0x08 /* want PIPESTATUS */ /* Error codes for j_lookup() */ #define JL_NOSUCH 0 /* no such job */ #define JL_AMBIG 1 /* %foo or %?foo is ambiguous */ #define JL_INVALID 2 /* non-pid, non-% job id */ static const char * const lookup_msgs[] = { "no such job", "ambiguous", "argument must be %job or process id" }; static Job *job_list; /* job list */ static Job *last_job; static Job *async_job; static pid_t async_pid; static int nzombie; /* # of zombies owned by this process */ static int njobs; /* # of jobs started */ #ifndef CHILD_MAX #define CHILD_MAX 25 #endif #ifndef MKSH_NOPROSPECTOFWORK /* held_sigchld is set if sigchld occurs before a job is completely started */ static volatile sig_atomic_t held_sigchld; #endif #ifndef MKSH_UNEMPLOYED static struct shf *shl_j; static bool ttypgrp_ok; /* set if can use tty pgrps */ static pid_t restore_ttypgrp = -1; static int const tt_sigs[] = { SIGTSTP, SIGTTIN, SIGTTOU }; #endif static void j_set_async(Job *); static void j_startjob(Job *); static int j_waitj(Job *, int, const char *); static void j_sigchld(int); static void j_print(Job *, int, struct shf *); static Job *j_lookup(const char *, int *); static Job *new_job(void); static Proc *new_proc(void); static void check_job(Job *); static void put_job(Job *, int); static void remove_job(Job *, const char *); static int kill_job(Job *, int); static void tty_init_talking(void); static void tty_init_state(void); /* initialise job control */ void j_init(void) { #ifndef MKSH_NOPROSPECTOFWORK (void)sigemptyset(&sm_default); sigprocmask(SIG_SETMASK, &sm_default, NULL); (void)sigemptyset(&sm_sigchld); (void)sigaddset(&sm_sigchld, SIGCHLD); setsig(&sigtraps[SIGCHLD], j_sigchld, SS_RESTORE_ORIG|SS_FORCE|SS_SHTRAP); #else /* Make sure SIGCHLD isn't ignored - can do odd things under SYSV */ setsig(&sigtraps[SIGCHLD], SIG_DFL, SS_RESTORE_ORIG|SS_FORCE); #endif #ifndef MKSH_UNEMPLOYED if (Flag(FMONITOR) == 127) Flag(FMONITOR) = Flag(FTALKING); /* * shl_j is used to do asynchronous notification (used in * an interrupt handler, so need a distinct shf) */ shl_j = shf_fdopen(2, SHF_WR, NULL); if (Flag(FMONITOR) || Flag(FTALKING)) { int i; /* * the TF_SHELL_USES test is a kludge that lets us know if * if the signals have been changed by the shell. */ for (i = NELEM(tt_sigs); --i >= 0; ) { sigtraps[tt_sigs[i]].flags |= TF_SHELL_USES; /* j_change() sets this to SS_RESTORE_DFL if FMONITOR */ setsig(&sigtraps[tt_sigs[i]], SIG_IGN, SS_RESTORE_IGN|SS_FORCE); } } /* j_change() calls tty_init_talking() and tty_init_state() */ if (Flag(FMONITOR)) j_change(); else #endif if (Flag(FTALKING)) { tty_init_talking(); tty_init_state(); } } static int proc_errorlevel(Proc *p) { switch (p->state) { case PEXITED: return ((WEXITSTATUS(p->status)) & 255); case PSIGNALLED: return (ksh_sigmask(WTERMSIG(p->status))); default: return (0); } } #if !defined(MKSH_UNEMPLOYED) && HAVE_GETSID /* suspend the shell */ void j_suspend(void) { struct sigaction sa, osa; /* Restore tty and pgrp. */ if (ttypgrp_ok) { if (tty_hasstate) mksh_tcset(tty_fd, &tty_state); if (restore_ttypgrp >= 0) { if (tcsetpgrp(tty_fd, restore_ttypgrp) < 0) { warningf(false, Tf_ssfaileds, Tj_suspend, "tcsetpgrp", cstrerror(errno)); } else if (setpgid(0, restore_ttypgrp) < 0) { warningf(false, Tf_ssfaileds, Tj_suspend, "setpgid", cstrerror(errno)); } } } /* Suspend the shell. */ memset(&sa, 0, sizeof(sa)); sigemptyset(&sa.sa_mask); sa.sa_handler = SIG_DFL; sigaction(SIGTSTP, &sa, &osa); kill(0, SIGTSTP); /* Back from suspend, reset signals, pgrp and tty. */ sigaction(SIGTSTP, &osa, NULL); if (ttypgrp_ok) { if (restore_ttypgrp >= 0) { if (setpgid(0, kshpid) < 0) { warningf(false, Tf_ssfaileds, Tj_suspend, "setpgid", cstrerror(errno)); ttypgrp_ok = false; } else if (tcsetpgrp(tty_fd, kshpid) < 0) { warningf(false, Tf_ssfaileds, Tj_suspend, "tcsetpgrp", cstrerror(errno)); ttypgrp_ok = false; } } tty_init_state(); } } #endif /* job cleanup before shell exit */ void j_exit(void) { /* kill stopped, and possibly running, jobs */ Job *j; bool killed = false; for (j = job_list; j != NULL; j = j->next) { if (j->ppid == procpid && (j->state == PSTOPPED || (j->state == PRUNNING && ((j->flags & JF_FG) || (Flag(FLOGIN) && !Flag(FNOHUP) && procpid == kshpid))))) { killed = true; if (j->pgrp == 0) kill_job(j, SIGHUP); else mksh_killpg(j->pgrp, SIGHUP); #ifndef MKSH_UNEMPLOYED if (j->state == PSTOPPED) { if (j->pgrp == 0) kill_job(j, SIGCONT); else mksh_killpg(j->pgrp, SIGCONT); } #endif } } if (killed) sleep(1); j_notify(); #ifndef MKSH_UNEMPLOYED if (kshpid == procpid && restore_ttypgrp >= 0) { /* * Need to restore the tty pgrp to what it was when the * shell started up, so that the process that started us * will be able to access the tty when we are done. * Also need to restore our process group in case we are * about to do an exec so that both our parent and the * process we are to become will be able to access the tty. */ tcsetpgrp(tty_fd, restore_ttypgrp); setpgid(0, restore_ttypgrp); } if (Flag(FMONITOR)) { Flag(FMONITOR) = 0; j_change(); } #endif } #ifndef MKSH_UNEMPLOYED /* turn job control on or off according to Flag(FMONITOR) */ void j_change(void) { int i; if (Flag(FMONITOR)) { bool use_tty = Flag(FTALKING); /* don't call mksh_tcget until we own the tty process group */ if (use_tty) tty_init_talking(); /* no controlling tty, no SIGT* */ #ifndef ADAPT_FOR_LITEOS_A if ((ttypgrp_ok = (use_tty && tty_fd >= 0 && tty_devtty))) { #else // ADAPT_FOR_LITEOS_A if ((ttypgrp_ok = (use_tty && tty_fd >= 0))) { #endif // ADAPT_FOR_LITEOS_A setsig(&sigtraps[SIGTTIN], SIG_DFL, SS_RESTORE_ORIG|SS_FORCE); /* wait to be given tty (POSIX.1, B.2, job control) */ while (/* CONSTCOND */ 1) { pid_t ttypgrp; if ((ttypgrp = tcgetpgrp(tty_fd)) < 0) { warningf(false, Tf_ssfaileds, "j_init", "tcgetpgrp", cstrerror(errno)); ttypgrp_ok = false; break; } if (ttypgrp == kshpgrp) break; kill(0, SIGTTIN); } } for (i = NELEM(tt_sigs); --i >= 0; ) setsig(&sigtraps[tt_sigs[i]], SIG_IGN, SS_RESTORE_DFL|SS_FORCE); if (ttypgrp_ok && kshpgrp != kshpid) { if (setpgid(0, kshpid) < 0) { warningf(false, Tf_ssfaileds, "j_init", "setpgid", cstrerror(errno)); ttypgrp_ok = false; } else { if (tcsetpgrp(tty_fd, kshpid) < 0) { warningf(false, Tf_ssfaileds, "j_init", "tcsetpgrp", cstrerror(errno)); ttypgrp_ok = false; } else restore_ttypgrp = kshpgrp; kshpgrp = kshpid; } } #ifndef MKSH_DISABLE_TTY_WARNING if (use_tty && !ttypgrp_ok) warningf(false, Tf_sD_s, "warning", "won't have full job control"); #endif } else { ttypgrp_ok = false; if (Flag(FTALKING)) for (i = NELEM(tt_sigs); --i >= 0; ) setsig(&sigtraps[tt_sigs[i]], SIG_IGN, SS_RESTORE_IGN|SS_FORCE); else for (i = NELEM(tt_sigs); --i >= 0; ) { if (sigtraps[tt_sigs[i]].flags & (TF_ORIG_IGN | TF_ORIG_DFL)) setsig(&sigtraps[tt_sigs[i]], (sigtraps[tt_sigs[i]].flags & TF_ORIG_IGN) ? SIG_IGN : SIG_DFL, SS_RESTORE_ORIG|SS_FORCE); } } tty_init_state(); } #endif #if HAVE_NICE /* run nice(3) and ignore the result */ static void ksh_nice(int ness) { #if defined(__USE_FORTIFY_LEVEL) && (__USE_FORTIFY_LEVEL > 0) int eno; errno = 0; /* this is gonna annoy users; complain to your distro, people! */ if (nice(ness) == -1 && (eno = errno) != 0) warningf(false, Tf_sD_s, "bgnice", cstrerror(eno)); #else (void)nice(ness); #endif } #endif /* execute tree in child subprocess */ int exchild(struct op *t, int flags, volatile int *xerrok, /* used if XPCLOSE or XCCLOSE */ int close_fd) { /* for pipelines */ static Proc *last_proc; int rv = 0, forksleep, jwflags = JW_NONE; #ifndef MKSH_NOPROSPECTOFWORK sigset_t omask; #endif Proc *p; Job *j; pid_t cldpid; if (flags & XPIPEST) { flags &= ~XPIPEST; jwflags |= JW_PIPEST; } if (flags & XEXEC) /* * Clear XFORK|XPCLOSE|XCCLOSE|XCOPROC|XPIPEO|XPIPEI|XXCOM|XBGND * (also done in another execute() below) */ return (execute(t, flags & (XEXEC | XERROK), xerrok)); #ifndef MKSH_NOPROSPECTOFWORK /* no SIGCHLDs while messing with job and process lists */ sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); #endif p = new_proc(); p->next = NULL; p->state = PRUNNING; p->status = 0; p->pid = 0; /* link process into jobs list */ if (flags & XPIPEI) { /* continuing with a pipe */ if (!last_job) internal_errorf("exchild: XPIPEI and no last_job - pid %d", (int)procpid); j = last_job; if (last_proc) last_proc->next = p; last_proc = p; } else { /* fills in j->job */ j = new_job(); /* * we don't consider XXCOMs foreground since they don't get * tty process group and we don't save or restore tty modes. */ j->flags = (flags & XXCOM) ? JF_XXCOM : ((flags & XBGND) ? 0 : (JF_FG|JF_USETTYMODE)); timerclear(&j->usrtime); timerclear(&j->systime); j->state = PRUNNING; j->pgrp = 0; j->ppid = procpid; j->age = ++njobs; j->proc_list = p; j->coproc_id = 0; last_job = j; last_proc = p; put_job(j, PJ_PAST_STOPPED); } vistree(p->command, sizeof(p->command), t); /* create child process */ forksleep = 1; while ((cldpid = fork()) < 0 && errno == EAGAIN && forksleep < 32) { if (intrsig) /* allow user to ^C out... */ break; sleep(forksleep); forksleep <<= 1; } /* ensure $RANDOM changes between parent and child */ rndset((unsigned long)cldpid); /* fork failed? */ if (cldpid < 0) { kill_job(j, SIGKILL); remove_job(j, "fork failed"); #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif errorf("can't fork - try again"); } p->pid = cldpid ? cldpid : (procpid = getpid()); #ifndef MKSH_UNEMPLOYED /* job control set up */ if (Flag(FMONITOR) && !(flags&XXCOM)) { bool dotty = false; if (j->pgrp == 0) { /* First process */ j->pgrp = p->pid; dotty = true; } /* * set pgrp in both parent and child to deal with race * condition */ setpgid(p->pid, j->pgrp); if (ttypgrp_ok && dotty && !(flags & XBGND)) tcsetpgrp(tty_fd, j->pgrp); } #endif /* used to close pipe input fd */ if (close_fd >= 0 && (((flags & XPCLOSE) && cldpid) || ((flags & XCCLOSE) && !cldpid))) close(close_fd); if (!cldpid) { /* child */ /* Do this before restoring signal */ if (flags & XCOPROC) coproc_cleanup(false); cleanup_parents_env(); #ifndef MKSH_UNEMPLOYED /* * If FMONITOR or FTALKING is set, these signals are ignored, * if neither FMONITOR nor FTALKING are set, the signals have * their inherited values. */ if (Flag(FMONITOR) && !(flags & XXCOM)) { for (forksleep = NELEM(tt_sigs); --forksleep >= 0; ) setsig(&sigtraps[tt_sigs[forksleep]], SIG_DFL, SS_RESTORE_DFL|SS_FORCE); } #endif #if HAVE_NICE if (Flag(FBGNICE) && (flags & XBGND)) ksh_nice(4); #endif if ((flags & XBGND) #ifndef MKSH_UNEMPLOYED && !Flag(FMONITOR) #endif ) { setsig(&sigtraps[SIGINT], SIG_IGN, SS_RESTORE_IGN|SS_FORCE); setsig(&sigtraps[SIGQUIT], SIG_IGN, SS_RESTORE_IGN|SS_FORCE); if ((!(flags & (XPIPEI | XCOPROC))) && ((forksleep = open("/dev/null", 0)) > 0)) { (void)ksh_dup2(forksleep, 0, true); close(forksleep); } } /* in case of $(jobs) command */ remove_job(j, "child"); #ifndef MKSH_NOPROSPECTOFWORK /* remove_job needs SIGCHLD blocked still */ sigprocmask(SIG_SETMASK, &omask, NULL); #endif nzombie = 0; #ifndef MKSH_UNEMPLOYED ttypgrp_ok = false; Flag(FMONITOR) = 0; #endif Flag(FTALKING) = 0; cleartraps(); /* no return */ execute(t, (flags & XERROK) | XEXEC, NULL); #ifndef MKSH_SMALL if (t->type == TPIPE) unwind(LLEAVE); internal_warningf("%s: execute() returned", "exchild"); fptreef(shl_out, 8, "%s: tried to execute {\n\t%T\n}\n", "exchild", t); shf_flush(shl_out); #endif unwind(LLEAVE); /* NOTREACHED */ } /* shell (parent) stuff */ if (!(flags & XPIPEO)) { /* last process in a job */ j_startjob(j); if (flags & XCOPROC) { j->coproc_id = coproc.id; /* n jobs using co-process output */ coproc.njobs++; /* j using co-process input */ coproc.job = (void *)j; } if (flags & XBGND) { j_set_async(j); if (Flag(FTALKING)) { shf_fprintf(shl_out, "[%d]", j->job); for (p = j->proc_list; p; p = p->next) shf_fprintf(shl_out, Tf__d, (int)p->pid); shf_putchar('\n', shl_out); shf_flush(shl_out); } } else rv = j_waitj(j, jwflags, "jw:last proc"); } #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif return (rv); } /* start the last job: only used for $(command) jobs */ void startlast(void) { #ifndef MKSH_NOPROSPECTOFWORK sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); #endif /* no need to report error - waitlast() will do it */ if (last_job) { /* ensure it isn't removed by check_job() */ last_job->flags |= JF_WAITING; j_startjob(last_job); } #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif } /* wait for last job: only used for $(command) jobs */ int waitlast(void) { int rv; Job *j; #ifndef MKSH_NOPROSPECTOFWORK sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); #endif j = last_job; if (!j || !(j->flags & JF_STARTED)) { if (!j) warningf(true, Tf_sD_s, "waitlast", "no last job"); else internal_warningf(Tf_sD_s, "waitlast", Tnot_started); #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif /* not so arbitrary, non-zero value */ return (125); } rv = j_waitj(j, JW_NONE, "waitlast"); #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif return (rv); } /* wait for child, interruptable. */ int waitfor(const char *cp, int *sigp) { int rv, ecode, flags = JW_INTERRUPT|JW_ASYNCNOTIFY; Job *j; #ifndef MKSH_NOPROSPECTOFWORK sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); #endif *sigp = 0; if (cp == NULL) { /* * wait for an unspecified job - always returns 0, so * don't have to worry about exited/signaled jobs */ for (j = job_list; j; j = j->next) /* AT&T ksh will wait for stopped jobs - we don't */ if (j->ppid == procpid && j->state == PRUNNING) break; if (!j) { #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif return (-1); } } else if ((j = j_lookup(cp, &ecode))) { /* don't report normal job completion */ flags &= ~JW_ASYNCNOTIFY; if (j->ppid != procpid) { #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif return (-1); } } else { #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif if (ecode != JL_NOSUCH) bi_errorf(Tf_sD_s, cp, lookup_msgs[ecode]); return (-1); } /* AT&T ksh will wait for stopped jobs - we don't */ rv = j_waitj(j, flags, "jw:waitfor"); #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif if (rv < 0) /* we were interrupted */ *sigp = ksh_sigmask(-rv); return (rv); } /* kill (built-in) a job */ int j_kill(const char *cp, int sig) { Job *j; int rv = 0, ecode; #ifndef MKSH_NOPROSPECTOFWORK sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); #endif if ((j = j_lookup(cp, &ecode)) == NULL) { #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif bi_errorf(Tf_sD_s, cp, lookup_msgs[ecode]); return (1); } if (j->pgrp == 0) { /* started when !Flag(FMONITOR) */ if (kill_job(j, sig) < 0) { bi_errorf(Tf_sD_s, cp, cstrerror(errno)); rv = 1; } } else { #ifndef MKSH_UNEMPLOYED if (j->state == PSTOPPED && (sig == SIGTERM || sig == SIGHUP)) mksh_killpg(j->pgrp, SIGCONT); #endif if (mksh_killpg(j->pgrp, sig) < 0) { bi_errorf(Tf_sD_s, cp, cstrerror(errno)); rv = 1; } } #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif return (rv); } #ifndef MKSH_UNEMPLOYED /* fg and bg built-ins: called only if Flag(FMONITOR) set */ int j_resume(const char *cp, int bg) { Job *j; Proc *p; int ecode, rv = 0; bool running; sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); if ((j = j_lookup(cp, &ecode)) == NULL) { sigprocmask(SIG_SETMASK, &omask, NULL); bi_errorf(Tf_sD_s, cp, lookup_msgs[ecode]); return (1); } if (j->pgrp == 0) { sigprocmask(SIG_SETMASK, &omask, NULL); bi_errorf("job not job-controlled"); return (1); } if (bg) shprintf("[%d] ", j->job); running = false; for (p = j->proc_list; p != NULL; p = p->next) { if (p->state == PSTOPPED) { p->state = PRUNNING; p->status = 0; running = true; } shf_puts(p->command, shl_stdout); if (p->next) shf_puts("| ", shl_stdout); } shf_putc('\n', shl_stdout); shf_flush(shl_stdout); if (running) j->state = PRUNNING; put_job(j, PJ_PAST_STOPPED); if (bg) j_set_async(j); else { /* attach tty to job */ if (j->state == PRUNNING) { if (ttypgrp_ok && (j->flags & JF_SAVEDTTY)) mksh_tcset(tty_fd, &j->ttystat); /* See comment in j_waitj regarding saved_ttypgrp. */ if (ttypgrp_ok && tcsetpgrp(tty_fd, (j->flags & JF_SAVEDTTYPGRP) ? j->saved_ttypgrp : j->pgrp) < 0) { rv = errno; if (j->flags & JF_SAVEDTTY) mksh_tcset(tty_fd, &tty_state); sigprocmask(SIG_SETMASK, &omask, NULL); bi_errorf(Tf_ldfailed, "fg: 1st", "tcsetpgrp", tty_fd, (long)((j->flags & JF_SAVEDTTYPGRP) ? j->saved_ttypgrp : j->pgrp), cstrerror(rv)); return (1); } } j->flags |= JF_FG; j->flags &= ~JF_KNOWN; if (j == async_job) async_job = NULL; } if (j->state == PRUNNING && mksh_killpg(j->pgrp, SIGCONT) < 0) { int eno = errno; if (!bg) { j->flags &= ~JF_FG; if (ttypgrp_ok && (j->flags & JF_SAVEDTTY)) mksh_tcset(tty_fd, &tty_state); if (ttypgrp_ok && tcsetpgrp(tty_fd, kshpgrp) < 0) warningf(true, Tf_ldfailed, "fg: 2nd", "tcsetpgrp", tty_fd, (long)kshpgrp, cstrerror(errno)); } sigprocmask(SIG_SETMASK, &omask, NULL); bi_errorf(Tf_s_sD_s, "can't continue job", cp, cstrerror(eno)); return (1); } if (!bg) { if (ttypgrp_ok) { j->flags &= ~(JF_SAVEDTTY | JF_SAVEDTTYPGRP); } rv = j_waitj(j, JW_NONE, "jw:resume"); } sigprocmask(SIG_SETMASK, &omask, NULL); return (rv); } #endif /* are there any running or stopped jobs ? */ int j_stopped_running(void) { Job *j; int which = 0; for (j = job_list; j != NULL; j = j->next) { #ifndef MKSH_UNEMPLOYED if (j->ppid == procpid && j->state == PSTOPPED) which |= 1; #endif if (Flag(FLOGIN) && !Flag(FNOHUP) && procpid == kshpid && j->ppid == procpid && j->state == PRUNNING) which |= 2; } if (which) { shellf("You have %s%s%s jobs\n", which & 1 ? "stopped" : "", which == 3 ? " and " : "", which & 2 ? "running" : ""); return (1); } return (0); } /* list jobs for jobs built-in */ int j_jobs(const char *cp, int slp, /* 0: short, 1: long, 2: pgrp */ int nflag) { Job *j, *tmp; int how, zflag = 0; #ifndef MKSH_NOPROSPECTOFWORK sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); #endif if (nflag < 0) { /* kludge: print zombies */ nflag = 0; zflag = 1; } if (cp) { int ecode; if ((j = j_lookup(cp, &ecode)) == NULL) { #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif bi_errorf(Tf_sD_s, cp, lookup_msgs[ecode]); return (1); } } else j = job_list; how = slp == 0 ? JP_MEDIUM : (slp == 1 ? JP_LONG : JP_PGRP); for (; j; j = j->next) { if ((!(j->flags & JF_ZOMBIE) || zflag) && (!nflag || (j->flags & JF_CHANGED))) { j_print(j, how, shl_stdout); if (j->state == PEXITED || j->state == PSIGNALLED) j->flags |= JF_REMOVE; } if (cp) break; } /* Remove jobs after printing so there won't be multiple + or - jobs */ for (j = job_list; j; j = tmp) { tmp = j->next; if (j->flags & JF_REMOVE) remove_job(j, Tjobs); } #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif return (0); } /* list jobs for top-level notification */ void j_notify(void) { Job *j, *tmp; #ifndef MKSH_NOPROSPECTOFWORK sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); #endif for (j = job_list; j; j = j->next) { #ifndef MKSH_UNEMPLOYED if (Flag(FMONITOR) && (j->flags & JF_CHANGED)) j_print(j, JP_MEDIUM, shl_out); #endif /* * Remove job after doing reports so there aren't * multiple +/- jobs. */ if (j->state == PEXITED || j->state == PSIGNALLED) j->flags |= JF_REMOVE; } for (j = job_list; j; j = tmp) { tmp = j->next; if (j->flags & JF_REMOVE) { if (j == async_job || (j->flags & JF_KNOWN)) { j->flags = (j->flags & ~JF_REMOVE) | JF_ZOMBIE; j->job = -1; nzombie++; } else remove_job(j, "notify"); } } shf_flush(shl_out); #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif } /* Return pid of last process in last asynchronous job */ pid_t j_async(void) { #ifndef MKSH_NOPROSPECTOFWORK sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); #endif if (async_job) async_job->flags |= JF_KNOWN; #ifndef MKSH_NOPROSPECTOFWORK sigprocmask(SIG_SETMASK, &omask, NULL); #endif return (async_pid); } /* * Make j the last async process * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static void j_set_async(Job *j) { Job *jl, *oldest; if (async_job && (async_job->flags & (JF_KNOWN|JF_ZOMBIE)) == JF_ZOMBIE) remove_job(async_job, "async"); if (!(j->flags & JF_STARTED)) { internal_warningf(Tf_sD_s, "j_async", Tjob_not_started); return; } async_job = j; async_pid = j->last_proc->pid; while (nzombie > CHILD_MAX) { oldest = NULL; for (jl = job_list; jl; jl = jl->next) if (jl != async_job && (jl->flags & JF_ZOMBIE) && (!oldest || jl->age < oldest->age)) oldest = jl; if (!oldest) { /* XXX debugging */ if (!(async_job->flags & JF_ZOMBIE) || nzombie != 1) { internal_warningf("%s: bad nzombie (%d)", "j_async", nzombie); nzombie = 0; } break; } remove_job(oldest, "zombie"); } } /* * Start a job: set STARTED, check for held signals and set j->last_proc * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static void j_startjob(Job *j) { Proc *p; j->flags |= JF_STARTED; for (p = j->proc_list; p->next; p = p->next) ; j->last_proc = p; #ifndef MKSH_NOPROSPECTOFWORK if (held_sigchld) { held_sigchld = 0; /* Don't call j_sigchld() as it may remove job... */ kill(procpid, SIGCHLD); } #endif } /* * wait for job to complete or change state * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static int j_waitj(Job *j, /* see JW_* */ int flags, const char *where) { Proc *p; int rv; #ifdef MKSH_NO_SIGSUSPEND sigset_t omask; #endif /* * No auto-notify on the job we are waiting on. */ j->flags |= JF_WAITING; if (flags & JW_ASYNCNOTIFY) j->flags |= JF_W_ASYNCNOTIFY; #ifndef MKSH_UNEMPLOYED if (!Flag(FMONITOR)) #endif flags |= JW_STOPPEDWAIT; while (j->state == PRUNNING || ((flags & JW_STOPPEDWAIT) && j->state == PSTOPPED)) { #ifndef MKSH_NOPROSPECTOFWORK #ifdef MKSH_NO_SIGSUSPEND sigprocmask(SIG_SETMASK, &sm_default, &omask); pause(); /* note that handlers may run here so they need to know */ sigprocmask(SIG_SETMASK, &omask, NULL); #else sigsuspend(&sm_default); #endif #else j_sigchld(SIGCHLD); #endif if (fatal_trap) { int oldf = j->flags & (JF_WAITING|JF_W_ASYNCNOTIFY); j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY); runtraps(TF_FATAL); /* not reached... */ j->flags |= oldf; } if ((flags & JW_INTERRUPT) && (rv = trap_pending())) { j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY); return (-rv); } } j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY); if (j->flags & JF_FG) { j->flags &= ~JF_FG; #ifndef MKSH_UNEMPLOYED if (Flag(FMONITOR) && ttypgrp_ok && j->pgrp) { /* * Save the tty's current pgrp so it can be restored * when the job is foregrounded. This is to * deal with things like the GNU su which does * a fork/exec instead of an exec (the fork means * the execed shell gets a different pid from its * pgrp, so naturally it sets its pgrp and gets hosed * when it gets foregrounded by the parent shell which * has restored the tty's pgrp to that of the su * process). */ if (j->state == PSTOPPED && (j->saved_ttypgrp = tcgetpgrp(tty_fd)) >= 0) j->flags |= JF_SAVEDTTYPGRP; if (tcsetpgrp(tty_fd, kshpgrp) < 0) warningf(true, Tf_ldfailed, "j_waitj:", "tcsetpgrp", tty_fd, (long)kshpgrp, cstrerror(errno)); if (j->state == PSTOPPED) { j->flags |= JF_SAVEDTTY; mksh_tcget(tty_fd, &j->ttystat); } } #endif if (tty_hasstate) { /* * Only restore tty settings if job was originally * started in the foreground. Problems can be * caused by things like 'more foobar &' which will * typically get and save the shell's vi/emacs tty * settings before setting up the tty for itself; * when more exits, it restores the 'original' * settings, and things go down hill from there... */ if (j->state == PEXITED && j->status == 0 && (j->flags & JF_USETTYMODE)) { mksh_tcget(tty_fd, &tty_state); } else { mksh_tcset(tty_fd, &tty_state); /*- * Don't use tty mode if job is stopped and * later restarted and exits. Consider * the sequence: * vi foo (stopped) * ... * stty something * ... * fg (vi; ZZ) * mode should be that of the stty, not what * was before the vi started. */ if (j->state == PSTOPPED) j->flags &= ~JF_USETTYMODE; } } #ifndef MKSH_UNEMPLOYED /* * If it looks like user hit ^C to kill a job, pretend we got * one too to break out of for loops, etc. (AT&T ksh does this * even when not monitoring, but this doesn't make sense since * a tty generated ^C goes to the whole process group) */ if (Flag(FMONITOR) && j->state == PSIGNALLED && WIFSIGNALED(j->last_proc->status)) { int termsig; if ((termsig = WTERMSIG(j->last_proc->status)) > 0 && termsig < ksh_NSIG && (sigtraps[termsig].flags & TF_TTY_INTR)) trapsig(termsig); } #endif } j_usrtime = j->usrtime; j_systime = j->systime; rv = j->status; if (!(p = j->proc_list)) { ; /* nothing */ } else if (flags & JW_PIPEST) { uint32_t num = 0; struct tbl *vp; unset(vp_pipest, 1); vp = vp_pipest; vp->flag = DEFINED | ISSET | INTEGER | RDONLY | ARRAY | INT_U; goto got_array; while (p != NULL) { { struct tbl *vq; /* strlen(vp_pipest->name) == 10 */ vq = alloc(offsetof(struct tbl, name[0]) + 11, vp_pipest->areap); memset(vq, 0, offsetof(struct tbl, name[0])); memcpy(vq->name, vp_pipest->name, 11); vp->u.array = vq; vp = vq; } vp->areap = vp_pipest->areap; vp->ua.index = ++num; vp->flag = DEFINED | ISSET | INTEGER | RDONLY | ARRAY | INT_U | AINDEX; got_array: vp->val.i = proc_errorlevel(p); if (Flag(FPIPEFAIL) && vp->val.i) rv = vp->val.i; p = p->next; } } else if (Flag(FPIPEFAIL)) { do { const int i = proc_errorlevel(p); if (i) rv = i; } while ((p = p->next)); } if (!(flags & JW_ASYNCNOTIFY) #ifndef MKSH_UNEMPLOYED && (!Flag(FMONITOR) || j->state != PSTOPPED) #endif ) { j_print(j, JP_SHORT, shl_out); shf_flush(shl_out); } if (j->state != PSTOPPED #ifndef MKSH_UNEMPLOYED && (!Flag(FMONITOR) || !(flags & JW_ASYNCNOTIFY)) #endif ) remove_job(j, where); return (rv); } /* * SIGCHLD handler to reap children and update job states * * If jobs are compiled in then this routine expects sigchld to be blocked. */ /* ARGSUSED */ static void j_sigchld(int sig MKSH_A_UNUSED) { int saved_errno = errno; Job *j; Proc *p = NULL; pid_t pid; int status; struct rusage ru0, ru1; #ifdef MKSH_NO_SIGSUSPEND sigset_t omask; /* this handler can run while SIGCHLD is not blocked, so block it now */ sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); #endif #ifndef MKSH_NOPROSPECTOFWORK /* * Don't wait for any processes if a job is partially started. * This is so we don't do away with the process group leader * before all the processes in a pipe line are started (so the * setpgid() won't fail) */ for (j = job_list; j; j = j->next) if (j->ppid == procpid && !(j->flags & JF_STARTED)) { held_sigchld = 1; goto j_sigchld_out; } #endif getrusage(RUSAGE_CHILDREN, &ru0); do { #ifdef ADAPT_FOR_LITEOS_A pid = waitpid(-1, &status, WNOHANG); #else // ADAPT_FOR_LITEOS_A #ifndef MKSH_NOPROSPECTOFWORK pid = waitpid(-1, &status, (WNOHANG | #if defined(WCONTINUED) && defined(WIFCONTINUED) WCONTINUED | #endif WUNTRACED)); #else pid = wait(&status); #endif #endif // ADAPT_FOR_LITEOS_A /* * return if this would block (0) or no children * or interrupted (-1) */ if (pid <= 0) goto j_sigchld_out; getrusage(RUSAGE_CHILDREN, &ru1); /* find job and process structures for this pid */ for (j = job_list; j != NULL; j = j->next) for (p = j->proc_list; p != NULL; p = p->next) if (p->pid == pid) goto found; found: if (j == NULL) { /* Can occur if process has kids, then execs shell warningf(true, "bad process waited for (pid = %d)", pid); */ ru0 = ru1; continue; } timeradd(&j->usrtime, &ru1.ru_utime, &j->usrtime); timersub(&j->usrtime, &ru0.ru_utime, &j->usrtime); timeradd(&j->systime, &ru1.ru_stime, &j->systime); timersub(&j->systime, &ru0.ru_stime, &j->systime); ru0 = ru1; p->status = status; #ifndef MKSH_UNEMPLOYED if (WIFSTOPPED(status)) p->state = PSTOPPED; else #if defined(WCONTINUED) && defined(WIFCONTINUED) if (WIFCONTINUED(status)) { p->state = j->state = PRUNNING; /* skip check_job(), no-op in this case */ continue; } else #endif #endif if (WIFSIGNALED(status)) p->state = PSIGNALLED; else p->state = PEXITED; /* check to see if entire job is done */ check_job(j); } #ifndef MKSH_NOPROSPECTOFWORK while (/* CONSTCOND */ 1); #else while (/* CONSTCOND */ 0); #endif j_sigchld_out: #ifdef MKSH_NO_SIGSUSPEND sigprocmask(SIG_SETMASK, &omask, NULL); #endif errno = saved_errno; } /* * Called only when a process in j has exited/stopped (ie, called only * from j_sigchld()). If no processes are running, the job status * and state are updated, asynchronous job notification is done and, * if unneeded, the job is removed. * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static void check_job(Job *j) { int jstate; Proc *p; /* XXX debugging (nasty - interrupt routine using shl_out) */ if (!(j->flags & JF_STARTED)) { internal_warningf("check_job: job started (flags 0x%X)", (unsigned int)j->flags); return; } jstate = PRUNNING; for (p=j->proc_list; p != NULL; p = p->next) { if (p->state == PRUNNING) /* some processes still running */ return; if (p->state > jstate) jstate = p->state; } j->state = jstate; j->status = proc_errorlevel(j->last_proc); /* * Note when co-process dies: can't be done in j_wait() nor * remove_job() since neither may be called for non-interactive * shells. */ if (j->state == PEXITED || j->state == PSIGNALLED) { /* * No need to keep co-process input any more * (at least, this is what ksh93d thinks) */ if (coproc.job == j) { coproc.job = NULL; /* * XXX would be nice to get the closes out of here * so they aren't done in the signal handler. * Would mean a check in coproc_getfd() to * do "if job == 0 && write >= 0, close write". */ coproc_write_close(coproc.write); } /* Do we need to keep the output? */ if (j->coproc_id && j->coproc_id == coproc.id && --coproc.njobs == 0) coproc_readw_close(coproc.read); } j->flags |= JF_CHANGED; #ifndef MKSH_UNEMPLOYED if (Flag(FMONITOR) && !(j->flags & JF_XXCOM)) { /* * Only put stopped jobs at the front to avoid confusing * the user (don't want finished jobs effecting %+ or %-) */ if (j->state == PSTOPPED) put_job(j, PJ_ON_FRONT); if (Flag(FNOTIFY) && (j->flags & (JF_WAITING|JF_W_ASYNCNOTIFY)) != JF_WAITING) { /* Look for the real file descriptor 2 */ { struct env *ep; int fd = 2; for (ep = e; ep; ep = ep->oenv) if (ep->savefd && ep->savefd[2]) fd = ep->savefd[2]; shf_reopen(fd, SHF_WR, shl_j); } /* * Can't call j_notify() as it removes jobs. The job * must stay in the job list as j_waitj() may be * running with this job. */ j_print(j, JP_MEDIUM, shl_j); shf_flush(shl_j); if (!(j->flags & JF_WAITING) && j->state != PSTOPPED) remove_job(j, "notify"); } } #endif if ( #ifndef MKSH_UNEMPLOYED !Flag(FMONITOR) && #endif !(j->flags & (JF_WAITING|JF_FG)) && j->state != PSTOPPED) { if (j == async_job || (j->flags & JF_KNOWN)) { j->flags |= JF_ZOMBIE; j->job = -1; nzombie++; } else remove_job(j, "checkjob"); } } /* * Print job status in either short, medium or long format. * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static void j_print(Job *j, int how, struct shf *shf) { Proc *p; int state; int status; #ifdef WCOREDUMP bool coredumped; #endif char jobchar = ' '; char buf[64]; const char *filler; int output = 0; if (how == JP_PGRP) { /* * POSIX doesn't say what to do it there is no process * group leader (ie, !FMONITOR). We arbitrarily return * last pid (which is what $! returns). */ shf_fprintf(shf, Tf_dN, (int)(j->pgrp ? j->pgrp : (j->last_proc ? j->last_proc->pid : 0))); return; } j->flags &= ~JF_CHANGED; filler = j->job > 10 ? "\n " : "\n "; if (j == job_list) jobchar = '+'; else if (j == job_list->next) jobchar = '-'; for (p = j->proc_list; p != NULL;) { #ifdef WCOREDUMP coredumped = false; #endif switch (p->state) { case PRUNNING: memcpy(buf, "Running", 8); break; case PSTOPPED: { int stopsig = WSTOPSIG(p->status); strlcpy(buf, stopsig > 0 && stopsig < ksh_NSIG ? sigtraps[stopsig].mess : "Stopped", sizeof(buf)); break; } case PEXITED: { int exitstatus = (WEXITSTATUS(p->status)) & 255; if (how == JP_SHORT) buf[0] = '\0'; else if (exitstatus == 0) memcpy(buf, "Done", 5); else shf_snprintf(buf, sizeof(buf), "Done (%d)", exitstatus); break; } case PSIGNALLED: { int termsig = WTERMSIG(p->status); #ifdef WCOREDUMP if (WCOREDUMP(p->status)) coredumped = true; #endif /* * kludge for not reporting 'normal termination * signals' (i.e. SIGINT, SIGPIPE) */ if (how == JP_SHORT && #ifdef WCOREDUMP !coredumped && #endif (termsig == SIGINT || termsig == SIGPIPE)) { buf[0] = '\0'; } else strlcpy(buf, termsig > 0 && termsig < ksh_NSIG ? sigtraps[termsig].mess : "Signalled", sizeof(buf)); break; } default: buf[0] = '\0'; } if (how != JP_SHORT) { if (p == j->proc_list) shf_fprintf(shf, "[%d] %c ", j->job, jobchar); else shf_puts(filler, shf); } if (how == JP_LONG) shf_fprintf(shf, "%5d ", (int)p->pid); if (how == JP_SHORT) { if (buf[0]) { output = 1; #ifdef WCOREDUMP shf_fprintf(shf, "%s%s ", buf, coredumped ? " (core dumped)" : null); #else shf_puts(buf, shf); shf_putchar(' ', shf); #endif } } else { output = 1; shf_fprintf(shf, "%-20s %s%s%s", buf, p->command, p->next ? "|" : null, #ifdef WCOREDUMP coredumped ? " (core dumped)" : #endif null); } state = p->state; status = p->status; p = p->next; while (p && p->state == state && p->status == status) { if (how == JP_LONG) shf_fprintf(shf, "%s%5d %-20s %s%s", filler, (int)p->pid, T1space, p->command, p->next ? "|" : null); else if (how == JP_MEDIUM) shf_fprintf(shf, Tf__ss, p->command, p->next ? "|" : null); p = p->next; } } if (output) shf_putc('\n', shf); } /* * Convert % sequence to job * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static Job * j_lookup(const char *cp, int *ecodep) { Job *j, *last_match; Proc *p; size_t len; int job = 0; if (ctype(*cp, C_DIGIT) && getn(cp, &job)) { /* Look for last_proc->pid (what $! returns) first... */ for (j = job_list; j != NULL; j = j->next) if (j->last_proc && j->last_proc->pid == job) return (j); /* * ...then look for process group (this is non-POSIX, * but should not break anything */ for (j = job_list; j != NULL; j = j->next) if (j->pgrp && j->pgrp == job) return (j); goto j_lookup_nosuch; } if (*cp != '%') { j_lookup_invalid: if (ecodep) *ecodep = JL_INVALID; return (NULL); } switch (*++cp) { case '\0': /* non-standard */ case '+': case '%': if (job_list != NULL) return (job_list); break; case '-': if (job_list != NULL && job_list->next) return (job_list->next); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (!getn(cp, &job)) goto j_lookup_invalid; for (j = job_list; j != NULL; j = j->next) if (j->job == job) return (j); break; /* %?string */ case '?': last_match = NULL; for (j = job_list; j != NULL; j = j->next) for (p = j->proc_list; p != NULL; p = p->next) if (strstr(p->command, cp+1) != NULL) { if (last_match) { if (ecodep) *ecodep = JL_AMBIG; return (NULL); } last_match = j; } if (last_match) return (last_match); break; /* %string */ default: len = strlen(cp); last_match = NULL; for (j = job_list; j != NULL; j = j->next) if (strncmp(cp, j->proc_list->command, len) == 0) { if (last_match) { if (ecodep) *ecodep = JL_AMBIG; return (NULL); } last_match = j; } if (last_match) return (last_match); break; } j_lookup_nosuch: if (ecodep) *ecodep = JL_NOSUCH; return (NULL); } static Job *free_jobs; static Proc *free_procs; /* * allocate a new job and fill in the job number. * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static Job * new_job(void) { int i; Job *newj, *j; if (free_jobs != NULL) { newj = free_jobs; free_jobs = free_jobs->next; } else { char *cp; /* * struct job includes ALLOC_ITEM for alignment constraints * so first get the actually used memory, then assign it */ cp = alloc(sizeof(Job) - sizeof(ALLOC_ITEM), APERM); /* undo what alloc() did to the malloc result address */ newj = (void *)(cp - sizeof(ALLOC_ITEM)); } /* brute force method */ i = 0; do { ++i; j = job_list; while (j && j->job != i) j = j->next; } while (j); newj->job = i; return (newj); } /* * Allocate new process struct * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static Proc * new_proc(void) { Proc *p; if (free_procs != NULL) { p = free_procs; free_procs = free_procs->next; } else p = alloc(sizeof(Proc), APERM); return (p); } /* * Take job out of job_list and put old structures into free list. * Keeps nzombies, last_job and async_job up to date. * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static void remove_job(Job *j, const char *where) { Proc *p, *tmp; Job **prev, *curr; prev = &job_list; curr = job_list; while (curr && curr != j) { prev = &curr->next; curr = *prev; } if (curr != j) { internal_warningf("remove_job: job %s (%s)", Tnot_found, where); return; } *prev = curr->next; /* free up proc structures */ for (p = j->proc_list; p != NULL; ) { tmp = p; p = p->next; tmp->next = free_procs; free_procs = tmp; } if ((j->flags & JF_ZOMBIE) && j->ppid == procpid) --nzombie; j->next = free_jobs; free_jobs = j; if (j == last_job) last_job = NULL; if (j == async_job) async_job = NULL; } /* * put j in a particular location (taking it out job_list if it is there * already) * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static void put_job(Job *j, int where) { Job **prev, *curr; /* Remove job from list (if there) */ prev = &job_list; curr = job_list; while (curr && curr != j) { prev = &curr->next; curr = *prev; } if (curr == j) *prev = curr->next; switch (where) { case PJ_ON_FRONT: j->next = job_list; job_list = j; break; case PJ_PAST_STOPPED: prev = &job_list; curr = job_list; for (; curr && curr->state == PSTOPPED; prev = &curr->next, curr = *prev) ; j->next = curr; *prev = j; break; } } /* * nuke a job (called when unable to start full job). * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static int kill_job(Job *j, int sig) { Proc *p; int rval = 0; for (p = j->proc_list; p != NULL; p = p->next) if (p->pid != 0) if (kill(p->pid, sig) < 0) rval = -1; return (rval); } static void tty_init_talking(void) { switch (tty_init_fd()) { case 0: break; case 1: #ifndef MKSH_DISABLE_TTY_WARNING warningf(false, Tf_sD_s_sD_s, "No controlling tty", Topen, T_devtty, cstrerror(errno)); #endif break; case 2: #ifndef MKSH_DISABLE_TTY_WARNING warningf(false, Tf_s_sD_s, Tcant_find, Ttty_fd, cstrerror(errno)); #endif break; case 3: warningf(false, Tf_ssfaileds, "j_ttyinit", Ttty_fd_dupof, cstrerror(errno)); break; case 4: warningf(false, Tf_sD_sD_s, "j_ttyinit", "can't set close-on-exec flag", cstrerror(errno)); break; } } static void tty_init_state(void) { if (tty_fd >= 0) { mksh_tcget(tty_fd, &tty_state); tty_hasstate = true; } }