Net2/usr/src/sbin/savecore/savecore.c
/*
* Copyright (c) 1980, 1986, 1989 The Regents of the University of California.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1980, 1986, 1989 The Regents of the University of California.\n\
All rights reserved.\n";
#endif /* not lint */
#ifndef lint
static char sccsid[] = "@(#)savecore.c 5.26 (Berkeley) 4/8/91";
#endif /* not lint */
#include <sys/param.h>
#include <sys/mount.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/file.h>
#include <sys/syslog.h>
#include <dirent.h>
#include <stdio.h>
#include <nlist.h>
#include <paths.h>
#define DAY (60L*60L*24L)
#define LEEWAY (3*DAY)
#define eq(a,b) (!strcmp(a,b))
#ifdef vax
#define ok(number) ((number)&0x7fffffff)
#else
#ifdef tahoe
#define ok(number) ((number)&~0xc0000000)
#else
#ifdef i386
#define ok(number) ((number)&~0xfe000000)
#else
#define ok(number) (number)
#endif
#endif
#endif
struct nlist current_nl[] = { /* namelist for currently running system */
#define X_DUMPDEV 0
{ "_dumpdev" },
#define X_DUMPLO 1
{ "_dumplo" },
#define X_TIME 2
{ "_time" },
#define X_DUMPSIZE 3
{ "_dumpsize" },
#define X_VERSION 4
{ "_version" },
#define X_PANICSTR 5
{ "_panicstr" },
#define X_DUMPMAG 6
{ "_dumpmag" },
{ "" },
};
struct nlist dump_nl[] = { /* name list for dumped system */
{ "_dumpdev" }, /* entries MUST be the same as */
{ "_dumplo" }, /* those in current_nl[] */
{ "_time" },
{ "_dumpsize" },
{ "_version" },
{ "_panicstr" },
{ "_dumpmag" },
{ "" },
};
char *system;
char *dirname; /* directory to save dumps in */
char *ddname; /* name of dump device */
int dumpfd; /* read/write descriptor on block dev */
char *find_dev();
dev_t dumpdev; /* dump device */
time_t dumptime; /* time the dump was taken */
int dumplo; /* where dump starts on dumpdev */
int dumpsize; /* amount of memory dumped */
int dumpmag; /* magic number in dump */
time_t now; /* current date */
char *path();
char *malloc();
char *ctime();
char vers[80];
char core_vers[80];
char panic_mesg[80];
int panicstr;
off_t lseek();
off_t Lseek();
int verbose;
int force;
int clear;
extern int errno;
main(argc, argv)
char **argv;
int argc;
{
extern char *optarg;
extern int optind;
int ch;
char *cp;
while ((ch = getopt(argc, argv, "cdfv")) != EOF)
switch(ch) {
case 'c':
clear = 1;
break;
case 'd': /* not documented */
case 'v':
verbose = 1;
break;
case 'f':
force = 1;
break;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
/* This is wrong, but I want "savecore -c" to work. */
if (!clear) {
if (argc != 1 && argc != 2)
usage();
dirname = argv[0];
}
if (argc == 2)
system = argv[1];
openlog("savecore", LOG_ODELAY, LOG_AUTH);
read_kmem();
if (!dump_exists()) {
(void)fprintf(stderr, "savecore: no core dump\n");
if (!force)
exit(0);
}
if (clear) {
clear_dump();
exit(0);
}
(void) time(&now);
check_kmem();
if (panicstr)
log(LOG_CRIT, "reboot after panic: %s\n", panic_mesg);
else
syslog(LOG_CRIT, "reboot\n");
if (access(dirname, W_OK) < 0) {
Perror(LOG_ERR, "%s: %m\n", dirname);
exit(1);
}
if ((!get_crashtime() || !check_space()) && !force)
exit(1);
save_core();
clear_dump();
exit(0);
}
dump_exists()
{
int word;
Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), L_SET);
Read(dumpfd, (char *)&word, sizeof (word));
if (verbose && word != dumpmag)
printf("magic number mismatch: %x != %x\n", word, dumpmag);
return (word == dumpmag);
}
clear_dump()
{
int zero = 0;
Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), L_SET);
Write(dumpfd, (char *)&zero, sizeof (zero));
}
char *
find_dev(dev, type)
register dev_t dev;
register int type;
{
register DIR *dfd = opendir(_PATH_DEV);
struct dirent *dir;
struct stat statb;
static char devname[MAXPATHLEN + 1];
char *dp;
strcpy(devname, _PATH_DEV);
while ((dir = readdir(dfd))) {
strcpy(devname + sizeof(_PATH_DEV) - 1, dir->d_name);
if (stat(devname, &statb)) {
perror(devname);
continue;
}
if ((statb.st_mode&S_IFMT) != type)
continue;
if (dev == statb.st_rdev) {
closedir(dfd);
dp = malloc(strlen(devname)+1);
strcpy(dp, devname);
return (dp);
}
}
closedir(dfd);
log(LOG_ERR, "Can't find device %d/%d\n", major(dev), minor(dev));
exit(1);
/*NOTREACHED*/
}
char *
rawname(s)
char *s;
{
static char name[MAXPATHLEN];
char *sl, *rindex();
if ((sl = rindex(s, '/')) == NULL || sl[1] == '0') {
log(LOG_ERR, "can't make raw dump device name from %s?\n", s);
return (s);
}
sprintf(name, "%.*s/r%s", sl - s, s, sl + 1);
return (name);
}
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()
{
register char *cp;
FILE *fp;
char *dump_sys;
int kmem, i;
dump_sys = system ? system : _PATH_UNIX;
nlist(_PATH_UNIX, 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.
* The values obtained from the current system are used
* to look for things in /dev/kmem that cannot be found
* in the dump_sys namelist, but are presumed to be the same
* (since the disk partitions are probably the same!)
*/
for (i = 0; cursyms[i] != -1; i++)
if (current_nl[cursyms[i]].n_value == 0) {
log(LOG_ERR, "%s: %s not in namelist\n", _PATH_UNIX,
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\n", dump_sys,
dump_nl[dumpsyms[i]].n_name);
exit(1);
}
kmem = Open(_PATH_KMEM, O_RDONLY);
Lseek(kmem, (long)current_nl[X_DUMPDEV].n_value, L_SET);
Read(kmem, (char *)&dumpdev, sizeof (dumpdev));
Lseek(kmem, (long)current_nl[X_DUMPLO].n_value, L_SET);
Read(kmem, (char *)&dumplo, sizeof (dumplo));
if (verbose)
printf("dumplo = %d (%d * %d)\n", dumplo, dumplo/DEV_BSIZE,
DEV_BSIZE);
Lseek(kmem, (long)current_nl[X_DUMPMAG].n_value, L_SET);
Read(kmem, (char *)&dumpmag, sizeof (dumpmag));
dumplo *= DEV_BSIZE;
ddname = find_dev(dumpdev, S_IFBLK);
dumpfd = Open(ddname, O_RDWR);
fp = fdopen(kmem, "r");
if (fp == NULL) {
log(LOG_ERR, "Couldn't fdopen kmem\n");
exit(1);
}
if (system)
return;
fseek(fp, (long)current_nl[X_VERSION].n_value, L_SET);
fgets(vers, sizeof (vers), fp);
fclose(fp);
}
check_kmem()
{
FILE *fp;
register char *cp;
fp = fdopen(dumpfd, "r");
if (fp == NULL) {
log(LOG_ERR, "Can't fdopen dumpfd\n");
exit(1);
}
fseek(fp, (off_t)(dumplo+ok(dump_nl[X_VERSION].n_value)), L_SET);
fgets(core_vers, sizeof (core_vers), fp);
if (!eq(vers, core_vers) && system == 0) {
log(LOG_WARNING, "Warning: %s version mismatch:\n", _PATH_UNIX);
log(LOG_WARNING, "\t%s\n", vers);
log(LOG_WARNING, "and\t%s\n", core_vers);
}
fseek(fp, (off_t)(dumplo + ok(dump_nl[X_PANICSTR].n_value)), L_SET);
fread((char *)&panicstr, sizeof (panicstr), 1, fp);
if (panicstr) {
fseek(fp, dumplo + ok(panicstr), L_SET);
cp = panic_mesg;
do
*cp = getc(fp);
while (*cp++ && cp < &panic_mesg[sizeof(panic_mesg)]);
}
/* don't fclose(fp); we want the file descriptor */
}
get_crashtime()
{
time_t clobber = (time_t)0;
Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_TIME].n_value)), L_SET);
Read(dumpfd, (char *)&dumptime, sizeof dumptime);
if (dumptime == 0) {
if (verbose)
printf("Dump time is zero.\n");
return (0);
}
printf("System went down at %s", ctime(&dumptime));
if (dumptime < now - LEEWAY || dumptime > now + LEEWAY) {
printf("dump time is unreasonable\n");
return (0);
}
return (1);
}
char *
path(file)
char *file;
{
register char *cp = malloc(strlen(file) + strlen(dirname) + 2);
(void) strcpy(cp, dirname);
(void) strcat(cp, "/");
(void) strcat(cp, file);
return (cp);
}
check_space()
{
long minfree, spacefree;
struct statfs fsbuf;
if (statfs(dirname, &fsbuf) < 0) {
Perror(LOG_ERR, "%s: %m\n", dirname);
exit(1);
}
spacefree = fsbuf.f_bavail * fsbuf.f_fsize / 1024;
minfree = read_number("minfree");
if (minfree > 0 && spacefree - dumpsize < minfree) {
log(LOG_WARNING, "Dump omitted, not enough space on device\n");
return (0);
}
if (spacefree - dumpsize < minfree)
log(LOG_WARNING,
"Dump performed, but free space threshold crossed\n");
return (1);
}
read_number(fn)
char *fn;
{
char lin[80];
register FILE *fp;
fp = fopen(path(fn), "r");
if (fp == NULL)
return (0);
if (fgets(lin, 80, fp) == NULL) {
fclose(fp);
return (0);
}
fclose(fp);
return (atoi(lin));
}
#define BUFSIZE (256*1024) /* 1/4 Mb */
save_core()
{
register int n;
register char *cp;
register int ifd, ofd, bounds;
int ret;
char *bfile;
register FILE *fp;
cp = malloc(BUFSIZE);
if (cp == 0) {
log(LOG_ERR, "savecore: Can't allocate i/o buffer.\n");
return;
}
bounds = read_number("bounds");
ifd = Open(system ? system : _PATH_UNIX, O_RDONLY);
(void)sprintf(cp, "vmunix.%d", bounds);
ofd = Create(path(cp), 0644);
while((n = Read(ifd, cp, BUFSIZE)) > 0)
Write(ofd, cp, n);
close(ifd);
close(ofd);
if ((ifd = open(rawname(ddname), O_RDONLY)) == -1) {
log(LOG_WARNING, "Can't open %s (%m); using block device",
rawname(ddname));
ifd = dumpfd;
}
Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPSIZE].n_value)), L_SET);
Read(dumpfd, (char *)&dumpsize, sizeof (dumpsize));
(void)sprintf(cp, "vmcore.%d", bounds);
ofd = Create(path(cp), 0644);
Lseek(ifd, (off_t)dumplo, L_SET);
dumpsize *= NBPG;
log(LOG_NOTICE, "Saving %d bytes of image in vmcore.%d\n",
dumpsize, bounds);
while (dumpsize > 0) {
n = read(ifd, cp,
dumpsize > BUFSIZE ? BUFSIZE : dumpsize);
if (n <= 0) {
if (n == 0)
log(LOG_WARNING,
"WARNING: EOF on dump device; %s\n",
"vmcore may be incomplete");
else
Perror(LOG_ERR, "read from dumpdev: %m",
"read");
break;
}
if ((ret = write(ofd, cp, n)) < n) {
if (ret < 0)
Perror(LOG_ERR, "write: %m", "write");
else
log(LOG_ERR, "short write: wrote %d of %d\n",
ret, n);
log(LOG_WARNING, "WARNING: vmcore may be incomplete\n");
break;
}
dumpsize -= n;
}
close(ifd);
close(ofd);
bfile = path("bounds");
fp = fopen(bfile, "w");
if (fp) {
fprintf(fp, "%d\n", bounds+1);
fclose(fp);
} else
Perror(LOG_ERR, "Can't create bounds file %s: %m", bfile);
free(cp);
}
/*
* Versions of std routines that exit on error.
*/
Open(name, rw)
char *name;
int rw;
{
int fd;
fd = open(name, rw);
if (fd < 0) {
Perror(LOG_ERR, "%s: %m", name);
exit(1);
}
return (fd);
}
Read(fd, buff, size)
int fd, size;
char *buff;
{
int ret;
ret = read(fd, buff, size);
if (ret < 0) {
Perror(LOG_ERR, "read: %m", "read");
exit(1);
}
return (ret);
}
off_t
Lseek(fd, off, flag)
int fd, flag;
long off;
{
long ret;
ret = lseek(fd, off, flag);
if (ret == -1) {
Perror(LOG_ERR, "lseek: %m", "lseek");
exit(1);
}
return (ret);
}
Create(file, mode)
char *file;
int mode;
{
register int fd;
fd = creat(file, mode);
if (fd < 0) {
Perror(LOG_ERR, "%s: %m", file);
exit(1);
}
return (fd);
}
Write(fd, buf, size)
int fd, size;
char *buf;
{
int n;
if ((n = write(fd, buf, size)) < size) {
if (n < 0)
Perror(LOG_ERR, "write: %m", "write");
else
log(LOG_ERR, "short write: wrote %d of %d\n", n, size);
exit(1);
}
}
/* VARARGS2 */
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, *s;
{
int oerrno = errno;
perror(s);
errno = oerrno;
syslog(level, msg, s);
}
usage()
{
(void)fprintf(stderr, "usage: savecore [-cfv] dirname [system]\n");
exit(1);
}