busybox/runit/runsvdir.c

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

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

#define MAXSERVICES 1000

static char *svdir;
static unsigned long dev;
static unsigned long ino;
static struct service {
	unsigned long dev;
	unsigned long ino;
	int pid;
	int isgone;
} *sv;
static int svnum;
static int check = 1;
static char *rplog;
static int rploglen;
static int logpipe[2];
static iopause_fd io[1];
static struct taia stamplog;
static int exitsoon;
static int pgrp;

#define usage() bb_show_usage()
static void fatal2_cannot(char *m1, char *m2)
{
	bb_perror_msg_and_die("%s: fatal: cannot %s%s", svdir, m1, m2);
	/* was exiting 100 */
}
static void warn3x(char *m1, char *m2, char *m3)
{
	bb_error_msg("%s: warning: %s%s%s", svdir, m1, m2, m3);
}
static void warn2_cannot(char *m1, char *m2)
{
	warn3x("cannot ", m1, m2);
}
static void warnx(char *m1)
{
	warn3x(m1, "", "");
}

static void s_term(int sig_no)
{
	exitsoon = 1;
}
static void s_hangup(int sig_no)
{
	exitsoon = 2;
}

static void runsv(int no, char *name)
{
	int pid = fork();

	if (pid == -1) {
		warn2_cannot("fork for ", name);
		return;
	}
	if (pid == 0) {
		/* child */
		char *prog[3];

		prog[0] = "runsv";
		prog[1] = name;
		prog[2] = 0;
		sig_uncatch(sig_hangup);
		sig_uncatch(sig_term);
		if (pgrp) setsid();
		execvp(prog[0], prog);
		//pathexec_run(*prog, prog, (char* const*)environ);
		fatal2_cannot("start runsv ", name);
	}
	sv[no].pid = pid;
}

static void runsvdir(void)
{
	DIR *dir;
	direntry *d;
	int i;
	struct stat s;

	dir = opendir(".");
	if (!dir) {
		warn2_cannot("open directory ", svdir);
		return;
	}
	for (i = 0; i < svnum; i++)
		sv[i].isgone = 1;
	errno = 0;
	while ((d = readdir(dir))) {
		if (d->d_name[0] == '.') continue;
		if (stat(d->d_name, &s) == -1) {
			warn2_cannot("stat ", d->d_name);
			errno = 0;
			continue;
		}
		if (!S_ISDIR(s.st_mode)) continue;
		for (i = 0; i < svnum; i++) {
			if ((sv[i].ino == s.st_ino) && (sv[i].dev == s.st_dev)) {
				sv[i].isgone = 0;
				if (!sv[i].pid)
					runsv(i, d->d_name);
				break;
			}
		}
		if (i == svnum) {
			/* new service */
			struct service *svnew = realloc(sv, (i+1) * sizeof(*sv));
			if (!svnew) {
				warn3x("cannot start runsv ", d->d_name,
						" too many services");
				continue;
			}
			sv = svnew;
			svnum++;
			memset(&sv[i], 0, sizeof(sv[i]));
			sv[i].ino = s.st_ino;
			sv[i].dev = s.st_dev;
			//sv[i].pid = 0;
			//sv[i].isgone = 0;
			runsv(i, d->d_name);
			check = 1;
		}
	}
	if (errno) {
		warn2_cannot("read directory ", svdir);
		closedir(dir);
		check = 1;
		return;
	}
	closedir(dir);

	/* SIGTERM removed runsv's */
	for (i = 0; i < svnum; i++) {
		if (!sv[i].isgone)
			continue;
		if (sv[i].pid)
			kill(sv[i].pid, SIGTERM);
		sv[i] = sv[--svnum];
		check = 1;
	}
}

static int setup_log(void)
{
	rploglen = strlen(rplog);
	if (rploglen < 7) {
		warnx("log must have at least seven characters");
		return 0;
	}
	if (pipe(logpipe) == -1) {
		warnx("cannot create pipe for log");
		return -1;
	}
	coe(logpipe[1]);
	coe(logpipe[0]);
	ndelay_on(logpipe[0]);
	ndelay_on(logpipe[1]);
	if (fd_copy(2, logpipe[1]) == -1) {
		warnx("cannot set filedescriptor for log");
		return -1;
	}
	io[0].fd = logpipe[0];
	io[0].events = IOPAUSE_READ;
	taia_now(&stamplog);
	return 1;
}

int runsvdir_main(int argc, char **argv)
{
	struct stat s;
	time_t mtime = 0;
	int wstat;
	int curdir;
	int pid;
	struct taia deadline;
	struct taia now;
	struct taia stampcheck;
	char ch;
	int i;

	argv++;
	if (!argv || !*argv) usage();
	if (**argv == '-') {
		switch (*(*argv + 1)) {
		case 'P': pgrp = 1;
		case '-': ++argv;
		}
		if (!argv || !*argv) usage();
	}

	sig_catch(sig_term, s_term);
	sig_catch(sig_hangup, s_hangup);
	svdir = *argv++;
	if (argv && *argv) {
		rplog = *argv;
		if (setup_log() != 1) {
			rplog = 0;
			warnx("log service disabled");
		}
	}
	curdir = open_read(".");
	if (curdir == -1)
		fatal2_cannot("open current directory", "");
	coe(curdir);

	taia_now(&stampcheck);

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

		taia_now(&now);
		if (now.sec.x < (stampcheck.sec.x - 3)) {
			/* time warp */
			warnx("time warp: resetting time stamp");
			taia_now(&stampcheck);
			taia_now(&now);
			if (rplog) taia_now(&stamplog);
		}
		if (taia_less(&now, &stampcheck) == 0) {
			/* wait at least a second */
			taia_uint(&deadline, 1);
			taia_add(&stampcheck, &now, &deadline);

			if (stat(svdir, &s) != -1) {
				if (check || s.st_mtime != mtime
				 || s.st_ino != ino || s.st_dev != dev
				) {
					/* svdir modified */
					if (chdir(svdir) != -1) {
						mtime = s.st_mtime;
						dev = s.st_dev;
						ino = s.st_ino;
						check = 0;
						if (now.sec.x <= (4611686018427387914ULL + (uint64_t)mtime))
							sleep(1);
						runsvdir();
						while (fchdir(curdir) == -1) {
							warn2_cannot("change directory, pausing", "");
							sleep(5);
						}
					} else
						warn2_cannot("change directory to ", svdir);
				}
			} else
				warn2_cannot("stat ", svdir);
		}

		if (rplog) {
			if (taia_less(&now, &stamplog) == 0) {
				write(logpipe[1], ".", 1);
				taia_uint(&deadline, 900);
				taia_add(&stamplog, &now, &deadline);
			}
		}
		taia_uint(&deadline, check ? 1 : 5);
		taia_add(&deadline, &now, &deadline);

		sig_block(sig_child);
		if (rplog)
			iopause(io, 1, &deadline, &now);
		else
			iopause(0, 0, &deadline, &now);
		sig_unblock(sig_child);

		if (rplog && (io[0].revents | IOPAUSE_READ))
			while (read(logpipe[0], &ch, 1) > 0)
				if (ch) {
					for (i = 6; i < rploglen; i++)
						rplog[i-1] = rplog[i];
					rplog[rploglen-1] = ch;
				}

		switch (exitsoon) {
		case 1:
			_exit(0);
		case 2:
			for (i = 0; i < svnum; i++)
				if (sv[i].pid)
					kill(sv[i].pid, SIGTERM);
			_exit(111);
		}
	}
	/* not reached */
	return 0;
}
1	/* Busyboxed by Denis Vlasenko <vda.linux@googlemail.com> */
2	/* TODO: depends on runit_lib.c - review and reduce/eliminate */
3
4	#include <sys/poll.h>
5	#include <sys/file.h>
6	#include "busybox.h"
7	#include "runit_lib.h"
8
9	#define MAXSERVICES 1000
10
11	static char *svdir;
12	static unsigned long dev;
13	static unsigned long ino;
14	static struct service {
15	unsigned long dev;
16	unsigned long ino;
17	int pid;
18	int isgone;
19	} *sv;
20	static int svnum;
21	static int check = 1;
22	static char *rplog;
23	static int rploglen;
24	static int logpipe[2];
25	static iopause_fd io[1];
26	static struct taia stamplog;
27	static int exitsoon;
28	static int pgrp;
29
30	#define usage() bb_show_usage()
31	static void fatal2_cannot(char m1, char m2)
32	{
33	bb_perror_msg_and_die("%s: fatal: cannot %s%s", svdir, m1, m2);
34	/* was exiting 100 */
35	}
36	static void warn3x(char m1, char m2, char *m3)
37	{
38	bb_error_msg("%s: warning: %s%s%s", svdir, m1, m2, m3);
39	}
40	static void warn2_cannot(char m1, char m2)
41	{
42	warn3x("cannot ", m1, m2);
43	}
44	static void warnx(char *m1)
45	{
46	warn3x(m1, "", "");
47	}
48
49	static void s_term(int sig_no)
50	{
51	exitsoon = 1;
52	}
53	static void s_hangup(int sig_no)
54	{
55	exitsoon = 2;
56	}
57
58	static void runsv(int no, char *name)
59	{
60	int pid = fork();
61
62	if (pid == -1) {
63	warn2_cannot("fork for ", name);
64	return;
65	}
66	if (pid == 0) {
67	/* child */
68	char *prog[3];
69
70	prog[0] = "runsv";
71	prog[1] = name;
72	prog[2] = 0;
73	sig_uncatch(sig_hangup);
74	sig_uncatch(sig_term);
75	if (pgrp) setsid();
76	execvp(prog[0], prog);
77	//pathexec_run(prog, prog, (char const*)environ);
78	fatal2_cannot("start runsv ", name);
79	}
80	sv[no].pid = pid;
81	}
82
83	static void runsvdir(void)
84	{
85	DIR *dir;
86	direntry *d;
87	int i;
88	struct stat s;
89
90	dir = opendir(".");
91	if (!dir) {
92	warn2_cannot("open directory ", svdir);
93	return;
94	}
95	for (i = 0; i < svnum; i++)
96	sv[i].isgone = 1;
97	errno = 0;
98	while ((d = readdir(dir))) {
99	if (d->d_name[0] == '.') continue;
100	if (stat(d->d_name, &s) == -1) {
101	warn2_cannot("stat ", d->d_name);
102	errno = 0;
103	continue;
104	}
105	if (!S_ISDIR(s.st_mode)) continue;
106	for (i = 0; i < svnum; i++) {
107	if ((sv[i].ino == s.st_ino) && (sv[i].dev == s.st_dev)) {
108	sv[i].isgone = 0;
109	if (!sv[i].pid)
110	runsv(i, d->d_name);
111	break;
112	}
113	}
114	if (i == svnum) {
115	/* new service */
116	struct service svnew = realloc(sv, (i+1) sizeof(*sv));
117	if (!svnew) {
118	warn3x("cannot start runsv ", d->d_name,
119	" too many services");
120	continue;
121	}
122	sv = svnew;
123	svnum++;
124	memset(&sv[i], 0, sizeof(sv[i]));
125	sv[i].ino = s.st_ino;
126	sv[i].dev = s.st_dev;
127	//sv[i].pid = 0;
128	//sv[i].isgone = 0;
129	runsv(i, d->d_name);
130	check = 1;
131	}
132	}
133	if (errno) {
134	warn2_cannot("read directory ", svdir);
135	closedir(dir);
136	check = 1;
137	return;
138	}
139	closedir(dir);
140
141	/* SIGTERM removed runsv's */
142	for (i = 0; i < svnum; i++) {
143	if (!sv[i].isgone)
144	continue;
145	if (sv[i].pid)
146	kill(sv[i].pid, SIGTERM);
147	sv[i] = sv[--svnum];
148	check = 1;
149	}
150	}
151
152	static int setup_log(void)
153	{
154	rploglen = strlen(rplog);
155	if (rploglen < 7) {
156	warnx("log must have at least seven characters");
157	return 0;
158	}
159	if (pipe(logpipe) == -1) {
160	warnx("cannot create pipe for log");
161	return -1;
162	}
163	coe(logpipe[1]);
164	coe(logpipe[0]);
165	ndelay_on(logpipe[0]);
166	ndelay_on(logpipe[1]);
167	if (fd_copy(2, logpipe[1]) == -1) {
168	warnx("cannot set filedescriptor for log");
169	return -1;
170	}
171	io[0].fd = logpipe[0];
172	io[0].events = IOPAUSE_READ;
173	taia_now(&stamplog);
174	return 1;
175	}
176
177	int runsvdir_main(int argc, char **argv)
178	{
179	struct stat s;
180	time_t mtime = 0;
181	int wstat;
182	int curdir;
183	int pid;
184	struct taia deadline;
185	struct taia now;
186	struct taia stampcheck;
187	char ch;
188	int i;
189
190	argv++;
191	if (!argv \|\| !*argv) usage();
192	if (**argv == '-') {
193	switch ((argv + 1)) {
194	case 'P': pgrp = 1;
195	case '-': ++argv;
196	}
197	if (!argv \|\| !*argv) usage();
198	}
199
200	sig_catch(sig_term, s_term);
201	sig_catch(sig_hangup, s_hangup);
202	svdir = *argv++;
203	if (argv && *argv) {
204	rplog = *argv;
205	if (setup_log() != 1) {
206	rplog = 0;
207	warnx("log service disabled");
208	}
209	}
210	curdir = open_read(".");
211	if (curdir == -1)
212	fatal2_cannot("open current directory", "");
213	coe(curdir);
214
215	taia_now(&stampcheck);
216
217	for (;;) {
218	/* collect children */
219	for (;;) {
220	pid = wait_nohang(&wstat);
221	if (pid <= 0) break;
222	for (i = 0; i < svnum; i++) {
223	if (pid == sv[i].pid) {
224	/* runsv has gone */
225	sv[i].pid = 0;
226	check = 1;
227	break;
228	}
229	}
230	}
231
232	taia_now(&now);
233	if (now.sec.x < (stampcheck.sec.x - 3)) {
234	/* time warp */
235	warnx("time warp: resetting time stamp");
236	taia_now(&stampcheck);
237	taia_now(&now);
238	if (rplog) taia_now(&stamplog);
239	}
240	if (taia_less(&now, &stampcheck) == 0) {
241	/* wait at least a second */
242	taia_uint(&deadline, 1);
243	taia_add(&stampcheck, &now, &deadline);
244
245	if (stat(svdir, &s) != -1) {
246	if (check \|\| s.st_mtime != mtime
247	\|\| s.st_ino != ino \|\| s.st_dev != dev
248	) {
249	/* svdir modified */
250	if (chdir(svdir) != -1) {
251	mtime = s.st_mtime;
252	dev = s.st_dev;
253	ino = s.st_ino;
254	check = 0;
255	if (now.sec.x <= (4611686018427387914ULL + (uint64_t)mtime))
256	sleep(1);
257	runsvdir();
258	while (fchdir(curdir) == -1) {
259	warn2_cannot("change directory, pausing", "");
260	sleep(5);
261	}
262	} else
263	warn2_cannot("change directory to ", svdir);
264	}
265	} else
266	warn2_cannot("stat ", svdir);
267	}
268
269	if (rplog) {
270	if (taia_less(&now, &stamplog) == 0) {
271	write(logpipe[1], ".", 1);
272	taia_uint(&deadline, 900);
273	taia_add(&stamplog, &now, &deadline);
274	}
275	}
276	taia_uint(&deadline, check ? 1 : 5);
277	taia_add(&deadline, &now, &deadline);
278
279	sig_block(sig_child);
280	if (rplog)
281	iopause(io, 1, &deadline, &now);
282	else
283	iopause(0, 0, &deadline, &now);
284	sig_unblock(sig_child);
285
286	if (rplog && (io[0].revents \| IOPAUSE_READ))
287	while (read(logpipe[0], &ch, 1) > 0)
288	if (ch) {
289	for (i = 6; i < rploglen; i++)
290	rplog[i-1] = rplog[i];
291	rplog[rploglen-1] = ch;
292	}
293
294	switch (exitsoon) {
295	case 1:
296	_exit(0);
297	case 2:
298	for (i = 0; i < svnum; i++)
299	if (sv[i].pid)
300	kill(sv[i].pid, SIGTERM);
301	_exit(111);
302	}
303	}
304	/* not reached */
305	return 0;
306	}