summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorFlorian Pritz <bluewind@xinu.at>2012-05-22 21:27:06 +0200
committerFlorian Pritz <bluewind@xinu.at>2012-05-22 21:27:06 +0200
commitbd888fc9e1e1226df65cd6c939155e6428a6f85a (patch)
treeccd9f4fca43406accce25c324bdfaf85e7754964
downloadbootlogd-bd888fc9e1e1226df65cd6c939155e6428a6f85a.tar.gz
bootlogd-bd888fc9e1e1226df65cd6c939155e6428a6f85a.tar.xz
initial commit
Signed-off-by: Florian Pritz <bluewind@xinu.at>
-rw-r--r--bootlogd.c690
1 files changed, 690 insertions, 0 deletions
diff --git a/bootlogd.c b/bootlogd.c
new file mode 100644
index 0000000..570d382
--- /dev/null
+++ b/bootlogd.c
@@ -0,0 +1,690 @@
+/*
+ * bootlogd.c Store output from the console during bootup into a file.
+ * The file is usually located on the /var partition, and
+ * gets written (and fsynced) as soon as possible.
+ *
+ * Version: @(#)bootlogd 2.86pre 12-Jan-2004 miquels@cistron.nl
+ *
+ * Bugs: Uses openpty(), only available in glibc. Sorry.
+ *
+ * This file is part of the sysvinit suite,
+ * Copyright (C) 1991-2004 Miquel van Smoorenburg.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * *NOTE* *NOTE* *NOTE*
+ * This is a PROOF OF CONCEPT IMPLEMENTATION
+ *
+ * I have bigger plans for Debian, but for now
+ * this has to do ;)
+ *
+ */
+
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/utsname.h>
+#include <time.h>
+#include <stdio.h>
+#include <errno.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <getopt.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <pty.h>
+#include <ctype.h>
+#ifdef __linux__
+#include <sys/mount.h>
+#endif
+
+char *Version = "@(#) bootlogd 2.86 03-Jun-2004 miquels@cistron.nl";
+
+#define LOGFILE "/var/log/boot"
+
+char ringbuf[32768];
+char *endptr = ringbuf + sizeof(ringbuf);
+char *inptr = ringbuf;
+char *outptr = ringbuf;
+
+int got_signal = 0;
+int didnl = 1;
+int createlogfile = 0;
+int syncalot = 0;
+
+struct line {
+ char buf[256];
+ int pos;
+} line;
+
+/*
+ * Console devices as listed on the kernel command line and
+ * the mapping to actual devices in /dev
+ */
+struct consdev {
+ char *cmdline;
+ char *dev1;
+ char *dev2;
+} consdev[] = {
+ { "ttyB", "/dev/ttyB%s", NULL },
+ { "ttySC", "/dev/ttySC%s", "/dev/ttsc/%s" },
+ { "ttyS", "/dev/ttyS%s", "/dev/tts/%s" },
+ { "tty", "/dev/tty%s", "/dev/vc/%s" },
+ { "hvc", "/dev/hvc%s", "/dev/hvc/%s" },
+ { NULL, NULL, NULL },
+};
+
+/*
+ * Devices to try as console if not found on kernel command line.
+ * Tried from left to right (as opposed to kernel cmdline).
+ */
+char *defcons[] = { "tty0", "hvc0", "ttyS0", "ttySC0", "ttyB0", NULL };
+
+/*
+ * Catch signals.
+ */
+void handler(int sig)
+{
+ got_signal = sig;
+}
+
+
+/*
+ * Scan /dev and find the device name.
+ */
+static int findtty(char *res, const char *startdir, int rlen, dev_t dev)
+{
+ DIR *dir;
+ struct dirent *ent;
+ struct stat st;
+ int r = -1;
+ char *olddir = getcwd(NULL, 0);
+
+ if (chdir(startdir) < 0 || (dir = opendir(".")) == NULL) {
+ int msglen = strlen(startdir) + 11;
+ char *msg = malloc(msglen);
+ snprintf(msg, msglen, "bootlogd: %s", startdir);
+ perror(msg);
+ free(msg);
+ chdir(olddir);
+ return -1;
+ }
+ while ((ent = readdir(dir)) != NULL) {
+ if (lstat(ent->d_name, &st) != 0)
+ continue;
+ if (S_ISDIR(st.st_mode)
+ && 0 != strcmp(".", ent->d_name)
+ && 0 != strcmp("..", ent->d_name)) {
+ char *path = malloc(rlen);
+ snprintf(path, rlen, "%s/%s", startdir, ent->d_name);
+ r = findtty(res, path, rlen, dev);
+ free(path);
+ if (0 == r) { /* device found, return */
+ closedir(dir);
+ chdir(olddir);
+ return 0;
+ }
+ continue;
+ }
+ if (!S_ISCHR(st.st_mode))
+ continue;
+ if (st.st_rdev == dev) {
+ if ( (int) (strlen(ent->d_name) + strlen(startdir) + 1) >= rlen) {
+ fprintf(stderr, "bootlogd: console device name too long\n");
+ closedir(dir);
+ chdir(olddir);
+ return -1;
+ } else {
+ snprintf(res, rlen, "%s/%s", startdir, ent->d_name);
+ closedir(dir);
+ chdir(olddir);
+ return 0;
+ }
+ }
+ }
+ closedir(dir);
+
+ chdir(olddir);
+ return r;
+}
+
+/*
+ * For some reason, openpty() in glibc sometimes doesn't
+ * work at boot-time. It must be a bug with old-style pty
+ * names, as new-style (/dev/pts) is not available at that
+ * point. So, we find a pty/tty pair ourself if openpty()
+ * fails for whatever reason.
+ */
+int findpty(int *master, int *slave, char *name)
+{
+ char pty[16];
+ char tty[16];
+ int i, j;
+ int found;
+
+ if (openpty(master, slave, name, NULL, NULL) >= 0)
+ return 0;
+
+ found = 0;
+
+ for (i = 'p'; i <= 'z'; i++) {
+ for (j = '0'; j <= 'f'; j++) {
+ if (j == '9' + 1) j = 'a';
+ sprintf(pty, "/dev/pty%c%c", i, j);
+ sprintf(tty, "/dev/tty%c%c", i, j);
+ if ((*master = open(pty, O_RDWR|O_NOCTTY)) >= 0) {
+ *slave = open(tty, O_RDWR|O_NOCTTY);
+ if (*slave >= 0) {
+ found = 1;
+ break;
+ }
+ }
+ }
+ if (found) break;
+ }
+ if (!found) return -1;
+
+ if (name) strcpy(name, tty);
+
+ return 0;
+}
+/*
+ * See if a console taken from the kernel command line maps
+ * to a character device we know about, and if we can open it.
+ */
+int isconsole(char *s, char *res, int rlen)
+{
+ struct consdev *c;
+ int l, sl, i, fd;
+ char *p, *q;
+
+ sl = strlen(s);
+
+ for (c = consdev; c->cmdline; c++) {
+ l = strlen(c->cmdline);
+ if (sl <= l) continue;
+ p = s + l;
+ if (strncmp(s, c->cmdline, l) != 0 || !isdigit(*p))
+ continue;
+ for (i = 0; i < 2; i++) {
+ snprintf(res, rlen, i ? c->dev1 : c->dev2, p);
+ if ((q = strchr(res, ',')) != NULL) *q = 0;
+ if ((fd = open(res, O_RDONLY|O_NONBLOCK)) >= 0) {
+ close(fd);
+ return 1;
+ }
+ }
+ }
+ return 0;
+}
+
+/*
+ * Find out the _real_ console. Assume that stdin is connected to
+ * the console device (/dev/console).
+ */
+int consolename(char *res, int rlen)
+{
+#ifdef TIOCGDEV
+ unsigned int kdev;
+#endif
+ struct stat st, st2;
+ char buf[256];
+ char *p;
+ int didmount = 0;
+ int n, r;
+ int fd;
+
+ fstat(0, &st);
+ if (major(st.st_rdev) != 5 || minor(st.st_rdev) != 1) {
+ /*
+ * Old kernel, can find real device easily.
+ */
+ int r = findtty(res, "/dev", rlen, st.st_rdev);
+ if (0 != r)
+ fprintf(stderr, "bootlogd: cannot find console device "
+ "%d:%d under /dev\n", major(st.st_rdev), minor(st.st_rdev));
+ return r;
+ }
+
+#ifdef TIOCGDEV
+# ifndef ENOIOCTLCMD
+# define ENOIOCTLCMD 515
+# endif
+ if (ioctl(0, TIOCGDEV, &kdev) == 0) {
+ int r = findtty(res, "/dev", rlen, (dev_t)kdev);
+ if (0 != r)
+ fprintf(stderr, "bootlogd: cannot find console device "
+ "%d:%d under /dev\n", major(kdev), minor(kdev));
+ return r;
+ }
+ if (errno != ENOIOCTLCMD) return -1;
+#endif
+
+#ifdef __linux__
+ /*
+ * Read /proc/cmdline.
+ */
+ stat("/", &st);
+ if (stat("/proc", &st2) < 0) {
+ perror("bootlogd: /proc");
+ return -1;
+ }
+ if (st.st_dev == st2.st_dev) {
+ if (mount("proc", "/proc", "proc", 0, NULL) < 0) {
+ perror("bootlogd: mount /proc");
+ return -1;
+ }
+ didmount = 1;
+ }
+
+ n = 0;
+ r = -1;
+ if ((fd = open("/proc/cmdline", O_RDONLY)) < 0) {
+ perror("bootlogd: /proc/cmdline");
+ } else {
+ buf[0] = 0;
+ if ((n = read(fd, buf, sizeof(buf) - 1)) >= 0)
+ r = 0;
+ else
+ perror("bootlogd: /proc/cmdline");
+ close(fd);
+ }
+ if (didmount) umount("/proc");
+
+ if (r < 0) return r;
+
+ /*
+ * OK, so find console= in /proc/cmdline.
+ * Parse in reverse, opening as we go.
+ */
+ p = buf + n;
+ *p-- = 0;
+ r = -1;
+ while (p >= buf) {
+ if (*p == ' ' || *p == '\t' || *p == '\r' || *p == '\n') {
+ *p-- = 0;
+ continue;
+ }
+ if (strncmp(p, "console=", 8) == 0 &&
+ isconsole(p + 8, res, rlen)) {
+ r = 0;
+ break;
+ }
+ p--;
+ }
+
+ if (r == 0) return r;
+#endif
+
+ /*
+ * Okay, no console on the command line -
+ * guess the default console.
+ */
+ for (n = 0; defcons[n]; n++)
+ if (isconsole(defcons[n], res, rlen))
+ return 0;
+
+ fprintf(stderr, "bootlogd: cannot deduce real console device\n");
+
+ return -1;
+}
+
+
+/*
+ * Write data and make sure it's on disk.
+ */
+void writelog(FILE *fp, unsigned char *ptr, int len)
+{
+ time_t t;
+ char *s;
+ char tmp[8];
+ int olen = len;
+ int dosync = 0;
+ int tlen;
+
+ while (len > 0) {
+ tmp[0] = 0;
+ if (didnl) {
+ time(&t);
+ s = ctime(&t);
+ fprintf(fp, "%.24s: ", s);
+ didnl = 0;
+ }
+ switch (*ptr) {
+ case 27: /* ESC */
+ strcpy(tmp, "^[");
+ break;
+ case '\r':
+ line.pos = 0;
+ break;
+ case 8: /* ^H */
+ if (line.pos > 0) line.pos--;
+ break;
+ case '\n':
+ didnl = 1;
+ dosync = 1;
+ break;
+ case '\t':
+ line.pos += (line.pos / 8 + 1) * 8;
+ if (line.pos >= (int)sizeof(line.buf))
+ line.pos = sizeof(line.buf) - 1;
+ break;
+ case 32 ... 127:
+ case 161 ... 255:
+ tmp[0] = *ptr;
+ tmp[1] = 0;
+ break;
+ default:
+ sprintf(tmp, "\\%03o", *ptr);
+ break;
+ }
+ ptr++;
+ len--;
+
+ tlen = strlen(tmp);
+ if (tlen && (line.pos + tlen < (int)sizeof(line.buf))) {
+ memcpy(line.buf + line.pos, tmp, tlen);
+ line.pos += tlen;
+ }
+ if (didnl) {
+ fprintf(fp, "%s\n", line.buf);
+ memset(&line, 0, sizeof(line));
+ }
+ }
+
+ if (dosync) {
+ fflush(fp);
+ if (syncalot) {
+ fdatasync(fileno(fp));
+ }
+ }
+
+ outptr += olen;
+ if (outptr >= endptr)
+ outptr = ringbuf;
+
+}
+
+
+/*
+ * Print usage message and exit.
+ */
+void usage(void)
+{
+ fprintf(stderr, "Usage: bootlogd [-v] [-r] [-d] [-s] [-c] [-p pidfile] [-l logfile]\n");
+ exit(1);
+}
+
+int open_nb(char *buf)
+{
+ int fd, n;
+
+ if ((fd = open(buf, O_WRONLY|O_NONBLOCK|O_NOCTTY)) < 0)
+ return -1;
+ n = fcntl(fd, F_GETFL);
+ n &= ~(O_NONBLOCK);
+ fcntl(fd, F_SETFL, n);
+
+ return fd;
+}
+
+/*
+ * We got a write error on the real console. If its an EIO,
+ * somebody hung up our filedescriptor, so try to re-open it.
+ */
+int write_err(int pts, int realfd, char *realcons, int e)
+{
+ int fd;
+
+ if (e != EIO) {
+werr:
+ close(pts);
+ fprintf(stderr, "bootlogd: writing to console: %s\n",
+ strerror(e));
+ return -1;
+ }
+ close(realfd);
+ if ((fd = open_nb(realcons)) < 0)
+ goto werr;
+
+ return fd;
+}
+
+int main(int argc, char **argv)
+{
+ FILE *fp;
+ struct timeval tv;
+ fd_set fds;
+ char buf[1024];
+ char realcons[1024];
+ char *p;
+ char *logfile;
+ char *pidfile;
+ int rotate;
+ int dontfork;
+ int ptm, pts;
+ int realfd;
+ int n, m, i;
+ int todo;
+
+ fp = NULL;
+ logfile = LOGFILE;
+ pidfile = NULL;
+ rotate = 0;
+ dontfork = 0;
+
+ while ((i = getopt(argc, argv, "cdsl:p:rv")) != EOF) switch(i) {
+ case 'l':
+ logfile = optarg;
+ break;
+ case 'r':
+ rotate = 1;
+ break;
+ case 'v':
+ printf("%s\n", Version);
+ exit(0);
+ break;
+ case 'p':
+ pidfile = optarg;
+ break;
+ case 'c':
+ createlogfile = 1;
+ break;
+ case 'd':
+ dontfork = 1;
+ break;
+ case 's':
+ syncalot = 1;
+ break;
+ default:
+ usage();
+ break;
+ }
+ if (optind < argc) usage();
+
+ signal(SIGTERM, handler);
+ signal(SIGQUIT, handler);
+ signal(SIGINT, handler);
+ signal(SIGTTIN, SIG_IGN);
+ signal(SIGTTOU, SIG_IGN);
+ signal(SIGTSTP, SIG_IGN);
+
+ /*
+ * Open console device directly.
+ */
+ if (consolename(realcons, sizeof(realcons)) < 0)
+ return 1;
+
+ if (strcmp(realcons, "/dev/tty0") == 0)
+ strcpy(realcons, "/dev/tty1");
+ if (strcmp(realcons, "/dev/vc/0") == 0)
+ strcpy(realcons, "/dev/vc/1");
+
+ if ((realfd = open_nb(realcons)) < 0) {
+ fprintf(stderr, "bootlogd: %s: %s\n", buf, strerror(errno));
+ return 1;
+ }
+
+ /*
+ * Grab a pty, and redirect console messages to it.
+ */
+ ptm = -1;
+ pts = -1;
+ buf[0] = 0;
+ if (findpty(&ptm, &pts, buf) < 0) {
+ fprintf(stderr,
+ "bootlogd: cannot allocate pseudo tty: %s\n",
+ strerror(errno));
+ return 1;
+ }
+
+ (void)ioctl(0, TIOCCONS, NULL);
+#if 1
+ /* Work around bug in 2.1/2.2 kernels. Fixed in 2.2.13 and 2.3.18 */
+ if ((n = open("/dev/tty0", O_RDWR)) >= 0) {
+ (void)ioctl(n, TIOCCONS, NULL);
+ close(n);
+ }
+#endif
+ if (ioctl(pts, TIOCCONS, NULL) < 0) {
+ fprintf(stderr, "bootlogd: ioctl(%s, TIOCCONS): %s\n",
+ buf, strerror(errno));
+ return 1;
+ }
+
+ /*
+ * Fork and write pidfile if needed.
+ */
+ if (!dontfork) {
+ pid_t child_pid = fork();
+ switch (child_pid) {
+ case -1: /* I am parent and the attempt to create a child failed */
+ fprintf(stderr, "bootlogd: fork failed: %s\n",
+ strerror(errno));
+ exit(1);
+ break;
+ case 0: /* I am the child */
+ break;
+ default: /* I am parent and got child's pid */
+ exit(0);
+ break;
+ }
+ setsid();
+ }
+ if (pidfile) {
+ unlink(pidfile);
+ if ((fp = fopen(pidfile, "w")) != NULL) {
+ fprintf(fp, "%d\n", (int)getpid());
+ fclose(fp);
+ }
+ fp = NULL;
+ }
+
+ /*
+ * Read the console messages from the pty, and write
+ * to the real console and the logfile.
+ */
+ while (!got_signal) {
+
+ /*
+ * We timeout after 5 seconds if we still need to
+ * open the logfile. There might be buffered messages
+ * we want to write.
+ */
+ tv.tv_sec = 0;
+ tv.tv_usec = 500000;
+ FD_ZERO(&fds);
+ FD_SET(ptm, &fds);
+ if (select(ptm + 1, &fds, NULL, NULL, &tv) == 1) {
+ /*
+ * See how much space there is left, read.
+ */
+ if ((n = read(ptm, inptr, endptr - inptr)) >= 0) {
+ /*
+ * Write data (in chunks if needed)
+ * to the real output device.
+ */
+ m = n;
+ p = inptr;
+ while (m > 0) {
+ i = write(realfd, p, m);
+ if (i >= 0) {
+ m -= i;
+ p += i;
+ continue;
+ }
+ /*
+ * Handle EIO (somebody hung
+ * up our filedescriptor)
+ */
+ realfd = write_err(pts, realfd,
+ realcons, errno);
+ if (realfd >= 0) continue;
+ got_signal = 1; /* Not really */
+ break;
+ }
+
+ /*
+ * Increment buffer position. Handle
+ * wraps, and also drag output pointer
+ * along if we cross it.
+ */
+ inptr += n;
+ if (inptr - n < outptr && inptr > outptr)
+ outptr = inptr;
+ if (inptr >= endptr)
+ inptr = ringbuf;
+ if (outptr >= endptr)
+ outptr = ringbuf;
+ }
+ }
+
+ /*
+ * Perhaps we need to open the logfile.
+ */
+ if (fp == NULL && access(logfile, F_OK) == 0) {
+ if (rotate) {
+ snprintf(buf, sizeof(buf), "%s~", logfile);
+ rename(logfile, buf);
+ }
+ fp = fopen(logfile, "a");
+ }
+ if (fp == NULL && createlogfile)
+ fp = fopen(logfile, "a");
+
+ if (inptr >= outptr)
+ todo = inptr - outptr;
+ else
+ todo = endptr - outptr;
+ if (fp && todo)
+ writelog(fp, (unsigned char *)outptr, todo);
+ }
+
+ if (fp) {
+ if (!didnl) fputc('\n', fp);
+ fclose(fp);
+ }
+
+ close(pts);
+ close(ptm);
+ close(realfd);
+
+ return 0;
+}
+