busybox/runit/runsvdir.c

/*
Copyright (c) 2001-2006, Gerrit Pape
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

   1. Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.
   2. Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
   3. The name of the author may not be used to endorse or promote products
      derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/* Busyboxed by Denys Vlasenko <vda.linux@googlemail.com> */
/* TODO: depends on runit_lib.c - review and reduce/eliminate */

#include <sys/poll.h>
#include <sys/file.h>
#include "libbb.h"
#include "runit_lib.h"

#define MAXSERVICES 1000

/* Should be not needed - all dirs are on same FS, right? */
#define CHECK_DEVNO_TOO 0

struct service {
#if CHECK_DEVNO_TOO
	dev_t dev;
#endif
	ino_t ino;
	pid_t pid;
	smallint isgone;
};

struct globals {
	struct service *sv;
	char *svdir;
	int svnum;
#if ENABLE_FEATURE_RUNSVDIR_LOG
	char *rplog;
	int rploglen;
	struct fd_pair logpipe;
	struct pollfd pfd[1];
	unsigned stamplog;
#endif
};
#define G (*(struct globals*)&bb_common_bufsiz1)
#define sv          (G.sv          )
#define svdir       (G.svdir       )
#define svnum       (G.svnum       )
#define rplog       (G.rplog       )
#define rploglen    (G.rploglen    )
#define logpipe     (G.logpipe     )
#define pfd         (G.pfd         )
#define stamplog    (G.stamplog    )
#define INIT_G() do { \
} while (0)

static void fatal2_cannot(const char *m1, const char *m2)
{
	bb_perror_msg_and_die("%s: fatal: can't %s%s", svdir, m1, m2);
	/* was exiting 100 */
}
static void warn3x(const char *m1, const char *m2, const char *m3)
{
	bb_error_msg("%s: warning: %s%s%s", svdir, m1, m2, m3);
}
static void warn2_cannot(const char *m1, const char *m2)
{
	warn3x("can't ", m1, m2);
}
#if ENABLE_FEATURE_RUNSVDIR_LOG
static void warnx(const char *m1)
{
	warn3x(m1, "", "");
}
#endif

/* inlining + vfork -> bigger code */
static NOINLINE pid_t runsv(const char *name)
{
	pid_t pid;

	/* If we got signaled, stop spawning children at once! */
	if (bb_got_signal)
		return 0;

	pid = vfork();
	if (pid == -1) {
		warn2_cannot("vfork", "");
		return 0;
	}
	if (pid == 0) {
		/* child */
		if (option_mask32 & 1) /* -P option? */
			setsid();
/* man execv:
 * "Signals set to be caught by the calling process image
 *  shall be set to the default action in the new process image."
 * Therefore, we do not need this: */
#if 0
		bb_signals(0
			| (1 << SIGHUP)
			| (1 << SIGTERM)
			, SIG_DFL);
#endif
		execlp("runsv", "runsv", name, (char *) NULL);
		fatal2_cannot("start runsv ", name);
	}
	return pid;
}

/* gcc 4.3.0 does better with NOINLINE */
static NOINLINE int do_rescan(void)
{
	DIR *dir;
	struct dirent *d;
	int i;
	struct stat s;
	int need_rescan = 0;

	dir = opendir(".");
	if (!dir) {
		warn2_cannot("open directory ", svdir);
		return 1; /* need to rescan again soon */
	}
	for (i = 0; i < svnum; i++)
		sv[i].isgone = 1;

	while (1) {
		errno = 0;
		d = readdir(dir);
		if (!d)
			break;
		if (d->d_name[0] == '.')
			continue;
		if (stat(d->d_name, &s) == -1) {
			warn2_cannot("stat ", d->d_name);
			continue;
		}
		if (!S_ISDIR(s.st_mode))
			continue;
		/* Do we have this service listed already? */
		for (i = 0; i < svnum; i++) {
			if ((sv[i].ino == s.st_ino)
#if CHECK_DEVNO_TOO
			 && (sv[i].dev == s.st_dev)
#endif
			) {
				if (sv[i].pid == 0) /* restart if it has died */
					goto run_ith_sv;
				sv[i].isgone = 0; /* "we still see you" */
				goto next_dentry;
			}
		}
		{ /* Not found, make new service */
			struct service *svnew = realloc(sv, (i+1) * sizeof(*sv));
			if (!svnew) {
				warn2_cannot("start runsv ", d->d_name);
				need_rescan = 1;
				continue;
			}
			sv = svnew;
			svnum++;
#if CHECK_DEVNO_TOO
			sv[i].dev = s.st_dev;
#endif
			sv[i].ino = s.st_ino;
 run_ith_sv:
			sv[i].pid = runsv(d->d_name);
			sv[i].isgone = 0;
		}
 next_dentry: ;
	}
	i = errno;
	closedir(dir);
	if (i) { /* readdir failed */
		warn2_cannot("read directory ", svdir);
		return 1; /* need to rescan again soon */
	}

	/* Send SIGTERM to runsv whose directories
	 * were no longer found (-> must have been removed) */
	for (i = 0; i < svnum; i++) {
		if (!sv[i].isgone)
			continue;
		if (sv[i].pid)
			kill(sv[i].pid, SIGTERM);
		svnum--;
		sv[i] = sv[svnum];
		i--; /* so that we don't skip new sv[i] (bug was here!) */
	}
	return need_rescan;
}

int runsvdir_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int runsvdir_main(int argc UNUSED_PARAM, char **argv)
{
	struct stat s;
	dev_t last_dev = last_dev; /* for gcc */
	ino_t last_ino = last_ino; /* for gcc */
	time_t last_mtime = 0;
	int wstat;
	int curdir;
	pid_t pid;
	unsigned deadline;
	unsigned now;
	unsigned stampcheck;
	int i;
	int need_rescan = 1;
	char *opt_s_argv[3];

	INIT_G();

	opt_complementary = "-1";
	opt_s_argv[0] = NULL;
	opt_s_argv[2] = NULL;
	getopt32(argv, "Ps:", &opt_s_argv[0]);
	argv += optind;

	bb_signals(0
		| (1 << SIGTERM)
		| (1 << SIGHUP)
		/* For busybox's init, SIGTERM == reboot,
		 * SIGUSR1 == halt
		 * SIGUSR2 == poweroff
		 * so we need to intercept SIGUSRn too.
		 * Note that we do not implement actual reboot
		 * (killall(TERM) + umount, etc), we just pause
		 * respawing and avoid exiting (-> making kernel oops).
		 * The user is responsible for the rest. */
		| (getpid() == 1 ? ((1 << SIGUSR1) | (1 << SIGUSR2)) : 0)
		, record_signo);
	svdir = *argv++;

#if ENABLE_FEATURE_RUNSVDIR_LOG
	/* setup log */
	if (*argv) {
		rplog = *argv;
		rploglen = strlen(rplog);
		if (rploglen < 7) {
			warnx("log must have at least seven characters");
		} else if (piped_pair(logpipe)) {
			warnx("can't create pipe for log");
		} else {
			close_on_exec_on(logpipe.rd);
			close_on_exec_on(logpipe.wr);
			ndelay_on(logpipe.rd);
			ndelay_on(logpipe.wr);
			if (dup2(logpipe.wr, 2) == -1) {
				warnx("can't set filedescriptor for log");
			} else {
				pfd[0].fd = logpipe.rd;
				pfd[0].events = POLLIN;
				stamplog = monotonic_sec();
				goto run;
			}
		}
		rplog = NULL;
		warnx("log service disabled");
	}
 run:
#endif
	curdir = open_read(".");
	if (curdir == -1)
		fatal2_cannot("open current directory", "");
	close_on_exec_on(curdir);

	stampcheck = monotonic_sec();

	for (;;) {
		/* collect children */
		for (;;) {
			pid = wait_any_nohang(&wstat);
			if (pid <= 0)
				break;
			for (i = 0; i < svnum; i++) {
				if (pid == sv[i].pid) {
					/* runsv has died */
					sv[i].pid = 0;
					need_rescan = 1;
				}
			}
		}

		now = monotonic_sec();
		if ((int)(now - stampcheck) >= 0) {
			/* wait at least a second */
			stampcheck = now + 1;

			if (stat(svdir, &s) != -1) {
				if (need_rescan || s.st_mtime != last_mtime
				 || s.st_ino != last_ino || s.st_dev != last_dev
				) {
					/* svdir modified */
					if (chdir(svdir) != -1) {
						last_mtime = s.st_mtime;
						last_dev = s.st_dev;
						last_ino = s.st_ino;
						//if (now <= mtime)
						//	sleep(1);
						need_rescan = do_rescan();
						while (fchdir(curdir) == -1) {
							warn2_cannot("change directory, pausing", "");
							sleep(5);
						}
					} else {
						warn2_cannot("change directory to ", svdir);
					}
				}
			} else {
				warn2_cannot("stat ", svdir);
			}
		}

#if ENABLE_FEATURE_RUNSVDIR_LOG
		if (rplog) {
			if ((int)(now - stamplog) >= 0) {
				write(logpipe.wr, ".", 1);
				stamplog = now + 900;
			}
		}
		pfd[0].revents = 0;
#endif
		deadline = (need_rescan ? 1 : 5);
		sig_block(SIGCHLD);
#if ENABLE_FEATURE_RUNSVDIR_LOG
		if (rplog)
			poll(pfd, 1, deadline*1000);
		else
#endif
			sleep(deadline);
		sig_unblock(SIGCHLD);

#if ENABLE_FEATURE_RUNSVDIR_LOG
		if (pfd[0].revents & POLLIN) {
			char ch;
			while (read(logpipe.rd, &ch, 1) > 0) {
				if (ch < ' ')
					ch = ' ';
				for (i = 6; i < rploglen; i++)
					rplog[i-1] = rplog[i];
				rplog[rploglen-1] = ch;
			}
		}
#endif
		if (!bb_got_signal)
			continue;

		/* -s SCRIPT: useful if we are init.
		 * In this case typically script never returns,
		 * it halts/powers off/reboots the system. */
		if (opt_s_argv[0]) {
			/* Single parameter: signal# */
			opt_s_argv[1] = utoa(bb_got_signal);
			pid = spawn(opt_s_argv);
			if (pid > 0) {
				/* Remembering to wait for _any_ children,
				 * not just pid */
				while (wait(NULL) != pid)
					continue;
			}
		}

		if (bb_got_signal == SIGHUP) {
			for (i = 0; i < svnum; i++)
				if (sv[i].pid)
					kill(sv[i].pid, SIGTERM);
		}
		/* SIGHUP or SIGTERM (or SIGUSRn if we are init) */
		/* Exit unless we are init */
		if (getpid() != 1)
			return (SIGHUP == bb_got_signal) ? 111 : EXIT_SUCCESS;

		/* init continues to monitor services forever */
		bb_got_signal = 0;
	} /* for (;;) */
}
1	/*
2	Copyright (c) 2001-2006, Gerrit Pape
3	All rights reserved.
4
5	Redistribution and use in source and binary forms, with or without
6	modification, are permitted provided that the following conditions are met:
7
8	1. Redistributions of source code must retain the above copyright notice,
9	this list of conditions and the following disclaimer.
10	2. Redistributions in binary form must reproduce the above copyright
11	notice, this list of conditions and the following disclaimer in the
12	documentation and/or other materials provided with the distribution.
13	3. The name of the author may not be used to endorse or promote products
14	derived from this software without specific prior written permission.
15
16	THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17	WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18	MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19	EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21	PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22	OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23	WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24	OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25	ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26	*/
27
28	/* Busyboxed by Denys Vlasenko <vda.linux@googlemail.com> */
29	/* TODO: depends on runit_lib.c - review and reduce/eliminate */
30
31	#include <sys/poll.h>
32	#include <sys/file.h>
33	#include "libbb.h"
34	#include "runit_lib.h"
35
36	#define MAXSERVICES 1000
37
38	/* Should be not needed - all dirs are on same FS, right? */
39	#define CHECK_DEVNO_TOO 0
40
41	struct service {
42	#if CHECK_DEVNO_TOO
43	dev_t dev;
44	#endif
45	ino_t ino;
46	pid_t pid;
47	smallint isgone;
48	};
49
50	struct globals {
51	struct service *sv;
52	char *svdir;
53	int svnum;
54	#if ENABLE_FEATURE_RUNSVDIR_LOG
55	char *rplog;
56	int rploglen;
57	struct fd_pair logpipe;
58	struct pollfd pfd[1];
59	unsigned stamplog;
60	#endif
61	};
62	#define G ((struct globals)&bb_common_bufsiz1)
63	#define sv (G.sv )
64	#define svdir (G.svdir )
65	#define svnum (G.svnum )
66	#define rplog (G.rplog )
67	#define rploglen (G.rploglen )
68	#define logpipe (G.logpipe )
69	#define pfd (G.pfd )
70	#define stamplog (G.stamplog )
71	#define INIT_G() do { \
72	} while (0)
73
74	static void fatal2_cannot(const char m1, const char m2)
75	{
76	bb_perror_msg_and_die("%s: fatal: can't %s%s", svdir, m1, m2);
77	/* was exiting 100 */
78	}
79	static void warn3x(const char m1, const char m2, const char *m3)
80	{
81	bb_error_msg("%s: warning: %s%s%s", svdir, m1, m2, m3);
82	}
83	static void warn2_cannot(const char m1, const char m2)
84	{
85	warn3x("can't ", m1, m2);
86	}
87	#if ENABLE_FEATURE_RUNSVDIR_LOG
88	static void warnx(const char *m1)
89	{
90	warn3x(m1, "", "");
91	}
92	#endif
93
94	/* inlining + vfork -> bigger code */
95	static NOINLINE pid_t runsv(const char *name)
96	{
97	pid_t pid;
98
99	/* If we got signaled, stop spawning children at once! */
100	if (bb_got_signal)
101	return 0;
102
103	pid = vfork();
104	if (pid == -1) {
105	warn2_cannot("vfork", "");
106	return 0;
107	}
108	if (pid == 0) {
109	/* child */
110	if (option_mask32 & 1) /* -P option? */
111	setsid();
112	/* man execv:
113	* "Signals set to be caught by the calling process image
114	* shall be set to the default action in the new process image."
115	* Therefore, we do not need this: */
116	#if 0
117	bb_signals(0
118	\| (1 << SIGHUP)
119	\| (1 << SIGTERM)
120	, SIG_DFL);
121	#endif
122	execlp("runsv", "runsv", name, (char *) NULL);
123	fatal2_cannot("start runsv ", name);
124	}
125	return pid;
126	}
127
128	/* gcc 4.3.0 does better with NOINLINE */
129	static NOINLINE int do_rescan(void)
130	{
131	DIR *dir;
132	struct dirent *d;
133	int i;
134	struct stat s;
135	int need_rescan = 0;
136
137	dir = opendir(".");
138	if (!dir) {
139	warn2_cannot("open directory ", svdir);
140	return 1; /* need to rescan again soon */
141	}
142	for (i = 0; i < svnum; i++)
143	sv[i].isgone = 1;
144
145	while (1) {
146	errno = 0;
147	d = readdir(dir);
148	if (!d)
149	break;
150	if (d->d_name[0] == '.')
151	continue;
152	if (stat(d->d_name, &s) == -1) {
153	warn2_cannot("stat ", d->d_name);
154	continue;
155	}
156	if (!S_ISDIR(s.st_mode))
157	continue;
158	/* Do we have this service listed already? */
159	for (i = 0; i < svnum; i++) {
160	if ((sv[i].ino == s.st_ino)
161	#if CHECK_DEVNO_TOO
162	&& (sv[i].dev == s.st_dev)
163	#endif
164	) {
165	if (sv[i].pid == 0) /* restart if it has died */
166	goto run_ith_sv;
167	sv[i].isgone = 0; /* "we still see you" */
168	goto next_dentry;
169	}
170	}
171	{ /* Not found, make new service */
172	struct service svnew = realloc(sv, (i+1) sizeof(*sv));
173	if (!svnew) {
174	warn2_cannot("start runsv ", d->d_name);
175	need_rescan = 1;
176	continue;
177	}
178	sv = svnew;
179	svnum++;
180	#if CHECK_DEVNO_TOO
181	sv[i].dev = s.st_dev;
182	#endif
183	sv[i].ino = s.st_ino;
184	run_ith_sv:
185	sv[i].pid = runsv(d->d_name);
186	sv[i].isgone = 0;
187	}
188	next_dentry: ;
189	}
190	i = errno;
191	closedir(dir);
192	if (i) { /* readdir failed */
193	warn2_cannot("read directory ", svdir);
194	return 1; /* need to rescan again soon */
195	}
196
197	/* Send SIGTERM to runsv whose directories
198	* were no longer found (-> must have been removed) */
199	for (i = 0; i < svnum; i++) {
200	if (!sv[i].isgone)
201	continue;
202	if (sv[i].pid)
203	kill(sv[i].pid, SIGTERM);
204	svnum--;
205	sv[i] = sv[svnum];
206	i--; /* so that we don't skip new sv[i] (bug was here!) */
207	}
208	return need_rescan;
209	}
210
211	int runsvdir_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
212	int runsvdir_main(int argc UNUSED_PARAM, char **argv)
213	{
214	struct stat s;
215	dev_t last_dev = last_dev; /* for gcc */
216	ino_t last_ino = last_ino; /* for gcc */
217	time_t last_mtime = 0;
218	int wstat;
219	int curdir;
220	pid_t pid;
221	unsigned deadline;
222	unsigned now;
223	unsigned stampcheck;
224	int i;
225	int need_rescan = 1;
226	char *opt_s_argv[3];
227
228	INIT_G();
229
230	opt_complementary = "-1";
231	opt_s_argv[0] = NULL;
232	opt_s_argv[2] = NULL;
233	getopt32(argv, "Ps:", &opt_s_argv[0]);
234	argv += optind;
235
236	bb_signals(0
237	\| (1 << SIGTERM)
238	\| (1 << SIGHUP)
239	/* For busybox's init, SIGTERM == reboot,
240	* SIGUSR1 == halt
241	* SIGUSR2 == poweroff
242	* so we need to intercept SIGUSRn too.
243	* Note that we do not implement actual reboot
244	* (killall(TERM) + umount, etc), we just pause
245	* respawing and avoid exiting (-> making kernel oops).
246	* The user is responsible for the rest. */
247	\| (getpid() == 1 ? ((1 << SIGUSR1) \| (1 << SIGUSR2)) : 0)
248	, record_signo);
249	svdir = *argv++;
250
251	#if ENABLE_FEATURE_RUNSVDIR_LOG
252	/* setup log */
253	if (*argv) {
254	rplog = *argv;
255	rploglen = strlen(rplog);
256	if (rploglen < 7) {
257	warnx("log must have at least seven characters");
258	} else if (piped_pair(logpipe)) {
259	warnx("can't create pipe for log");
260	} else {
261	close_on_exec_on(logpipe.rd);
262	close_on_exec_on(logpipe.wr);
263	ndelay_on(logpipe.rd);
264	ndelay_on(logpipe.wr);
265	if (dup2(logpipe.wr, 2) == -1) {
266	warnx("can't set filedescriptor for log");
267	} else {
268	pfd[0].fd = logpipe.rd;
269	pfd[0].events = POLLIN;
270	stamplog = monotonic_sec();
271	goto run;
272	}
273	}
274	rplog = NULL;
275	warnx("log service disabled");
276	}
277	run:
278	#endif
279	curdir = open_read(".");
280	if (curdir == -1)
281	fatal2_cannot("open current directory", "");
282	close_on_exec_on(curdir);
283
284	stampcheck = monotonic_sec();
285
286	for (;;) {
287	/* collect children */
288	for (;;) {
289	pid = wait_any_nohang(&wstat);
290	if (pid <= 0)
291	break;
292	for (i = 0; i < svnum; i++) {
293	if (pid == sv[i].pid) {
294	/* runsv has died */
295	sv[i].pid = 0;
296	need_rescan = 1;
297	}
298	}
299	}
300
301	now = monotonic_sec();
302	if ((int)(now - stampcheck) >= 0) {
303	/* wait at least a second */
304	stampcheck = now + 1;
305
306	if (stat(svdir, &s) != -1) {
307	if (need_rescan \|\| s.st_mtime != last_mtime
308	\|\| s.st_ino != last_ino \|\| s.st_dev != last_dev
309	) {
310	/* svdir modified */
311	if (chdir(svdir) != -1) {
312	last_mtime = s.st_mtime;
313	last_dev = s.st_dev;
314	last_ino = s.st_ino;
315	//if (now <= mtime)
316	// sleep(1);
317	need_rescan = do_rescan();
318	while (fchdir(curdir) == -1) {
319	warn2_cannot("change directory, pausing", "");
320	sleep(5);
321	}
322	} else {
323	warn2_cannot("change directory to ", svdir);
324	}
325	}
326	} else {
327	warn2_cannot("stat ", svdir);
328	}
329	}
330
331	#if ENABLE_FEATURE_RUNSVDIR_LOG
332	if (rplog) {
333	if ((int)(now - stamplog) >= 0) {
334	write(logpipe.wr, ".", 1);
335	stamplog = now + 900;
336	}
337	}
338	pfd[0].revents = 0;
339	#endif
340	deadline = (need_rescan ? 1 : 5);
341	sig_block(SIGCHLD);
342	#if ENABLE_FEATURE_RUNSVDIR_LOG
343	if (rplog)
344	poll(pfd, 1, deadline*1000);
345	else
346	#endif
347	sleep(deadline);
348	sig_unblock(SIGCHLD);
349
350	#if ENABLE_FEATURE_RUNSVDIR_LOG
351	if (pfd[0].revents & POLLIN) {
352	char ch;
353	while (read(logpipe.rd, &ch, 1) > 0) {
354	if (ch < ' ')
355	ch = ' ';
356	for (i = 6; i < rploglen; i++)
357	rplog[i-1] = rplog[i];
358	rplog[rploglen-1] = ch;
359	}
360	}
361	#endif
362	if (!bb_got_signal)
363	continue;
364
365	/* -s SCRIPT: useful if we are init.
366	* In this case typically script never returns,
367	* it halts/powers off/reboots the system. */
368	if (opt_s_argv[0]) {
369	/* Single parameter: signal# */
370	opt_s_argv[1] = utoa(bb_got_signal);
371	pid = spawn(opt_s_argv);
372	if (pid > 0) {
373	/* Remembering to wait for _any_ children,
374	* not just pid */
375	while (wait(NULL) != pid)
376	continue;
377	}
378	}
379
380	if (bb_got_signal == SIGHUP) {
381	for (i = 0; i < svnum; i++)
382	if (sv[i].pid)
383	kill(sv[i].pid, SIGTERM);
384	}
385	/* SIGHUP or SIGTERM (or SIGUSRn if we are init) */
386	/* Exit unless we are init */
387	if (getpid() != 1)
388	return (SIGHUP == bb_got_signal) ? 111 : EXIT_SUCCESS;
389
390	/* init continues to monitor services forever */
391	bb_got_signal = 0;
392	} /* for (;;) */
393	}