Context Navigation

source: mainline/uspace/app/ash/jobs.c@ 8ccd2ea

Visit:

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export

Last change on this file since 8ccd2ea was c28a023, checked in by Josef Cejka <malyzelenyhnus@…>, 17 years ago
Initial commit of ash shell. It cannot be compiled yet.
Property mode set to `100644`
File size: 26.2 KB

Rev	Line
[c28a023]	1	/* $NetBSD: jobs.c,v 1.36 2000/05/22 10:18:47 elric Exp $ */
	2
	3	/*-
	4	* Copyright (c) 1991, 1993
	5	* The Regents of the University of California. All rights reserved.
	6	*
	7	* This code is derived from software contributed to Berkeley by
	8	* Kenneth Almquist.
	9	*
	10	* Redistribution and use in source and binary forms, with or without
	11	* modification, are permitted provided that the following conditions
	12	* are met:
	13	* 1. Redistributions of source code must retain the above copyright
	14	* notice, this list of conditions and the following disclaimer.
	15	* 2. Redistributions in binary form must reproduce the above copyright
	16	* notice, this list of conditions and the following disclaimer in the
	17	* documentation and/or other materials provided with the distribution.
	18	* 3. All advertising materials mentioning features or use of this software
	19	* must display the following acknowledgement:
	20	* This product includes software developed by the University of
	21	* California, Berkeley and its contributors.
	22	* 4. Neither the name of the University nor the names of its contributors
	23	* may be used to endorse or promote products derived from this software
	24	* without specific prior written permission.
	25	*
	26	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	27	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	28	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	29	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	30	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	31	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	32	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	33	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	34	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	35	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	36	* SUCH DAMAGE.
	37	*/
	38
	39	#include <sys/cdefs.h>
	40	#ifndef lint
	41	#if 0
	42	static char sccsid[] = "@(#)jobs.c 8.5 (Berkeley) 5/4/95";
	43	#else
	44	__RCSID("$NetBSD: jobs.c,v 1.36 2000/05/22 10:18:47 elric Exp $");
	45	#endif
	46	#endif /* not lint */
	47
	48	#include <fcntl.h>
	49	#include <signal.h>
	50	#include <errno.h>
	51	#include <unistd.h>
	52	#include <stdlib.h>
	53	#include <paths.h>
	54	#include <sys/types.h>
	55	#include <sys/param.h>
	56	#ifdef BSD
	57	#include <sys/wait.h>
	58	#include <sys/time.h>
	59	#include <sys/resource.h>
	60	#endif
	61	#include <sys/ioctl.h>
	62
	63	#include "shell.h"
	64	#if JOBS
	65	#if OLD_TTY_DRIVER
	66	#include "sgtty.h"
	67	#else
	68	#include <termios.h>
	69	#endif
	70	#undef CEOF /* syntax.h redefines this */
	71	#endif
	72	#include "redir.h"
	73	#include "show.h"
	74	#include "main.h"
	75	#include "parser.h"
	76	#include "nodes.h"
	77	#include "jobs.h"
	78	#include "options.h"
	79	#include "trap.h"
	80	#include "syntax.h"
	81	#include "input.h"
	82	#include "output.h"
	83	#include "memalloc.h"
	84	#include "error.h"
	85	#include "mystring.h"
	86
	87
	88	struct job jobtab; / array of jobs */
	89	int njobs; /* size of array */
	90	MKINIT short backgndpid = -1; /* pid of last background process */
	91	#if JOBS
	92	int initialpgrp; /* pgrp of shell on invocation */
	93	short curjob; /* current job */
	94	#endif
	95	STATIC int intreceived;
	96
	97	STATIC void restartjob (struct job *);
	98	STATIC void freejob (struct job *);
	99	STATIC struct job getjob (char );
	100	STATIC int dowait (int, struct job *);
	101	STATIC int onsigchild (void);
	102	STATIC int waitproc (int, int *);
	103	STATIC void cmdtxt (union node *);
	104	STATIC void cmdputs (const char *);
	105	STATIC void waitonint(int);
	106
	107
	108	#if JOBS
	109	/*
	110	* Turn job control on and off.
	111	*
	112	* Note: This code assumes that the third arg to ioctl is a character
	113	* pointer, which is true on Berkeley systems but not System V. Since
	114	* System V doesn't have job control yet, this isn't a problem now.
	115	*/
	116
	117	MKINIT int jobctl;
	118
	119	void
	120	setjobctl(on)
	121	int on;
	122	{
	123	#ifdef OLD_TTY_DRIVER
	124	int ldisc;
	125	#endif
	126
	127	if (on == jobctl \|\| rootshell == 0)
	128	return;
	129	if (on) {
	130	do { /* while we are in the background */
	131	#ifdef OLD_TTY_DRIVER
	132	if (ioctl(fd2, TIOCGPGRP, (char *)&initialpgrp) < 0) {
	133	#else
	134	initialpgrp = tcgetpgrp(fd2);
	135	if (initialpgrp < 0) {
	136	#endif
	137	out2str("sh: can't access tty; job control turned off\n");
	138	mflag = 0;
	139	return;
	140	}
	141	if (initialpgrp == -1)
	142	initialpgrp = getpgrp();
	143	else if (initialpgrp != getpgrp()) {
	144	killpg(initialpgrp, SIGTTIN);
	145	continue;
	146	}
	147	} while (0);
	148	#ifdef OLD_TTY_DRIVER
	149	if (ioctl(fd2, TIOCGETD, (char *)&ldisc) < 0 \|\| ldisc != NTTYDISC) {
	150	out2str("sh: need new tty driver to run job control; job control turned off\n");
	151	mflag = 0;
	152	return;
	153	}
	154	#endif
	155	setsignal(SIGTSTP);
	156	setsignal(SIGTTOU);
	157	setsignal(SIGTTIN);
	158	setpgid(0, rootpid);
	159	#ifdef OLD_TTY_DRIVER
	160	ioctl(fd2, TIOCSPGRP, (char *)&rootpid);
	161	#else
	162	tcsetpgrp(fd2, rootpid);
	163	#endif
	164	} else { /* turning job control off */
	165	setpgid(0, initialpgrp);
	166	#ifdef OLD_TTY_DRIVER
	167	ioctl(fd2, TIOCSPGRP, (char *)&initialpgrp);
	168	#else
	169	tcsetpgrp(fd2, initialpgrp);
	170	#endif
	171	setsignal(SIGTSTP);
	172	setsignal(SIGTTOU);
	173	setsignal(SIGTTIN);
	174	}
	175	jobctl = on;
	176	}
	177	#endif
	178
	179
	180	#ifdef mkinit
	181	INCLUDE <stdlib.h>
	182
	183	SHELLPROC {
	184	backgndpid = -1;
	185	#if JOBS
	186	jobctl = 0;
	187	#endif
	188	}
	189
	190	#endif
	191
	192
	193
	194	#if JOBS
	195	int
	196	killcmd(argc, argv)
	197	int argc;
	198	char **argv;
	199	{
	200	extern char *signal_names[];
	201	int signo = -1;
	202	int list = 0;
	203	int i;
	204	pid_t pid;
	205	struct job *jp;
	206
	207	if (argc <= 1) {
	208	error(
	209	"Usage: kill [-s sigspec \| -signum \| -sigspec] [pid \| job]... or\n"
	210	"kill -l [exitstatus]"
	211	);
	212	}
	213
	214	if (*argv[1] == '-') {
	215	signo = decode_signal(argv[1]+1);
	216	if (signo < 0) {
	217	int c;
	218
	219	while ((c = nextopt("ls:")) != '\0')
	220	switch (c) {
	221	case 'l':
	222	list = 1;
	223	break;
	224	case 's':
	225	signo = decode_signal(optarg);
	226	break;
	227	default:
	228	error(
	229	"nextopt returned character code 0%o", c);
	230	}
	231	} else
	232	argptr++;
	233	}
	234
	235	if (!list && signo < 0)
	236	signo = SIGTERM;
	237
	238	if ((signo < 0 \|\| !*argptr) ^ list) {
	239	error(
	240	"Usage: kill [-s sigspec \| -signum \| -sigspec] [pid \| job]... or\n"
	241	"kill -l [exitstatus]"
	242	);
	243	}
	244
	245	if (list) {
	246	if (!*argptr) {
	247	out1fmt("0\n");
	248	for (i = 1; i < NSIG; i++) {
	249	if (strncmp(signal_names[i], "SIGJUNK(", 8)
	250	== 0)
	251	continue;
	252	out1fmt("%s\n", signal_names[i] + 3);
	253	}
	254	return 0;
	255	}
	256	signo = atoi(*argptr);
	257	if (signo > 128)
	258	signo -= 128;
	259	if (0 < signo && signo < NSIG)
	260	out1fmt("%s\n", signal_names[signo] + 3);
	261	else
	262	error("invalid signal number or exit status: %s",
	263	*argptr);
	264	return 0;
	265	}
	266
	267	do {
	268	if (**argptr == '%') {
	269	jp = getjob(*argptr);
	270	if (jp->jobctl == 0)
	271	error("job %s not created under job control",
	272	*argptr);
	273	pid = -jp->ps[0].pid;
	274	} else
	275	pid = atoi(*argptr);
	276	if (kill(pid, signo) != 0)
	277	error("%s: %s", *argptr, strerror(errno));
	278	} while (*++argptr);
	279
	280	return 0;
	281	}
	282
	283	int
	284	fgcmd(argc, argv)
	285	int argc;
	286	char **argv;
	287	{
	288	struct job *jp;
	289	int pgrp;
	290	int status;
	291
	292	jp = getjob(argv[1]);
	293	if (jp->jobctl == 0)
	294	error("job not created under job control");
	295	pgrp = jp->ps[0].pid;
	296	#ifdef OLD_TTY_DRIVER
	297	ioctl(fd2, TIOCSPGRP, (char *)&pgrp);
	298	#else
	299	tcsetpgrp(fd2, pgrp);
	300	#endif
	301	restartjob(jp);
	302	INTOFF;
	303	status = waitforjob(jp);
	304	INTON;
	305	return status;
	306	}
	307
	308
	309	int
	310	bgcmd(argc, argv)
	311	int argc;
	312	char **argv;
	313	{
	314	struct job *jp;
	315
	316	do {
	317	jp = getjob(*++argv);
	318	if (jp->jobctl == 0)
	319	error("job not created under job control");
	320	restartjob(jp);
	321	} while (--argc > 1);
	322	return 0;
	323	}
	324
	325
	326	STATIC void
	327	restartjob(jp)
	328	struct job *jp;
	329	{
	330	struct procstat *ps;
	331	int i;
	332
	333	if (jp->state == JOBDONE)
	334	return;
	335	INTOFF;
	336	killpg(jp->ps[0].pid, SIGCONT);
	337	for (ps = jp->ps, i = jp->nprocs ; --i >= 0 ; ps++) {
	338	if (WIFSTOPPED(ps->status)) {
	339	ps->status = -1;
	340	jp->state = 0;
	341	}
	342	}
	343	INTON;
	344	}
	345	#endif
	346
	347
	348	int
	349	jobscmd(argc, argv)
	350	int argc;
	351	char **argv;
	352	{
	353	showjobs(0);
	354	return 0;
	355	}
	356
	357
	358	/*
	359	* Print a list of jobs. If "change" is nonzero, only print jobs whose
	360	* statuses have changed since the last call to showjobs.
	361	*
	362	* If the shell is interrupted in the process of creating a job, the
	363	* result may be a job structure containing zero processes. Such structures
	364	* will be freed here.
	365	*/
	366
	367	void
	368	showjobs(change)
	369	int change;
	370	{
	371	int jobno;
	372	int procno;
	373	int i;
	374	struct job *jp;
	375	struct procstat *ps;
	376	int col;
	377	char s[64];
	378
	379	TRACE(("showjobs(%d) called\n", change));
	380	while (dowait(0, (struct job *)NULL) > 0);
	381	for (jobno = 1, jp = jobtab ; jobno <= njobs ; jobno++, jp++) {
	382	if (! jp->used)
	383	continue;
	384	if (jp->nprocs == 0) {
	385	freejob(jp);
	386	continue;
	387	}
	388	if (change && ! jp->changed)
	389	continue;
	390	procno = jp->nprocs;
	391	for (ps = jp->ps ; ; ps++) { /* for each process */
	392	if (ps == jp->ps)
	393	fmtstr(s, 64, "[%d] %ld ", jobno,
	394	(long)ps->pid);
	395	else
	396	fmtstr(s, 64, " %ld ",
	397	(long)ps->pid);
	398	out1str(s);
	399	col = strlen(s);
	400	s[0] = '\0';
	401	if (ps->status == -1) {
	402	/* don't print anything */
	403	} else if (WIFEXITED(ps->status)) {
	404	fmtstr(s, 64, "Exit %d",
	405	WEXITSTATUS(ps->status));
	406	} else {
	407	#if JOBS
	408	if (WIFSTOPPED(ps->status))
	409	i = WSTOPSIG(ps->status);
	410	else /* WIFSIGNALED(ps->status) */
	411	#endif
	412	i = WTERMSIG(ps->status);
	413	if ((i & 0x7F) < NSIG && sys_siglist[i & 0x7F])
	414	scopy(sys_siglist[i & 0x7F], s);
	415	else
	416	fmtstr(s, 64, "Signal %d", i & 0x7F);
	417	if (WCOREDUMP(ps->status))
	418	strcat(s, " (core dumped)");
	419	}
	420	out1str(s);
	421	col += strlen(s);
	422	do {
	423	out1c(' ');
	424	col++;
	425	} while (col < 30);
	426	out1str(ps->cmd);
	427	out1c('\n');
	428	if (--procno <= 0)
	429	break;
	430	}
	431	jp->changed = 0;
	432	if (jp->state == JOBDONE) {
	433	freejob(jp);
	434	}
	435	}
	436	}
	437
	438
	439	/*
	440	* Mark a job structure as unused.
	441	*/
	442
	443	STATIC void
	444	freejob(jp)
	445	struct job *jp;
	446	{
	447	struct procstat *ps;
	448	int i;
	449
	450	INTOFF;
	451	for (i = jp->nprocs, ps = jp->ps ; --i >= 0 ; ps++) {
	452	if (ps->cmd != nullstr)
	453	ckfree(ps->cmd);
	454	}
	455	if (jp->ps != &jp->ps0)
	456	ckfree(jp->ps);
	457	jp->used = 0;
	458	#if JOBS
	459	if (curjob == jp - jobtab + 1)
	460	curjob = 0;
	461	#endif
	462	INTON;
	463	}
	464
	465
	466
	467	int
	468	waitcmd(argc, argv)
	469	int argc;
	470	char **argv;
	471	{
	472	struct job *job;
	473	int status, retval;
	474	struct job *jp;
	475
	476	if (argc > 1) {
	477	job = getjob(argv[1]);
	478	} else {
	479	job = NULL;
	480	}
	481	for (;;) { /* loop until process terminated or stopped */
	482	if (job != NULL) {
	483	if (job->state) {
	484	status = job->ps[job->nprocs - 1].status;
	485	if (WIFEXITED(status))
	486	retval = WEXITSTATUS(status);
	487	#if JOBS
	488	else if (WIFSTOPPED(status))
	489	retval = WSTOPSIG(status) + 128;
	490	#endif
	491	else {
	492	/* XXX: limits number of signals */
	493	retval = WTERMSIG(status) + 128;
	494	}
	495	if (! iflag)
	496	freejob(job);
	497	return retval;
	498	}
	499	} else {
	500	for (jp = jobtab ; ; jp++) {
	501	if (jp >= jobtab + njobs) { /* no running procs */
	502	return 0;
	503	}
	504	if (jp->used && jp->state == 0)
	505	break;
	506	}
	507	}
	508	dowait(1, (struct job *)NULL);
	509	}
	510	}
	511
	512
	513
	514	int
	515	jobidcmd(argc, argv)
	516	int argc;
	517	char **argv;
	518	{
	519	struct job *jp;
	520	int i;
	521
	522	jp = getjob(argv[1]);
	523	for (i = 0 ; i < jp->nprocs ; ) {
	524	out1fmt("%ld", (long)jp->ps[i].pid);
	525	out1c(++i < jp->nprocs? ' ' : '\n');
	526	}
	527	return 0;
	528	}
	529
	530
	531
	532	/*
	533	* Convert a job name to a job structure.
	534	*/
	535
	536	STATIC struct job *
	537	getjob(name)
	538	char *name;
	539	{
	540	int jobno;
	541	struct job *jp;
	542	int pid;
	543	int i;
	544
	545	if (name == NULL) {
	546	#if JOBS
	547	currentjob:
	548	if ((jobno = curjob) == 0 \|\| jobtab[jobno - 1].used == 0)
	549	error("No current job");
	550	return &jobtab[jobno - 1];
	551	#else
	552	error("No current job");
	553	#endif
	554	} else if (name[0] == '%') {
	555	if (is_digit(name[1])) {
	556	jobno = number(name + 1);
	557	if (jobno > 0 && jobno <= njobs
	558	&& jobtab[jobno - 1].used != 0)
	559	return &jobtab[jobno - 1];
	560	#if JOBS
	561	} else if (name[1] == '%' && name[2] == '\0') {
	562	goto currentjob;
	563	#endif
	564	} else {
	565	struct job *found = NULL;
	566	for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
	567	if (jp->used && jp->nprocs > 0
	568	&& prefix(name + 1, jp->ps[0].cmd)) {
	569	if (found)
	570	error("%s: ambiguous", name);
	571	found = jp;
	572	}
	573	}
	574	if (found)
	575	return found;
	576	}
	577	} else if (is_number(name)) {
	578	pid = number(name);
	579	for (jp = jobtab, i = njobs ; --i >= 0 ; jp++) {
	580	if (jp->used && jp->nprocs > 0
	581	&& jp->ps[jp->nprocs - 1].pid == pid)
	582	return jp;
	583	}
	584	}
	585	error("No such job: %s", name);
	586	/* NOTREACHED */
	587	}
	588
	589
	590
	591	/*
	592	* Return a new job structure,
	593	*/
	594
	595	struct job *
	596	makejob(node, nprocs)
	597	union node *node;
	598	int nprocs;
	599	{
	600	int i;
	601	struct job *jp;
	602
	603	for (i = njobs, jp = jobtab ; ; jp++) {
	604	if (--i < 0) {
	605	INTOFF;
	606	if (njobs == 0) {
	607	jobtab = ckmalloc(4 * sizeof jobtab[0]);
	608	} else {
	609	jp = ckmalloc((njobs + 4) * sizeof jobtab[0]);
	610	memcpy(jp, jobtab, njobs * sizeof jp[0]);
	611	/* Relocate `ps' pointers */
	612	for (i = 0; i < njobs; i++)
	613	if (jp[i].ps == &jobtab[i].ps0)
	614	jp[i].ps = &jp[i].ps0;
	615	ckfree(jobtab);
	616	jobtab = jp;
	617	}
	618	jp = jobtab + njobs;
	619	for (i = 4 ; --i >= 0 ; jobtab[njobs++].used = 0);
	620	INTON;
	621	break;
	622	}
	623	if (jp->used == 0)
	624	break;
	625	}
	626	INTOFF;
	627	jp->state = 0;
	628	jp->used = 1;
	629	jp->changed = 0;
	630	jp->nprocs = 0;
	631	#if JOBS
	632	jp->jobctl = jobctl;
	633	#endif
	634	if (nprocs > 1) {
	635	jp->ps = ckmalloc(nprocs * sizeof (struct procstat));
	636	} else {
	637	jp->ps = &jp->ps0;
	638	}
	639	INTON;
	640	TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long)node, nprocs,
	641	jp - jobtab + 1));
	642	return jp;
	643	}
	644
	645
	646	/*
	647	* Fork of a subshell. If we are doing job control, give the subshell its
	648	* own process group. Jp is a job structure that the job is to be added to.
	649	* N is the command that will be evaluated by the child. Both jp and n may
	650	* be NULL. The mode parameter can be one of the following:
	651	* FORK_FG - Fork off a foreground process.
	652	* FORK_BG - Fork off a background process.
	653	* FORK_NOJOB - Like FORK_FG, but don't give the process its own
	654	* process group even if job control is on.
	655	*
	656	* When job control is turned off, background processes have their standard
	657	* input redirected to /dev/null (except for the second and later processes
	658	* in a pipeline).
	659	*/
	660
	661	int
	662	forkshell(jp, n, mode)
	663	union node *n;
	664	struct job *jp;
	665	int mode;
	666	{
	667	int pid;
	668	int pgrp;
	669	const char *devnull = _PATH_DEVNULL;
	670	const char *nullerr = "Can't open %s";
	671
	672	TRACE(("forkshell(%%%d, 0x%lx, %d) called\n", jp - jobtab, (long)n,
	673	mode));
	674	INTOFF;
	675	pid = fork();
	676	if (pid == -1) {
	677	TRACE(("Fork failed, errno=%d\n", errno));
	678	INTON;
	679	error("Cannot fork");
	680	}
	681	if (pid == 0) {
	682	struct job *p;
	683	int wasroot;
	684	int i;
	685
	686	TRACE(("Child shell %d\n", getpid()));
	687	wasroot = rootshell;
	688	rootshell = 0;
	689	closescript();
	690	INTON;
	691	clear_traps();
	692	#if JOBS
	693	jobctl = 0; /* do job control only in root shell */
	694	if (wasroot && mode != FORK_NOJOB && mflag) {
	695	if (jp == NULL \|\| jp->nprocs == 0)
	696	pgrp = getpid();
	697	else
	698	pgrp = jp->ps[0].pid;
	699	setpgid(0, pgrp);
	700	if (mode == FORK_FG) {
	701	/* this causes superfluous TIOCSPGRPS */
	702	#ifdef OLD_TTY_DRIVER
	703	if (ioctl(fd2, TIOCSPGRP, (char *)&pgrp) < 0)
	704	error("TIOCSPGRP failed, errno=%d", errno);
	705	#else
	706	if (tcsetpgrp(fd2, pgrp) < 0)
	707	error("tcsetpgrp failed, errno=%d", errno);
	708	#endif
	709	}
	710	setsignal(SIGTSTP);
	711	setsignal(SIGTTOU);
	712	} else if (mode == FORK_BG) {
	713	ignoresig(SIGINT);
	714	ignoresig(SIGQUIT);
	715	ignoresig(SIGHUP);
	716	if ((jp == NULL \|\| jp->nprocs == 0) &&
	717	! fd0_redirected_p ()) {
	718	close(0);
	719	if (open(devnull, O_RDONLY) != 0)
	720	error(nullerr, devnull);
	721	}
	722	}
	723	#else
	724	if (mode == FORK_BG) {
	725	ignoresig(SIGINT);
	726	ignoresig(SIGQUIT);
	727	ignoresig(SIGHUP);
	728	if ((jp == NULL \|\| jp->nprocs == 0) &&
	729	! fd0_redirected_p ()) {
	730	close(0);
	731	if (open(devnull, O_RDONLY) != 0)
	732	error(nullerr, devnull);
	733	}
	734	}
	735	#endif
	736	for (i = njobs, p = jobtab ; --i >= 0 ; p++)
	737	if (p->used)
	738	freejob(p);
	739	if (wasroot && iflag) {
	740	setsignal(SIGINT);
	741	setsignal(SIGQUIT);
	742	setsignal(SIGTERM);
	743	}
	744	return pid;
	745	}
	746	if (rootshell && mode != FORK_NOJOB && mflag) {
	747	if (jp == NULL \|\| jp->nprocs == 0)
	748	pgrp = pid;
	749	else
	750	pgrp = jp->ps[0].pid;
	751	setpgid(pid, pgrp);
	752	}
	753	if (mode == FORK_BG)
	754	backgndpid = pid; /* set $! */
	755	if (jp) {
	756	struct procstat *ps = &jp->ps[jp->nprocs++];
	757	ps->pid = pid;
	758	ps->status = -1;
	759	ps->cmd = nullstr;
	760	if (iflag && rootshell && n)
	761	ps->cmd = commandtext(n);
	762	}
	763	INTON;
	764	TRACE(("In parent shell: child = %d\n", pid));
	765	return pid;
	766	}
	767
	768
	769
	770	/*
	771	* Wait for job to finish.
	772	*
	773	* Under job control we have the problem that while a child process is
	774	* running interrupts generated by the user are sent to the child but not
	775	* to the shell. This means that an infinite loop started by an inter-
	776	* active user may be hard to kill. With job control turned off, an
	777	* interactive user may place an interactive program inside a loop. If
	778	* the interactive program catches interrupts, the user doesn't want
	779	* these interrupts to also abort the loop. The approach we take here
	780	* is to have the shell ignore interrupt signals while waiting for a
	781	* forground process to terminate, and then send itself an interrupt
	782	* signal if the child process was terminated by an interrupt signal.
	783	* Unfortunately, some programs want to do a bit of cleanup and then
	784	* exit on interrupt; unless these processes terminate themselves by
	785	* sending a signal to themselves (instead of calling exit) they will
	786	* confuse this approach.
	787	*/
	788
	789	int
	790	waitforjob(jp)
	791	struct job *jp;
	792	{
	793	#if JOBS
	794	int mypgrp = getpgrp();
	795	#endif
	796	int status;
	797	int st;
	798	struct sigaction act, oact;
	799
	800	INTOFF;
	801	intreceived = 0;
	802	#if JOBS
	803	if (!jobctl) {
	804	#else
	805	if (!iflag) {
	806	#endif
	807	sigaction(SIGINT, 0, &act);
	808	act.sa_handler = waitonint;
	809	sigaction(SIGINT, &act, &oact);
	810	}
	811	TRACE(("waitforjob(%%%d) called\n", jp - jobtab + 1));
	812	while (jp->state == 0) {
	813	dowait(1, jp);
	814	}
	815	#if JOBS
	816	if (!jobctl) {
	817	#else
	818	if (!iflag) {
	819	#endif
	820	extern char *trap[];
	821	sigaction(SIGINT, &oact, 0);
	822	if (intreceived && trap[SIGINT]) kill(getpid(), SIGINT);
	823	}
	824	#if JOBS
	825	if (jp->jobctl) {
	826	#ifdef OLD_TTY_DRIVER
	827	if (ioctl(fd2, TIOCSPGRP, (char *)&mypgrp) < 0)
	828	error("TIOCSPGRP failed, errno=%d\n", errno);
	829	#else
	830	if (tcsetpgrp(fd2, mypgrp) < 0)
	831	error("tcsetpgrp failed, errno=%d\n", errno);
	832	#endif
	833	}
	834	if (jp->state == JOBSTOPPED)
	835	curjob = jp - jobtab + 1;
	836	#endif
	837	status = jp->ps[jp->nprocs - 1].status;
	838	/* convert to 8 bits */
	839	if (WIFEXITED(status))
	840	st = WEXITSTATUS(status);
	841	#if JOBS
	842	else if (WIFSTOPPED(status))
	843	st = WSTOPSIG(status) + 128;
	844	#endif
	845	else
	846	st = WTERMSIG(status) + 128;
	847	#if JOBS
	848	if (jp->jobctl) {
	849	/*
	850	* This is truly gross.
	851	* If we're doing job control, then we did a TIOCSPGRP which
	852	* caused us (the shell) to no longer be in the controlling
	853	* session -- so we wouldn't have seen any ^C/SIGINT. So, we
	854	* intuit from the subprocess exit status whether a SIGINT
	855	* occured, and if so interrupt ourselves. Yuck. - mycroft
	856	*/
	857	if (WIFSIGNALED(status) && WTERMSIG(status) == SIGINT)
	858	raise(SIGINT);
	859	}
	860	#endif
	861	if (! JOBS \|\| jp->state == JOBDONE)
	862	freejob(jp);
	863	INTON;
	864	return st;
	865	}
	866
	867
	868
	869	/*
	870	* Wait for a process to terminate.
	871	*/
	872
	873	STATIC int
	874	dowait(block, job)
	875	int block;
	876	struct job *job;
	877	{
	878	int pid;
	879	int status;
	880	struct procstat *sp;
	881	struct job *jp;
	882	struct job *thisjob;
	883	int done;
	884	int stopped;
	885	int core;
	886	int sig;
	887
	888	TRACE(("dowait(%d) called\n", block));
	889	do {
	890	pid = waitproc(block, &status);
	891	TRACE(("wait returns %d, status=%d\n", pid, status));
	892	} while (pid == -1 && errno == EINTR);
	893	if (pid <= 0)
	894	return pid;
	895	INTOFF;
	896	thisjob = NULL;
	897	for (jp = jobtab ; jp < jobtab + njobs ; jp++) {
	898	if (jp->used) {
	899	done = 1;
	900	stopped = 1;
	901	for (sp = jp->ps ; sp < jp->ps + jp->nprocs ; sp++) {
	902	if (sp->pid == -1)
	903	continue;
	904	if (sp->pid == pid) {
	905	TRACE(("Changing status of proc %d from 0x%x to 0x%x\n", pid, sp->status, status));
	906	sp->status = status;
	907	thisjob = jp;
	908	}
	909	if (sp->status == -1)
	910	stopped = 0;
	911	else if (WIFSTOPPED(sp->status))
	912	done = 0;
	913	}
	914	if (stopped) { /* stopped or done */
	915	int state = done? JOBDONE : JOBSTOPPED;
	916	if (jp->state != state) {
	917	TRACE(("Job %d: changing state from %d to %d\n", jp - jobtab + 1, jp->state, state));
	918	jp->state = state;
	919	#if JOBS
	920	if (done && curjob == jp - jobtab + 1)
	921	curjob = 0; /* no current job */
	922	#endif
	923	}
	924	}
	925	}
	926	}
	927	INTON;
	928	if (! rootshell \|\| ! iflag \|\| (job && thisjob == job)) {
	929	core = WCOREDUMP(status);
	930	#if JOBS
	931	if (WIFSTOPPED(status)) sig = WSTOPSIG(status);
	932	else
	933	#endif
	934	if (WIFEXITED(status)) sig = 0;
	935	else sig = WTERMSIG(status);
	936
	937	if (sig != 0 && sig != SIGINT && sig != SIGPIPE) {
	938	if (thisjob != job)
	939	outfmt(out2, "%d: ", pid);
	940	#if JOBS
	941	if (sig == SIGTSTP && rootshell && iflag)
	942	outfmt(out2, "%%%ld ",
	943	(long)(job - jobtab + 1));
	944	#endif
	945	if (sig < NSIG && sys_siglist[sig])
	946	out2str(sys_siglist[sig]);
	947	else
	948	outfmt(out2, "Signal %d", sig);
	949	if (core)
	950	out2str(" - core dumped");
	951	out2c('\n');
	952	flushout(&errout);
	953	} else {
	954	TRACE(("Not printing status: status=%d, sig=%d\n",
	955	status, sig));
	956	}
	957	} else {
	958	TRACE(("Not printing status, rootshell=%d, job=0x%x\n", rootshell, job));
	959	if (thisjob)
	960	thisjob->changed = 1;
	961	}
	962	return pid;
	963	}
	964
	965
	966
	967	/*
	968	* Do a wait system call. If job control is compiled in, we accept
	969	* stopped processes. If block is zero, we return a value of zero
	970	* rather than blocking.
	971	*
	972	* System V doesn't have a non-blocking wait system call. It does
	973	* have a SIGCLD signal that is sent to a process when one of it's
	974	* children dies. The obvious way to use SIGCLD would be to install
	975	* a handler for SIGCLD which simply bumped a counter when a SIGCLD
	976	* was received, and have waitproc bump another counter when it got
	977	* the status of a process. Waitproc would then know that a wait
	978	* system call would not block if the two counters were different.
	979	* This approach doesn't work because if a process has children that
	980	* have not been waited for, System V will send it a SIGCLD when it
	981	* installs a signal handler for SIGCLD. What this means is that when
	982	* a child exits, the shell will be sent SIGCLD signals continuously
	983	* until is runs out of stack space, unless it does a wait call before
	984	* restoring the signal handler. The code below takes advantage of
	985	* this (mis)feature by installing a signal handler for SIGCLD and
	986	* then checking to see whether it was called. If there are any
	987	* children to be waited for, it will be.
	988	*
	989	* If neither SYSV nor BSD is defined, we don't implement nonblocking
	990	* waits at all. In this case, the user will not be informed when
	991	* a background process until the next time she runs a real program
	992	* (as opposed to running a builtin command or just typing return),
	993	* and the jobs command may give out of date information.
	994	*/
	995
	996	#ifdef SYSV
	997	STATIC int gotsigchild;
	998
	999	STATIC int onsigchild() {
	1000	gotsigchild = 1;
	1001	}
	1002	#endif
	1003
	1004
	1005	STATIC int
	1006	waitproc(block, status)
	1007	int block;
	1008	int *status;
	1009	{
	1010	#ifdef BSD
	1011	int flags;
	1012
	1013	flags = 0;
	1014	#if JOBS
	1015	if (jobctl)
	1016	flags \|= WUNTRACED;
	1017	#endif
	1018	if (block == 0)
	1019	flags \|= WNOHANG;
	1020	return wait3(status, flags, (struct rusage *)NULL);
	1021	#else
	1022	#ifdef SYSV
	1023	int (*save)();
	1024
	1025	if (block == 0) {
	1026	gotsigchild = 0;
	1027	save = signal(SIGCLD, onsigchild);
	1028	signal(SIGCLD, save);
	1029	if (gotsigchild == 0)
	1030	return 0;
	1031	}
	1032	return wait(status);
	1033	#else
	1034	if (block == 0)
	1035	return 0;
	1036	return wait(status);
	1037	#endif
	1038	#endif
	1039	}
	1040
	1041	/*
	1042	* return 1 if there are stopped jobs, otherwise 0
	1043	*/
	1044	int job_warning = 0;
	1045	int
	1046	stoppedjobs()
	1047	{
	1048	int jobno;
	1049	struct job *jp;
	1050
	1051	if (job_warning)
	1052	return (0);
	1053	for (jobno = 1, jp = jobtab; jobno <= njobs; jobno++, jp++) {
	1054	if (jp->used == 0)
	1055	continue;
	1056	if (jp->state == JOBSTOPPED) {
	1057	out2str("You have stopped jobs.\n");
	1058	job_warning = 2;
	1059	return (1);
	1060	}
	1061	}
	1062
	1063	return (0);
	1064	}
	1065
	1066	/*
	1067	* Return a string identifying a command (to be printed by the
	1068	* jobs command.
	1069	*/
	1070
	1071	STATIC char *cmdnextc;
	1072	STATIC int cmdnleft;
	1073	#define MAXCMDTEXT 200
	1074
	1075	char *
	1076	commandtext(n)
	1077	union node *n;
	1078	{
	1079	char *name;
	1080
	1081	cmdnextc = name = ckmalloc(MAXCMDTEXT);
	1082	cmdnleft = MAXCMDTEXT - 4;
	1083	cmdtxt(n);
	1084	*cmdnextc = '\0';
	1085	return name;
	1086	}
	1087
	1088
	1089	STATIC void
	1090	cmdtxt(n)
	1091	union node *n;
	1092	{
	1093	union node *np;
	1094	struct nodelist *lp;
	1095	const char *p;
	1096	int i;
	1097	char s[2];
	1098
	1099	if (n == NULL)
	1100	return;
	1101	switch (n->type) {
	1102	case NSEMI:
	1103	cmdtxt(n->nbinary.ch1);
	1104	cmdputs("; ");
	1105	cmdtxt(n->nbinary.ch2);
	1106	break;
	1107	case NAND:
	1108	cmdtxt(n->nbinary.ch1);
	1109	cmdputs(" && ");
	1110	cmdtxt(n->nbinary.ch2);
	1111	break;
	1112	case NOR:
	1113	cmdtxt(n->nbinary.ch1);
	1114	cmdputs(" \|\| ");
	1115	cmdtxt(n->nbinary.ch2);
	1116	break;
	1117	case NPIPE:
	1118	for (lp = n->npipe.cmdlist ; lp ; lp = lp->next) {
	1119	cmdtxt(lp->n);
	1120	if (lp->next)
	1121	cmdputs(" \| ");
	1122	}
	1123	break;
	1124	case NSUBSHELL:
	1125	cmdputs("(");
	1126	cmdtxt(n->nredir.n);
	1127	cmdputs(")");
	1128	break;
	1129	case NREDIR:
	1130	case NBACKGND:
	1131	cmdtxt(n->nredir.n);
	1132	break;
	1133	case NIF:
	1134	cmdputs("if ");
	1135	cmdtxt(n->nif.test);
	1136	cmdputs("; then ");
	1137	cmdtxt(n->nif.ifpart);
	1138	cmdputs("...");
	1139	break;
	1140	case NWHILE:
	1141	cmdputs("while ");
	1142	goto until;
	1143	case NUNTIL:
	1144	cmdputs("until ");
	1145	until:
	1146	cmdtxt(n->nbinary.ch1);
	1147	cmdputs("; do ");
	1148	cmdtxt(n->nbinary.ch2);
	1149	cmdputs("; done");
	1150	break;
	1151	case NFOR:
	1152	cmdputs("for ");
	1153	cmdputs(n->nfor.var);
	1154	cmdputs(" in ...");
	1155	break;
	1156	case NCASE:
	1157	cmdputs("case ");
	1158	cmdputs(n->ncase.expr->narg.text);
	1159	cmdputs(" in ...");
	1160	break;
	1161	case NDEFUN:
	1162	cmdputs(n->narg.text);
	1163	cmdputs("() ...");
	1164	break;
	1165	case NCMD:
	1166	for (np = n->ncmd.args ; np ; np = np->narg.next) {
	1167	cmdtxt(np);
	1168	if (np->narg.next)
	1169	cmdputs(" ");
	1170	}
	1171	for (np = n->ncmd.redirect ; np ; np = np->nfile.next) {
	1172	cmdputs(" ");
	1173	cmdtxt(np);
	1174	}
	1175	break;
	1176	case NARG:
	1177	cmdputs(n->narg.text);
	1178	break;
	1179	case NTO:
	1180	p = ">"; i = 1; goto redir;
	1181	case NAPPEND:
	1182	p = ">>"; i = 1; goto redir;
	1183	case NTOFD:
	1184	p = ">&"; i = 1; goto redir;
	1185	case NTOOV:
	1186	p = ">\|"; i = 1; goto redir;
	1187	case NFROM:
	1188	p = "<"; i = 0; goto redir;
	1189	case NFROMFD:
	1190	p = "<&"; i = 0; goto redir;
	1191	case NFROMTO:
	1192	p = "<>"; i = 0; goto redir;
	1193	redir:
	1194	if (n->nfile.fd != i) {
	1195	s[0] = n->nfile.fd + '0';
	1196	s[1] = '\0';
	1197	cmdputs(s);
	1198	}
	1199	cmdputs(p);
	1200	if (n->type == NTOFD \|\| n->type == NFROMFD) {
	1201	s[0] = n->ndup.dupfd + '0';
	1202	s[1] = '\0';
	1203	cmdputs(s);
	1204	} else {
	1205	cmdtxt(n->nfile.fname);
	1206	}
	1207	break;
	1208	case NHERE:
	1209	case NXHERE:
	1210	cmdputs("<<...");
	1211	break;
	1212	default:
	1213	cmdputs("???");
	1214	break;
	1215	}
	1216	}
	1217
	1218
	1219
	1220	STATIC void
	1221	cmdputs(s)
	1222	const char *s;
	1223	{
	1224	const char *p;
	1225	char *q;
	1226	char c;
	1227	int subtype = 0;
	1228
	1229	if (cmdnleft <= 0)
	1230	return;
	1231	p = s;
	1232	q = cmdnextc;
	1233	while ((c = *p++) != '\0') {
	1234	if (c == CTLESC)
	1235	q++ = p++;
	1236	else if (c == CTLVAR) {
	1237	*q++ = '$';
	1238	if (--cmdnleft > 0)
	1239	*q++ = '{';
	1240	subtype = *p++;
	1241	} else if (c == '=' && subtype != 0) {
	1242	*q++ = "}-+?="[(subtype & VSTYPE) - VSNORMAL];
	1243	subtype = 0;
	1244	} else if (c == CTLENDVAR) {
	1245	*q++ = '}';
	1246	} else if (c == CTLBACKQ \|\| c == CTLBACKQ+CTLQUOTE)
	1247	cmdnleft++; /* ignore it */
	1248	else
	1249	*q++ = c;
	1250	if (--cmdnleft <= 0) {
	1251	*q++ = '.';
	1252	*q++ = '.';
	1253	*q++ = '.';
	1254	break;
	1255	}
	1256	}
	1257	cmdnextc = q;
	1258	}
	1259
	1260	STATIC void waitonint(int sig) {
	1261	intreceived = 1;
	1262	return;
	1263	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: