2 Copyright (c) 2001-2006, Gerrit Pape
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
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.
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.
28 /* Busyboxed by Denys Vlasenko <vda.linux@googlemail.com> */
33 On startup, and after receiving a HUP signal, svlogd checks for each
34 log directory log if the configuration file log/config exists,
35 and if so, reads the file line by line and adjusts configuration
38 If the line is empty, or starts with a #, it is ignored. A line
42 sets the maximum file size of current when svlogd should rotate
43 the current log file to size bytes. Default is 1000000.
44 If size is zero, svlogd doesnt rotate log files
45 You should set size to at least (2 * len).
47 sets the number of old log files svlogd should maintain to num.
48 If svlogd sees more that num old log files in log after log file
49 rotation, it deletes the oldest one. Default is 10.
50 If num is zero, svlogd doesnt remove old log files.
52 sets the minimum number of old log files svlogd should maintain
53 to min. min must be less than num. If min is set, and svlogd
54 cannot write to current because the filesystem is full,
55 and it sees more than min old log files, it deletes the oldest one.
57 sets the maximum age of the current log file when svlogd should
58 rotate the current log file to timeout seconds. If current
59 is timeout seconds old, and is not empty, svlogd forces log file rotation.
61 tells svlogd to feed each recent log file through processor
62 (see above) on log file rotation. By default log files are not processed.
64 tells svlogd to transmit the first len characters of selected
65 log messages to the IP address a.b.c.d, port number port.
66 If port isnt set, the default port for syslog is used (514).
67 len can be set through the -l option, see below. If svlogd
68 has trouble sending udp packets, it writes error messages
69 to the log directory. Attention: logging through udp is unreliable,
70 and should be used in private networks only.
72 is the same as the u line above, but the log messages are no longer
73 written to the log directory, but transmitted through udp only.
74 Error messages from svlogd concerning sending udp packages still go
77 tells svlogd to prefix each line to be written to the log directory,
78 to standard error, or through UDP, with prefix.
80 If a line starts with a -, +, e, or E, svlogd matches the first len characters
81 of each log message against pattern and acts accordingly:
84 the log message is deselected.
86 the log message is selected.
88 the log message is selected to be printed to standard error.
90 the log message is deselected to be printed to standard error.
92 Initially each line is selected to be written to log/current. Deselected
93 log messages are discarded from log. Initially each line is deselected
94 to be written to standard err. Log messages selected for standard error
95 are written to standard error.
99 svlogd matches a log message against the string pattern as follows:
101 pattern is applied to the log message one character by one, starting
102 with the first. A character not a star (*) and not a plus (+) matches itself.
103 A plus matches the next character in pattern in the log message one
104 or more times. A star before the end of pattern matches any string
105 in the log message that does not include the next character in pattern.
106 A star at the end of pattern matches any string.
108 Timestamps optionally added by svlogd are not considered part
111 An svlogd pattern is not a regular expression. For example consider
112 a log message like this
114 2005-12-18_09:13:50.97618 tcpsvd: info: pid 1977 from 10.4.1.14
116 The following pattern doesnt match
120 because the first star matches up to the first p in tcpsvd,
121 and then the match fails because i is not s. To match this
122 log message, you can use a pattern like this instead
127 //config:config SVLOGD
128 //config: bool "svlogd (15 kb)"
131 //config: svlogd continuously reads log data from its standard input, optionally
132 //config: filters log messages, and writes the data to one or more automatically
133 //config: rotated logs.
135 //applet:IF_SVLOGD(APPLET(svlogd, BB_DIR_USR_SBIN, BB_SUID_DROP))
137 //kbuild:lib-$(CONFIG_SVLOGD) += svlogd.o
139 //usage:#define svlogd_trivial_usage
140 //usage: "[-tttv] [-r C] [-R CHARS] [-l MATCHLEN] [-b BUFLEN] DIR..."
141 //usage:#define svlogd_full_usage "\n\n"
142 //usage: "Read log data from stdin and write to rotated log files in DIRs"
144 //usage: "\n""DIR/config file modifies behavior:"
145 //usage: "\n""sSIZE - when to rotate logs"
146 //usage: "\n""nNUM - number of files to retain"
147 /*usage: "\n""NNUM - min number files to retain" - confusing */
148 /*usage: "\n""tSEC - rotate file if it get SEC seconds old" - confusing */
149 //usage: "\n""!PROG - process rotated log with PROG"
150 /*usage: "\n""uIPADDR - send log over UDP" - unsupported */
151 /*usage: "\n""UIPADDR - send log over UDP and DONT log" - unsupported */
152 /*usage: "\n""pPFX - prefix each line with PFX" - unsupported */
153 //usage: "\n""+,-PATTERN - (de)select line for logging"
154 //usage: "\n""E,ePATTERN - (de)select line for stderr"
156 #include <sys/file.h>
158 #include "common_bufsiz.h"
159 #include "runit_lib.h"
161 #define LESS(a,b) ((int)((unsigned)(b) - (unsigned)(a)) > 0)
167 /* pattern list to match, in "aa\0bb\0\cc\0\0" form */
175 unsigned rotate_period;
181 unsigned next_rotate;
182 char fnsave[FMT_PTIME];
198 unsigned nearest_rotate;
200 void* (*memRchr)(const void *, int, size_t);
206 smallint linecomplete;
214 sigset_t blocked_sigset;
216 #define G (*ptr_to_globals)
218 #define verbose (G.verbose )
219 #define linemax (G.linemax )
220 #define buflen (G.buflen )
221 #define linelen (G.linelen )
222 #define fndir (G.fndir )
223 #define fdwdir (G.fdwdir )
224 #define wstat (G.wstat )
225 #define memRchr (G.memRchr )
226 #define nearest_rotate (G.nearest_rotate)
227 #define exitasap (G.exitasap )
228 #define rotateasap (G.rotateasap )
229 #define reopenasap (G.reopenasap )
230 #define linecomplete (G.linecomplete )
231 #define tmaxflag (G.tmaxflag )
232 #define repl (G.repl )
233 #define replace (G.replace )
234 #define blocked_sigset (G.blocked_sigset)
235 #define fl_flag_0 (G.fl_flag_0 )
236 #define dirn (G.dirn )
237 #define line bb_common_bufsiz1
238 #define INIT_G() do { \
239 setup_common_bufsiz(); \
240 SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
248 #define FATAL "fatal: "
249 #define WARNING "warning: "
250 #define PAUSE "pausing: "
251 #define INFO "info: "
253 static void fatalx(const char *m0)
255 bb_error_msg_and_die(FATAL"%s", m0);
257 static void warn(const char *m0)
259 bb_perror_msg(WARNING"%s", m0);
261 static void warn2(const char *m0, const char *m1)
263 bb_perror_msg(WARNING"%s: %s", m0, m1);
265 static void warnx(const char *m0, const char *m1)
267 bb_error_msg(WARNING"%s: %s", m0, m1);
269 static void pause_nomem(void)
271 bb_error_msg(PAUSE"out of memory");
274 static void pause1cannot(const char *m0)
276 bb_perror_msg(PAUSE"can't %s", m0);
279 static void pause2cannot(const char *m0, const char *m1)
281 bb_perror_msg(PAUSE"can't %s %s", m0, m1);
285 static char* wstrdup(const char *str)
288 while (!(s = strdup(str)))
293 static unsigned pmatch(const char *p, const char *s, unsigned len)
311 if (c != *s) return 0;
322 if (*s != '?') return 0;
330 if (*s != c) return 0;
339 /*** ex fmt_ptime.[ch] ***/
342 static void fmt_time_human_30nul(char *s, char dt_delim)
347 gettimeofday(&tv, NULL);
348 ptm = gmtime(&tv.tv_sec);
349 sprintf(s, "%04u-%02u-%02u%c%02u:%02u:%02u.%06u000",
350 (unsigned)(1900 + ptm->tm_year),
351 (unsigned)(ptm->tm_mon + 1),
352 (unsigned)(ptm->tm_mday),
354 (unsigned)(ptm->tm_hour),
355 (unsigned)(ptm->tm_min),
356 (unsigned)(ptm->tm_sec),
357 (unsigned)(tv.tv_usec)
359 /* 4+1 + 2+1 + 2+1 + 2+1 + 2+1 + 2+1 + 9 = */
360 /* 5 + 3 + 3 + 3 + 3 + 3 + 9 = */
361 /* 20 (up to '.' inclusive) + 9 (not including '\0') */
364 /* NOT terminated! */
365 static void fmt_time_bernstein_25(char *s)
371 gettimeofday(&tv, NULL);
372 sec_hi = (0x400000000000000aULL + tv.tv_sec) >> 32;
373 tv.tv_sec = (time_t)(0x400000000000000aULL) + tv.tv_sec;
375 /* Network order is big-endian: most significant byte first.
376 * This is exactly what we want here */
377 pack[0] = htonl(sec_hi);
378 pack[1] = htonl(tv.tv_sec);
379 pack[2] = htonl(tv.tv_usec);
381 bin2hex(s, (char*)pack, 12);
384 static void processorstart(struct logdir *ld)
389 if (!ld->processor) return;
391 warnx("processor already running", ld->name);
395 /* vfork'ed child trashes this byte, save... */
396 sv_ch = ld->fnsave[26];
399 G.shell = xstrdup(get_shell_name());
401 while ((pid = vfork()) == -1)
402 pause2cannot("vfork for processor", ld->name);
407 /* Non-ignored signals revert to SIG_DFL on exec anyway */
413 sig_unblock(SIGTERM);
414 sig_unblock(SIGALRM);
418 bb_error_msg(INFO"processing: %s/%s", ld->name, ld->fnsave);
419 fd = xopen(ld->fnsave, O_RDONLY|O_NDELAY);
421 ld->fnsave[26] = 't'; /* <- that's why we need sv_ch! */
422 fd = xopen(ld->fnsave, O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT);
424 fd = open("state", O_RDONLY|O_NDELAY);
427 bb_perror_msg_and_die(FATAL"can't %s processor %s", "open state for", ld->name);
428 close(xopen("state", O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT));
429 fd = xopen("state", O_RDONLY|O_NDELAY);
432 fd = xopen("newstate", O_WRONLY|O_NDELAY|O_TRUNC|O_CREAT);
435 execl(G.shell, G.shell, "-c", ld->processor, (char*) NULL);
436 bb_perror_msg_and_die(FATAL"can't %s processor %s", "run", ld->name);
438 ld->fnsave[26] = sv_ch; /* ...restore */
442 static unsigned processorstop(struct logdir *ld)
448 while (safe_waitpid(ld->ppid, &wstat, 0) == -1)
449 pause2cannot("wait for processor", ld->name);
455 while (fchdir(ld->fddir) == -1)
456 pause2cannot("change directory, want processor", ld->name);
457 if (WEXITSTATUS(wstat) != 0) {
458 warnx("processor failed, restart", ld->name);
459 ld->fnsave[26] = 't';
461 ld->fnsave[26] = 'u';
463 while (fchdir(fdwdir) == -1)
464 pause1cannot("change to initial working directory");
465 return ld->processor ? 0 : 1;
467 ld->fnsave[26] = 't';
468 memcpy(f, ld->fnsave, 26);
471 while (rename(ld->fnsave, f) == -1)
472 pause2cannot("rename processed", ld->name);
473 while (chmod(f, 0744) == -1)
474 pause2cannot("set mode of processed", ld->name);
475 ld->fnsave[26] = 'u';
476 if (unlink(ld->fnsave) == -1)
477 bb_error_msg(WARNING"can't unlink: %s/%s", ld->name, ld->fnsave);
478 while (rename("newstate", "state") == -1)
479 pause2cannot("rename state", ld->name);
481 bb_error_msg(INFO"processed: %s/%s", ld->name, f);
482 while (fchdir(fdwdir) == -1)
483 pause1cannot("change to initial working directory");
487 static void rmoldest(struct logdir *ld)
491 char oldest[FMT_PTIME];
494 oldest[0] = 'A'; oldest[1] = oldest[27] = 0;
495 while (!(d = opendir(".")))
496 pause2cannot("open directory, want rotate", ld->name);
498 while ((f = readdir(d))) {
499 if ((f->d_name[0] == '@') && (strlen(f->d_name) == 27)) {
500 if (f->d_name[26] == 't') {
501 if (unlink(f->d_name) == -1)
502 warn2("can't unlink processor leftover", f->d_name);
505 if (strcmp(f->d_name, oldest) < 0)
506 memcpy(oldest, f->d_name, 27);
512 warn2("can't read directory", ld->name);
515 if (ld->nmax && (n > ld->nmax)) {
517 bb_error_msg(INFO"delete: %s/%s", ld->name, oldest);
518 if ((*oldest == '@') && (unlink(oldest) == -1))
519 warn2("can't unlink oldest logfile", ld->name);
523 static unsigned rotate(struct logdir *ld)
528 if (ld->fddir == -1) {
529 ld->rotate_period = 0;
533 while (!processorstop(ld))
536 while (fchdir(ld->fddir) == -1)
537 pause2cannot("change directory, want rotate", ld->name);
539 /* create new filename */
540 ld->fnsave[25] = '.';
541 ld->fnsave[26] = 's';
543 ld->fnsave[26] = 'u';
544 ld->fnsave[27] = '\0';
546 fmt_time_bernstein_25(ld->fnsave);
548 stat(ld->fnsave, &st);
549 } while (errno != ENOENT);
551 now = monotonic_sec();
552 if (ld->rotate_period && LESS(ld->next_rotate, now)) {
553 ld->next_rotate = now + ld->rotate_period;
554 if (LESS(ld->next_rotate, nearest_rotate))
555 nearest_rotate = ld->next_rotate;
559 while (fflush(ld->filecur) || fsync(ld->fdcur) == -1)
560 pause2cannot("fsync current logfile", ld->name);
561 while (fchmod(ld->fdcur, 0744) == -1)
562 pause2cannot("set mode of current", ld->name);
563 ////close(ld->fdcur);
567 bb_error_msg(INFO"rename: %s/current %s %u", ld->name,
568 ld->fnsave, ld->size);
570 while (rename("current", ld->fnsave) == -1)
571 pause2cannot("rename current", ld->name);
572 while ((ld->fdcur = open("current", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600)) == -1)
573 pause2cannot("create new current", ld->name);
574 while ((ld->filecur = fdopen(ld->fdcur, "a")) == NULL) ////
575 pause2cannot("create new current", ld->name); /* very unlikely */
576 setvbuf(ld->filecur, NULL, _IOFBF, linelen); ////
577 close_on_exec_on(ld->fdcur);
579 while (fchmod(ld->fdcur, 0644) == -1)
580 pause2cannot("set mode of current", ld->name);
586 while (fchdir(fdwdir) == -1)
587 pause1cannot("change to initial working directory");
591 static int buffer_pwrite(int n, char *s, unsigned len)
594 struct logdir *ld = &dir[n];
597 if (ld->size >= ld->sizemax)
599 if (len > (ld->sizemax - ld->size))
600 len = ld->sizemax - ld->size;
603 ////i = full_write(ld->fdcur, s, len);
604 ////if (i != -1) break;
605 i = fwrite(s, 1, len, ld->filecur);
608 if ((errno == ENOSPC) && (ld->nmin < ld->nmax)) {
611 char oldest[FMT_PTIME];
614 while (fchdir(ld->fddir) == -1)
615 pause2cannot("change directory, want remove old logfile",
618 oldest[1] = oldest[27] = '\0';
619 while (!(d = opendir(".")))
620 pause2cannot("open directory, want remove old logfile",
623 while ((f = readdir(d)))
624 if ((f->d_name[0] == '@') && (strlen(f->d_name) == 27)) {
626 if (strcmp(f->d_name, oldest) < 0)
627 memcpy(oldest, f->d_name, 27);
629 if (errno) warn2("can't read directory, want remove old logfile",
634 if (*oldest == '@') {
635 bb_error_msg(WARNING"out of disk space, delete: %s/%s",
638 if (unlink(oldest) == -1) {
639 warn2("can't unlink oldest logfile", ld->name);
642 while (fchdir(fdwdir) == -1)
643 pause1cannot("change to initial working directory");
648 pause2cannot("write to current", ld->name);
654 if (ld->size >= (ld->sizemax - linemax))
659 static void logdir_close(struct logdir *ld)
664 bb_error_msg(INFO"close: %s", ld->name);
668 return; /* impossible */
669 while (fflush(ld->filecur) || fsync(ld->fdcur) == -1)
670 pause2cannot("fsync current logfile", ld->name);
671 while (fchmod(ld->fdcur, 0744) == -1)
672 pause2cannot("set mode of current", ld->name);
673 ////close(ld->fdcur);
676 if (ld->fdlock == -1)
677 return; /* impossible */
681 ld->processor = NULL;
684 static NOINLINE unsigned logdir_open(struct logdir *ld, const char *fn)
692 now = monotonic_sec();
694 ld->fddir = open(fn, O_RDONLY|O_NDELAY);
695 if (ld->fddir == -1) {
696 warn2("can't open log directory", (char*)fn);
699 close_on_exec_on(ld->fddir);
700 if (fchdir(ld->fddir) == -1) {
702 warn2("can't change directory", (char*)fn);
705 ld->fdlock = open("lock", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600);
706 if ((ld->fdlock == -1)
707 || (flock(ld->fdlock, LOCK_EX | LOCK_NB) == -1)
710 warn2("can't lock directory", (char*)fn);
711 while (fchdir(fdwdir) == -1)
712 pause1cannot("change to initial working directory");
715 close_on_exec_on(ld->fdlock);
718 ld->sizemax = 1000000;
719 ld->nmax = ld->nmin = 10;
720 ld->rotate_period = 0;
721 ld->name = (char*)fn;
724 free(ld->inst); ld->inst = NULL;
725 free(ld->processor); ld->processor = NULL;
728 i = open_read_close("config", buf, sizeof(buf) - 1);
729 if (i < 0 && errno != ENOENT)
730 bb_perror_msg(WARNING"%s/config", ld->name);
734 bb_error_msg(INFO"read: %s/config", ld->name);
737 np = strchr(s, '\n');
745 /* Filtering requires one-line buffering,
746 * resetting the "find newline" function
749 /* Add '\n'-terminated line to ld->inst */
751 int l = asprintf(&new, "%s%s\n", ld->inst ? ld->inst : "", s);
760 ld->sizemax = xatou_sfx(&s[1], km_suffixes);
764 ld->nmax = xatoi_positive(&s[1]);
767 ld->nmin = xatoi_positive(&s[1]);
770 static const struct suffix_mult mh_suffixes[] = {
773 /*{ "d", 24*60*60 },*/
776 ld->rotate_period = xatou_sfx(&s[1], mh_suffixes);
777 if (ld->rotate_period) {
778 ld->next_rotate = now + ld->rotate_period;
779 if (!tmaxflag || LESS(ld->next_rotate, nearest_rotate))
780 nearest_rotate = ld->next_rotate;
788 ld->processor = wstrdup(&s[1]);
794 /* Convert "aa\nbb\ncc\n\0" to "aa\0bb\0cc\0\0" */
797 np = strchr(s, '\n');
805 i = stat("current", &st);
807 if (st.st_size && !(st.st_mode & S_IXUSR)) {
808 ld->fnsave[25] = '.';
809 ld->fnsave[26] = 'u';
810 ld->fnsave[27] = '\0';
812 fmt_time_bernstein_25(ld->fnsave);
814 stat(ld->fnsave, &st);
815 } while (errno != ENOENT);
816 while (rename("current", ld->fnsave) == -1)
817 pause2cannot("rename current", ld->name);
821 /* st.st_size can be not just bigger, but WIDER!
822 * This code is safe: if st.st_size > 4GB, we select
823 * ld->sizemax (because it's "unsigned") */
824 ld->size = (st.st_size > ld->sizemax) ? ld->sizemax : st.st_size;
827 if (errno != ENOENT) {
829 warn2("can't stat current", ld->name);
830 while (fchdir(fdwdir) == -1)
831 pause1cannot("change to initial working directory");
835 while ((ld->fdcur = open("current", O_WRONLY|O_NDELAY|O_APPEND|O_CREAT, 0600)) == -1)
836 pause2cannot("open current", ld->name);
837 while ((ld->filecur = fdopen(ld->fdcur, "a")) == NULL)
838 pause2cannot("open current", ld->name); ////
839 setvbuf(ld->filecur, NULL, _IOFBF, linelen); ////
841 close_on_exec_on(ld->fdcur);
842 while (fchmod(ld->fdcur, 0644) == -1)
843 pause2cannot("set mode of current", ld->name);
846 if (i == 0) bb_error_msg(INFO"append: %s/current", ld->name);
847 else bb_error_msg(INFO"new: %s/current", ld->name);
850 while (fchdir(fdwdir) == -1)
851 pause1cannot("change to initial working directory");
855 static void logdirs_reopen(void)
861 for (l = 0; l < dirn; ++l) {
862 logdir_close(&dir[l]);
863 if (logdir_open(&dir[l], fndir[l]))
867 fatalx("no functional log directories");
870 /* Will look good in libbb one day */
871 static ssize_t ndelay_read(int fd, void *buf, size_t count)
873 if (!(fl_flag_0 & O_NONBLOCK))
874 fcntl(fd, F_SETFL, fl_flag_0 | O_NONBLOCK);
875 count = safe_read(fd, buf, count);
876 if (!(fl_flag_0 & O_NONBLOCK))
877 fcntl(fd, F_SETFL, fl_flag_0);
881 /* Used for reading stdin */
882 static int buffer_pread(/*int fd, */char *s, unsigned len)
888 input.fd = STDIN_FILENO;
889 input.events = POLLIN;
893 for (i = 0; i < dirn; ++i)
906 now = monotonic_sec();
907 nearest_rotate = now + (45 * 60 + 45);
908 for (i = 0; i < dirn; ++i) {
909 if (dir[i].rotate_period) {
910 if (LESS(dir[i].next_rotate, now))
912 if (LESS(dir[i].next_rotate, nearest_rotate))
913 nearest_rotate = dir[i].next_rotate;
917 sigprocmask(SIG_UNBLOCK, &blocked_sigset, NULL);
918 i = nearest_rotate - now;
923 poll(&input, 1, i * 1000);
924 sigprocmask(SIG_BLOCK, &blocked_sigset, NULL);
926 i = ndelay_read(STDIN_FILENO, s, len);
931 if (errno != EAGAIN) {
932 warn("can't read standard input");
935 /* else: EAGAIN - normal, repeat silently */
940 linecomplete = (s[i-1] == '\n');
948 if (ch < 32 || ch > 126)
952 for (j = 0; replace[j]; ++j) {
953 if (ch == replace[j]) {
966 static void sig_term_handler(int sig_no UNUSED_PARAM)
969 bb_error_msg(INFO"sig%s received", "term");
973 static void sig_child_handler(int sig_no UNUSED_PARAM)
979 bb_error_msg(INFO"sig%s received", "child");
980 while ((pid = wait_any_nohang(&wstat)) > 0) {
981 for (l = 0; l < dirn; ++l) {
982 if (dir[l].ppid == pid) {
984 processorstop(&dir[l]);
991 static void sig_alarm_handler(int sig_no UNUSED_PARAM)
994 bb_error_msg(INFO"sig%s received", "alarm");
998 static void sig_hangup_handler(int sig_no UNUSED_PARAM)
1001 bb_error_msg(INFO"sig%s received", "hangup");
1005 static void logmatch(struct logdir *ld)
1016 if (pmatch(s+1, line, linelen))
1021 if (pmatch(s+1, line, linelen))
1022 ld->matcherr = s[0];
1029 int svlogd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1030 int svlogd_main(int argc, char **argv)
1033 ssize_t stdin_cnt = 0;
1036 unsigned timestamp = 0;
1040 opt_complementary = "tt:vv";
1041 opt = getopt32(argv, "r:R:l:b:tv",
1042 &r, &replace, &l, &b, ×tamp, &verbose);
1043 if (opt & 1) { // -r
1048 if (opt & 2) if (!repl) repl = '_'; // -R
1049 if (opt & 4) { // -l
1050 linemax = xatou_range(l, 0, COMMON_BUFSIZE-26);
1052 linemax = COMMON_BUFSIZE-26;
1056 ////if (opt & 8) { // -b
1057 //// buflen = xatoi_positive(b);
1058 //// if (buflen == 0) buflen = 1024;
1060 //if (opt & 0x10) timestamp++; // -t
1061 //if (opt & 0x20) verbose++; // -v
1062 //if (timestamp > 2) timestamp = 2;
1069 ////if (buflen <= linemax) bb_show_usage();
1070 fdwdir = xopen(".", O_RDONLY|O_NDELAY);
1071 close_on_exec_on(fdwdir);
1072 dir = xzalloc(dirn * sizeof(dir[0]));
1073 for (i = 0; i < dirn; ++i) {
1076 ////dir[i].btmp = xmalloc(buflen);
1077 /*dir[i].ppid = 0;*/
1079 /* line = xmalloc(linemax + (timestamp ? 26 : 0)); */
1081 /* We cannot set NONBLOCK on fd #0 permanently - this setting
1082 * _isn't_ per-process! It is shared among all other processes
1083 * with the same stdin */
1084 fl_flag_0 = fcntl(0, F_GETFL);
1086 sigemptyset(&blocked_sigset);
1087 sigaddset(&blocked_sigset, SIGTERM);
1088 sigaddset(&blocked_sigset, SIGCHLD);
1089 sigaddset(&blocked_sigset, SIGALRM);
1090 sigaddset(&blocked_sigset, SIGHUP);
1091 sigprocmask(SIG_BLOCK, &blocked_sigset, NULL);
1092 bb_signals_recursive_norestart(1 << SIGTERM, sig_term_handler);
1093 bb_signals_recursive_norestart(1 << SIGCHLD, sig_child_handler);
1094 bb_signals_recursive_norestart(1 << SIGALRM, sig_alarm_handler);
1095 bb_signals_recursive_norestart(1 << SIGHUP, sig_hangup_handler);
1097 /* Without timestamps, we don't have to print each line
1098 * separately, so we can look for _last_ newline, not first,
1099 * thus batching writes. If filtering is enabled in config,
1100 * logdirs_reopen resets it to memchr.
1102 memRchr = (timestamp ? memchr : memrchr);
1106 setvbuf(stderr, NULL, _IOFBF, linelen);
1108 /* Each iteration processes one or more lines */
1110 char stamp[FMT_PTIME];
1121 /* lineptr[0..linemax-1] - buffer for stdin */
1122 /* (possibly has some unprocessed data from prev loop) */
1124 /* Refill the buffer if needed */
1125 np = memRchr(lineptr, '\n', stdin_cnt);
1126 if (!np && !exitasap) {
1127 i = linemax - stdin_cnt; /* avail. bytes at tail */
1129 i = buffer_pread(/*0, */lineptr + stdin_cnt, i);
1130 if (i <= 0) /* EOF or error on stdin */
1133 np = memRchr(lineptr + stdin_cnt, '\n', i);
1138 if (stdin_cnt <= 0 && exitasap)
1141 /* Search for '\n' (in fact, np already holds the result) */
1142 linelen = stdin_cnt;
1145 /* NB: starting from here lineptr may point
1146 * farther out into line[] */
1147 linelen = np - lineptr + 1;
1149 /* linelen == no of chars incl. '\n' (or == stdin_cnt) */
1150 ch = lineptr[linelen-1];
1152 /* Biggest performance hit was coming from the fact
1153 * that we did not buffer writes. We were reading many lines
1154 * in one read() above, but wrote one line per write().
1155 * We are using stdio to fix that */
1157 /* write out lineptr[0..linelen-1] to each log destination
1158 * (or lineptr[-26..linelen-1] if timestamping) */
1163 fmt_time_bernstein_25(stamp);
1165 fmt_time_human_30nul(stamp, timestamp == 2 ? '_' : 'T');
1168 memcpy(printptr, stamp, 25);
1171 for (i = 0; i < dirn; ++i) {
1172 struct logdir *ld = &dir[i];
1173 if (ld->fddir == -1)
1177 if (ld->matcherr == 'e') {
1178 /* runit-1.8.0 compat: if timestamping, do it on stderr too */
1179 ////full_write(STDERR_FILENO, printptr, printlen);
1180 fwrite(printptr, 1, printlen, stderr);
1182 if (ld->match != '+')
1184 buffer_pwrite(i, printptr, printlen);
1187 /* If we didn't see '\n' (long input line), */
1188 /* read/write repeatedly until we see it */
1189 while (ch != '\n') {
1190 /* lineptr is emptied now, safe to use as buffer */
1191 stdin_cnt = exitasap ? -1 : buffer_pread(/*0, */lineptr, linemax);
1192 if (stdin_cnt <= 0) { /* EOF or error on stdin */
1194 lineptr[0] = ch = '\n';
1198 linelen = stdin_cnt;
1199 np = memRchr(lineptr, '\n', stdin_cnt);
1201 linelen = np - lineptr + 1;
1202 ch = lineptr[linelen-1];
1204 /* linelen == no of chars incl. '\n' (or == stdin_cnt) */
1205 for (i = 0; i < dirn; ++i) {
1206 if (dir[i].fddir == -1)
1208 if (dir[i].matcherr == 'e') {
1209 ////full_write(STDERR_FILENO, lineptr, linelen);
1210 fwrite(lineptr, 1, linelen, stderr);
1212 if (dir[i].match != '+')
1214 buffer_pwrite(i, lineptr, linelen);
1218 stdin_cnt -= linelen;
1219 if (stdin_cnt > 0) {
1221 /* If we see another '\n', we don't need to read
1222 * next piece of input: can print what we have */
1223 np = memRchr(lineptr, '\n', stdin_cnt);
1226 /* Move unprocessed data to the front of line */
1227 memmove((timestamp ? line+26 : line), lineptr, stdin_cnt);
1232 for (i = 0; i < dirn; ++i) {
1234 while (!processorstop(&dir[i]))
1236 logdir_close(&dir[i]);