sbin/savecore/savecore.c

   1 /*      $NetBSD: savecore.c,v 1.80 2009/04/06 12:32:30 lukem Exp $      */
   2
   3 /*-
   4  * Copyright (c) 1986, 1992, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #ifndef lint
  34 __COPYRIGHT("@(#) Copyright (c) 1986, 1992, 1993\
  35  The Regents of the University of California.  All rights reserved.");
  36 #endif /* not lint */
  37
  38 #ifndef lint
  39 #if 0
  40 static char sccsid[] = "@(#)savecore.c  8.5 (Berkeley) 4/28/95";
  41 #else
  42 __RCSID("$NetBSD: savecore.c,v 1.80 2009/04/06 12:32:30 lukem Exp $");
  43 #endif
  44 #endif /* not lint */
  45
  46 #define _KSYMS_PRIVATE
  47
  48 #include <stdbool.h>
  49
  50 #include <sys/param.h>
  51 #include <sys/mount.h>
  52 #include <sys/msgbuf.h>
  53 #include <sys/syslog.h>
  54 #include <sys/time.h>
  55 #include <sys/ksyms.h>
  56
  57 #include <dirent.h>
  58 #include <errno.h>
  59 #include <fcntl.h>
  60 #include <nlist.h>
  61 #include <paths.h>
  62 #include <stddef.h>
  63 #include <stdio.h>
  64 #include <stdlib.h>
  65 #include <string.h>
  66 #include <time.h>
  67 #include <tzfile.h>
  68 #include <unistd.h>
  69 #include <util.h>
  70 #include <limits.h>
  71 #include <kvm.h>
  72
  73 extern FILE *zopen(const char *fname, const char *mode);
  74
  75 #define KREAD(kd, addr, p)\
  76         (kvm_read(kd, addr, (char *)(p), sizeof(*(p))) != sizeof(*(p)))
  77
  78 struct nlist current_nl[] = {   /* Namelist for currently running system. */
  79 #define X_DUMPDEV       0
  80         { .n_name = "_dumpdev" },
  81 #define X_DUMPLO        1
  82         { .n_name = "_dumplo" },
  83 #define X_TIME_SECOND   2
  84         { .n_name = "_time_second" },
  85 #define X_TIME          3
  86         { .n_name = "_time" },
  87 #define X_DUMPSIZE      4
  88         { .n_name = "_dumpsize" },
  89 #define X_VERSION       5
  90         { .n_name = "_version" },
  91 #define X_DUMPMAG       6
  92         { .n_name = "_dumpmag" },
  93 #define X_PANICSTR      7
  94         { .n_name = "_panicstr" },
  95 #define X_PANICSTART    8
  96         { .n_name = "_panicstart" },
  97 #define X_PANICEND      9
  98         { .n_name = "_panicend" },
  99 #define X_MSGBUF        10
 100         { .n_name = "_msgbufp" },
 101 #define X_DUMPCDEV      11
 102         { .n_name = "_dumpcdev" },
 103 #define X_SYMSZ         12
 104         { .n_name = "_ksyms_symsz" },
 105 #define X_STRSZ         13
 106         { .n_name = "_ksyms_strsz" },
 107 #define X_KHDR          14
 108         { .n_name = "_ksyms_hdr" },
 109 #define X_SYMTABS       15
 110         { .n_name = "_ksyms_symtabs" },
 111         { .n_name = NULL },
 112 };
 113 int cursyms[] = { X_DUMPDEV, X_DUMPLO, X_VERSION, X_DUMPMAG, X_DUMPCDEV, -1 };
 114 int dumpsyms[] = { X_TIME_SECOND, X_TIME, X_DUMPSIZE, X_VERSION, X_PANICSTR,
 115     X_DUMPMAG, X_SYMSZ, X_STRSZ, X_KHDR, X_SYMTABS, -1 };
 116
 117 struct nlist dump_nl[] = {      /* Name list for dumped system. */
 118         { .n_name = "_dumpdev" },       /* Entries MUST be the same as */
 119         { .n_name = "_dumplo" },        /*      those in current_nl[].  */
 120         { .n_name = "_time_second" },
 121         { .n_name = "_time" },
 122         { .n_name = "_dumpsize" },
 123         { .n_name = "_version" },
 124         { .n_name = "_dumpmag" },
 125         { .n_name = "_panicstr" },
 126         { .n_name = "_panicstart" },
 127         { .n_name = "_panicend" },
 128         { .n_name = "_msgbufp" },
 129         { .n_name = "_dumpcdev" },
 130         { .n_name = "_ksyms_symsz" },
 131         { .n_name = "_ksyms_strsz" },
 132         { .n_name = "_ksyms_hdr" },
 133         { .n_name = "_ksyms_symtabs" },
 134         { .n_name = NULL },
 135 };
 136
 137 /* Types match kernel declarations. */
 138 off_t   dumplo;                         /* where dump starts on dumpdev */
 139 u_int32_t dumpmag;                      /* magic number in dump */
 140 int     dumpsize;                       /* amount of memory dumped */
 141 off_t dumpbytes;                        /* in bytes */
 142
 143 const char      *kernel;                /* name of used kernel */
 144 char    *dirname;                       /* directory to save dumps in */
 145 char    *ddname;                        /* name of dump device */
 146 dev_t   dumpdev;                        /* dump device */
 147 dev_t   dumpcdev = NODEV;               /* dump device (char equivalent) */
 148 int     dumpfd;                         /* read/write descriptor on dev */
 149 kvm_t   *kd_dump;                       /* kvm descriptor on dev        */
 150 time_t  now;                            /* current date */
 151 char    panic_mesg[1024];
 152 long    panicstr;
 153 char    vers[1024];
 154 char    gzmode[3];
 155
 156 static int      clear, compress, force, verbose;        /* flags */
 157
 158 void    check_kmem(void);
 159 int     check_space(void);
 160 void    clear_dump(void);
 161 int     Create(char *, int);
 162 int     dump_exists(void);
 163 char    *find_dev(dev_t, mode_t);
 164 int     get_crashtime(void);
 165 void    kmem_setup(void);
 166 void    Lseek(int, off_t, int);
 167 int     main(int, char *[]);
 168 int     Open(const char *, int rw);
 169 char    *rawname(char *s);
 170 void    save_core(void);
 171 void    usage(void);
 172 void    Write(int, void *, int);
 173
 174 int
 175 main(int argc, char *argv[])
 176 {
 177         int ch, level, testonly;
 178         char *ep;
 179
 180         dirname = NULL;
 181         kernel = NULL;
 182         level = 1;              /* default to fastest gzip compression */
 183         testonly = 0;
 184         gzmode[0] = 'w';
 185
 186         openlog("savecore", LOG_PERROR, LOG_DAEMON);
 187
 188         while ((ch = getopt(argc, argv, "cdfnN:vzZ:")) != -1)
 189                 switch(ch) {
 190                 case 'c':
 191                         clear = 1;
 192                         break;
 193                 case 'd':               /* Not documented. */
 194                 case 'v':
 195                         verbose = 1;
 196                         break;
 197                 case 'f':
 198                         force = 1;
 199                         break;
 200                 case 'n':
 201                         testonly = 1;
 202                         break;
 203                 case 'N':
 204                         kernel = optarg;
 205                         break;
 206                 case 'z':
 207                         compress = 1;
 208                         break;
 209                 case 'Z':
 210                         level = (int)strtol(optarg, &ep, 10);
 211                         if (level < 0 || level > 9) {
 212                                 (void)syslog(LOG_ERR, "invalid compression %s",
 213                                     optarg);
 214                                 usage();
 215                         }
 216                         break;
 217                 case '?':
 218                 default:
 219                         usage();
 220                 }
 221         argc -= optind;
 222         argv += optind;
 223
 224         if (argc != ((clear || testonly) ? 0 : 1))
 225                 usage();
 226
 227         gzmode[1] = level + '0';
 228         if (!clear)
 229                 dirname = argv[0];
 230
 231         (void)time(&now);
 232         kmem_setup();
 233
 234         if (clear && !testonly) {
 235                 clear_dump();
 236                 exit(0);
 237         }
 238
 239         if (!dump_exists() && !force)
 240                 exit(1);
 241
 242         if (testonly)
 243                 /* If -n was passed and there was a dump, exit at level 0 */
 244                 exit(0);
 245
 246         check_kmem();
 247
 248         if (panicstr)
 249                 syslog(LOG_ALERT, "reboot after panic: %s", panic_mesg);
 250         else
 251                 syslog(LOG_ALERT, "reboot");
 252
 253         if ((!get_crashtime() || !check_space()) && !force)
 254                 exit(1);
 255
 256         save_core();
 257
 258         clear_dump();
 259         exit(0);
 260 }
 261
 262 void
 263 kmem_setup(void)
 264 {
 265         kvm_t *kd_kern;
 266         char errbuf[_POSIX2_LINE_MAX];
 267         int i, hdrsz;
 268
 269         /*
 270          * Some names we need for the currently running system, others for
 271          * the system that was running when the dump was made.  The values
 272          * obtained from the current system are used to look for things in
 273          * /dev/kmem that cannot be found in the kernel namelist, but are
 274          * presumed to be the same (since the disk partitions are probably
 275          * the same!)
 276          */
 277         kd_kern = kvm_openfiles(kernel, NULL, NULL, O_RDONLY, errbuf);
 278         if (kd_kern == NULL) {
 279                 syslog(LOG_ERR, "%s: kvm_openfiles: %s", kernel, errbuf);
 280                 exit(1);
 281         }
 282         if (kvm_nlist(kd_kern, current_nl) == -1)
 283                 syslog(LOG_ERR, "%s: kvm_nlist: %s", kernel,
 284                     kvm_geterr(kd_kern));
 285
 286         for (i = 0; cursyms[i] != -1; i++) {
 287                 if (current_nl[cursyms[i]].n_value != 0)
 288                         continue;
 289                 switch (cursyms[i]) {
 290                 case X_TIME_SECOND:
 291                 case X_TIME:
 292                 case X_DUMPCDEV:
 293                         break;
 294                 default:
 295                         syslog(LOG_ERR, "%s: %s not in namelist",
 296                             kernel, current_nl[cursyms[i]].n_name);
 297                         exit(1);
 298                 }
 299         }
 300
 301         if (KREAD(kd_kern, current_nl[X_DUMPDEV].n_value, &dumpdev) != 0) {
 302                 if (verbose)
 303                     syslog(LOG_WARNING, "kvm_read: %s", kvm_geterr(kd_kern));
 304                 exit(1);
 305         }
 306         if (dumpdev == NODEV) {
 307                 syslog(LOG_WARNING, "no core dump (no dumpdev)");
 308                 exit(1);
 309         }
 310         {
 311             long l_dumplo;
 312
 313             if (KREAD(kd_kern, current_nl[X_DUMPLO].n_value, &l_dumplo) != 0) {
 314                     if (verbose)
 315                         syslog(LOG_WARNING, "kvm_read: %s", kvm_geterr(kd_kern));
 316                     exit(1);
 317             }
 318             if (l_dumplo == -1) {
 319                 syslog(LOG_WARNING, "no core dump (invalid dumplo)");
 320                 exit(1);
 321             }
 322             dumplo = DEV_BSIZE * (off_t) l_dumplo;
 323         }
 324
 325         if (verbose)
 326                 (void)printf("dumplo = %lld (%ld * %ld)\n",
 327                     (long long)dumplo, (long)(dumplo / DEV_BSIZE), (long)DEV_BSIZE);
 328         if (KREAD(kd_kern, current_nl[X_DUMPMAG].n_value, &dumpmag) != 0) {
 329                 if (verbose)
 330                     syslog(LOG_WARNING, "kvm_read: %s", kvm_geterr(kd_kern));
 331                 exit(1);
 332         }
 333
 334         (void)kvm_read(kd_kern, current_nl[X_VERSION].n_value, vers,
 335             sizeof(vers));
 336         vers[sizeof(vers) - 1] = '\0';
 337
 338         if (current_nl[X_DUMPCDEV].n_value != 0) {
 339                 if (KREAD(kd_kern, current_nl[X_DUMPCDEV].n_value,
 340                     &dumpcdev) != 0) {
 341                         if (verbose)
 342                                 syslog(LOG_WARNING, "kvm_read: %s",
 343                                     kvm_geterr(kd_kern));
 344                         exit(1);
 345                 }
 346                 ddname = find_dev(dumpcdev, S_IFCHR);
 347         } else
 348                 ddname = find_dev(dumpdev, S_IFBLK);
 349         if (strncmp(ddname, "/dev/cons", 8) == 0 ||
 350             strncmp(ddname, "/dev/tty", 7) == 0 ||
 351             strncmp(ddname, "/dev/pty", 7) == 0 ||
 352             strncmp(ddname, "/dev/pts", 7) == 0) {
 353                 syslog(LOG_ERR, "dumpdev %s is tty; override kernel", ddname);
 354                 exit(1);
 355         }
 356         dumpfd = Open(ddname, O_RDWR);
 357
 358         kd_dump = kvm_openfiles(kernel, ddname, NULL, O_RDWR, errbuf);
 359         if (kd_dump == NULL) {
 360                 syslog(LOG_ERR, "%s: kvm_openfiles: %s", kernel, errbuf);
 361                 exit(1);
 362         }
 363
 364         if (kvm_nlist(kd_dump, dump_nl) == -1)
 365                 syslog(LOG_ERR, "%s: kvm_nlist: %s", kernel,
 366                     kvm_geterr(kd_dump));
 367
 368         for (i = 0; dumpsyms[i] != -1; i++)
 369                 if (dump_nl[dumpsyms[i]].n_value == 0 &&
 370                         dumpsyms[i] != X_TIME_SECOND &&
 371                         dumpsyms[i] != X_TIME) {
 372                         syslog(LOG_ERR, "%s: %s not in namelist",
 373                             kernel, dump_nl[dumpsyms[i]].n_name);
 374                         exit(1);
 375                 }
 376         hdrsz = kvm_dump_mkheader(kd_dump, dumplo);
 377
 378         /*
 379          * If 'hdrsz' == 0, kvm_dump_mkheader() failed on the magic-number
 380          * checks, ergo no dump is present...
 381          */
 382         if (hdrsz == 0) {
 383                 syslog(LOG_WARNING, "no core dump");
 384                 exit(1);
 385         }
 386         if (hdrsz == -1) {
 387                 syslog(LOG_ERR, "%s: kvm_dump_mkheader: %s", kernel,
 388                     kvm_geterr(kd_dump));
 389                 exit(1);
 390         }
 391         dumplo += hdrsz;
 392         kvm_close(kd_kern);
 393 }
 394
 395 void
 396 check_kmem(void)
 397 {
 398         char *cp, *bufdata;
 399         struct kern_msgbuf msgbuf, *bufp;
 400         long panicloc, panicstart, panicend;
 401         char core_vers[1024];
 402
 403         (void)kvm_read(kd_dump, dump_nl[X_VERSION].n_value, core_vers,
 404             sizeof(core_vers));
 405         core_vers[sizeof(core_vers) - 1] = '\0';
 406
 407         if (strcmp(vers, core_vers) != 0)
 408                 syslog(LOG_WARNING,
 409                     "warning: %s version mismatch:\n\t%s\nand\t%s\n",
 410                     kernel, vers, core_vers);
 411
 412         panicstart = panicend = 0;
 413         if (KREAD(kd_dump, dump_nl[X_PANICSTART].n_value, &panicstart) != 0) {
 414                 if (verbose)
 415                     syslog(LOG_WARNING, "kvm_read: %s", kvm_geterr(kd_dump));
 416                 goto nomsguf;
 417         }
 418         if (KREAD(kd_dump, dump_nl[X_PANICEND].n_value, &panicend) != 0) {
 419                 if (verbose)
 420                     syslog(LOG_WARNING, "kvm_read: %s", kvm_geterr(kd_dump));
 421                 goto nomsguf;
 422         }
 423         if (panicstart != 0 && panicend != 0) {
 424                 if (KREAD(kd_dump, dump_nl[X_MSGBUF].n_value, &bufp)) {
 425                         if (verbose)
 426                                 syslog(LOG_WARNING, "kvm_read: %s", kvm_geterr(kd_dump));
 427                         goto nomsguf;
 428                 }
 429                 if (kvm_read(kd_dump, (long)bufp, &msgbuf,
 430                     offsetof(struct kern_msgbuf, msg_bufc)) !=
 431                     offsetof(struct kern_msgbuf, msg_bufc)) {
 432                         if (verbose)
 433                                 syslog(LOG_WARNING, "kvm_read: %s", kvm_geterr(kd_dump));
 434                         goto nomsguf;
 435                 }
 436                 if (msgbuf.msg_magic != MSG_MAGIC) {
 437                         if (verbose)
 438                                 syslog(LOG_WARNING, "msgbuf magic incorrect");
 439                         goto nomsguf;
 440                 }
 441                 bufdata = malloc(msgbuf.msg_bufs);
 442                 if (bufdata == NULL) {
 443                         if (verbose)
 444                                 syslog(LOG_WARNING, "couldn't allocate space for msgbuf data");
 445                         goto nomsguf;
 446                 }
 447                 if (kvm_read(kd_dump, (long)&bufp->msg_bufc, bufdata,
 448                     msgbuf.msg_bufs) != msgbuf.msg_bufs) {
 449                         if (verbose)
 450                                 syslog(LOG_WARNING, "kvm_read: %s", kvm_geterr(kd_dump));
 451                         free(bufdata);
 452                         goto nomsguf;
 453                 }
 454                 cp = panic_mesg;
 455                 while (panicstart != panicend && cp < &panic_mesg[sizeof(panic_mesg)-1]) {
 456                         *cp++ = bufdata[panicstart];
 457                         panicstart++;
 458                         if (panicstart >= msgbuf.msg_bufs)
 459                                 panicstart = 0;
 460                 }
 461                 /* Don't end in a new-line */
 462                 cp = &panic_mesg[strlen(panic_mesg)] - 1;
 463                 if (*cp == '\n')
 464                         *cp = '\0';
 465                 panic_mesg[sizeof(panic_mesg) - 1] = '\0';
 466                 free(bufdata);
 467
 468                 panicstr = 1;   /* anything not zero */
 469                 return;
 470         }
 471 nomsguf:
 472         if (KREAD(kd_dump, dump_nl[X_PANICSTR].n_value, &panicstr) != 0) {
 473                 if (verbose)
 474                     syslog(LOG_WARNING, "kvm_read: %s", kvm_geterr(kd_dump));
 475                 return;
 476         }
 477         if (panicstr) {
 478                 cp = panic_mesg;
 479                 panicloc = panicstr;
 480                 do {
 481                         if (KREAD(kd_dump, panicloc, cp) != 0) {
 482                                 if (verbose)
 483                                     syslog(LOG_WARNING, "kvm_read: %s",
 484                                         kvm_geterr(kd_dump));
 485                                 break;
 486                         }
 487                         panicloc++;
 488                 } while (*cp++ && cp < &panic_mesg[sizeof(panic_mesg)-1]);
 489                 panic_mesg[sizeof(panic_mesg) - 1] = '\0';
 490         }
 491 }
 492
 493 int
 494 dump_exists(void)
 495 {
 496         u_int32_t newdumpmag;
 497
 498         if (KREAD(kd_dump, dump_nl[X_DUMPMAG].n_value, &newdumpmag) != 0) {
 499                 if (verbose)
 500                     syslog(LOG_WARNING, "kvm_read: %s", kvm_geterr(kd_dump));
 501                 return (0);
 502         }
 503
 504         /* Read the dump size. */
 505         if (KREAD(kd_dump, dump_nl[X_DUMPSIZE].n_value, &dumpsize) != 0) {
 506                 if (verbose)
 507                     syslog(LOG_WARNING, "kvm_read: %s", kvm_geterr(kd_dump));
 508                 return (0);
 509         }
 510         dumpbytes = (off_t)dumpsize * getpagesize();
 511
 512         /*
 513          * Return zero if core dump doesn't seem to be there, and note
 514          * it for syslog.  This check and return happens after the dump size
 515          * is read, so dumpsize is whether or not the core is valid (for -f).
 516          */
 517         if (newdumpmag != dumpmag) {
 518                 if (verbose)
 519                         syslog(LOG_WARNING,
 520                             "magic number mismatch (0x%x != 0x%x)",
 521                             newdumpmag, dumpmag);
 522                 syslog(LOG_WARNING, "no core dump");
 523                 return (0);
 524         }
 525         return (1);
 526 }
 527
 528 void
 529 clear_dump(void)
 530 {
 531         if (kvm_dump_inval(kd_dump) == -1)
 532                 syslog(LOG_ERR, "%s: kvm_dump_inval: %s", ddname,
 533                     kvm_geterr(kd_dump));
 534
 535 }
 536
 537 char buf[1024 * 1024];
 538
 539 static void
 540 save_kernel(int ofd, FILE *fp, char *path)
 541 {
 542         int nw, nr, ifd;
 543
 544         ifd = Open(kernel, O_RDONLY);
 545         while ((nr = read(ifd, buf, sizeof(buf))) > 0) {
 546                 if (compress)
 547                         nw = fwrite(buf, 1, nr, fp);
 548                 else
 549                         nw = write(ofd, buf, nr);
 550                 if (nw != nr) {
 551                         syslog(LOG_ERR, "%s: %s",
 552                             path, strerror(nw == 0 ? EIO : errno));
 553                         syslog(LOG_WARNING,
 554                             "WARNING: kernel may be incomplete");
 555                         exit(1);
 556                 }
 557         }
 558         if (nr < 0) {
 559                 syslog(LOG_ERR, "%s: %m", kernel);
 560                 syslog(LOG_WARNING, "WARNING: kernel may be incomplete");
 561                 exit(1);
 562         }
 563 }
 564
 565 static int
 566 ksymsget(u_long addr, void *ptr, size_t size)
 567 {
 568
 569         if ((size_t)kvm_read(kd_dump, addr, ptr, size) != size) {
 570                 if (verbose)
 571                         syslog(LOG_WARNING, "kvm_read: %s",
 572                             kvm_geterr(kd_dump));
 573                 return 1;
 574         }
 575         return 0;
 576 }
 577
 578 static int
 579 save_ksyms(int ofd, FILE *fp, char *path)
 580 {
 581         struct ksyms_hdr khdr;
 582         int nw, symsz, strsz;
 583         TAILQ_HEAD(, ksyms_symtab) symtabs;
 584         struct ksyms_symtab st, *stptr;
 585         void *p;
 586
 587         /* Get basic info and ELF headers, check if ksyms was on. */
 588         if (ksymsget(dump_nl[X_KHDR].n_value, &khdr, sizeof(khdr)))
 589                 return 1;
 590         if (ksymsget(dump_nl[X_SYMSZ].n_value, &symsz, sizeof(symsz)))
 591                 return 1;
 592         if (ksymsget(dump_nl[X_STRSZ].n_value, &strsz, sizeof(strsz)))
 593                 return 1;
 594         if (symsz == 0 || strsz == 0)
 595                 return 1;
 596
 597         /* Update the ELF section headers for symbols/strings. */
 598         khdr.kh_shdr[SYMTAB].sh_size = symsz;
 599         khdr.kh_shdr[SYMTAB].sh_info = symsz / sizeof(Elf_Sym);
 600         khdr.kh_shdr[STRTAB].sh_offset = symsz +
 601             khdr.kh_shdr[SYMTAB].sh_offset;
 602         khdr.kh_shdr[STRTAB].sh_size = strsz;
 603
 604         /* Write out the ELF headers. */
 605         if (compress)
 606                 nw = fwrite(&khdr, 1, sizeof(khdr), fp);
 607         else
 608                 nw = write(ofd, &khdr, sizeof(khdr));
 609         if (nw != sizeof(khdr)) {
 610                 syslog(LOG_ERR, "%s: %s",
 611                     path, strerror(nw == 0 ? EIO : errno));
 612                 syslog(LOG_WARNING,
 613                     "WARNING: kernel may be incomplete");
 614                 exit(1);
 615         }
 616
 617         /* Dump symbol table. */
 618         if (ksymsget(dump_nl[X_SYMTABS].n_value, &symtabs, sizeof(symtabs)))
 619                 return 1;
 620         stptr = TAILQ_FIRST(&symtabs);
 621         while (stptr != NULL) {
 622                 if (ksymsget((u_long)stptr, &st, sizeof(st)))
 623                         return 1;
 624                 stptr = TAILQ_NEXT(&st, sd_queue);
 625                 if ((p = malloc(st.sd_symsize)) == NULL)
 626                         return 1;
 627                 if (ksymsget((u_long)st.sd_symstart, p, st.sd_symsize)) {
 628                         free(p);
 629                         return 1;
 630                 }
 631                 if (compress)
 632                         nw = fwrite(p, 1, st.sd_symsize, fp);
 633                 else
 634                         nw = write(ofd, p, st.sd_symsize);
 635                 free(p);
 636                 if (nw != st.sd_symsize) {
 637                         syslog(LOG_ERR, "%s: %s",
 638                             path, strerror(nw == 0 ? EIO : errno));
 639                         syslog(LOG_WARNING,
 640                             "WARNING: kernel may be incomplete");
 641                         exit(1);
 642                 }
 643         }
 644
 645         /* Dump string table. */
 646         if (ksymsget(dump_nl[X_SYMTABS].n_value, &symtabs, sizeof(symtabs)))
 647                 return 1;
 648         stptr = TAILQ_FIRST(&symtabs);
 649         while (stptr != NULL) {
 650                 if (ksymsget((u_long)stptr, &st, sizeof(st)))
 651                         return 1;
 652                 stptr = TAILQ_NEXT(&st, sd_queue);
 653                 if ((p = malloc(st.sd_symsize)) == NULL)
 654                         return 1;
 655                 if (ksymsget((u_long)st.sd_strstart, p, st.sd_strsize)) {
 656                         free(p);
 657                         return 1;
 658                 }
 659                 if (compress)
 660                         nw = fwrite(p, 1, st.sd_strsize, fp);
 661                 else
 662                         nw = write(ofd, p, st.sd_strsize);
 663                 free(p);
 664                 if (nw != st.sd_strsize) {
 665                         syslog(LOG_ERR, "%s: %s",
 666                             path, strerror(nw == 0 ? EIO : errno));
 667                         syslog(LOG_WARNING,
 668                             "WARNING: kernel may be incomplete");
 669                         exit(1);
 670                 }
 671         }
 672
 673         return 0;
 674 }
 675
 676 void
 677 save_core(void)
 678 {
 679         FILE *fp;
 680         int bounds, ifd, nr, nw, ofd, tryksyms;
 681         char *rawp, path[MAXPATHLEN];
 682
 683         ofd = -1;
 684         /*
 685          * Get the current number and update the bounds file.  Do the update
 686          * now, because may fail later and don't want to overwrite anything.
 687          */
 688         umask(066);
 689         (void)snprintf(path, sizeof(path), "%s/bounds", dirname);
 690         if ((fp = fopen(path, "r")) == NULL)
 691                 goto err1;
 692         if (fgets(buf, sizeof(buf), fp) == NULL) {
 693                 if (ferror(fp))
 694 err1:                   syslog(LOG_WARNING, "%s: %m", path);
 695                 bounds = 0;
 696         } else
 697                 bounds = atoi(buf);
 698         if (fp != NULL)
 699                 (void)fclose(fp);
 700         if ((fp = fopen(path, "w")) == NULL)
 701                 syslog(LOG_ERR, "%s: %m", path);
 702         else {
 703                 (void)fprintf(fp, "%d\n", bounds + 1);
 704                 (void)fclose(fp);
 705         }
 706
 707         /* Create the core file. */
 708         (void)snprintf(path, sizeof(path), "%s/netbsd.%d.core%s",
 709             dirname, bounds, compress ? ".gz" : "");
 710         if (compress) {
 711                 if ((fp = zopen(path, gzmode)) == NULL) {
 712                         syslog(LOG_ERR, "%s: %m", path);
 713                         exit(1);
 714                 }
 715         } else {
 716                 ofd = Create(path, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 717                 fp  = fdopen(ofd, "w");
 718                 if (fp == NULL) {
 719                         syslog(LOG_ERR, "%s: fdopen: %m", path);
 720                         exit(1);
 721                 }
 722         }
 723
 724         if (dumpcdev == NODEV) {
 725                 /* Open the raw device. */
 726                 rawp = rawname(ddname);
 727                 if ((ifd = open(rawp, O_RDONLY)) == -1) {
 728                         syslog(LOG_WARNING, "%s: %m; using block device",
 729                             rawp);
 730                         ifd = dumpfd;
 731                 }
 732         } else {
 733                 rawp = ddname;
 734                 ifd = dumpfd;
 735         }
 736
 737         /* Seek to the start of the core. */
 738         Lseek(ifd, dumplo, SEEK_SET);
 739
 740         if (kvm_dump_wrtheader(kd_dump, fp, (int32_t)dumpbytes) == -1) {
 741                 syslog(LOG_ERR, "kvm_dump_wrtheader: %s : %s", path,
 742                     kvm_geterr(kd_dump));
 743                 exit(1);
 744         }
 745
 746         /* Copy the core file. */
 747         syslog(LOG_NOTICE, "writing %score to %s",
 748             compress ? "compressed " : "", path);
 749         for (; dumpbytes > (off_t)0; dumpbytes -= (off_t)nr) {
 750                 char nbuf[7];
 751                 humanize_number(nbuf, 7, dumpbytes, "", HN_AUTOSCALE, 0);
 752                 (void)printf("%7s\r", nbuf);
 753                 (void)fflush(stdout);
 754                 nr = read(ifd, buf, MIN(dumpbytes, (off_t)sizeof(buf)));
 755                 if (nr <= 0) {
 756                         if (nr == 0)
 757                                 syslog(LOG_WARNING,
 758                                     "WARNING: EOF on dump device");
 759                         else
 760                                 syslog(LOG_ERR, "%s: %m", rawp);
 761                         goto err2;
 762                 }
 763                 nw = fwrite(buf, 1, nr, fp);
 764                 if (nw != nr) {
 765                         syslog(LOG_ERR, "%s: %s",
 766                             path, strerror(nw == 0 ? EIO : errno));
 767 err2:                   syslog(LOG_WARNING,
 768                             "WARNING: core may be incomplete");
 769                         (void)printf("\n");
 770                         exit(1);
 771                 }
 772         }
 773         if (dumpcdev == NODEV)
 774                 (void)close(ifd);
 775         (void)fclose(fp);
 776
 777         /* Create a kernel. */
 778         (void)snprintf(path, sizeof(path), "%s/netbsd.%d%s",
 779             dirname, bounds, compress ? ".gz" : "");
 780         syslog(LOG_NOTICE, "writing %skernel to %s",
 781             compress ? "compressed " : "", path);
 782         for (tryksyms = 1;; tryksyms = 0) {
 783                 if (compress) {
 784                         if ((fp = zopen(path, gzmode)) == NULL) {
 785                                 syslog(LOG_ERR, "%s: %m", path);
 786                                 exit(1);
 787                         }
 788                 } else
 789                         ofd = Create(path, S_IRUSR | S_IWUSR);
 790                 if (tryksyms) {
 791                         if (!save_ksyms(ofd, fp, path))
 792                                 break;
 793                         if (compress)
 794                                 (void)fclose(fp);
 795                         else
 796                                 (void)close(ofd);
 797                         unlink(path);
 798                 } else {
 799                         save_kernel(ofd, fp, path);
 800                         break;
 801                 }
 802         }
 803         if (compress)
 804                 (void)fclose(fp);
 805         else
 806                 (void)close(ofd);
 807
 808         /*
 809          * For development systems where the crash occurs during boot
 810          * to multiuser.
 811          */
 812         sync();
 813         sleep(1);
 814         sync();
 815         sleep(1);
 816 }
 817
 818 char *
 819 find_dev(dev_t dev, mode_t type)
 820 {
 821         DIR *dfd;
 822         struct dirent *dir;
 823         struct stat sb;
 824         char *dp, device[MAXPATHLEN + 1], *p;
 825         size_t l;
 826
 827         if ((dfd = opendir(_PATH_DEV)) == NULL) {
 828                 syslog(LOG_ERR, "%s: %m", _PATH_DEV);
 829                 exit(1);
 830         }
 831         strlcpy(device, _PATH_DEV, sizeof(device));
 832         p = &device[strlen(device)];
 833         l = sizeof(device) - strlen(device);
 834         while ((dir = readdir(dfd))) {
 835                 strlcpy(p, dir->d_name, l);
 836                 if (lstat(device, &sb)) {
 837                         syslog(LOG_ERR, "%s: %m", device);
 838                         continue;
 839                 }
 840                 if ((sb.st_mode & S_IFMT) != type)
 841                         continue;
 842                 if (dev == sb.st_rdev) {
 843                         closedir(dfd);
 844                         if ((dp = strdup(device)) == NULL) {
 845                                 syslog(LOG_ERR, "%m");
 846                                 exit(1);
 847                         }
 848                         return (dp);
 849                 }
 850         }
 851         closedir(dfd);
 852         syslog(LOG_ERR, "can't find device %lld/%lld",
 853             (long long)major(dev), (long long)minor(dev));
 854         exit(1);
 855 }
 856
 857 char *
 858 rawname(char *s)
 859 {
 860         char *sl;
 861         char name[MAXPATHLEN];
 862
 863         if ((sl = strrchr(s, '/')) == NULL || sl[1] == '0') {
 864                 syslog(LOG_ERR,
 865                     "can't make raw dump device name from %s", s);
 866                 return (s);
 867         }
 868         (void)snprintf(name, sizeof(name), "%.*s/r%s", (int)(sl - s), s,
 869             sl + 1);
 870         if ((sl = strdup(name)) == NULL) {
 871                 syslog(LOG_ERR, "%m");
 872                 exit(1);
 873         }
 874         return (sl);
 875 }
 876
 877 int
 878 get_crashtime(void)
 879 {
 880         time_t dumptime;                        /* Time the dump was taken. */
 881         struct timeval dtime;
 882
 883         if (KREAD(kd_dump, dump_nl[X_TIME_SECOND].n_value, &dumptime) != 0) {
 884                 if (KREAD(kd_dump, dump_nl[X_TIME].n_value, &dtime) != 0) {
 885                         if (verbose)
 886                                 syslog(LOG_WARNING, "kvm_read: %s (and _time_second is not defined also)", kvm_geterr(kd_dump));
 887                         return (0);
 888                 }
 889                 dumptime = dtime.tv_sec;
 890         }
 891         if (dumptime == 0) {
 892                 if (verbose)
 893                         syslog(LOG_ERR, "dump time is zero");
 894                 return (0);
 895         }
 896         (void)printf("savecore: system went down at %s", ctime(&dumptime));
 897 #define LEEWAY  (60 * SECSPERDAY)
 898         if (dumptime < now - LEEWAY || dumptime > now + LEEWAY) {
 899                 (void)printf("dump time is unreasonable\n");
 900                 return (0);
 901         }
 902         return (1);
 903 }
 904
 905 int
 906 check_space(void)
 907 {
 908         FILE *fp;
 909         off_t minfree, spacefree, kernelsize, needed;
 910         struct stat st;
 911         struct statvfs fsbuf;
 912         char mbuf[100], path[MAXPATHLEN];
 913
 914         /* XXX assume a reasonable default, unless we find a kernel. */
 915         kernelsize = 20 * 1024 * 1024;
 916         if (!stat(kernel, &st)) kernelsize = st.st_blocks * S_BLKSIZE;
 917         if (statvfs(dirname, &fsbuf) < 0) {
 918                 syslog(LOG_ERR, "%s: %m", dirname);
 919                 exit(1);
 920         }
 921         spacefree = fsbuf.f_bavail;
 922         spacefree *= fsbuf.f_frsize;
 923         spacefree /= 1024;
 924
 925         (void)snprintf(path, sizeof(path), "%s/minfree", dirname);
 926         if ((fp = fopen(path, "r")) == NULL)
 927                 minfree = 0;
 928         else {
 929                 if (fgets(mbuf, sizeof(mbuf), fp) == NULL)
 930                         minfree = 0;
 931                 else
 932                         minfree = atoi(mbuf);
 933                 (void)fclose(fp);
 934         }
 935
 936         needed = (dumpbytes + kernelsize) / 1024;
 937         if (minfree > 0 && spacefree - needed < minfree) {
 938                 syslog(LOG_WARNING,
 939                     "no dump, not enough free space in %s", dirname);
 940                 return (0);
 941         }
 942         if (spacefree - needed < minfree)
 943                 syslog(LOG_WARNING,
 944                     "dump performed, but free space threshold crossed");
 945         return (1);
 946 }
 947
 948 int
 949 Open(const char *name, int rw)
 950 {
 951         int fd;
 952
 953         if ((fd = open(name, rw, 0)) < 0) {
 954                 syslog(LOG_ERR, "%s: %m", name);
 955                 exit(1);
 956         }
 957         return (fd);
 958 }
 959
 960 void
 961 Lseek(int fd, off_t off, int flag)
 962 {
 963         off_t ret;
 964
 965         ret = lseek(fd, off, flag);
 966         if (ret == -1) {
 967                 syslog(LOG_ERR, "lseek: %m");
 968                 exit(1);
 969         }
 970 }
 971
 972 int
 973 Create(char *file, int mode)
 974 {
 975         int fd;
 976
 977         fd = open(file, O_WRONLY | O_CREAT | O_TRUNC, mode);
 978         if (fd < 0) {
 979                 syslog(LOG_ERR, "%s: %m", file);
 980                 exit(1);
 981         }
 982         return (fd);
 983 }
 984
 985 void
 986 Write(int fd, void *bp, int size)
 987 {
 988         int n;
 989
 990         if ((n = write(fd, bp, size)) < size) {
 991                 syslog(LOG_ERR, "write: %s", strerror(n == -1 ? errno : EIO));
 992                 exit(1);
 993         }
 994 }
 995
 996 void
 997 usage(void)
 998 {
 999         (void)syslog(LOG_ERR,
1000             "usage: savecore [-cfnvz] [-N system] [-Z level] directory");
1001         exit(1);
1002 }