projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
convert SBLOCK to SBOFF; generalize use of dev_bsize
[unix-history] / usr / src / sbin / savecore / savecore.c
diff --git a/usr/src/sbin/savecore/savecore.c b/usr/src/sbin/savecore/savecore.c
index cd6ac7a..e1e272b 100644 (file)
--- a/usr/src/sbin/savecore/savecore.c
+++ b/usr/src/sbin/savecore/savecore.c
@@ -1,6 +1,18 @@
+/*
+ * Copyright (c) 1980,1986 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ */
+
 #ifndef lint
 #ifndef lint
-static char *sccsid = "@(#)savecore.c  4.14 (Berkeley) 84/07/17";
-#endif
+char copyright[] =
+"@(#) Copyright (c) 1980,1986 Regents of the University of California.\n\
+ All rights reserved.\n";
+#endif not lint
+
+#ifndef lint
+static char sccsid[] = "@(#)savecore.c 5.11 (Berkeley) %G%";
+#endif not lint
 
 /*
  * savecore
 
 /*
  * savecore
@@ -12,6 +24,8 @@ static        char *sccsid = "@(#)savecore.c  4.14 (Berkeley) 84/07/17";
 #include <sys/dir.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/dir.h>
 #include <sys/stat.h>
 #include <sys/time.h>
+#include <sys/file.h>
+#include <sys/syslog.h>
 
 #define        DAY     (60L*60L*24L)
 #define        LEEWAY  (3*DAY)
 
 #define        DAY     (60L*60L*24L)
 #define        LEEWAY  (3*DAY)
@@ -20,10 +34,12 @@ static      char *sccsid = "@(#)savecore.c  4.14 (Berkeley) 84/07/17";
 #ifdef vax
 #define ok(number) ((number)&0x7fffffff)
 #else
 #ifdef vax
 #define ok(number) ((number)&0x7fffffff)
 #else
+#ifdef tahoe
+#define ok(number) ((number)&~0xc0000000)
+#else
 #define ok(number) (number)
 #endif
 #define ok(number) (number)
 #endif
-
-#define SHUTDOWNLOG "/usr/adm/shutdownlog"
+#endif
 
 struct nlist current_nl[] = {  /* namelist for currently running system */
 #define X_DUMPDEV      0
 
 struct nlist current_nl[] = {  /* namelist for currently running system */
 #define X_DUMPDEV      0
@@ -65,7 +81,7 @@ int   dumpsize;                       /* amount of memory dumped */
 int    dumpmag;                        /* magic number in dump */
 time_t now;                            /* current date */
 char   *path();
 int    dumpmag;                        /* magic number in dump */
 time_t now;                            /* current date */
 char   *path();
-unsigned malloc();
+char   *malloc();
 char   *ctime();
 char   vers[80];
 char   core_vers[80];
 char   *ctime();
 char   vers[80];
 char   core_vers[80];
@@ -74,54 +90,59 @@ int panicstr;
 off_t  lseek();
 off_t  Lseek();
 int    Verbose;
 off_t  lseek();
 off_t  Lseek();
 int    Verbose;
+int    force;
+extern int errno;
 
 main(argc, argv)
        char **argv;
        int argc;
 {
 
 main(argc, argv)
        char **argv;
        int argc;
 {
+       char *cp;
+
+       argc--, argv++;
+       while (argc > 0 && argv[0][0] == '-') {
+               for (cp = &argv[0][1]; *cp; cp++) switch (*cp) {
+
+               case 'f':
+                       force++;
+                       break;
 
 
-       while ((argc > 1) && (argv[1][0] == '-')) {
-               switch (argv[1][1]) {
                case 'v':
                case 'v':
-                       Verbose = 1;
+                       Verbose++;
                        break;
                        break;
+
                default:
                default:
-                       fprintf(stderr, "savecore: illegal flag -%c\n",
-                               argv[1][1]);
+               usage:
                        fprintf(stderr,
                        fprintf(stderr,
-                               "usage: savecore [-v] dirname [ system ]\n");
+                           "usage: savecore [-f] [-v] dirname [ system ]\n");
                        exit(1);
                }
                        exit(1);
                }
-               argc--;
-               argv++;
+               argc--, argv++;
        }
        }
-
-       if (argc != 2 && argc != 3) {
-               fprintf(stderr, "usage: savecore [-v] dirname [ system ]\n");
-               exit(1);
-       }
-       dirname = argv[1];
-       if (argc == 3)
-               system = argv[2];
-       if (access(dirname, 2) < 0) {
-               perror(dirname);
+       if (argc != 1 && argc != 2)
+               goto usage;
+       dirname = argv[0];
+       if (argc == 2)
+               system = argv[1];
+       openlog("savecore", LOG_ODELAY, LOG_AUTH);
+       if (access(dirname, W_OK) < 0) {
+               Perror(LOG_ERR, "%s: %m", dirname);
                exit(1);
        }
        read_kmem();
 }
 
                exit(1);
        }
        read_kmem();
 }
 
-int
 dump_exists()
 {
        register int dumpfd;
        int word;
 
 dump_exists()
 {
        register int dumpfd;
        int word;
 
-       dumpfd = Open(ddname, 0);
-       Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), 0);
-       Read(dumpfd, (char *)&word, sizeof word);
+       dumpfd = Open(ddname, O_RDONLY);
+       Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), L_SET);
+       Read(dumpfd, (char *)&word, sizeof (word));
        close(dumpfd);
        close(dumpfd);
-       if (Verbose && (word != dumpmag)) {
-               printf("dumplo = %d (%d bytes)\n", dumplo/512, dumplo);
+       if (Verbose && word != dumpmag) {
+               printf("dumplo = %d (%d bytes)\n", dumplo/DEV_BSIZE, dumplo);
                printf("magic number mismatch: %x != %x\n", word, dumpmag);
        }
        return (word == dumpmag);
                printf("magic number mismatch: %x != %x\n", word, dumpmag);
        }
        return (word == dumpmag);
@@ -132,9 +153,9 @@ clear_dump()
        register int dumpfd;
        int zero = 0;
 
        register int dumpfd;
        int zero = 0;
 
-       dumpfd = Open(ddname, 1);
-       Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), 0);
-       Write(dumpfd, (char *)&zero, sizeof zero);
+       dumpfd = Open(ddname, O_WRONLY);
+       Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), L_SET);
+       Write(dumpfd, (char *)&zero, sizeof (zero));
        close(dumpfd);
 }
 
        close(dumpfd);
 }
 
@@ -154,29 +175,30 @@ find_dev(dev, type)
                if ((statb.st_mode&S_IFMT) != type)
                        continue;
                if (dev == statb.st_rdev) {
                if ((statb.st_mode&S_IFMT) != type)
                        continue;
                if (dev == statb.st_rdev) {
-                       dp = (char *)malloc(strlen(devname)+1);
+                       dp = malloc(strlen(devname)+1);
                        strcpy(dp, devname);
                        strcpy(dp, devname);
-                       return dp;
+                       return (dp);
                }
        }
                }
        }
-       fprintf(stderr, "savecore: Can't find device %d,%d\n",
-               major(dev), minor(dev));
+       log(LOG_ERR, "Can't find device %d/%d\n", major(dev), minor(dev));
        exit(1);
        /*NOTREACHED*/
 }
 
        exit(1);
        /*NOTREACHED*/
 }
 
+int    cursyms[] =
+    { X_DUMPDEV, X_DUMPLO, X_VERSION, X_DUMPMAG, -1 };
+int    dumpsyms[] =
+    { X_TIME, X_DUMPSIZE, X_VERSION, X_PANICSTR, X_DUMPMAG, -1 };
 read_kmem()
 {
 read_kmem()
 {
-       int kmem;
-       FILE *fp;
        register char *cp;
        register char *cp;
+       FILE *fp;
        char *dump_sys;
        char *dump_sys;
+       int kmem, i;
        
        dump_sys = system ? system : "/vmunix";
        
        dump_sys = system ? system : "/vmunix";
-
        nlist("/vmunix", current_nl);
        nlist(dump_sys, dump_nl);
        nlist("/vmunix", current_nl);
        nlist(dump_sys, dump_nl);
-
        /*
         * Some names we need for the currently running system,
         * others for the system that was running when the dump was made.
        /*
         * Some names we need for the currently running system,
         * others for the system that was running when the dump was made.
@@ -185,67 +207,36 @@ read_kmem()
         * in the dump_sys namelist, but are presumed to be the same
         * (since the disk partitions are probably the same!)
         */
         * in the dump_sys namelist, but are presumed to be the same
         * (since the disk partitions are probably the same!)
         */
-       if (current_nl[X_DUMPDEV].n_value == 0) {
-               fprintf(stderr, "savecore: /vmunix: dumpdev not in namelist\n");
-               exit(1);
-       }
-       if (current_nl[X_DUMPLO].n_value == 0) {
-               fprintf(stderr, "savecore: /vmunix: dumplo not in namelist\n");
-               exit(1);
-       }
-       if (dump_nl[X_TIME].n_value == 0) {
-               fprintf(stderr, "savecore: %s: time not in namelist\n",
-                               dump_sys);
-               exit(1);
-       }
-       if (dump_nl[X_DUMPSIZE].n_value == 0) {
-               fprintf(stderr, "savecore: %s: dumpsize not in namelist\n",
-                               dump_sys);
-               exit(1);
-       }
-       /* we need VERSION in both images */
-       if (current_nl[X_VERSION].n_value == 0) {
-               fprintf(stderr, "savecore: /vmunix: version not in namelist\n",
-                               dump_sys);
-               exit(1);
-       }
-       if (dump_nl[X_VERSION].n_value == 0) {
-               fprintf(stderr, "savecore: %s: version not in namelist\n",
-                               dump_sys);
-               exit(1);
-       }
-       if (dump_nl[X_PANICSTR].n_value == 0) {
-               fprintf(stderr, "savecore: %s: panicstr not in namelist\n",
-                               dump_sys);
-               exit(1);
-       }
-       /* we need DUMPMAG in both images */
-       if (current_nl[X_DUMPMAG].n_value == 0) {
-               fprintf(stderr, "savecore: /vmunix: dumpmag not in namelist\n");
-               exit(1);
-       }
-       if (dump_nl[X_DUMPMAG].n_value == 0) {
-               fprintf(stderr, "savecore: %s: dumpmag not in namelist\n",
-                               dump_sys);
-               exit(1);
-       }
-       kmem = Open("/dev/kmem", 0);
-       Lseek(kmem, (long)current_nl[X_DUMPDEV].n_value, 0);
+       for (i = 0; cursyms[i] != -1; i++)
+               if (current_nl[cursyms[i]].n_value == 0) {
+                       log(LOG_ERR, "/vmunix: %s not in namelist",
+                           current_nl[cursyms[i]].n_name);
+                       exit(1);
+               }
+       for (i = 0; dumpsyms[i] != -1; i++)
+               if (dump_nl[dumpsyms[i]].n_value == 0) {
+                       log(LOG_ERR, "%s: %s not in namelist", dump_sys,
+                           dump_nl[dumpsyms[i]].n_name);
+                       exit(1);
+               }
+       kmem = Open("/dev/kmem", O_RDONLY);
+       Lseek(kmem, (long)current_nl[X_DUMPDEV].n_value, L_SET);
        Read(kmem, (char *)&dumpdev, sizeof (dumpdev));
        Read(kmem, (char *)&dumpdev, sizeof (dumpdev));
-       Lseek(kmem, (long)current_nl[X_DUMPLO].n_value, 0);
+       Lseek(kmem, (long)current_nl[X_DUMPLO].n_value, L_SET);
        Read(kmem, (char *)&dumplo, sizeof (dumplo));
        Read(kmem, (char *)&dumplo, sizeof (dumplo));
-       Lseek(kmem, (long)current_nl[X_DUMPMAG].n_value, 0);
+       Lseek(kmem, (long)current_nl[X_DUMPMAG].n_value, L_SET);
        Read(kmem, (char *)&dumpmag, sizeof (dumpmag));
        Read(kmem, (char *)&dumpmag, sizeof (dumpmag));
-       dumplo *= 512L;
+       dumplo *= DEV_BSIZE;
        ddname = find_dev(dumpdev, S_IFBLK);
        ddname = find_dev(dumpdev, S_IFBLK);
-       if ((fp = fdopen(kmem, "r")) == NULL) {
-               fprintf(stderr, "savecore: Couldn't fdopen kmem\n");
+       fp = fdopen(kmem, "r");
+       if (fp == NULL) {
+               log(LOG_ERR, "Couldn't fdopen kmem");
                exit(1);
        }
        if (system)
                return;
                exit(1);
        }
        if (system)
                return;
-       fseek(fp, (long)current_nl[X_VERSION].n_value, 0);
-       fgets(vers, sizeof vers, fp);
+       fseek(fp, (long)current_nl[X_VERSION].n_value, L_SET);
+       fgets(vers, sizeof (vers), fp);
        fclose(fp);
 }
 
        fclose(fp);
 }
 
@@ -254,22 +245,23 @@ check_kmem()
        FILE *fp;
        register char *cp;
 
        FILE *fp;
        register char *cp;
 
-       if ((fp = fopen(ddname, "r")) == NULL) {
-               perror(ddname);
+       fp = fopen(ddname, "r");
+       if (fp == NULL) {
+               Perror(LOG_ERR, "%s: %m", ddname);
                exit(1);
        }
                exit(1);
        }
-       fseek(fp, (off_t)(dumplo+ok(dump_nl[X_VERSION].n_value)), 0);
-       fgets(core_vers, sizeof core_vers, fp);
+       fseek(fp, (off_t)(dumplo+ok(dump_nl[X_VERSION].n_value)), L_SET);
+       fgets(core_vers, sizeof (core_vers), fp);
        fclose(fp);
        fclose(fp);
-       if (!eq(vers, core_vers) && (system == 0))
-               fprintf(stderr,
-                  "savecore: Warning: vmunix version mismatch:\n\t%sand\n\t%s",
+       if (!eq(vers, core_vers) && system == 0)
+               log(LOG_WARNING,
+                  "Warning: vmunix version mismatch:\n\t%sand\n\t%s",
                   vers, core_vers);
        fp = fopen(ddname, "r");
                   vers, core_vers);
        fp = fopen(ddname, "r");
-       fseek(fp, (off_t)(dumplo + ok(dump_nl[X_PANICSTR].n_value)), 0);
-       fread((char *)&panicstr, sizeof panicstr, 1, fp);
+       fseek(fp, (off_t)(dumplo + ok(dump_nl[X_PANICSTR].n_value)), L_SET);
+       fread((char *)&panicstr, sizeof (panicstr), 1, fp);
        if (panicstr) {
        if (panicstr) {
-               fseek(fp, dumplo + ok(panicstr), 0);
+               fseek(fp, dumplo + ok(panicstr), L_SET);
                cp = panic_mesg;
                do
                        *cp = getc(fp);
                cp = panic_mesg;
                do
                        *cp = getc(fp);
@@ -283,19 +275,18 @@ get_crashtime()
        int dumpfd;
        time_t clobber = (time_t)0;
 
        int dumpfd;
        time_t clobber = (time_t)0;
 
-       if (system)
-               return (1);
-       Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_TIME].n_value)), 0);
+       dumpfd = Open(ddname, O_RDONLY);
+       Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_TIME].n_value)), L_SET);
        Read(dumpfd, (char *)&dumptime, sizeof dumptime);
        close(dumpfd);
        if (dumptime == 0) {
                if (Verbose)
        Read(dumpfd, (char *)&dumptime, sizeof dumptime);
        close(dumpfd);
        if (dumptime == 0) {
                if (Verbose)
-                       printf("dump time not found\n");
+                       printf("Dump time is zero.\n");
                return (0);
        }
        printf("System went down at %s", ctime(&dumptime));
        if (dumptime < now - LEEWAY || dumptime > now + LEEWAY) {
                return (0);
        }
        printf("System went down at %s", ctime(&dumptime));
        if (dumptime < now - LEEWAY || dumptime > now + LEEWAY) {
-               printf("Dump time is unreasonable\n");
+               printf("dump time is unreasonable\n");
                return (0);
        }
        return (1);
                return (0);
        }
        return (1);
@@ -305,7 +296,7 @@ char *
 path(file)
        char *file;
 {
 path(file)
        char *file;
 {
-       register char *cp = (char *)malloc(strlen(file) + strlen(dirname) + 2);
+       register char *cp = malloc(strlen(file) + strlen(dirname) + 2);
 
        (void) strcpy(cp, dirname);
        (void) strcat(cp, "/");
 
        (void) strcpy(cp, dirname);
        (void) strcat(cp, "/");
@@ -321,24 +312,22 @@ check_space()
        struct fs fs;
 
        if (stat(dirname, &dsb) < 0) {
        struct fs fs;
 
        if (stat(dirname, &dsb) < 0) {
-               perror(dirname);
+               Perror(LOG_ERR, "%s: %m", dirname);
                exit(1);
        }
        ddev = find_dev(dsb.st_dev, S_IFBLK);
                exit(1);
        }
        ddev = find_dev(dsb.st_dev, S_IFBLK);
-       dfd = Open(ddev, 0);
-       Lseek(dfd, (long)(SBLOCK * DEV_BSIZE), 0);
-       Read(dfd, (char *)&fs, sizeof fs);
+       dfd = Open(ddev, O_RDONLY);
+       Lseek(dfd, SBOFF, L_SET);
+       Read(dfd, (char *)&fs, sizeof (fs));
        close(dfd);
        close(dfd);
-       spacefree = fs.fs_cstotal.cs_nbfree * fs.fs_bsize / 1024;
-       if (read_number("minfree") > spacefree) {
-               fprintf(stderr,
-                  "savecore: Dump omitted, not enough space on device\n");
+       spacefree = freespace(&fs, fs.fs_minfree) * fs.fs_fsize / 1024;
+       if (spacefree < read_number("minfree")) {
+               log(LOG_WARNING, "Dump omitted, not enough space on device");
                return (0);
        }
                return (0);
        }
-       if (fs.fs_cstotal.cs_nbfree * fs.fs_frag + fs.fs_cstotal.cs_nffree <
-           fs.fs_dsize * fs.fs_minfree / 100)
-               fprintf(stderr,
-                       "Dump performed, but free space threshold crossed\n");
+       if (freespace(&fs, fs.fs_minfree) < 0)
+               log(LOG_WARNING,
+                   "Dump performed, but free space threshold crossed");
        return (1);
 }
 
        return (1);
 }
 
@@ -348,7 +337,8 @@ read_number(fn)
        char lin[80];
        register FILE *fp;
 
        char lin[80];
        register FILE *fp;
 
-       if ((fp = fopen(path(fn), "r")) == NULL)
+       fp = fopen(path(fn), "r");
+       if (fp == NULL)
                return (0);
        if (fgets(lin, 80, fp) == NULL) {
                fclose(fp);
                return (0);
        if (fgets(lin, 80, fp) == NULL) {
                fclose(fp);
@@ -358,30 +348,41 @@ read_number(fn)
        return (atoi(lin));
 }
 
        return (atoi(lin));
 }
 
+#define        BUFPAGES        (256*1024/NBPG)         /* 1/4 Mb */
+
 save_core()
 {
        register int n;
 save_core()
 {
        register int n;
-       char buffer[32*NBPG];
-       register char *cp = buffer;
+       register char *cp;
        register int ifd, ofd, bounds;
        register FILE *fp;
 
        register int ifd, ofd, bounds;
        register FILE *fp;
 
+       cp = malloc(BUFPAGES*NBPG);
+       if (cp == 0) {
+               fprintf(stderr, "savecore: Can't allocate i/o buffer.\n");
+               return;
+       }
        bounds = read_number("bounds");
        bounds = read_number("bounds");
-       ifd = Open(system?system:"/vmunix", 0);
+       ifd = Open(system?system:"/vmunix", O_RDONLY);
        while((n = Read(ifd, cp, BUFSIZ)) > 0)
                Write(ofd, cp, n);
        close(ifd);
        close(ofd);
        while((n = Read(ifd, cp, BUFSIZ)) > 0)
                Write(ofd, cp, n);
        close(ifd);
        close(ofd);
-       ifd = Open(ddname, 0);
-       Lseek(ifd, (off_t)(dumplo + ok(dump_nl[X_DUMPSIZE].n_value)), 0);
+       ifd = Open(ddname, O_RDONLY);
+       Lseek(ifd, (off_t)(dumplo + ok(dump_nl[X_DUMPSIZE].n_value)), L_SET);
        Read(ifd, (char *)&dumpsize, sizeof (dumpsize));
        sprintf(cp, "vmcore.%d", bounds);
        ofd = Create(path(cp), 0644);
        Read(ifd, (char *)&dumpsize, sizeof (dumpsize));
        sprintf(cp, "vmcore.%d", bounds);
        ofd = Create(path(cp), 0644);
-       Lseek(ifd, (off_t)dumplo, 0);
-       printf("Saving %d bytes of image in vmcore.%d\n", NBPG*dumpsize,
-               bounds);
+       Lseek(ifd, (off_t)dumplo, L_SET);
+       log(LOG_NOTICE, "Saving %d bytes of image in vmcore.%d\n",
+           NBPG*dumpsize, bounds);
        while (dumpsize > 0) {
        while (dumpsize > 0) {
-               n = Read(ifd, cp, (dumpsize > 32 ? 32 : dumpsize) * NBPG);
+               n = Read(ifd, cp,
+                   (dumpsize > BUFPAGES ? BUFPAGES : dumpsize) * NBPG);
+               if (n == 0) {
+                       log(LOG_WARNING, "WARNING: vmcore may be incomplete");
+                       break;
+               }
                Write(ofd, cp, n);
                dumpsize -= n/NBPG;
        }
                Write(ofd, cp, n);
                dumpsize -= n/NBPG;
        }
@@ -390,52 +391,24 @@ save_core()
        fp = fopen(path("bounds"), "w");
        fprintf(fp, "%d\n", bounds+1);
        fclose(fp);
        fp = fopen(path("bounds"), "w");
        fprintf(fp, "%d\n", bounds+1);
        fclose(fp);
-}
-
-char *days[] = {
-       "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
-};
-
-char *months[] = {
-       "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
-       "Oct", "Nov", "Dec"
-};
-
-log_entry()
-{
-       FILE *fp;
-       struct tm *tm, *localtime();
-
-       tm = localtime(&now);
-       fp = fopen("/usr/adm/shutdownlog", "a");
-       if (fp == 0)
-               return;
-       fseek(fp, 0L, 2);
-       fprintf(fp, "%02d:%02d  %s %s %2d, %4d.  Reboot", tm->tm_hour,
-               tm->tm_min, days[tm->tm_wday], months[tm->tm_mon],
-               tm->tm_mday, tm->tm_year + 1900);
-       if (panicstr)
-               fprintf(fp, " after panic: %s\n", panic_mesg);
-       else
-               putc('\n', fp);
-       fclose(fp);
+       free(cp);
 }
 
 /*
  * Versions of std routines that exit on error.
  */
 }
 
 /*
  * Versions of std routines that exit on error.
  */
-
 Open(name, rw)
        char *name;
        int rw;
 {
        int fd;
 
 Open(name, rw)
        char *name;
        int rw;
 {
        int fd;
 
-       if ((fd = open(name, rw)) < 0) {
-               perror(name);
+       fd = open(name, rw);
+       if (fd < 0) {
+               Perror(LOG_ERR, "%s: %m", name);
                exit(1);
        }
                exit(1);
        }
-       return fd;
+       return (fd);
 }
 
 Read(fd, buff, size)
 }
 
 Read(fd, buff, size)
@@ -444,11 +417,12 @@ Read(fd, buff, size)
 {
        int ret;
 
 {
        int ret;
 
-       if ((ret = read(fd, buff, size)) < 0) {
-               perror("read");
+       ret = read(fd, buff, size);
+       if (ret < 0) {
+               Perror(LOG_ERR, "read: %m");
                exit(1);
        }
                exit(1);
        }
-       return ret;
+       return (ret);
 }
 
 off_t
 }
 
 off_t
@@ -458,11 +432,12 @@ Lseek(fd, off, flag)
 {
        long ret;
 
 {
        long ret;
 
-       if ((ret = lseek(fd, off, flag)) == -1L) {
-               perror("lseek");
+       ret = lseek(fd, off, flag);
+       if (ret == -1) {
+               Perror(LOG_ERR, "lseek: %m");
                exit(1);
        }
                exit(1);
        }
-       return ret;
+       return (ret);
 }
 
 Create(file, mode)
 }
 
 Create(file, mode)
@@ -471,11 +446,12 @@ Create(file, mode)
 {
        register int fd;
 
 {
        register int fd;
 
-       if ((fd = creat(file, mode)) < 0) {
-               perror(file);
+       fd = creat(file, mode);
+       if (fd < 0) {
+               Perror(LOG_ERR, "%s: %m", file);
                exit(1);
        }
                exit(1);
        }
-       return fd;
+       return (fd);
 }
 
 Write(fd, buf, size)
 }
 
 Write(fd, buf, size)
@@ -484,7 +460,27 @@ Write(fd, buf, size)
 {
 
        if (write(fd, buf, size) < size) {
 {
 
        if (write(fd, buf, size) < size) {
-               perror("write");
+               Perror(LOG_ERR, "write: %m");
                exit(1);
        }
 }
                exit(1);
        }
 }
+
+log(level, msg, a1, a2)
+       int level;
+       char *msg;
+{
+
+       fprintf(stderr, msg, a1, a2);
+       syslog(level, msg, a1, a2);
+}
+
+Perror(level, msg, s)
+       int level;
+       char *msg;
+{
+       int oerrno = errno;
+       
+       perror(s);
+       errno = oerrno;
+       syslog(level, msg, s);
+}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.