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