[unix-history] / 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>
#include <vm/vm.h>
#include <vm/vm_param.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)-KERNBASE))
#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 */
#define	BUFSIZE		(8*1024)

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, "system.%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, "ram.%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 ram.%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",
				    "ram file 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: ram file 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);
}
Commit	Line	Data
15637ed4 RG	1	/*
	2	* Copyright (c) 1980, 1986, 1989 The Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, 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. All advertising materials mentioning features or use of this software
	14	* must display the following acknowledgement:
	15	* This product includes software developed by the University of
	16	* California, Berkeley and its contributors.
	17	* 4. Neither the name of the University nor the names of its contributors
	18	* may be used to endorse or promote products derived from this software
	19	* without specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	31	* SUCH DAMAGE.
	32	*/
	33
	34	#ifndef lint
	35	char copyright[] =
	36	"@(#) Copyright (c) 1980, 1986, 1989 The Regents of the University of California.\n\
	37	All rights reserved.\n";
	38	#endif /* not lint */
	39
	40	#ifndef lint
	41	static char sccsid[] = "@(#)savecore.c 5.26 (Berkeley) 4/8/91";
	42	#endif /* not lint */
	43
	44	#include <sys/param.h>
	45	#include <sys/mount.h>
	46	#include <sys/stat.h>
	47	#include <sys/time.h>
	48	#include <sys/file.h>
	49	#include <sys/syslog.h>
	50	#include <dirent.h>
	51	#include <stdio.h>
	52	#include <nlist.h>
	53	#include <paths.h>
d8c91b41 CR	54	#include <vm/vm.h>
d8c91b41 CR	55	#include <vm/vm_param.h>
15637ed4 RG	56
	57	#define DAY (60L60L24L)
	58	#define LEEWAY (3*DAY)
	59
	60	#define eq(a,b) (!strcmp(a,b))
	61	#ifdef vax
	62	#define ok(number) ((number)&0x7fffffff)
	63	#else
	64	#ifdef tahoe
	65	#define ok(number) ((number)&~0xc0000000)
	66	#else
	67	#ifdef i386
d8c91b41	68	#define ok(number) (((number)-KERNBASE))
15637ed4 RG	69	#else
	70	#define ok(number) (number)
	71	#endif
	72	#endif
	73	#endif
	74
	75	struct nlist current_nl[] = { /* namelist for currently running system */
	76	#define X_DUMPDEV 0
	77	{ "_dumpdev" },
	78	#define X_DUMPLO 1
	79	{ "_dumplo" },
	80	#define X_TIME 2
	81	{ "_time" },
	82	#define X_DUMPSIZE 3
	83	{ "_dumpsize" },
	84	#define X_VERSION 4
	85	{ "_version" },
	86	#define X_PANICSTR 5
	87	{ "_panicstr" },
	88	#define X_DUMPMAG 6
	89	{ "_dumpmag" },
	90	{ "" },
	91	};
	92
	93	struct nlist dump_nl[] = { /* name list for dumped system */
	94	{ "_dumpdev" }, /* entries MUST be the same as */
	95	{ "_dumplo" }, /* those in current_nl[] */
	96	{ "_time" },
	97	{ "_dumpsize" },
	98	{ "_version" },
	99	{ "_panicstr" },
	100	{ "_dumpmag" },
	101	{ "" },
	102	};
	103
	104	char *system;
	105	char dirname; / directory to save dumps in */
	106	char ddname; / name of dump device */
	107	int dumpfd; /* read/write descriptor on block dev */
	108	char *find_dev();
	109	dev_t dumpdev; /* dump device */
	110	time_t dumptime; /* time the dump was taken */
	111	int dumplo; /* where dump starts on dumpdev */
	112	int dumpsize; /* amount of memory dumped */
	113	int dumpmag; /* magic number in dump */
	114	time_t now; /* current date */
	115	char *path();
	116	char *malloc();
	117	char *ctime();
	118	char vers[80];
	119	char core_vers[80];
	120	char panic_mesg[80];
	121	int panicstr;
	122	off_t lseek();
	123	off_t Lseek();
	124	int verbose;
	125	int force;
	126	int clear;
	127	extern int errno;
	128
	129	main(argc, argv)
	130	char **argv;
	131	int argc;
	132	{
133	extern char *optarg;
134	extern int optind;
135	int ch;
136	char *cp;
137
138	while ((ch = getopt(argc, argv, "cdfv")) != EOF)
139	switch(ch) {
140	case 'c':
141	clear = 1;
142	break;
143	case 'd': /* not documented */
144	case 'v':
145	verbose = 1;
146	break;
147	case 'f':
148	force = 1;
149	break;
150	case '?':
151	default:
152	usage();
153	}
154	argc -= optind;
155	argv += optind;
156
157	/* This is wrong, but I want "savecore -c" to work. */
158	if (!clear) {
159	if (argc != 1 && argc != 2)
160	usage();
161	dirname = argv[0];
162	}
163	if (argc == 2)
164	system = argv[1];
165
166	openlog("savecore", LOG_ODELAY, LOG_AUTH);
167
168	read_kmem();
169	if (!dump_exists()) {
170	/* (void)fprintf(stderr, "savecore: no core dump\n");*/
171	if (!force)
172	exit(0);
173	}
174	if (clear) {
175	clear_dump();
176	exit(0);
177	}
178	(void) time(&now);
179	check_kmem();
180	if (panicstr)
181	log(LOG_CRIT, "reboot after panic: %s\n", panic_mesg);
182	else
183	syslog(LOG_CRIT, "reboot\n");
184
185	if (access(dirname, W_OK) < 0) {
186	Perror(LOG_ERR, "%s: %m\n", dirname);
187	exit(1);
188	}
189	if ((!get_crashtime() \|\| !check_space()) && !force)
190	exit(1);
191	save_core();
192	clear_dump();
193	exit(0);
194	}
195
196	dump_exists()
197	{
198	int word;
199
200	Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), L_SET);
201	Read(dumpfd, (char *)&word, sizeof (word));
202	if (verbose && word != dumpmag)
203	printf("magic number mismatch: %x != %x\n", word, dumpmag);
204	return (word == dumpmag);
205	}
206
207	clear_dump()
208	{
209	int zero = 0;
210
211	Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), L_SET);
212	Write(dumpfd, (char *)&zero, sizeof (zero));
213	}
214
215	char *
216	find_dev(dev, type)
217	register dev_t dev;
218	register int type;
219	{
220	register DIR *dfd = opendir(_PATH_DEV);
221	struct dirent *dir;
222	struct stat statb;
223	static char devname[MAXPATHLEN + 1];
224	char *dp;
225
226	strcpy(devname, _PATH_DEV);
227	while ((dir = readdir(dfd))) {
228	strcpy(devname + sizeof(_PATH_DEV) - 1, dir->d_name);
229	if (stat(devname, &statb)) {
230	perror(devname);
231	continue;
232	}
233	if ((statb.st_mode&S_IFMT) != type)
234	continue;
235	if (dev == statb.st_rdev) {
236	closedir(dfd);
237	dp = malloc(strlen(devname)+1);
238	strcpy(dp, devname);
239	return (dp);
240	}
241	}
242	closedir(dfd);
243	log(LOG_ERR, "Can't find device %d/%d\n", major(dev), minor(dev));
244	exit(1);
245	/NOTREACHED/
246	}
247
248	char *
249	rawname(s)
250	char *s;
251	{
252	static char name[MAXPATHLEN];
253	char sl, rindex();
254
255	if ((sl = rindex(s, '/')) == NULL \|\| sl[1] == '0') {
256	log(LOG_ERR, "can't make raw dump device name from %s?\n", s);
257	return (s);
258	}
259	sprintf(name, "%.*s/r%s", sl - s, s, sl + 1);
260	return (name);
261	}
262
263	int cursyms[] =
264	{ X_DUMPDEV, X_DUMPLO, X_VERSION, X_DUMPMAG, -1 };
265	int dumpsyms[] =
266	{ X_TIME, X_DUMPSIZE, X_VERSION, X_PANICSTR, X_DUMPMAG, -1 };
267	read_kmem()
268	{
269	register char *cp;
270	FILE *fp;
271	char *dump_sys;
272	int kmem, i;
273
274	dump_sys = system ? system : _PATH_UNIX;
275	nlist(_PATH_UNIX, current_nl);
276	nlist(dump_sys, dump_nl);
277	/*
278	* Some names we need for the currently running system,
279	* others for the system that was running when the dump was made.
280	* The values obtained from the current system are used
281	* to look for things in /dev/kmem that cannot be found
282	* in the dump_sys namelist, but are presumed to be the same
283	* (since the disk partitions are probably the same!)
284	*/
285	for (i = 0; cursyms[i] != -1; i++)
286	if (current_nl[cursyms[i]].n_value == 0) {
287	log(LOG_ERR, "%s: %s not in namelist\n", _PATH_UNIX,
288	current_nl[cursyms[i]].n_name);
289	exit(1);
290	}
291	for (i = 0; dumpsyms[i] != -1; i++)
292	if (dump_nl[dumpsyms[i]].n_value == 0) {
293	log(LOG_ERR, "%s: %s not in namelist\n", dump_sys,
294	dump_nl[dumpsyms[i]].n_name);
295	exit(1);
296	}
297	kmem = Open(_PATH_KMEM, O_RDONLY);
298	Lseek(kmem, (long)current_nl[X_DUMPDEV].n_value, L_SET);
299	Read(kmem, (char *)&dumpdev, sizeof (dumpdev));
300	Lseek(kmem, (long)current_nl[X_DUMPLO].n_value, L_SET);
301	Read(kmem, (char *)&dumplo, sizeof (dumplo));
302	if (verbose)
303	printf("dumplo = %d (%d * %d)\n", dumplo, dumplo/DEV_BSIZE,
304	DEV_BSIZE);
305	Lseek(kmem, (long)current_nl[X_DUMPMAG].n_value, L_SET);
306	Read(kmem, (char *)&dumpmag, sizeof (dumpmag));
307	dumplo *= DEV_BSIZE;
308	ddname = find_dev(dumpdev, S_IFBLK);
309	dumpfd = Open(ddname, O_RDWR);
310	fp = fdopen(kmem, "r");
311	if (fp == NULL) {
312	log(LOG_ERR, "Couldn't fdopen kmem\n");
313	exit(1);
314	}
315	if (system)
316	return;
317	fseek(fp, (long)current_nl[X_VERSION].n_value, L_SET);
318	fgets(vers, sizeof (vers), fp);
319	fclose(fp);
320	}
321
322	check_kmem()
323	{
324	FILE *fp;
325	register char *cp;
326
327	fp = fdopen(dumpfd, "r");
328	if (fp == NULL) {
329	log(LOG_ERR, "Can't fdopen dumpfd\n");
330	exit(1);
331	}
332
333	fseek(fp, (off_t)(dumplo+ok(dump_nl[X_VERSION].n_value)), L_SET);
334	fgets(core_vers, sizeof (core_vers), fp);
335	if (!eq(vers, core_vers) && system == 0) {
336	log(LOG_WARNING, "Warning: %s version mismatch:\n", _PATH_UNIX);
337	log(LOG_WARNING, "\t%s\n", vers);
338	log(LOG_WARNING, "and\t%s\n", core_vers);
339	}
340
341	fseek(fp, (off_t)(dumplo + ok(dump_nl[X_PANICSTR].n_value)), L_SET);
342	fread((char *)&panicstr, sizeof (panicstr), 1, fp);
343	if (panicstr) {
344	fseek(fp, dumplo + ok(panicstr), L_SET);
345	cp = panic_mesg;
346	do
347	*cp = getc(fp);
348	while (*cp++ && cp < &panic_mesg[sizeof(panic_mesg)]);
349	}
350	/* don't fclose(fp); we want the file descriptor */
351	}
352
353	get_crashtime()
354	{
355	time_t clobber = (time_t)0;
356
357	Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_TIME].n_value)), L_SET);
358	Read(dumpfd, (char *)&dumptime, sizeof dumptime);
359	if (dumptime == 0) {
360	if (verbose)
361	printf("Dump time is zero.\n");
362	return (0);
363	}
364	printf("System went down at %s", ctime(&dumptime));
365	if (dumptime < now - LEEWAY \|\| dumptime > now + LEEWAY) {
366	printf("dump time is unreasonable\n");
367	return (0);
368	}
369	return (1);
370	}
371
372	char *
373	path(file)
374	char *file;
375	{
376	register char *cp = malloc(strlen(file) + strlen(dirname) + 2);
377
378	(void) strcpy(cp, dirname);
379	(void) strcat(cp, "/");
380	(void) strcat(cp, file);
381	return (cp);
382	}
383
384	check_space()
385	{
386	long minfree, spacefree;
387	struct statfs fsbuf;
388
389	if (statfs(dirname, &fsbuf) < 0) {
390	Perror(LOG_ERR, "%s: %m\n", dirname);
391	exit(1);
392	}
393	spacefree = fsbuf.f_bavail * fsbuf.f_fsize / 1024;
394	minfree = read_number("minfree");
395	if (minfree > 0 && spacefree - dumpsize < minfree) {
396	log(LOG_WARNING, "Dump omitted, not enough space on device\n");
397	return (0);
398	}
399	if (spacefree - dumpsize < minfree)
400	log(LOG_WARNING,
401	"Dump performed, but free space threshold crossed\n");
402	return (1);
403	}
404
405	read_number(fn)
406	char *fn;
407	{
408	char lin[80];
409	register FILE *fp;
410
411	fp = fopen(path(fn), "r");
412	if (fp == NULL)
413	return (0);
414	if (fgets(lin, 80, fp) == NULL) {
415	fclose(fp);
416	return (0);
417	}
418	fclose(fp);
419	return (atoi(lin));
420	}
421
422	/#define BUFSIZE (2561024) /* 1/4 Mb */
423	#define BUFSIZE (8*1024)
424
425	save_core()
426	{
427	register int n;
428	register char *cp;
429	register int ifd, ofd, bounds;
430	int ret;
431	char *bfile;
432	register FILE *fp;
433
434	cp = malloc(BUFSIZE);
435	if (cp == 0) {
436	log(LOG_ERR, "savecore: Can't allocate i/o buffer.\n");
437	return;
438	}
439	bounds = read_number("bounds");
440	ifd = Open(system ? system : _PATH_UNIX, O_RDONLY);
441	(void)sprintf(cp, "system.%d", bounds);
442	ofd = Create(path(cp), 0644);
443	while((n = Read(ifd, cp, BUFSIZE)) > 0)
444	Write(ofd, cp, n);
445	close(ifd);
446	close(ofd);
447	if ((ifd = open(rawname(ddname), O_RDONLY)) == -1) {
448	log(LOG_WARNING, "Can't open %s (%m); using block device",
449	rawname(ddname));
450	ifd = dumpfd;
451	}
452	Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPSIZE].n_value)), L_SET);
453	Read(dumpfd, (char *)&dumpsize, sizeof (dumpsize));
454	(void)sprintf(cp, "ram.%d", bounds);
455	ofd = Create(path(cp), 0644);
456	Lseek(ifd, (off_t)dumplo, L_SET);
457	dumpsize *= NBPG;
458	log(LOG_NOTICE, "Saving %d bytes of image in ram.%d\n",
459	dumpsize, bounds);
460	while (dumpsize > 0) {
461	n = read(ifd, cp,
462	dumpsize > BUFSIZE ? BUFSIZE : dumpsize);
463	if (n <= 0) {
464	if (n == 0)
465	log(LOG_WARNING,
466	"WARNING: EOF on dump device; %s\n",
467	"ram file may be incomplete");
468	else
469	Perror(LOG_ERR, "read from dumpdev: %m",
470	"read");
471	break;
472	}
473	if ((ret = write(ofd, cp, n)) < n) {
474	if (ret < 0)
475	Perror(LOG_ERR, "write: %m", "write");
476	else
477	log(LOG_ERR, "short write: wrote %d of %d\n",
478	ret, n);
479	log(LOG_WARNING, "WARNING: ram file may be incomplete\n");
480	break;
481	}
482	dumpsize -= n;
483	}
484	close(ifd);
485	close(ofd);
486	bfile = path("bounds");
487	fp = fopen(bfile, "w");
488	if (fp) {
489	fprintf(fp, "%d\n", bounds+1);
490	fclose(fp);
491	} else
492	Perror(LOG_ERR, "Can't create bounds file %s: %m", bfile);
493	free(cp);
494	}
495
496	/*
497	* Versions of std routines that exit on error.
498	*/
499	Open(name, rw)
500	char *name;
501	int rw;
502	{
503	int fd;
504
505	fd = open(name, rw);
506	if (fd < 0) {
507	Perror(LOG_ERR, "%s: %m", name);
508	exit(1);
509	}
510	return (fd);
511	}
512
513	Read(fd, buff, size)
514	int fd, size;
515	char *buff;
516	{
517	int ret;
518
519	ret = read(fd, buff, size);
520	if (ret < 0) {
521	Perror(LOG_ERR, "read: %m", "read");
522	exit(1);
523	}
524	return (ret);
525	}
526
527	off_t
528	Lseek(fd, off, flag)
529	int fd, flag;
530	long off;
531	{
532	long ret;
533
534	ret = lseek(fd, off, flag);
535	if (ret == -1) {
536	Perror(LOG_ERR, "lseek: %m", "lseek");
537	exit(1);
538	}
539	return (ret);
540	}
541
542	Create(file, mode)
543	char *file;
544	int mode;
545	{
546	register int fd;
547
548	fd = creat(file, mode);
549	if (fd < 0) {
550	Perror(LOG_ERR, "%s: %m", file);
551	exit(1);
552	}
553	return (fd);
554	}
555
556	Write(fd, buf, size)
557	int fd, size;
558	char *buf;
559	{
560	int n;
561
562	if ((n = write(fd, buf, size)) < size) {
563	if (n < 0)
564	Perror(LOG_ERR, "write: %m", "write");
565	else
566	log(LOG_ERR, "short write: wrote %d of %d\n", n, size);
567	exit(1);
568	}
569	}
570
571	/* VARARGS2 */
572	log(level, msg, a1, a2)
573	int level;
574	char *msg;
575	{
576
577	fprintf(stderr, msg, a1, a2);
578	syslog(level, msg, a1, a2);
579	}
580
581	Perror(level, msg, s)
582	int level;
583	char msg, s;
584	{
585	int oerrno = errno;
586
587	perror(s);
588	errno = oerrno;
589	syslog(level, msg, s);
590	}
591
592	usage()
593	{
594	(void)fprintf(stderr, "usage: savecore [-cfv] dirname [system]\n");
595	exit(1);
596	}