[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>

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