Import tcsh-6.17.00
[dragonfly.git] / contrib / tcsh-6 / sh.proc.c
CommitLineData
57e3f2b5 1/* $Header: /p/tcsh/cvsroot/tcsh/sh.proc.c,v 3.109 2009/06/25 21:15:37 christos Exp $ */
7d8fb588
MS
2/*
3 * sh.proc.c: Job manipulations
4 */
5/*-
6 * Copyright (c) 1980, 1991 The Regents of the University of California.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33#include "sh.h"
34
57e3f2b5 35RCSID("$tcsh: sh.proc.c,v 3.109 2009/06/25 21:15:37 christos Exp $")
7d8fb588
MS
36
37#include "ed.h"
38#include "tc.h"
39#include "tc.wait.h"
40
41#ifdef WINNT_NATIVE
42#undef POSIX
43#define POSIX
44#endif /* WINNT_NATIVE */
45#ifdef aiws
46# undef HZ
47# define HZ 16
48#endif /* aiws */
49
50#if defined(_BSD) || (defined(IRIS4D) && __STDC__) || defined(__lucid) || defined(linux) || defined(__GNU__) || defined(__GLIBC__)
51# define BSDWAIT
52#endif /* _BSD || (IRIS4D && __STDC__) || __lucid || glibc */
53#ifndef WTERMSIG
54# define WTERMSIG(w) (((union wait *) &(w))->w_termsig)
55# ifndef BSDWAIT
56# define BSDWAIT
57# endif /* !BSDWAIT */
58#endif /* !WTERMSIG */
59#ifndef WEXITSTATUS
60# define WEXITSTATUS(w) (((union wait *) &(w))->w_retcode)
61#endif /* !WEXITSTATUS */
62#ifndef WSTOPSIG
63# define WSTOPSIG(w) (((union wait *) &(w))->w_stopsig)
64#endif /* !WSTOPSIG */
65
66#ifdef __osf__
67# ifndef WCOREDUMP
68# define WCOREDUMP(x) (_W_INT(x) & WCOREFLAG)
69# endif
70#endif
71
72#ifndef WCOREDUMP
73# ifdef BSDWAIT
74# define WCOREDUMP(w) (((union wait *) &(w))->w_coredump)
75# else /* !BSDWAIT */
76# define WCOREDUMP(w) ((w) & 0200)
77# endif /* !BSDWAIT */
78#endif /* !WCOREDUMP */
79
80#ifndef JOBDEBUG
81# define jobdebug_xprintf(x) (void)0
82# define jobdebug_flush() (void)0
83#else
84# define jobdebug_xprintf(s) xprintf s
85# define jobdebug_flush() flush()
86#endif
87
88/*
89 * C Shell - functions that manage processes, handling hanging, termination
90 */
91
92#define BIGINDEX 9 /* largest desirable job index */
93
94#ifdef BSDTIMES
95# ifdef convex
96/* use 'cvxrusage' to get parallel statistics */
97static struct cvxrusage zru = {{0L, 0L}, {0L, 0L}, 0L, 0L, 0L, 0L,
98 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L,
99 {0L, 0L}, 0LL, 0LL, 0LL, 0LL, 0L, 0L, 0L,
100 0LL, 0LL, {0L, 0L, 0L, 0L, 0L}};
101# else
102static struct rusage zru;
103# endif /* convex */
104#else /* !BSDTIMES */
105# ifdef _SEQUENT_
106static struct process_stats zru = {{0L, 0L}, {0L, 0L}, 0, 0, 0, 0, 0, 0, 0,
107 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
108# else /* !_SEQUENT_ */
109# ifdef _SX
110static struct tms zru = {0, 0, 0, 0}, lru = {0, 0, 0, 0};
111# else /* !_SX */
112static struct tms zru = {0L, 0L, 0L, 0L}, lru = {0L, 0L, 0L, 0L};
113# endif /* !_SX */
114# endif /* !_SEQUENT_ */
115#endif /* !BSDTIMES */
116
117#ifndef BSDTIMES
118static int timesdone; /* shtimes buffer full ? */
119#endif /* BSDTIMES */
120
121#ifndef RUSAGE_CHILDREN
122# define RUSAGE_CHILDREN -1
123#endif /* RUSAGE_CHILDREN */
124
125static void pflushall (void);
126static void pflush (struct process *);
127static void pfree (struct process *);
128static void pclrcurr (struct process *);
57e3f2b5 129static void morecommand (size_t);
7d8fb588
MS
130static void padd (struct command *);
131static int pprint (struct process *, int);
132static void ptprint (struct process *);
133static void pads (Char *);
134static void pkill (Char **, int);
135static struct process *pgetcurr (struct process *);
136static void okpcntl (void);
137static void setttypgrp (int);
138
139/*
140 * pchild - call queued by the SIGCHLD signal
141 * indicating that at least one child has terminated or stopped
142 * thus at least one wait system call will definitely return a
143 * childs status. Top level routines (like pwait) must be sure
144 * to mask interrupts when playing with the proclist data structures!
145 */
146void
147pchild(void)
148{
149 struct process *pp;
150 struct process *fp;
151 pid_t pid;
152#ifdef BSDWAIT
153 union wait w;
154#else /* !BSDWAIT */
155 int w;
156#endif /* !BSDWAIT */
157 int jobflags;
158#ifdef BSDTIMES
159 struct sysrusage ru;
160#else /* !BSDTIMES */
161# ifdef _SEQUENT_
162 struct process_stats ru;
163 struct process_stats cpst1, cpst2;
164 timeval_t tv;
165# else /* !_SEQUENT_ */
166 struct tms proctimes;
167
168 if (!timesdone) {
169 timesdone++;
170 (void) times(&shtimes);
171 }
172# endif /* !_SEQUENT_ */
173#endif /* !BSDTIMES */
174
175 jobdebug_xprintf(("pchild()\n"));
176
177loop:
178 jobdebug_xprintf(("Waiting...\n"));
179 jobdebug_flush();
180 errno = 0; /* reset, just in case */
181
182#ifndef WINNT_NATIVE
183# ifdef BSDJOBS
184# ifdef BSDTIMES
185# ifdef convex
186 /* use 'cvxwait' to get parallel statistics */
187 pid = cvxwait(&w,
188 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), &ru);
189# else
190 /* both a wait3 and rusage */
191# if !defined(BSDWAIT) || defined(NeXT) || defined(MACH) || defined(linux) || defined(__GNU__) || defined(__GLIBC__) || (defined(IRIS4D) && SYSVREL <= 3) || defined(__lucid) || defined(__osf__)
192 pid = wait3(&w,
193 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), &ru);
194# else /* BSDWAIT */
195 pid = wait3(&w.w_status,
196 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), &ru);
197# endif /* BSDWAIT */
198# endif /* convex */
199# else /* !BSDTIMES */
200# ifdef _SEQUENT_
201 (void) get_process_stats(&tv, PS_SELF, 0, &cpst1);
202 pid = waitpid(-1, &w,
203 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG));
204 (void) get_process_stats(&tv, PS_SELF, 0, &cpst2);
205 pr_stat_sub(&cpst2, &cpst1, &ru);
206# else /* !_SEQUENT_ */
207# ifndef POSIX
208 /* we have a wait3, but no rusage stuff */
209 pid = wait3(&w.w_status,
210 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), 0);
211# else /* POSIX */
212 pid = waitpid(-1, &w,
213 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG));
214# endif /* POSIX */
215# endif /* !_SEQUENT_ */
216# endif /* !BSDTIMES */
217# else /* !BSDJOBS */
218# ifdef BSDTIMES
219# define HAVEwait3
220 /* both a wait3 and rusage */
221# ifdef hpux
222 pid = wait3(&w.w_status, WNOHANG, 0);
223# else /* !hpux */
224 pid = wait3(&w.w_status, WNOHANG, &ru);
225# endif /* !hpux */
226# else /* !BSDTIMES */
227# ifdef ODT /* For Sco Unix 3.2.0 or ODT 1.0 */
228# define HAVEwait3
229 pid = waitpid(-1, &w,
230 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG));
231# endif /* ODT */
232# if defined(aiws) || defined(uts)
233# define HAVEwait3
234 pid = wait3(&w.w_status,
235 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), 0);
236# endif /* aiws || uts */
237# ifndef HAVEwait3
238# ifndef BSDWAIT
239 /* no wait3, therefore no rusage */
240 /* on Sys V, this may hang. I hope it's not going to be a problem */
241 pid = wait(&w);
242# else /* BSDWAIT */
243 /*
244 * XXX: for greater than 3 we should use waitpid().
245 * but then again, SVR4 falls into the POSIX/BSDJOBS category.
246 */
247 pid = wait(&w.w_status);
248# endif /* BSDWAIT */
249# endif /* !HAVEwait3 */
250# endif /* !BSDTIMES */
251# endif /* !BSDJOBS */
252#else /* WINNT_NATIVE */
253 pid = waitpid(-1, &w,
254 (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG));
255#endif /* WINNT_NATIVE */
256
257 jobdebug_xprintf(("parent %d pid %d, retval %x termsig %x retcode %x\n",
258 (int)getpid(), (int)pid, w, WTERMSIG(w),
259 WEXITSTATUS(w)));
260 jobdebug_flush();
261
262 if ((pid == 0) || (pid == -1)) {
263 handle_pending_signals();
264 jobdebug_xprintf(("errno == %d\n", errno));
265 if (errno == EINTR)
266 goto loop;
267 goto end;
268 }
269 for (pp = proclist.p_next; pp != NULL; pp = pp->p_next)
270 if (pid == pp->p_procid)
271 goto found;
272#if !defined(BSDJOBS) && !defined(WINNT_NATIVE)
273 /* this should never have happened */
274 stderror(ERR_SYNC, pid);
275 xexit(0);
276#else /* BSDJOBS || WINNT_NATIVE */
277 goto loop;
278#endif /* !BSDJOBS && !WINNT_NATIVE */
279found:
280 pp->p_flags &= ~(PRUNNING | PSTOPPED | PREPORTED);
281 if (WIFSTOPPED(w)) {
282 pp->p_flags |= PSTOPPED;
283 pp->p_reason = WSTOPSIG(w);
284 }
285 else {
286 if (pp->p_flags & (PTIME | PPTIME) || adrof(STRtime))
287#ifndef BSDTIMES
288# ifdef _SEQUENT_
289 (void) get_process_stats(&pp->p_etime, PS_SELF, NULL, NULL);
290# else /* !_SEQUENT_ */
291 pp->p_etime = times(&proctimes);
292# endif /* !_SEQUENT_ */
293#else /* BSDTIMES */
294 (void) gettimeofday(&pp->p_etime, NULL);
295#endif /* BSDTIMES */
296
297
298#if defined(BSDTIMES) || defined(_SEQUENT_)
299 pp->p_rusage = ru;
300#else /* !BSDTIMES && !_SEQUENT_ */
301 (void) times(&proctimes);
302 pp->p_utime = proctimes.tms_cutime - shtimes.tms_cutime;
303 pp->p_stime = proctimes.tms_cstime - shtimes.tms_cstime;
304 shtimes = proctimes;
305#endif /* !BSDTIMES && !_SEQUENT_ */
306 if (WIFSIGNALED(w)) {
307 if (WTERMSIG(w) == SIGINT)
308 pp->p_flags |= PINTERRUPTED;
309 else
310 pp->p_flags |= PSIGNALED;
311 if (WCOREDUMP(w))
312 pp->p_flags |= PDUMPED;
313 pp->p_reason = WTERMSIG(w);
314 }
315 else {
316 pp->p_reason = WEXITSTATUS(w);
317 if (pp->p_reason != 0)
318 pp->p_flags |= PAEXITED;
319 else
320 pp->p_flags |= PNEXITED;
321 }
322 }
323 jobflags = 0;
324 fp = pp;
325 do {
326 if ((fp->p_flags & (PPTIME | PRUNNING | PSTOPPED)) == 0 &&
327 !child && adrof(STRtime) &&
328#ifdef BSDTIMES
329 fp->p_rusage.ru_utime.tv_sec + fp->p_rusage.ru_stime.tv_sec
330#else /* !BSDTIMES */
331# ifdef _SEQUENT_
332 fp->p_rusage.ps_utime.tv_sec + fp->p_rusage.ps_stime.tv_sec
333# else /* !_SEQUENT_ */
334# ifndef POSIX
335 (fp->p_utime + fp->p_stime) / HZ
336# else /* POSIX */
337 (fp->p_utime + fp->p_stime) / clk_tck
338# endif /* POSIX */
339# endif /* !_SEQUENT_ */
340#endif /* !BSDTIMES */
341 >= atoi(short2str(varval(STRtime))))
342 fp->p_flags |= PTIME;
343 jobflags |= fp->p_flags;
344 } while ((fp = fp->p_friends) != pp);
345 pp->p_flags &= ~PFOREGND;
346 if (pp == pp->p_friends && (pp->p_flags & PPTIME)) {
347 pp->p_flags &= ~PPTIME;
348 pp->p_flags |= PTIME;
349 }
350 if ((jobflags & (PRUNNING | PREPORTED)) == 0) {
351 fp = pp;
352 do {
353 if (fp->p_flags & PSTOPPED)
354 fp->p_flags |= PREPORTED;
355 } while ((fp = fp->p_friends) != pp);
356 while (fp->p_procid != fp->p_jobid)
357 fp = fp->p_friends;
358 if (jobflags & PSTOPPED) {
359 if (pcurrent && pcurrent != fp)
360 pprevious = pcurrent;
361 pcurrent = fp;
362 }
363 else
364 pclrcurr(fp);
365 if (jobflags & PFOREGND) {
366 if (!(jobflags & (PSIGNALED | PSTOPPED | PPTIME) ||
367#ifdef notdef
368 jobflags & PAEXITED ||
369#endif /* notdef */
370 !eq(dcwd->di_name, fp->p_cwd->di_name))) {
371 /* PWP: print a newline after ^C */
372 if (jobflags & PINTERRUPTED) {
373 xputchar('\r' | QUOTE);
374 xputchar('\n');
375 }
376#ifdef notdef
377 else if ((jobflags & (PTIME|PSTOPPED)) == PTIME)
378 ptprint(fp);
379#endif /* notdef */
380 }
381 }
382 else {
383 if (jobflags & PNOTIFY || adrof(STRnotify)) {
384 xputchar('\r' | QUOTE);
385 xputchar('\n');
386 (void) pprint(pp, NUMBER | NAME | REASON);
387 if ((jobflags & PSTOPPED) == 0)
388 pflush(pp);
389 if (GettingInput) {
390 errno = 0;
391 (void) Rawmode();
392#ifdef notdef
393 /*
394 * don't really want to do that, because it
395 * will erase our message in case of multi-line
396 * input
397 */
398 ClearLines();
399#endif /* notdef */
400 ClearDisp();
401 Refresh();
402 }
403 }
404 else {
405 fp->p_flags |= PNEEDNOTE;
406 neednote = 1;
407 }
408 }
409 }
410#if defined(BSDJOBS) || defined(HAVEwait3) ||defined(WINNT_NATIVE)
411 goto loop;
412#endif /* BSDJOBS || HAVEwait3 */
413 end:
414 ;
415}
416
417void
418pnote(void)
419{
420 struct process *pp;
421 int flags;
422
423 neednote = 0;
424 for (pp = proclist.p_next; pp != NULL; pp = pp->p_next) {
425 if (pp->p_flags & PNEEDNOTE) {
426 pchild_disabled++;
427 cleanup_push(&pchild_disabled, disabled_cleanup);
428 pp->p_flags &= ~PNEEDNOTE;
429 flags = pprint(pp, NUMBER | NAME | REASON);
430 if ((flags & (PRUNNING | PSTOPPED)) == 0)
431 pflush(pp);
432 cleanup_until(&pchild_disabled);
433 }
434 }
435}
436
437
438static void
439pfree(struct process *pp)
440{
441 xfree(pp->p_command);
442 if (pp->p_cwd && --pp->p_cwd->di_count == 0)
443 if (pp->p_cwd->di_next == 0)
444 dfree(pp->p_cwd);
445 xfree(pp);
446}
447
448
449/*
450 * pwait - wait for current job to terminate, maintaining integrity
451 * of current and previous job indicators.
452 */
453void
454pwait(void)
455{
456 struct process *fp, *pp;
457
458 /*
459 * Here's where dead procs get flushed.
460 */
461 for (pp = (fp = &proclist)->p_next; pp != NULL; pp = (fp = pp)->p_next)
462 if (pp->p_procid == 0) {
463 fp->p_next = pp->p_next;
464 pfree(pp);
465 pp = fp;
466 }
467 pjwait(pcurrjob);
468}
469
470
471/*
472 * pjwait - wait for a job to finish or become stopped
473 * It is assumed to be in the foreground state (PFOREGND)
474 */
475void
476pjwait(struct process *pp)
477{
478 struct process *fp;
479 int jobflags, reason;
480 sigset_t oset, set, pause_mask;
481 Char *reason_str;
482
483 while (pp->p_procid != pp->p_jobid)
484 pp = pp->p_friends;
485 fp = pp;
486
487 do {
488 if ((fp->p_flags & (PFOREGND | PRUNNING)) == PRUNNING)
57e3f2b5 489 xprintf("%s", CGETS(17, 1, "BUG: waiting for background job!\n"));
7d8fb588
MS
490 } while ((fp = fp->p_friends) != pp);
491 /*
492 * Now keep pausing as long as we are not interrupted (SIGINT), and the
493 * target process, or any of its friends, are running
494 */
495 fp = pp;
496 sigemptyset(&set);
497 sigaddset(&set, SIGINT);
498 sigaddset(&set, SIGCHLD);
499 (void)sigprocmask(SIG_BLOCK, &set, &oset);
500 cleanup_push(&oset, sigprocmask_cleanup);
501 pause_mask = oset;
502 sigdelset(&pause_mask, SIGCHLD);
503 for (;;) {
504 handle_pending_signals();
505 jobflags = 0;
506 do
507 jobflags |= fp->p_flags;
508 while ((fp = (fp->p_friends)) != pp);
509 if ((jobflags & PRUNNING) == 0)
510 break;
511 jobdebug_xprintf(("%d starting to sigsuspend for SIGCHLD on %d\n",
512 getpid(), fp->p_procid));
513 sigsuspend(&pause_mask);
514 }
515 cleanup_until(&oset);
516 jobdebug_xprintf(("%d returned from sigsuspend loop\n", getpid()));
517#ifdef BSDJOBS
518 if (tpgrp > 0) /* get tty back */
519 (void) tcsetpgrp(FSHTTY, tpgrp);
520#endif /* BSDJOBS */
521 if ((jobflags & (PSIGNALED | PSTOPPED | PTIME)) ||
57e3f2b5 522 fp->p_cwd == NULL || !eq(dcwd->di_name, fp->p_cwd->di_name)) {
7d8fb588
MS
523 if (jobflags & PSTOPPED) {
524 xputchar('\n');
525 if (adrof(STRlistjobs)) {
526 Char *jobcommand[3];
527
528 jobcommand[0] = STRjobs;
529 if (eq(varval(STRlistjobs), STRlong))
530 jobcommand[1] = STRml;
531 else
532 jobcommand[1] = NULL;
533 jobcommand[2] = NULL;
534
535 dojobs(jobcommand, NULL);
536 (void) pprint(pp, SHELLDIR);
537 }
538 else
539 (void) pprint(pp, AREASON | SHELLDIR);
540 }
541 else
542 (void) pprint(pp, AREASON | SHELLDIR);
543 }
544 if ((jobflags & (PINTERRUPTED | PSTOPPED)) && setintr &&
545 (!gointr || !eq(gointr, STRminus))) {
546 if ((jobflags & PSTOPPED) == 0)
547 pflush(pp);
548 pintr1(0);
549 /* NOTREACHED */
550 }
551 reason = 0;
552 fp = pp;
553 do {
554 if (fp->p_reason)
555 reason = fp->p_flags & (PSIGNALED | PINTERRUPTED) ?
556 fp->p_reason | META : fp->p_reason;
557 } while ((fp = fp->p_friends) != pp);
558 /*
559 * Don't report on backquoted jobs, cause it will mess up
560 * their output.
561 */
562 if ((reason != 0) && (adrof(STRprintexitvalue)) &&
563 (pp->p_flags & PBACKQ) == 0)
564 xprintf(CGETS(17, 2, "Exit %d\n"), reason);
565 reason_str = putn(reason);
566 cleanup_push(reason_str, xfree);
567 setv(STRstatus, reason_str, VAR_READWRITE);
568 cleanup_ignore(reason_str);
569 cleanup_until(reason_str);
570 if (reason && exiterr)
571 exitstat();
572 pflush(pp);
573}
574
575/*
576 * dowait - wait for all processes to finish
577 */
578
579/*ARGSUSED*/
580void
581dowait(Char **v, struct command *c)
582{
583 struct process *pp;
584 sigset_t pause_mask;
585
586 USE(c);
587 USE(v);
588 pjobs++;
589 sigprocmask(SIG_BLOCK, NULL, &pause_mask);
590 sigdelset(&pause_mask, SIGCHLD);
591 if (setintr)
592 sigdelset(&pause_mask, SIGINT);
593loop:
594 for (pp = proclist.p_next; pp; pp = pp->p_next)
595 if (pp->p_procid && /* pp->p_procid == pp->p_jobid && */
596 pp->p_flags & PRUNNING) {
597 handle_pending_signals();
598 sigsuspend(&pause_mask);
599 handle_pending_signals();
600 goto loop;
601 }
602 pjobs = 0;
603}
604
605/*
606 * pflushall - flush all jobs from list (e.g. at fork())
607 */
608static void
609pflushall(void)
610{
611 struct process *pp;
612
613 for (pp = proclist.p_next; pp != NULL; pp = pp->p_next)
614 if (pp->p_procid)
615 pflush(pp);
616}
617
618/*
619 * pflush - flag all process structures in the same job as the
620 * the argument process for deletion. The actual free of the
621 * space is not done here since pflush is called at interrupt level.
622 */
623static void
624pflush(struct process *pp)
625{
626 struct process *np;
627 int idx;
628
629 if (pp->p_procid == 0) {
57e3f2b5 630 xprintf("%s", CGETS(17, 3, "BUG: process flushed twice"));
7d8fb588
MS
631 return;
632 }
633 while (pp->p_procid != pp->p_jobid)
634 pp = pp->p_friends;
635 pclrcurr(pp);
636 if (pp == pcurrjob)
637 pcurrjob = 0;
638 idx = pp->p_index;
639 np = pp;
640 do {
641 np->p_index = np->p_procid = 0;
642 np->p_flags &= ~PNEEDNOTE;
643 } while ((np = np->p_friends) != pp);
644 if (idx == pmaxindex) {
645 for (np = proclist.p_next, idx = 0; np; np = np->p_next)
646 if (np->p_index > idx)
647 idx = np->p_index;
648 pmaxindex = idx;
649 }
650}
651
652/*
653 * pclrcurr - make sure the given job is not the current or previous job;
654 * pp MUST be the job leader
655 */
656static void
657pclrcurr(struct process *pp)
658{
659 if (pp == pcurrent) {
660 if (pprevious != NULL) {
661 pcurrent = pprevious;
662 pprevious = pgetcurr(pp);
663 }
664 else {
665 pcurrent = pgetcurr(pp);
666 pprevious = pgetcurr(pp);
667 }
668 }
669 else if (pp == pprevious)
670 pprevious = pgetcurr(pp);
671}
672
673/* +4 here is 1 for '\0', 1 ea for << >& >> */
57e3f2b5
SS
674static Char *cmdstr;
675static size_t cmdmax;
7d8fb588
MS
676static size_t cmdlen;
677static Char *cmdp;
57e3f2b5
SS
678#define CMD_INIT 1024
679#define CMD_INCR 64
680
681static void
682morecommand(size_t s)
683{
684 Char *ncmdstr;
685 ptrdiff_t d;
686
687 cmdmax += s;
688 ncmdstr = xrealloc(cmdstr, cmdmax * sizeof(*cmdstr));
689 d = ncmdstr - cmdstr;
690 cmdstr = ncmdstr;
691 cmdp += d;
692}
7d8fb588
MS
693
694/* GrP
695 * unparse - Export padd() functionality
696 */
697Char *
698unparse(struct command *t)
699{
57e3f2b5
SS
700 if (cmdmax == 0)
701 morecommand(CMD_INIT);
702 cmdp = cmdstr;
7d8fb588
MS
703 cmdlen = 0;
704 padd(t);
705 *cmdp++ = '\0';
57e3f2b5 706 return Strsave(cmdstr);
7d8fb588
MS
707}
708
709
710/*
711 * palloc - allocate a process structure and fill it up.
712 * an important assumption is made that the process is running.
713 */
714void
715palloc(pid_t pid, struct command *t)
716{
717 struct process *pp;
718 int i;
719
720 pp = xcalloc(1, sizeof(struct process));
721 pp->p_procid = pid;
722 pp->p_flags = ((t->t_dflg & F_AMPERSAND) ? 0 : PFOREGND) | PRUNNING;
723 if (t->t_dflg & F_TIME)
724 pp->p_flags |= PPTIME;
725 if (t->t_dflg & F_BACKQ)
726 pp->p_flags |= PBACKQ;
727 if (t->t_dflg & F_HUP)
728 pp->p_flags |= PHUP;
57e3f2b5
SS
729 if (cmdmax == 0)
730 morecommand(CMD_INIT);
731 cmdp = cmdstr;
7d8fb588
MS
732 cmdlen = 0;
733 padd(t);
734 *cmdp++ = 0;
735 if (t->t_dflg & F_PIPEOUT) {
736 pp->p_flags |= PPOU;
737 if (t->t_dflg & F_STDERR)
738 pp->p_flags |= PDIAG;
739 }
57e3f2b5 740 pp->p_command = Strsave(cmdstr);
7d8fb588
MS
741 if (pcurrjob) {
742 struct process *fp;
743
744 /* careful here with interrupt level */
745 pp->p_cwd = 0;
746 pp->p_index = pcurrjob->p_index;
747 pp->p_friends = pcurrjob;
748 pp->p_jobid = pcurrjob->p_procid;
749 for (fp = pcurrjob; fp->p_friends != pcurrjob; fp = fp->p_friends)
750 continue;
751 fp->p_friends = pp;
752 }
753 else {
754 pcurrjob = pp;
755 pp->p_jobid = pid;
756 pp->p_friends = pp;
757 pp->p_cwd = dcwd;
758 dcwd->di_count++;
759 if (pmaxindex < BIGINDEX)
760 pp->p_index = ++pmaxindex;
761 else {
762 struct process *np;
763
764 for (i = 1;; i++) {
765 for (np = proclist.p_next; np; np = np->p_next)
766 if (np->p_index == i)
767 goto tryagain;
768 pp->p_index = i;
769 if (i > pmaxindex)
770 pmaxindex = i;
771 break;
772 tryagain:;
773 }
774 }
775 if (pcurrent == NULL)
776 pcurrent = pp;
777 else if (pprevious == NULL)
778 pprevious = pp;
779 }
780 pp->p_next = proclist.p_next;
781 proclist.p_next = pp;
782#ifdef BSDTIMES
783 (void) gettimeofday(&pp->p_btime, NULL);
784#else /* !BSDTIMES */
785# ifdef _SEQUENT_
786 (void) get_process_stats(&pp->p_btime, PS_SELF, NULL, NULL);
787# else /* !_SEQUENT_ */
788 {
789 struct tms tmptimes;
790
791 pp->p_btime = times(&tmptimes);
792 }
793# endif /* !_SEQUENT_ */
794#endif /* !BSDTIMES */
795}
796
797static void
798padd(struct command *t)
799{
800 Char **argp;
801
802 if (t == 0)
803 return;
804 switch (t->t_dtyp) {
805
806 case NODE_PAREN:
807 pads(STRLparensp);
808 padd(t->t_dspr);
809 pads(STRspRparen);
810 break;
811
812 case NODE_COMMAND:
813 for (argp = t->t_dcom; *argp; argp++) {
814 pads(*argp);
815 if (argp[1])
816 pads(STRspace);
817 }
818 break;
819
820 case NODE_OR:
821 case NODE_AND:
822 case NODE_PIPE:
823 case NODE_LIST:
824 padd(t->t_dcar);
825 switch (t->t_dtyp) {
826 case NODE_OR:
827 pads(STRspor2sp);
828 break;
829 case NODE_AND:
830 pads(STRspand2sp);
831 break;
832 case NODE_PIPE:
833 pads(STRsporsp);
834 break;
835 case NODE_LIST:
836 pads(STRsemisp);
837 break;
838 default:
839 break;
840 }
841 padd(t->t_dcdr);
842 return;
843
844 default:
845 break;
846 }
847 if ((t->t_dflg & F_PIPEIN) == 0 && t->t_dlef) {
848 pads((t->t_dflg & F_READ) ? STRspLarrow2sp : STRspLarrowsp);
849 pads(t->t_dlef);
850 }
851 if ((t->t_dflg & F_PIPEOUT) == 0 && t->t_drit) {
852 pads((t->t_dflg & F_APPEND) ? STRspRarrow2 : STRspRarrow);
853 if (t->t_dflg & F_STDERR)
854 pads(STRand);
855 pads(STRspace);
856 pads(t->t_drit);
857 }
858}
859
860static void
861pads(Char *cp)
862{
57e3f2b5 863 size_t i, len;
7d8fb588
MS
864
865 /*
866 * Avoid the Quoted Space alias hack! Reported by:
867 * sam@john-bigboote.ICS.UCI.EDU (Sam Horrocks)
868 */
869 if (cp[0] == STRQNULL[0])
870 cp++;
871
872 i = Strlen(cp);
873
57e3f2b5
SS
874 len = cmdlen + i + CMD_INCR;
875 if (len >= cmdmax)
876 morecommand(len);
7d8fb588
MS
877 (void) Strcpy(cmdp, cp);
878 cmdp += i;
879 cmdlen += i;
880}
881
882/*
883 * psavejob - temporarily save the current job on a one level stack
884 * so another job can be created. Used for { } in exp6
885 * and `` in globbing.
886 */
887void
888psavejob(void)
889{
890 pholdjob = pcurrjob;
891 pcurrjob = NULL;
892}
893
894void
895psavejob_cleanup(void *dummy)
896{
897 USE(dummy);
898 pcurrjob = pholdjob;
899 pholdjob = NULL;
900}
901
902/*
903 * pendjob - indicate that a job (set of commands) has been completed
904 * or is about to begin.
905 */
906void
907pendjob(void)
908{
909 struct process *pp, *tp;
910
911 if (pcurrjob && (pcurrjob->p_flags & (PFOREGND | PSTOPPED)) == 0) {
912 pp = pcurrjob;
913 while (pp->p_procid != pp->p_jobid)
914 pp = pp->p_friends;
915 xprintf("[%d]", pp->p_index);
916 tp = pp;
917 do {
918 xprintf(" %d", pp->p_procid);
919 pp = pp->p_friends;
920 } while (pp != tp);
921 xputchar('\n');
922 }
923 pholdjob = pcurrjob = 0;
924}
925
926/*
927 * pprint - print a job
928 */
929
930/*
931 * Hacks have been added for SVR4 to deal with pipe's being spawned in
932 * reverse order
933 *
934 * David Dawes (dawes@physics.su.oz.au) Oct 1991
935 */
936
937static int
938pprint(struct process *pp, int flag)
939{
940 int status, reason;
941 struct process *tp;
942 int jobflags, pstatus, pcond;
943 const char *format;
944
945#ifdef BACKPIPE
946 struct process *pipehead = NULL, *pipetail = NULL, *pmarker = NULL;
947 int inpipe = 0;
948#endif /* BACKPIPE */
949
950 while (pp->p_procid != pp->p_jobid)
951 pp = pp->p_friends;
952 if (pp == pp->p_friends && (pp->p_flags & PPTIME)) {
953 pp->p_flags &= ~PPTIME;
954 pp->p_flags |= PTIME;
955 }
956 tp = pp;
957 status = reason = -1;
958 jobflags = 0;
959 do {
960#ifdef BACKPIPE
961 /*
962 * The pipeline is reversed, so locate the real head of the pipeline
963 * if pp is at the tail of a pipe (and not already in a pipeline)
964 */
965 if ((pp->p_friends->p_flags & PPOU) && !inpipe && (flag & NAME)) {
966 inpipe = 1;
967 pipetail = pp;
968 do
969 pp = pp->p_friends;
970 while (pp->p_friends->p_flags & PPOU);
971 pipehead = pp;
972 pmarker = pp;
973 /*
974 * pmarker is used to hold the place of the proc being processed, so
975 * we can search for the next one downstream later.
976 */
977 }
978 pcond = (tp != pp || (inpipe && tp == pp));
979#else /* !BACKPIPE */
980 pcond = (tp != pp);
981#endif /* BACKPIPE */
982
983 jobflags |= pp->p_flags;
984 pstatus = (int) (pp->p_flags & PALLSTATES);
985 if (pcond && linp != linbuf && !(flag & FANCY) &&
986 ((pstatus == status && pp->p_reason == reason) ||
987 !(flag & REASON)))
988 xputchar(' ');
989 else {
990 if (pcond && linp != linbuf)
991 xputchar('\n');
992 if (flag & NUMBER) {
993#ifdef BACKPIPE
994 pcond = ((pp == tp && !inpipe) ||
995 (inpipe && pipetail == tp && pp == pipehead));
996#else /* BACKPIPE */
997 pcond = (pp == tp);
998#endif /* BACKPIPE */
999 if (pcond)
1000 xprintf("[%d]%s %c ", pp->p_index,
1001 pp->p_index < 10 ? " " : "",
1002 pp == pcurrent ? '+' :
1003 (pp == pprevious ? '-' : ' '));
1004 else
1005 xprintf(" ");
1006 }
1007 if (flag & FANCY) {
1008 xprintf("%5d ", pp->p_procid);
1009#ifdef TCF
1010 xprintf("%11s ", sitename(pp->p_procid));
1011#endif /* TCF */
1012 }
1013 if (flag & (REASON | AREASON)) {
1014 if (flag & NAME)
1015 format = "%-30s";
1016 else
1017 format = "%s";
1018 if (pstatus == status) {
1019 if (pp->p_reason == reason) {
1020 xprintf(format, "");
1021 goto prcomd;
1022 }
1023 else
1024 reason = (int) pp->p_reason;
1025 }
1026 else {
1027 status = pstatus;
1028 reason = (int) pp->p_reason;
1029 }
1030 switch (status) {
1031
1032 case PRUNNING:
1033 xprintf(format, CGETS(17, 4, "Running "));
1034 break;
1035
1036 case PINTERRUPTED:
1037 case PSTOPPED:
1038 case PSIGNALED:
1039 /*
1040 * tell what happened to the background job
1041 * From: Michael Schroeder
1042 * <mlschroe@immd4.informatik.uni-erlangen.de>
1043 */
1044 if ((flag & REASON)
1045 || ((flag & AREASON)
1046 && reason != SIGINT
1047 && (reason != SIGPIPE
1048 || (pp->p_flags & PPOU) == 0))) {
1049 char *ptr;
1050 int free_ptr;
1051
1052 free_ptr = 0;
1053 ptr = (char *)(intptr_t)mesg[pp->p_reason & 0177].pname;
1054 if (ptr == NULL) {
1055 ptr = xasprintf("%s %d", CGETS(17, 5, "Signal"),
1056 pp->p_reason & 0177);
1057 cleanup_push(ptr, xfree);
1058 free_ptr = 1;
1059 }
1060 xprintf(format, ptr);
1061 if (free_ptr != 0)
1062 cleanup_until(ptr);
1063 }
1064 else
1065 reason = -1;
1066 break;
1067
1068 case PNEXITED:
1069 case PAEXITED:
1070 if (flag & REASON) {
1071 if (pp->p_reason)
1072 xprintf(CGETS(17, 6, "Exit %-25d"), pp->p_reason);
1073 else
1074 xprintf(format, CGETS(17, 7, "Done"));
1075 }
1076 break;
1077
1078 default:
1079 xprintf(CGETS(17, 8, "BUG: status=%-9o"),
1080 status);
1081 }
1082 }
1083 }
1084prcomd:
1085 if (flag & NAME) {
1086 xprintf("%S", pp->p_command);
1087 if (pp->p_flags & PPOU)
1088 xprintf(" |");
1089 if (pp->p_flags & PDIAG)
1090 xprintf("&");
1091 }
1092 if (flag & (REASON | AREASON) && pp->p_flags & PDUMPED)
57e3f2b5 1093 xprintf("%s", CGETS(17, 9, " (core dumped)"));
7d8fb588
MS
1094 if (tp == pp->p_friends) {
1095 if (flag & AMPERSAND)
1096 xprintf(" &");
1097 if (flag & JOBDIR &&
1098 !eq(tp->p_cwd->di_name, dcwd->di_name)) {
57e3f2b5 1099 xprintf("%s", CGETS(17, 10, " (wd: "));
7d8fb588
MS
1100 dtildepr(tp->p_cwd->di_name);
1101 xprintf(")");
1102 }
1103 }
1104 if (pp->p_flags & PPTIME && !(status & (PSTOPPED | PRUNNING))) {
1105 if (linp != linbuf)
1106 xprintf("\n\t");
1107#if defined(BSDTIMES) || defined(_SEQUENT_)
1108 prusage(&zru, &pp->p_rusage, &pp->p_etime,
1109 &pp->p_btime);
1110#else /* !BSDTIMES && !SEQUENT */
1111 lru.tms_utime = pp->p_utime;
1112 lru.tms_stime = pp->p_stime;
1113 lru.tms_cutime = 0;
1114 lru.tms_cstime = 0;
1115 prusage(&zru, &lru, pp->p_etime,
1116 pp->p_btime);
1117#endif /* !BSDTIMES && !SEQUENT */
1118
1119 }
1120#ifdef BACKPIPE
1121 pcond = ((tp == pp->p_friends && !inpipe) ||
1122 (inpipe && pipehead->p_friends == tp && pp == pipetail));
1123#else /* !BACKPIPE */
1124 pcond = (tp == pp->p_friends);
1125#endif /* BACKPIPE */
1126 if (pcond) {
1127 if (linp != linbuf)
1128 xputchar('\n');
1129 if (flag & SHELLDIR && !eq(tp->p_cwd->di_name, dcwd->di_name)) {
57e3f2b5 1130 xprintf("%s", CGETS(17, 11, "(wd now: "));
7d8fb588
MS
1131 dtildepr(dcwd->di_name);
1132 xprintf(")\n");
1133 }
1134 }
1135#ifdef BACKPIPE
1136 if (inpipe) {
1137 /*
1138 * if pmaker == pipetail, we are finished that pipeline, and
1139 * can now skip to past the head
1140 */
1141 if (pmarker == pipetail) {
1142 inpipe = 0;
1143 pp = pipehead;
1144 }
1145 else {
1146 /*
1147 * set pp to one before the one we want next, so the while below
1148 * increments to the correct spot.
1149 */
1150 do
1151 pp = pp->p_friends;
1152 while (pp->p_friends->p_friends != pmarker);
1153 pmarker = pp->p_friends;
1154 }
1155 }
1156 pcond = ((pp = pp->p_friends) != tp || inpipe);
1157#else /* !BACKPIPE */
1158 pcond = ((pp = pp->p_friends) != tp);
1159#endif /* BACKPIPE */
1160 } while (pcond);
1161
1162 if (jobflags & PTIME && (jobflags & (PSTOPPED | PRUNNING)) == 0) {
1163 if (jobflags & NUMBER)
1164 xprintf(" ");
1165 ptprint(tp);
1166 }
1167 return (jobflags);
1168}
1169
1170/*
1171 * All 4.3 BSD derived implementations are buggy and I've had enough.
1172 * The following implementation produces similar code and works in all
1173 * cases. The 4.3BSD one works only for <, >, !=
1174 */
1175# undef timercmp
1176# define timercmp(tvp, uvp, cmp) \
1177 (((tvp)->tv_sec == (uvp)->tv_sec) ? \
1178 ((tvp)->tv_usec cmp (uvp)->tv_usec) : \
1179 ((tvp)->tv_sec cmp (uvp)->tv_sec))
1180
1181static void
1182ptprint(struct process *tp)
1183{
1184#ifdef BSDTIMES
1185 struct timeval tetime, diff;
1186 static struct timeval ztime;
1187 struct sysrusage ru;
1188 struct process *pp = tp;
1189
1190 ru = zru;
1191 tetime = ztime;
1192 do {
1193 ruadd(&ru, &pp->p_rusage);
1194 tvsub(&diff, &pp->p_etime, &pp->p_btime);
1195 if (timercmp(&diff, &tetime, >))
1196 tetime = diff;
1197 } while ((pp = pp->p_friends) != tp);
1198 prusage(&zru, &ru, &tetime, &ztime);
1199#else /* !BSDTIMES */
1200# ifdef _SEQUENT_
1201 timeval_t tetime, diff;
1202 static timeval_t ztime;
1203 struct process_stats ru;
1204 struct process *pp = tp;
1205
1206 ru = zru;
1207 tetime = ztime;
1208 do {
1209 ruadd(&ru, &pp->p_rusage);
1210 tvsub(&diff, &pp->p_etime, &pp->p_btime);
1211 if (timercmp(&diff, &tetime, >))
1212 tetime = diff;
1213 } while ((pp = pp->p_friends) != tp);
1214 prusage(&zru, &ru, &tetime, &ztime);
1215# else /* !_SEQUENT_ */
1216# ifndef POSIX
1217 static time_t ztime = 0;
1218 static time_t zu_time = 0;
1219 static time_t zs_time = 0;
1220 time_t tetime, diff;
1221 time_t u_time, s_time;
1222
1223# else /* POSIX */
1224 static clock_t ztime = 0;
1225 static clock_t zu_time = 0;
1226 static clock_t zs_time = 0;
1227 clock_t tetime, diff;
1228 clock_t u_time, s_time;
1229
1230# endif /* POSIX */
1231 struct tms zts, rts;
1232 struct process *pp = tp;
1233
1234 u_time = zu_time;
1235 s_time = zs_time;
1236 tetime = ztime;
1237 do {
1238 u_time += pp->p_utime;
1239 s_time += pp->p_stime;
1240 diff = pp->p_etime - pp->p_btime;
1241 if (diff > tetime)
1242 tetime = diff;
1243 } while ((pp = pp->p_friends) != tp);
1244 zts.tms_utime = zu_time;
1245 zts.tms_stime = zs_time;
1246 zts.tms_cutime = 0;
1247 zts.tms_cstime = 0;
1248 rts.tms_utime = u_time;
1249 rts.tms_stime = s_time;
1250 rts.tms_cutime = 0;
1251 rts.tms_cstime = 0;
1252 prusage(&zts, &rts, tetime, ztime);
1253# endif /* !_SEQUENT_ */
1254#endif /* !BSDTIMES */
1255}
1256
1257/*
1258 * dojobs - print all jobs
1259 */
1260/*ARGSUSED*/
1261void
1262dojobs(Char **v, struct command *c)
1263{
1264 struct process *pp;
1265 int flag = NUMBER | NAME | REASON;
1266 int i;
1267
1268 USE(c);
1269 if (chkstop)
1270 chkstop = 2;
1271 if (*++v) {
1272 if (v[1] || !eq(*v, STRml))
1273 stderror(ERR_JOBS);
1274 flag |= FANCY | JOBDIR;
1275 }
1276 for (i = 1; i <= pmaxindex; i++)
1277 for (pp = proclist.p_next; pp; pp = pp->p_next)
1278 if (pp->p_index == i && pp->p_procid == pp->p_jobid) {
1279 pp->p_flags &= ~PNEEDNOTE;
1280 if (!(pprint(pp, flag) & (PRUNNING | PSTOPPED)))
1281 pflush(pp);
1282 break;
1283 }
1284}
1285
1286/*
1287 * dofg - builtin - put the job into the foreground
1288 */
1289/*ARGSUSED*/
1290void
1291dofg(Char **v, struct command *c)
1292{
1293 struct process *pp;
1294
1295 USE(c);
1296 okpcntl();
1297 ++v;
1298 do {
1299 pp = pfind(*v);
1300 if (!pstart(pp, 1)) {
1301 pp->p_procid = 0;
1302 stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno));
1303 continue;
1304 }
1305 pjwait(pp);
1306 } while (*v && *++v);
1307}
1308
1309/*
1310 * %... - builtin - put the job into the foreground
1311 */
1312/*ARGSUSED*/
1313void
1314dofg1(Char **v, struct command *c)
1315{
1316 struct process *pp;
1317
1318 USE(c);
1319 okpcntl();
1320 pp = pfind(v[0]);
1321 if (!pstart(pp, 1)) {
1322 pp->p_procid = 0;
1323 stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno));
1324 return;
1325 }
1326 pjwait(pp);
1327}
1328
1329/*
1330 * dobg - builtin - put the job into the background
1331 */
1332/*ARGSUSED*/
1333void
1334dobg(Char **v, struct command *c)
1335{
1336 struct process *pp;
1337
1338 USE(c);
1339 okpcntl();
1340 ++v;
1341 do {
1342 pp = pfind(*v);
1343 if (!pstart(pp, 0)) {
1344 pp->p_procid = 0;
1345 stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno));
1346 }
1347 } while (*v && *++v);
1348}
1349
1350/*
1351 * %... & - builtin - put the job into the background
1352 */
1353/*ARGSUSED*/
1354void
1355dobg1(Char **v, struct command *c)
1356{
1357 struct process *pp;
1358
1359 USE(c);
1360 pp = pfind(v[0]);
1361 if (!pstart(pp, 0)) {
1362 pp->p_procid = 0;
1363 stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno));
1364 }
1365}
1366
1367/*
1368 * dostop - builtin - stop the job
1369 */
1370/*ARGSUSED*/
1371void
1372dostop(Char **v, struct command *c)
1373{
1374 USE(c);
1375#ifdef BSDJOBS
1376 pkill(++v, SIGSTOP);
1377#endif /* BSDJOBS */
1378}
1379
1380/*
1381 * dokill - builtin - superset of kill (1)
1382 */
1383/*ARGSUSED*/
1384void
1385dokill(Char **v, struct command *c)
1386{
1387 int signum, len = 0;
1388 const char *name;
1389 Char *sigptr;
1390
1391 USE(c);
1392 v++;
1393 if (v[0] && v[0][0] == '-') {
1394 if (v[0][1] == 'l') {
1395 for (signum = 0; signum <= nsig; signum++) {
1396 if ((name = mesg[signum].iname) != NULL) {
1397 len += strlen(name) + 1;
1398 if (len >= TermH - 1) {
1399 xputchar('\n');
1400 len = strlen(name) + 1;
1401 }
1402 xprintf("%s ", name);
1403 }
1404 }
1405 xputchar('\n');
1406 return;
1407 }
1408 sigptr = &v[0][1];
1409 if (v[0][1] == 's') {
1410 if (v[1]) {
1411 v++;
1412 sigptr = &v[0][0];
1413 } else {
1414 stderror(ERR_NAME | ERR_TOOFEW);
1415 }
1416 }
1417 if (Isdigit(*sigptr)) {
1418 char *ep;
1419 signum = strtoul(short2str(sigptr), &ep, 0);
1420 if (*ep || signum < 0 || signum > (MAXSIG-1))
1421 stderror(ERR_NAME | ERR_BADSIG);
1422 }
1423 else {
1424 for (signum = 0; signum <= nsig; signum++)
1425 if (mesg[signum].iname &&
1426 eq(sigptr, str2short(mesg[signum].iname)))
1427 goto gotsig;
1428 setname(short2str(sigptr));
1429 stderror(ERR_NAME | ERR_UNKSIG);
1430 }
1431gotsig:
1432 v++;
1433 }
1434 else
1435 signum = SIGTERM;
1436 pkill(v, signum);
1437}
1438
1439static void
1440pkill(Char **v, int signum)
1441{
1442 struct process *pp, *np;
1443 int jobflags = 0, err1 = 0;
1444 pid_t pid;
1445 Char *cp, **vp, **globbed;
1446
7d8fb588
MS
1447 /* Avoid globbing %?x patterns */
1448 for (vp = v; vp && *vp; vp++)
1449 if (**vp == '%')
1450 (void) quote(*vp);
1451
1452 v = glob_all_or_error(v);
1453 globbed = v;
1454 cleanup_push(globbed, blk_cleanup);
1455
57e3f2b5
SS
1456 pchild_disabled++;
1457 cleanup_push(&pchild_disabled, disabled_cleanup);
1458 if (setintr) {
1459 pintr_disabled++;
1460 cleanup_push(&pintr_disabled, disabled_cleanup);
1461 }
7d8fb588
MS
1462
1463 while (v && (cp = *v)) {
1464 if (*cp == '%') {
1465 np = pp = pfind(cp);
1466 do
1467 jobflags |= np->p_flags;
1468 while ((np = np->p_friends) != pp);
1469#ifdef BSDJOBS
1470 switch (signum) {
1471
1472 case SIGSTOP:
1473 case SIGTSTP:
1474 case SIGTTIN:
1475 case SIGTTOU:
1476 if ((jobflags & PRUNNING) == 0) {
1477# ifdef SUSPENDED
1478 xprintf(CGETS(17, 12, "%S: Already suspended\n"), cp);
1479# else /* !SUSPENDED */
1480 xprintf(CGETS(17, 13, "%S: Already stopped\n"), cp);
1481# endif /* !SUSPENDED */
1482 err1++;
1483 goto cont;
1484 }
1485 break;
1486 /*
1487 * suspend a process, kill -CONT %, then type jobs; the shell
1488 * says it is suspended, but it is running; thanks jaap..
1489 */
1490 case SIGCONT:
1491 if (!pstart(pp, 0)) {
1492 pp->p_procid = 0;
1493 stderror(ERR_NAME|ERR_BADJOB, pp->p_command,
1494 strerror(errno));
1495 }
1496 goto cont;
1497 default:
1498 break;
1499 }
1500#endif /* BSDJOBS */
1501 if (killpg(pp->p_jobid, signum) < 0) {
1502 xprintf("%S: %s\n", cp, strerror(errno));
1503 err1++;
1504 }
1505#ifdef BSDJOBS
1506 if (signum == SIGTERM || signum == SIGHUP)
1507 (void) killpg(pp->p_jobid, SIGCONT);
1508#endif /* BSDJOBS */
1509 }
1510 else if (!(Isdigit(*cp) || *cp == '-'))
1511 stderror(ERR_NAME | ERR_JOBARGS);
1512 else {
1513 char *ep;
1514#ifndef WINNT_NATIVE
1515 pid = strtol(short2str(cp), &ep, 10);
1516#else
1517 pid = strtoul(short2str(cp), &ep, 0);
1518#endif /* WINNT_NATIVE */
1519 if (*ep)
1520 stderror(ERR_NAME | ERR_JOBARGS);
1521 else if (kill(pid, signum) < 0) {
1522 xprintf("%d: %s\n", pid, strerror(errno));
1523 err1++;
1524 goto cont;
1525 }
1526#ifdef BSDJOBS
1527 if (signum == SIGTERM || signum == SIGHUP)
1528 (void) kill(pid, SIGCONT);
1529#endif /* BSDJOBS */
1530 }
1531cont:
1532 v++;
1533 }
1534 cleanup_until(&pchild_disabled);
1535 if (err1)
1536 stderror(ERR_SILENT);
1537}
1538
1539/*
1540 * pstart - start the job in foreground/background
1541 */
1542int
1543pstart(struct process *pp, int foregnd)
1544{
1545 int rv = 0;
1546 struct process *np;
1547 /* We don't use jobflags in this function right now (see below) */
1548 /* long jobflags = 0; */
1549
1550 pchild_disabled++;
1551 cleanup_push(&pchild_disabled, disabled_cleanup);
1552 np = pp;
1553 do {
1554 /* We don't use jobflags in this function right now (see below) */
1555 /* jobflags |= np->p_flags; */
1556 if (np->p_flags & (PRUNNING | PSTOPPED)) {
1557 np->p_flags |= PRUNNING;
1558 np->p_flags &= ~PSTOPPED;
1559 if (foregnd)
1560 np->p_flags |= PFOREGND;
1561 else
1562 np->p_flags &= ~PFOREGND;
1563 }
1564 } while ((np = np->p_friends) != pp);
1565 if (!foregnd)
1566 pclrcurr(pp);
1567 (void) pprint(pp, foregnd ? NAME | JOBDIR : NUMBER | NAME | AMPERSAND);
1568
1569 /* GrP run jobcmd hook if foregrounding */
1570 if (foregnd) {
1571 job_cmd(pp->p_command);
1572 }
1573
1574#ifdef BSDJOBS
1575 if (foregnd) {
1576 rv = tcsetpgrp(FSHTTY, pp->p_jobid);
1577 }
1578 /*
1579 * 1. child process of csh (shell script) receives SIGTTIN/SIGTTOU
1580 * 2. parent process (csh) receives SIGCHLD
1581 * 3. The "csh" signal handling function pchild() is invoked
1582 * with a SIGCHLD signal.
1583 * 4. pchild() calls wait3(WNOHANG) which returns 0.
1584 * The child process is NOT ready to be waited for at this time.
1585 * pchild() returns without picking-up the correct status
1586 * for the child process which generated the SIGCHLD.
1587 * 5. CONSEQUENCE : csh is UNaware that the process is stopped
1588 * 6. THIS LINE HAS BEEN COMMENTED OUT : if (jobflags&PSTOPPED)
1589 * (beto@aixwiz.austin.ibm.com - aug/03/91)
1590 * 7. I removed the line completely and added extra checks for
1591 * pstart, so that if a job gets attached to and dies inside
1592 * a debugger it does not confuse the shell. [christos]
1593 * 8. on the nec sx-4 there seems to be a problem, which requires
1594 * a syscall(151, getpid(), getpid()) in osinit. Don't ask me
1595 * what this is doing. [schott@rzg.mpg.de]
1596 */
1597
1598 if (rv != -1)
1599 rv = killpg(pp->p_jobid, SIGCONT);
1600#endif /* BSDJOBS */
1601 cleanup_until(&pchild_disabled);
1602 return rv != -1;
1603}
1604
1605void
1606panystop(int neednl)
1607{
1608 struct process *pp;
1609
1610 chkstop = 2;
1611 for (pp = proclist.p_next; pp; pp = pp->p_next)
1612 if (pp->p_flags & PSTOPPED)
1613 stderror(ERR_STOPPED, neednl ? "\n" : "");
1614}
1615
1616struct process *
1617pfind(Char *cp)
1618{
1619 struct process *pp, *np;
1620
1621 if (cp == 0 || cp[1] == 0 || eq(cp, STRcent2) || eq(cp, STRcentplus)) {
1622 if (pcurrent == NULL)
1623 stderror(ERR_NAME | ERR_JOBCUR);
1624 return (pcurrent);
1625 }
1626 if (eq(cp, STRcentminus) || eq(cp, STRcenthash)) {
1627 if (pprevious == NULL)
1628 stderror(ERR_NAME | ERR_JOBPREV);
1629 return (pprevious);
1630 }
1631 if (Isdigit(cp[1])) {
1632 int idx = atoi(short2str(cp + 1));
1633
1634 for (pp = proclist.p_next; pp; pp = pp->p_next)
1635 if (pp->p_index == idx && pp->p_procid == pp->p_jobid)
1636 return (pp);
1637 stderror(ERR_NAME | ERR_NOSUCHJOB);
1638 }
1639 np = NULL;
1640 for (pp = proclist.p_next; pp; pp = pp->p_next)
1641 if (pp->p_procid == pp->p_jobid) {
1642 if (cp[1] == '?') {
1643 Char *dp;
1644
1645 for (dp = pp->p_command; *dp; dp++) {
1646 if (*dp != cp[2])
1647 continue;
1648 if (prefix(cp + 2, dp))
1649 goto match;
1650 }
1651 }
1652 else if (prefix(cp + 1, pp->p_command)) {
1653 match:
1654 if (np)
1655 stderror(ERR_NAME | ERR_AMBIG);
1656 np = pp;
1657 }
1658 }
1659 if (np)
1660 return (np);
1661 stderror(ERR_NAME | (cp[1] == '?' ? ERR_JOBPAT : ERR_NOSUCHJOB));
1662 /* NOTREACHED */
1663 return (0);
1664}
1665
1666
1667/*
1668 * pgetcurr - find most recent job that is not pp, preferably stopped
1669 */
1670static struct process *
1671pgetcurr(struct process *pp)
1672{
1673 struct process *np;
1674 struct process *xp = NULL;
1675
1676 for (np = proclist.p_next; np; np = np->p_next)
1677 if (np != pcurrent && np != pp && np->p_procid &&
1678 np->p_procid == np->p_jobid) {
1679 if (np->p_flags & PSTOPPED)
1680 return (np);
1681 if (xp == NULL)
1682 xp = np;
1683 }
1684 return (xp);
1685}
1686
1687/*
1688 * donotify - flag the job so as to report termination asynchronously
1689 */
1690/*ARGSUSED*/
1691void
1692donotify(Char **v, struct command *c)
1693{
1694 struct process *pp;
1695
1696 USE(c);
1697 pp = pfind(*++v);
1698 pp->p_flags |= PNOTIFY;
1699}
1700
1701#ifdef SIGSYNCH
1702static void
1703synch_handler(int sno)
1704{
1705 USE(sno);
1706}
1707#endif /* SIGSYNCH */
1708
1709/*
1710 * Do the fork and whatever should be done in the child side that
1711 * should not be done if we are not forking at all (like for simple builtin's)
1712 * Also do everything that needs any signals fiddled with in the parent side
1713 *
1714 * Wanttty tells whether process and/or tty pgrps are to be manipulated:
1715 * -1: leave tty alone; inherit pgrp from parent
1716 * 0: already have tty; manipulate process pgrps only
1717 * 1: want to claim tty; manipulate process and tty pgrps
1718 * It is usually just the value of tpgrp.
1719 */
1720
1721pid_t
1722pfork(struct command *t, int wanttty)
1723{
1724 pid_t pid;
1725 int ignint = 0;
1726 pid_t pgrp;
1727#ifdef SIGSYNCH
1728 struct sigaction osa, nsa;
1729#endif /* SIGSYNCH */
1730
1731 /*
1732 * A child will be uninterruptible only under very special conditions.
1733 * Remember that the semantics of '&' is implemented by disconnecting the
1734 * process from the tty so signals do not need to ignored just for '&'.
1735 * Thus signals are set to default action for children unless: we have had
1736 * an "onintr -" (then specifically ignored) we are not playing with
1737 * signals (inherit action)
1738 */
1739 if (setintr)
1740 ignint = (tpgrp == -1 && (t->t_dflg & F_NOINTERRUPT))
1741 || (gointr && eq(gointr, STRminus));
1742
1743 /*
1744 * Check for maximum nesting of 16 processes to avoid Forking loops
1745 */
1746 if (child == 16)
1747 stderror(ERR_NESTING, 16);
1748#ifdef SIGSYNCH
1749 nsa.sa_handler = synch_handler;
1750 sigfillset(&nsa.sa_mask);
1751 nsa.sa_flags = SA_RESTART;
1752 if (sigaction(SIGSYNCH, &nsa, &osa))
1753 stderror(ERR_SYSTEM, "pfork: sigaction set", strerror(errno));
1754#endif /* SIGSYNCH */
1755 /*
1756 * Hold pchild() until we have the process installed in our table.
1757 */
1758 if (wanttty < 0) {
1759 pchild_disabled++;
1760 cleanup_push(&pchild_disabled, disabled_cleanup);
1761 }
1762 while ((pid = fork()) == -1)
1763 if (setintr == 0)
1764 (void) sleep(FORKSLEEP);
1765 else
1766 stderror(ERR_NOPROC);
1767 if (pid == 0) {
1768 (void)cleanup_push_mark(); /* Never to be popped */
1769 pchild_disabled = 0;
1770 settimes();
1771 pgrp = pcurrjob ? pcurrjob->p_jobid : getpid();
1772 pflushall();
1773 pcurrjob = NULL;
1774#if !defined(BSDTIMES) && !defined(_SEQUENT_)
1775 timesdone = 0;
1776#endif /* !defined(BSDTIMES) && !defined(_SEQUENT_) */
1777 child++;
1778 if (setintr) {
1779 setintr = 0; /* until I think otherwise */
1780 /*
1781 * Children just get blown away on SIGINT, SIGQUIT unless "onintr
1782 * -" seen.
1783 */
1784 (void) signal(SIGINT, ignint ? SIG_IGN : SIG_DFL);
1785 (void) signal(SIGQUIT, ignint ? SIG_IGN : SIG_DFL);
1786#ifdef BSDJOBS
1787 if (wanttty >= 0) {
1788 /* make stoppable */
1789 (void) signal(SIGTSTP, SIG_DFL);
1790 (void) signal(SIGTTIN, SIG_DFL);
1791 (void) signal(SIGTTOU, SIG_DFL);
1792 }
1793#endif /* BSDJOBS */
1794 sigaction(SIGTERM, &parterm, NULL);
1795 }
1796 else if (tpgrp == -1 && (t->t_dflg & F_NOINTERRUPT)) {
1797 (void) signal(SIGINT, SIG_IGN);
1798 (void) signal(SIGQUIT, SIG_IGN);
1799 }
1800#ifdef OREO
1801 signal(SIGIO, SIG_IGN); /* ignore SIGIO in child too */
1802#endif /* OREO */
1803
1804 pgetty(wanttty, pgrp);
1805 /*
1806 * Nohup and nice apply only to NODE_COMMAND's but it would be nice
1807 * (?!?) if you could say "nohup (foo;bar)" Then the parser would have
1808 * to know about nice/nohup/time
1809 */
1810 if (t->t_dflg & F_NOHUP)
1811 (void) signal(SIGHUP, SIG_IGN);
1812 if (t->t_dflg & F_NICE) {
1813 int nval = SIGN_EXTEND_CHAR(t->t_nice);
1814#ifdef HAVE_SETPRIORITY
1815 if (setpriority(PRIO_PROCESS, 0, nval) == -1 && errno)
1816 stderror(ERR_SYSTEM, "setpriority", strerror(errno));
1817#else /* !HAVE_SETPRIORITY */
1818 (void) nice(nval);
1819#endif /* !HAVE_SETPRIORITY */
1820 }
1821#ifdef F_VER
1822 if (t->t_dflg & F_VER) {
1823 tsetenv(STRSYSTYPE, t->t_systype ? STRbsd43 : STRsys53);
1824 dohash(NULL, NULL);
1825 }
1826#endif /* F_VER */
1827#ifdef SIGSYNCH
1828 /* rfw 8/89 now parent can continue */
1829 if (kill(getppid(), SIGSYNCH))
1830 stderror(ERR_SYSTEM, "pfork child: kill", strerror(errno));
1831#endif /* SIGSYNCH */
1832
1833 }
1834 else {
1835#ifdef POSIXJOBS
1836 if (wanttty >= 0) {
1837 /*
1838 * `Walking' process group fix from Beto Appleton.
1839 * (beto@aixwiz.austin.ibm.com)
1840 * If setpgid fails at this point that means that
1841 * our process leader has died. We flush the current
1842 * job and become the process leader ourselves.
1843 * The parent will figure that out later.
1844 */
1845 pgrp = pcurrjob ? pcurrjob->p_jobid : pid;
1846 if (setpgid(pid, pgrp) == -1 && errno == EPERM) {
1847 pcurrjob = NULL;
1848 /*
1849 * We don't care if this causes an error here;
1850 * then we are already in the right process group
1851 */
1852 (void) setpgid(pid, pgrp = pid);
1853 }
1854 }
1855#endif /* POSIXJOBS */
1856 palloc(pid, t);
1857#ifdef SIGSYNCH
1858 {
1859 sigset_t pause_mask;
1860
1861 /*
1862 * rfw 8/89 Wait for child to own terminal. Solves half of ugly
1863 * synchronization problem. With this change, we know that the only
1864 * reason setpgrp to a previous process in a pipeline can fail is that
1865 * the previous process has already exited. Without this hack, he may
1866 * either have exited or not yet started to run. Two uglies become
1867 * one.
1868 */
1869 sigprocmask(SIG_BLOCK, NULL, &pause);
1870 sigdelset(&pause_mask, SIGCHLD);
1871 sigdelset(&pause_mask, SIGSYNCH);
1872 sigsuspend(&pause_mask);
1873 handle_pending_signals();
1874 if (sigaction(SIGSYNCH, &osa, NULL))
1875 stderror(ERR_SYSTEM, "pfork parent: sigaction restore",
1876 strerror(errno));
1877 }
1878#endif /* SIGSYNCH */
1879
1880 if (wanttty < 0)
1881 cleanup_until(&pchild_disabled);
1882 }
1883 return (pid);
1884}
1885
1886static void
1887okpcntl(void)
1888{
1889 if (tpgrp == -1)
1890 stderror(ERR_JOBCONTROL);
1891 if (tpgrp == 0)
1892 stderror(ERR_JOBCTRLSUB);
1893}
1894
1895
1896static void
1897setttypgrp(int pgrp)
1898{
1899 /*
1900 * If we are piping out a builtin, eg. 'echo | more' things can go
1901 * out of sequence, i.e. the more can run before the echo. This
1902 * can happen even if we have vfork, since the echo will be forked
1903 * with the regular fork. In this case, we need to set the tty
1904 * pgrp ourselves. If that happens, then the process will be still
1905 * alive. And the tty process group will already be set.
1906 * This should fix the famous sequent problem as a side effect:
1907 * The controlling terminal is lost if all processes in the
1908 * terminal process group are zombies. In this case tcgetpgrp()
1909 * returns 0. If this happens we must set the terminal process
1910 * group again.
1911 */
1912 if (tcgetpgrp(FSHTTY) != pgrp) {
1913#ifdef POSIXJOBS
1914 struct sigaction old;
1915
1916 /*
1917 * tcsetpgrp will set SIGTTOU to all the the processes in
1918 * the background according to POSIX... We ignore this here.
1919 */
1920 sigaction(SIGTTOU, NULL, &old);
1921 signal(SIGTTOU, SIG_IGN);
1922#endif
1923 (void) tcsetpgrp(FSHTTY, pgrp);
1924# ifdef POSIXJOBS
1925 sigaction(SIGTTOU, &old, NULL);
1926# endif
1927
1928 }
1929}
1930
1931
1932/*
1933 * if we don't have vfork(), things can still go in the wrong order
1934 * resulting in the famous 'Stopped (tty output)'. But some systems
1935 * don't permit the setpgid() call, (these are more recent secure
1936 * systems such as ibm's aix), when they do. Then we'd rather print
1937 * an error message than hang the shell!
1938 * I am open to suggestions how to fix that.
1939 */
1940void
1941pgetty(int wanttty, pid_t pgrp)
1942{
1943#ifdef BSDJOBS
1944# ifdef POSIXJOBS
1945 sigset_t oset, set;
1946# endif /* POSIXJOBS */
1947
1948 jobdebug_xprintf(("wanttty %d pid %d opgrp%d pgrp %d tpgrp %d\n",
1949 wanttty, (int)getpid(), (int)pgrp, (int)mygetpgrp(),
1950 (int)tcgetpgrp(FSHTTY)));
1951# ifdef POSIXJOBS
1952 /*
1953 * christos: I am blocking the tty signals till I've set things
1954 * correctly....
1955 */
1956 if (wanttty > 0) {
1957 sigemptyset(&set);
1958 sigaddset(&set, SIGTSTP);
1959 sigaddset(&set, SIGTTIN);
1960 (void)sigprocmask(SIG_BLOCK, &set, &oset);
1961 cleanup_push(&oset, sigprocmask_cleanup);
1962 }
1963# endif /* POSIXJOBS */
1964
1965# ifndef POSIXJOBS
1966 if (wanttty > 0)
1967 setttypgrp(pgrp);
1968# endif /* !POSIXJOBS */
1969
1970 /*
1971 * From: Michael Schroeder <mlschroe@immd4.informatik.uni-erlangen.de>
1972 * Don't check for tpgrp >= 0 so even non-interactive shells give
1973 * background jobs process groups Same for the comparison in the other part
1974 * of the #ifdef
1975 */
1976 if (wanttty >= 0) {
1977 if (setpgid(0, pgrp) == -1) {
1978# ifdef POSIXJOBS
1979 /* Walking process group fix; see above */
1980 if (setpgid(0, pgrp = getpid()) == -1) {
1981# endif /* POSIXJOBS */
1982 stderror(ERR_SYSTEM, "setpgid child:\n", strerror(errno));
1983 xexit(0);
1984# ifdef POSIXJOBS
1985 }
1986 wanttty = pgrp; /* Now we really want the tty, since we became the
1987 * the process group leader
1988 */
1989# endif /* POSIXJOBS */
1990 }
1991 }
1992
1993# ifdef POSIXJOBS
1994 if (wanttty > 0) {
1995 setttypgrp(pgrp);
1996 cleanup_until(&oset);
1997 }
1998# endif /* POSIXJOBS */
1999
2000 jobdebug_xprintf(("wanttty %d pid %d pgrp %d tpgrp %d\n",
2001 wanttty, getpid(), mygetpgrp(), tcgetpgrp(FSHTTY)));
2002
2003 if (tpgrp > 0)
2004 tpgrp = 0; /* gave tty away */
2005#endif /* BSDJOBS */
2006}