path: root/runit/runsv.c (plain)
blob: d941e897d0baf7917c3a8c084e16211f4590201f

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	//usage:#define runsv_trivial_usage
32	//usage: "DIR"
33	//usage:#define runsv_full_usage "\n\n"
34	//usage: "Start and monitor a service and optionally an appendant log service"
35
36	#include <sys/file.h>
37	#include "libbb.h"
38	#include "runit_lib.h"
39
40	#if ENABLE_MONOTONIC_SYSCALL
41	#include <sys/syscall.h>
42
43	/* libc has incredibly messy way of doing this,
44	* typically requiring -lrt. We just skip all this mess */
45	static void gettimeofday_ns(struct timespec *ts)
46	{
47	syscall(__NR_clock_gettime, CLOCK_REALTIME, ts);
48	}
49	#else
50	static void gettimeofday_ns(struct timespec *ts)
51	{
52	if (sizeof(struct timeval) == sizeof(struct timespec)
53	&& sizeof(((struct timeval*)ts)->tv_usec) == sizeof(ts->tv_nsec)
54	) {
55	/* Cheat */
56	gettimeofday((void*)ts, NULL);
57	ts->tv_nsec *= 1000;
58	} else {
59	extern void BUG_need_to_implement_gettimeofday_ns(void);
60	BUG_need_to_implement_gettimeofday_ns();
61	}
62	}
63	#endif
64
65	/* Compare possibly overflowing unsigned counters */
66	#define LESS(a,b) ((int)((unsigned)(b) - (unsigned)(a)) > 0)
67
68	/* state */
69	#define S_DOWN 0
70	#define S_RUN 1
71	#define S_FINISH 2
72	/* ctrl */
73	#define C_NOOP 0
74	#define C_TERM 1
75	#define C_PAUSE 2
76	/* want */
77	#define W_UP 0
78	#define W_DOWN 1
79	#define W_EXIT 2
80
81	struct svdir {
82	int pid;
83	smallint state;
84	smallint ctrl;
85	smallint sd_want;
86	smallint islog;
87	struct timespec start;
88	int fdlock;
89	int fdcontrol;
90	int fdcontrolwrite;
91	int wstat;
92	};
93
94	struct globals {
95	smallint haslog;
96	smallint sigterm;
97	smallint pidchanged;
98	struct fd_pair selfpipe;
99	struct fd_pair logpipe;
100	char *dir;
101	struct svdir svd[2];
102	} FIX_ALIASING;
103	#define G (*(struct globals*)&bb_common_bufsiz1)
104	#define haslog (G.haslog )
105	#define sigterm (G.sigterm )
106	#define pidchanged (G.pidchanged )
107	#define selfpipe (G.selfpipe )
108	#define logpipe (G.logpipe )
109	#define dir (G.dir )
110	#define svd (G.svd )
111	#define INIT_G() do { \
112	pidchanged = 1; \
113	} while (0)
114
115	static void fatal2_cannot(const char *m1, const char *m2)
116	{
117	bb_perror_msg_and_die("%s: fatal: cannot %s%s", dir, m1, m2);
118	/* was exiting 111 */
119	}
120	static void fatal_cannot(const char *m)
121	{
122	fatal2_cannot(m, "");
123	/* was exiting 111 */
124	}
125	static void fatal2x_cannot(const char *m1, const char *m2)
126	{
127	bb_error_msg_and_die("%s: fatal: cannot %s%s", dir, m1, m2);
128	/* was exiting 111 */
129	}
130	static void warn_cannot(const char *m)
131	{
132	bb_perror_msg("%s: warning: cannot %s", dir, m);
133	}
134
135	static void s_child(int sig_no UNUSED_PARAM)
136	{
137	write(selfpipe.wr, "", 1);
138	}
139
140	static void s_term(int sig_no UNUSED_PARAM)
141	{
142	sigterm = 1;
143	write(selfpipe.wr, "", 1); /* XXX */
144	}
145
146	static int open_trunc_or_warn(const char *name)
147	{
148	/* Why O_NDELAY? */
149	int fd = open(name, O_WRONLY | O_NDELAY | O_TRUNC | O_CREAT, 0644);
150	if (fd < 0)
151	bb_perror_msg("%s: warning: cannot open %s",
152	dir, name);
153	return fd;
154	}
155
156	static void update_status(struct svdir *s)
157	{
158	ssize_t sz;
159	int fd;
160	svstatus_t status;
161
162	/* pid */
163	if (pidchanged) {
164	fd = open_trunc_or_warn("supervise/pid.new");
165	if (fd < 0)
166	return;
167	if (s->pid) {
168	char spid[sizeof(int)*3 + 2];
169	int size = sprintf(spid, "%u\n", (unsigned)s->pid);
170	write(fd, spid, size);
171	}
172	close(fd);
173	if (rename_or_warn("supervise/pid.new",
174	s->islog ? "log/supervise/pid" : "log/supervise/pid"+4))
175	return;
176	pidchanged = 0;
177	}
178
179	/* stat */
180	fd = open_trunc_or_warn("supervise/stat.new");
181	if (fd < -1)
182	return;
183
184	{
185	char stat_buf[sizeof("finish, paused, got TERM, want down\n")];
186	char *p = stat_buf;
187	switch (s->state) {
188	case S_DOWN:
189	p = stpcpy(p, "down");
190	break;
191	case S_RUN:
192	p = stpcpy(p, "run");
193	break;
194	case S_FINISH:
195	p = stpcpy(p, "finish");
196	break;
197	}
198	if (s->ctrl & C_PAUSE)
199	p = stpcpy(p, ", paused");
200	if (s->ctrl & C_TERM)
201	p = stpcpy(p, ", got TERM");
202	if (s->state != S_DOWN)
203	switch (s->sd_want) {
204	case W_DOWN:
205	p = stpcpy(p, ", want down");
206	break;
207	case W_EXIT:
208	p = stpcpy(p, ", want exit");
209	break;
210	}
211	*p++ = '\n';
212	write(fd, stat_buf, p - stat_buf);
213	close(fd);
214	}
215
216	rename_or_warn("supervise/stat.new",
217	s->islog ? "log/supervise/stat" : "log/supervise/stat"+4);
218
219	/* supervise compatibility */
220	memset(&status, 0, sizeof(status));
221	status.time_be64 = SWAP_BE64(s->start.tv_sec + 0x400000000000000aULL);
222	status.time_nsec_be32 = SWAP_BE32(s->start.tv_nsec);
223	status.pid_le32 = SWAP_LE32(s->pid);
224	if (s->ctrl & C_PAUSE)
225	status.paused = 1;
226	if (s->sd_want == W_UP)
227	status.want = 'u';
228	else
229	status.want = 'd';
230	if (s->ctrl & C_TERM)
231	status.got_term = 1;
232	status.run_or_finish = s->state;
233	fd = open_trunc_or_warn("supervise/status.new");
234	if (fd < 0)
235	return;
236	sz = write(fd, &status, sizeof(status));
237	close(fd);
238	if (sz != sizeof(status)) {
239	warn_cannot("write supervise/status.new");
240	unlink("supervise/status.new");
241	return;
242	}
243	rename_or_warn("supervise/status.new",
244	s->islog ? "log/supervise/status" : "log/supervise/status"+4);
245	}
246
247	static unsigned custom(struct svdir *s, char c)
248	{
249	pid_t pid;
250	int w;
251	char a[10];
252	struct stat st;
253
254	if (s->islog)
255	return 0;
256	strcpy(a, "control/?");
257	a[8] = c; /* replace '?' */
258	if (stat(a, &st) == 0) {
259	if (st.st_mode & S_IXUSR) {
260	pid = vfork();
261	if (pid == -1) {
262	warn_cannot("vfork for control/?");
263	return 0;
264	}
265	if (pid == 0) {
266	/* child */
267	if (haslog && dup2(logpipe.wr, 1) == -1)
268	warn_cannot("setup stdout for control/?");
269	execl(a, a, (char *) NULL);
270	fatal_cannot("run control/?");
271	}
272	/* parent */
273	if (safe_waitpid(pid, &w, 0) == -1) {
274	warn_cannot("wait for child control/?");
275	return 0;
276	}
277	return WEXITSTATUS(w) == 0;
278	}
279	} else {
280	if (errno != ENOENT)
281	warn_cannot("stat control/?");
282	}
283	return 0;
284	}
285
286	static void stopservice(struct svdir *s)
287	{
288	if (s->pid && !custom(s, 't')) {
289	kill(s->pid, SIGTERM);
290	s->ctrl |= C_TERM;
291	update_status(s);
292	}
293	if (s->sd_want == W_DOWN) {
294	kill(s->pid, SIGCONT);
295	custom(s, 'd');
296	return;
297	}
298	if (s->sd_want == W_EXIT) {
299	kill(s->pid, SIGCONT);
300	custom(s, 'x');
301	}
302	}
303
304	static void startservice(struct svdir *s)
305	{
306	int p;
307	const char *arg[4];
308	char exitcode[sizeof(int)*3 + 2];
309
310	if (s->state == S_FINISH) {
311	/* Two arguments are given to ./finish. The first one is ./run exit code,
312	* or -1 if ./run didnt exit normally. The second one is
313	* the least significant byte of the exit status as determined by waitpid;
314	* for instance it is 0 if ./run exited normally, and the signal number
315	* if ./run was terminated by a signal. If runsv cannot start ./run
316	* for some reason, the exit code is 111 and the status is 0.
317	*/
318	arg[0] = "./finish";
319	arg[1] = "-1";
320	if (WIFEXITED(s->wstat)) {
321	*utoa_to_buf(WEXITSTATUS(s->wstat), exitcode, sizeof(exitcode)) = '\0';
322	arg[1] = exitcode;
323	}
324	//arg[2] = "0";
325	//if (WIFSIGNALED(s->wstat)) {
326	arg[2] = utoa(WTERMSIG(s->wstat));
327	//}
328	arg[3] = NULL;
329	} else {
330	arg[0] = "./run";
331	arg[1] = NULL;
332	custom(s, 'u');
333	}
334
335	if (s->pid != 0)
336	stopservice(s); /* should never happen */
337	while ((p = vfork()) == -1) {
338	warn_cannot("vfork, sleeping");
339	sleep(5);
340	}
341	if (p == 0) {
342	/* child */
343	if (haslog) {
344	/* NB: bug alert! right order is close, then dup2 */
345	if (s->islog) {
346	xchdir("./log");
347	close(logpipe.wr);
348	xdup2(logpipe.rd, 0);
349	} else {
350	close(logpipe.rd);
351	xdup2(logpipe.wr, 1);
352	}
353	}
354	/* Non-ignored signals revert to SIG_DFL on exec anyway */
355	/*bb_signals(0
356	+ (1 << SIGCHLD)
357	+ (1 << SIGTERM)
358	, SIG_DFL);*/
359	sig_unblock(SIGCHLD);
360	sig_unblock(SIGTERM);
361	execv(arg[0], (char**) arg);
362	fatal2_cannot(s->islog ? "start log/" : "start ", arg[0]);
363	}
364	/* parent */
365	if (s->state != S_FINISH) {
366	gettimeofday_ns(&s->start);
367	s->state = S_RUN;
368	}
369	s->pid = p;
370	pidchanged = 1;
371	s->ctrl = C_NOOP;
372	update_status(s);
373	}
374
375	static int ctrl(struct svdir *s, char c)
376	{
377	int sig;
378
379	switch (c) {
380	case 'd': /* down */
381	s->sd_want = W_DOWN;
382	update_status(s);
383	if (s->pid && s->state != S_FINISH)
384	stopservice(s);
385	break;
386	case 'u': /* up */
387	s->sd_want = W_UP;
388	update_status(s);
389	if (s->pid == 0)
390	startservice(s);
391	break;
392	case 'x': /* exit */
393	if (s->islog)
394	break;
395	s->sd_want = W_EXIT;
396	update_status(s);
397	/* FALLTHROUGH */
398	case 't': /* sig term */
399	if (s->pid && s->state != S_FINISH)
400	stopservice(s);
401	break;
402	case 'k': /* sig kill */
403	if (s->pid && !custom(s, c))
404	kill(s->pid, SIGKILL);
405	s->state = S_DOWN;
406	break;
407	case 'p': /* sig pause */
408	if (s->pid && !custom(s, c))
409	kill(s->pid, SIGSTOP);
410	s->ctrl |= C_PAUSE;
411	update_status(s);
412	break;
413	case 'c': /* sig cont */
414	if (s->pid && !custom(s, c))
415	kill(s->pid, SIGCONT);
416	s->ctrl &= ~C_PAUSE;
417	update_status(s);
418	break;
419	case 'o': /* once */
420	s->sd_want = W_DOWN;
421	update_status(s);
422	if (!s->pid)
423	startservice(s);
424	break;
425	case 'a': /* sig alarm */
426	sig = SIGALRM;
427	goto sendsig;
428	case 'h': /* sig hup */
429	sig = SIGHUP;
430	goto sendsig;
431	case 'i': /* sig int */
432	sig = SIGINT;
433	goto sendsig;
434	case 'q': /* sig quit */
435	sig = SIGQUIT;
436	goto sendsig;
437	case '1': /* sig usr1 */
438	sig = SIGUSR1;
439	goto sendsig;
440	case '2': /* sig usr2 */
441	sig = SIGUSR2;
442	goto sendsig;
443	}
444	return 1;
445	sendsig:
446	if (s->pid && !custom(s, c))
447	kill(s->pid, sig);
448	return 1;
449	}
450
451	int runsv_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
452	int runsv_main(int argc UNUSED_PARAM, char **argv)
453	{
454	struct stat s;
455	int fd;
456	int r;
457	char buf[256];
458
459	INIT_G();
460
461	dir = single_argv(argv);
462
463	xpiped_pair(selfpipe);
464	close_on_exec_on(selfpipe.rd);
465	close_on_exec_on(selfpipe.wr);
466	ndelay_on(selfpipe.rd);
467	ndelay_on(selfpipe.wr);
468
469	sig_block(SIGCHLD);
470	bb_signals_recursive_norestart(1 << SIGCHLD, s_child);
471	sig_block(SIGTERM);
472	bb_signals_recursive_norestart(1 << SIGTERM, s_term);
473
474	xchdir(dir);
475	/* bss: svd[0].pid = 0; */
476	if (S_DOWN) svd[0].state = S_DOWN; /* otherwise already 0 (bss) */
477	if (C_NOOP) svd[0].ctrl = C_NOOP;
478	if (W_UP) svd[0].sd_want = W_UP;
479	/* bss: svd[0].islog = 0; */
480	/* bss: svd[1].pid = 0; */
481	gettimeofday_ns(&svd[0].start);
482	if (stat("down", &s) != -1)
483	svd[0].sd_want = W_DOWN;
484
485	if (stat("log", &s) == -1) {
486	if (errno != ENOENT)
487	warn_cannot("stat ./log");
488	} else {
489	if (!S_ISDIR(s.st_mode)) {
490	errno = 0;
491	warn_cannot("stat log/down: log is not a directory");
492	} else {
493	haslog = 1;
494	svd[1].state = S_DOWN;
495	svd[1].ctrl = C_NOOP;
496	svd[1].sd_want = W_UP;
497	svd[1].islog = 1;
498	gettimeofday_ns(&svd[1].start);
499	if (stat("log/down", &s) != -1)
500	svd[1].sd_want = W_DOWN;
501	xpiped_pair(logpipe);
502	close_on_exec_on(logpipe.rd);
503	close_on_exec_on(logpipe.wr);
504	}
505	}
506
507	if (mkdir("supervise", 0700) == -1) {
508	r = readlink("supervise", buf, sizeof(buf));
509	if (r != -1) {
510	if (r == sizeof(buf))
511	fatal2x_cannot("readlink ./supervise", ": name too long");
512	buf[r] = 0;
513	mkdir(buf, 0700);
514	} else {
515	if ((errno != ENOENT) && (errno != EINVAL))
516	fatal_cannot("readlink ./supervise");
517	}
518	}
519	svd[0].fdlock = xopen3("log/supervise/lock"+4,
520	O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600);
521	if (flock(svd[0].fdlock, LOCK_EX | LOCK_NB) == -1)
522	fatal_cannot("lock supervise/lock");
523	close_on_exec_on(svd[0].fdlock);
524	if (haslog) {
525	if (mkdir("log/supervise", 0700) == -1) {
526	r = readlink("log/supervise", buf, 256);
527	if (r != -1) {
528	if (r == 256)
529	fatal2x_cannot("readlink ./log/supervise", ": name too long");
530	buf[r] = 0;
531	fd = xopen(".", O_RDONLY|O_NDELAY);
532	xchdir("./log");
533	mkdir(buf, 0700);
534	if (fchdir(fd) == -1)
535	fatal_cannot("change back to service directory");
536	close(fd);
537	}
538	else {
539	if ((errno != ENOENT) && (errno != EINVAL))
540	fatal_cannot("readlink ./log/supervise");
541	}
542	}
543	svd[1].fdlock = xopen3("log/supervise/lock",
544	O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600);
545	if (flock(svd[1].fdlock, LOCK_EX) == -1)
546	fatal_cannot("lock log/supervise/lock");
547	close_on_exec_on(svd[1].fdlock);
548	}
549
550	mkfifo("log/supervise/control"+4, 0600);
551	svd[0].fdcontrol = xopen("log/supervise/control"+4, O_RDONLY|O_NDELAY);
552	close_on_exec_on(svd[0].fdcontrol);
553	svd[0].fdcontrolwrite = xopen("log/supervise/control"+4, O_WRONLY|O_NDELAY);
554	close_on_exec_on(svd[0].fdcontrolwrite);
555	update_status(&svd[0]);
556	if (haslog) {
557	mkfifo("log/supervise/control", 0600);
558	svd[1].fdcontrol = xopen("log/supervise/control", O_RDONLY|O_NDELAY);
559	close_on_exec_on(svd[1].fdcontrol);
560	svd[1].fdcontrolwrite = xopen("log/supervise/control", O_WRONLY|O_NDELAY);
561	close_on_exec_on(svd[1].fdcontrolwrite);
562	update_status(&svd[1]);
563	}
564	mkfifo("log/supervise/ok"+4, 0600);
565	fd = xopen("log/supervise/ok"+4, O_RDONLY|O_NDELAY);
566	close_on_exec_on(fd);
567	if (haslog) {
568	mkfifo("log/supervise/ok", 0600);
569	fd = xopen("log/supervise/ok", O_RDONLY|O_NDELAY);
570	close_on_exec_on(fd);
571	}
572	for (;;) {
573	struct pollfd x[3];
574	unsigned deadline;
575	char ch;
576
577	if (haslog)
578	if (!svd[1].pid && svd[1].sd_want == W_UP)
579	startservice(&svd[1]);
580	if (!svd[0].pid)
581	if (svd[0].sd_want == W_UP || svd[0].state == S_FINISH)
582	startservice(&svd[0]);
583
584	x[0].fd = selfpipe.rd;
585	x[0].events = POLLIN;
586	x[1].fd = svd[0].fdcontrol;
587	x[1].events = POLLIN;
588	/* x[2] is used only if haslog == 1 */
589	x[2].fd = svd[1].fdcontrol;
590	x[2].events = POLLIN;
591	sig_unblock(SIGTERM);
592	sig_unblock(SIGCHLD);
593	poll(x, 2 + haslog, 3600*1000);
594	sig_block(SIGTERM);
595	sig_block(SIGCHLD);
596
597	while (read(selfpipe.rd, &ch, 1) == 1)
598	continue;
599
600	for (;;) {
601	pid_t child;
602	int wstat;
603
604	child = wait_any_nohang(&wstat);
605	if (!child)
606	break;
607	if ((child == -1) && (errno != EINTR))
608	break;
609	if (child == svd[0].pid) {
610	svd[0].wstat = wstat;
611	svd[0].pid = 0;
612	pidchanged = 1;
613	svd[0].ctrl &= ~C_TERM;
614	if (svd[0].state != S_FINISH) {
615	fd = open("finish", O_RDONLY|O_NDELAY);
616	if (fd != -1) {
617	close(fd);
618	svd[0].state = S_FINISH;
619	update_status(&svd[0]);
620	continue;
621	}
622	}
623	svd[0].state = S_DOWN;
624	deadline = svd[0].start.tv_sec + 1;
625	gettimeofday_ns(&svd[0].start);
626	update_status(&svd[0]);
627	if (LESS(svd[0].start.tv_sec, deadline))
628	sleep(1);
629	}
630	if (haslog) {
631	if (child == svd[1].pid) {
632	svd[0].wstat = wstat;
633	svd[1].pid = 0;
634	pidchanged = 1;
635	svd[1].state = S_DOWN;
636	svd[1].ctrl &= ~C_TERM;
637	deadline = svd[1].start.tv_sec + 1;
638	gettimeofday_ns(&svd[1].start);
639	update_status(&svd[1]);
640	if (LESS(svd[1].start.tv_sec, deadline))
641	sleep(1);
642	}
643	}
644	} /* for (;;) */
645	if (read(svd[0].fdcontrol, &ch, 1) == 1)
646	ctrl(&svd[0], ch);
647	if (haslog)
648	if (read(svd[1].fdcontrol, &ch, 1) == 1)
649	ctrl(&svd[1], ch);
650
651	if (sigterm) {
652	ctrl(&svd[0], 'x');
653	sigterm = 0;
654	}
655
656	if (svd[0].sd_want == W_EXIT && svd[0].state == S_DOWN) {
657	if (svd[1].pid == 0)
658	_exit(EXIT_SUCCESS);
659	if (svd[1].sd_want != W_EXIT) {
660	svd[1].sd_want = W_EXIT;
661	/* stopservice(&svd[1]); */
662	update_status(&svd[1]);
663	close(logpipe.wr);
664	close(logpipe.rd);
665	}
666	}
667	} /* for (;;) */
668	/* not reached */
669	return 0;
670	}
671