[unix-history] / usr / src / sbin / savecore / savecore.c

#ifndef lint
static	char *sccsid = "@(#)savecore.c	4.14 (Berkeley) 84/07/17";
#endif

/*
 * savecore
 */

#include <stdio.h>
#include <nlist.h>
#include <sys/param.h>
#include <sys/dir.h>
#include <sys/stat.h>
#include <sys/time.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
#define ok(number) (number)
#endif

#define SHUTDOWNLOG "/usr/adm/shutdownlog"

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 */
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();
unsigned malloc();
char	*ctime();
char	vers[80];
char	core_vers[80];
char	panic_mesg[80];
int	panicstr;
off_t	lseek();
off_t	Lseek();
int	Verbose;

main(argc, argv)
	char **argv;
	int argc;
{

	while ((argc > 1) && (argv[1][0] == '-')) {
		switch (argv[1][1]) {
		case 'v':
			Verbose = 1;
			break;
		default:
			fprintf(stderr, "savecore: illegal flag -%c\n",
				argv[1][1]);
			fprintf(stderr,
				"usage: savecore [-v] dirname [ system ]\n");
			exit(1);
		}
		argc--;
		argv++;
	}

	if (argc != 2 && argc != 3) {
		fprintf(stderr, "usage: savecore [-v] dirname [ system ]\n");
		exit(1);
	}
	dirname = argv[1];
	if (argc == 3)
		system = argv[2];
	if (access(dirname, 2) < 0) {
		perror(dirname);
		exit(1);
	}
	read_kmem();
}

int
dump_exists()
{
	register int dumpfd;
	int word;

	dumpfd = Open(ddname, 0);
	Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), 0);
	Read(dumpfd, (char *)&word, sizeof word);
	close(dumpfd);
	if (Verbose && (word != dumpmag)) {
		printf("dumplo = %d (%d bytes)\n", dumplo/512, dumplo);
		printf("magic number mismatch: %x != %x\n", word, dumpmag);
	}
	return (word == dumpmag);
}

clear_dump()
{
	register int dumpfd;
	int zero = 0;

	dumpfd = Open(ddname, 1);
	Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), 0);
	Write(dumpfd, (char *)&zero, sizeof zero);
	close(dumpfd);
}

char *
find_dev(dev, type)
	register dev_t dev;
	register int type;
{
	struct stat statb;
	char *dp;

	strcpy(devname, "/dev/");
		if (stat(devname, &statb)) {
			perror(devname);
			continue;
		}
		if ((statb.st_mode&S_IFMT) != type)
			continue;
		if (dev == statb.st_rdev) {
			dp = (char *)malloc(strlen(devname)+1);
			strcpy(dp, devname);
			return dp;
		}
	}
	fprintf(stderr, "savecore: Can't find device %d,%d\n",
		major(dev), minor(dev));
	exit(1);
	/*NOTREACHED*/
}

read_kmem()
{
	int kmem;
	FILE *fp;
	register char *cp;
	char *dump_sys;
	
	dump_sys = system ? system : "/vmunix";

	nlist("/vmunix", current_nl);
	nlist(dump_sys, dump_nl);

	/*
	 * Some names we need for the currently running system,
	 * others for the system that was running when the dump was made.
	 * 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!)
	 */
	if (current_nl[X_DUMPDEV].n_value == 0) {
		fprintf(stderr, "savecore: /vmunix: dumpdev not in namelist\n");
		exit(1);
	}
	if (current_nl[X_DUMPLO].n_value == 0) {
		fprintf(stderr, "savecore: /vmunix: dumplo not in namelist\n");
		exit(1);
	}
	if (dump_nl[X_TIME].n_value == 0) {
		fprintf(stderr, "savecore: %s: time not in namelist\n",
				dump_sys);
		exit(1);
	}
	if (dump_nl[X_DUMPSIZE].n_value == 0) {
		fprintf(stderr, "savecore: %s: dumpsize not in namelist\n",
				dump_sys);
		exit(1);
	}
	/* we need VERSION in both images */
	if (current_nl[X_VERSION].n_value == 0) {
		fprintf(stderr, "savecore: /vmunix: version not in namelist\n",
				dump_sys);
		exit(1);
	}
	if (dump_nl[X_VERSION].n_value == 0) {
		fprintf(stderr, "savecore: %s: version not in namelist\n",
				dump_sys);
		exit(1);
	}
	if (dump_nl[X_PANICSTR].n_value == 0) {
		fprintf(stderr, "savecore: %s: panicstr not in namelist\n",
				dump_sys);
		exit(1);
	}
	/* we need DUMPMAG in both images */
	if (current_nl[X_DUMPMAG].n_value == 0) {
		fprintf(stderr, "savecore: /vmunix: dumpmag not in namelist\n");
		exit(1);
	}
	if (dump_nl[X_DUMPMAG].n_value == 0) {
		fprintf(stderr, "savecore: %s: dumpmag not in namelist\n",
				dump_sys);
		exit(1);
	}
	kmem = Open("/dev/kmem", 0);
	Lseek(kmem, (long)current_nl[X_DUMPDEV].n_value, 0);
	Read(kmem, (char *)&dumpdev, sizeof (dumpdev));
	Lseek(kmem, (long)current_nl[X_DUMPLO].n_value, 0);
	Read(kmem, (char *)&dumplo, sizeof (dumplo));
	Lseek(kmem, (long)current_nl[X_DUMPMAG].n_value, 0);
	Read(kmem, (char *)&dumpmag, sizeof (dumpmag));
	dumplo *= 512L;
	ddname = find_dev(dumpdev, S_IFBLK);
	if ((fp = fdopen(kmem, "r")) == NULL) {
		fprintf(stderr, "savecore: Couldn't fdopen kmem\n");
		exit(1);
	}
	if (system)
		return;
	fseek(fp, (long)current_nl[X_VERSION].n_value, 0);
	fgets(vers, sizeof vers, fp);
	fclose(fp);
}

check_kmem()
{
	FILE *fp;
	register char *cp;

	if ((fp = fopen(ddname, "r")) == NULL) {
		perror(ddname);
		exit(1);
	}
	fseek(fp, (off_t)(dumplo+ok(dump_nl[X_VERSION].n_value)), 0);
	fgets(core_vers, sizeof core_vers, fp);
	fclose(fp);
	if (!eq(vers, core_vers) && (system == 0))
		fprintf(stderr,
		   "savecore: Warning: vmunix version mismatch:\n\t%sand\n\t%s",
		   vers, core_vers);
	fp = fopen(ddname, "r");
	fseek(fp, (off_t)(dumplo + ok(dump_nl[X_PANICSTR].n_value)), 0);
	fread((char *)&panicstr, sizeof panicstr, 1, fp);
	if (panicstr) {
		fseek(fp, dumplo + ok(panicstr), 0);
		cp = panic_mesg;
		do
			*cp = getc(fp);
		while (*cp++);
	}
	fclose(fp);
}

get_crashtime()
{
	int dumpfd;
	time_t clobber = (time_t)0;

	if (system)
		return (1);
	Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_TIME].n_value)), 0);
	Read(dumpfd, (char *)&dumptime, sizeof dumptime);
	close(dumpfd);
	if (dumptime == 0) {
		if (Verbose)
			printf("dump time not found\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 = (char *)malloc(strlen(file) + strlen(dirname) + 2);

	(void) strcpy(cp, dirname);
	(void) strcat(cp, "/");
	(void) strcat(cp, file);
	return (cp);
}

check_space()
{
	struct stat dsb;
	register char *ddev;
	int dfd, spacefree;
	struct fs fs;

	if (stat(dirname, &dsb) < 0) {
		perror(dirname);
		exit(1);
	}
	ddev = find_dev(dsb.st_dev, S_IFBLK);
	dfd = Open(ddev, 0);
	Lseek(dfd, (long)(SBLOCK * DEV_BSIZE), 0);
	Read(dfd, (char *)&fs, sizeof fs);
	close(dfd);
	spacefree = fs.fs_cstotal.cs_nbfree * fs.fs_bsize / 1024;
	if (read_number("minfree") > spacefree) {
		fprintf(stderr,
		   "savecore: Dump omitted, not enough space on device\n");
		return (0);
	}
	if (fs.fs_cstotal.cs_nbfree * fs.fs_frag + fs.fs_cstotal.cs_nffree <
	    fs.fs_dsize * fs.fs_minfree / 100)
		fprintf(stderr,
			"Dump performed, but free space threshold crossed\n");
	return (1);
}

read_number(fn)
	char *fn;
{
	char lin[80];
	register FILE *fp;

	if ((fp = fopen(path(fn), "r")) == NULL)
		return (0);
	if (fgets(lin, 80, fp) == NULL) {
		fclose(fp);
		return (0);
	}
	fclose(fp);
	return (atoi(lin));
}

save_core()
{
	register int n;
	char buffer[32*NBPG];
	register char *cp = buffer;
	register int ifd, ofd, bounds;
	register FILE *fp;

	bounds = read_number("bounds");
	ifd = Open(system?system:"/vmunix", 0);
	while((n = Read(ifd, cp, BUFSIZ)) > 0)
		Write(ofd, cp, n);
	close(ifd);
	close(ofd);
	ifd = Open(ddname, 0);
	Lseek(ifd, (off_t)(dumplo + ok(dump_nl[X_DUMPSIZE].n_value)), 0);
	Read(ifd, (char *)&dumpsize, sizeof (dumpsize));
	sprintf(cp, "vmcore.%d", bounds);
	ofd = Create(path(cp), 0644);
	Lseek(ifd, (off_t)dumplo, 0);
	printf("Saving %d bytes of image in vmcore.%d\n", NBPG*dumpsize,
		bounds);
	while (dumpsize > 0) {
		n = Read(ifd, cp, (dumpsize > 32 ? 32 : dumpsize) * NBPG);
		Write(ofd, cp, n);
		dumpsize -= n/NBPG;
	}
	close(ifd);
	close(ofd);
	fp = fopen(path("bounds"), "w");
	fprintf(fp, "%d\n", bounds+1);
	fclose(fp);
}

char *days[] = {
	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};

char *months[] = {
	"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
	"Oct", "Nov", "Dec"
};

log_entry()
{
	FILE *fp;
	struct tm *tm, *localtime();

	tm = localtime(&now);
	fp = fopen("/usr/adm/shutdownlog", "a");
	if (fp == 0)
		return;
	fseek(fp, 0L, 2);
	fprintf(fp, "%02d:%02d  %s %s %2d, %4d.  Reboot", tm->tm_hour,
		tm->tm_min, days[tm->tm_wday], months[tm->tm_mon],
		tm->tm_mday, tm->tm_year + 1900);
	if (panicstr)
		fprintf(fp, " after panic: %s\n", panic_mesg);
	else
		putc('\n', fp);
	fclose(fp);
}

/*
 * Versions of std routines that exit on error.
 */

Open(name, rw)
	char *name;
	int rw;
{
	int fd;

	if ((fd = open(name, rw)) < 0) {
		perror(name);
		exit(1);
	}
	return fd;
}

Read(fd, buff, size)
	int fd, size;
	char *buff;
{
	int ret;

	if ((ret = read(fd, buff, size)) < 0) {
		perror("read");
		exit(1);
	}
	return ret;
}

off_t
Lseek(fd, off, flag)
	int fd, flag;
	long off;
{
	long ret;

	if ((ret = lseek(fd, off, flag)) == -1L) {
		perror("lseek");
		exit(1);
	}
	return ret;
}

Create(file, mode)
	char *file;
	int mode;
{
	register int fd;

	if ((fd = creat(file, mode)) < 0) {
		perror(file);
		exit(1);
	}
	return fd;
}

Write(fd, buf, size)
	int fd, size;
	char *buf;
{

	if (write(fd, buf, size) < size) {
		perror("write");
		exit(1);
	}
}
Commit	Line	Data
261f5d78	1	#ifndef lint
a3e4f1d7	2	static char *sccsid = "@(#)savecore.c 4.14 (Berkeley) 84/07/17";
261f5d78 SL	3	#endif
261f5d78 SL	4
d112e9ff	5	/*
97d6da0b	6	* savecore
d112e9ff	7	*/
a3e4f1d7	8
d112e9ff BJ	9	#include <stdio.h>
	10	#include <nlist.h>
	11	#include <sys/param.h>
	12	#include <sys/dir.h>
	13	#include <sys/stat.h>
ce4fd43b	14	#include <sys/time.h>
d112e9ff	15
97d6da0b BJ	16	#define DAY (60L60L24L)
	17	#define LEEWAY (3*DAY)
	18
	19	#define eq(a,b) (!strcmp(a,b))
261f5d78	20	#ifdef vax
97d6da0b	21	#define ok(number) ((number)&0x7fffffff)
261f5d78 SL	22	#else
	23	#define ok(number) (number)
	24	#endif
97d6da0b	25
d112e9ff	26	#define SHUTDOWNLOG "/usr/adm/shutdownlog"
d112e9ff	27
a3e4f1d7	28	struct nlist current_nl[] = { /* namelist for currently running system */
d112e9ff BJ	29	#define X_DUMPDEV 0
	30	{ "_dumpdev" },
	31	#define X_DUMPLO 1
	32	{ "_dumplo" },
	33	#define X_TIME 2
	34	{ "_time" },
261f5d78 SL	35	#define X_DUMPSIZE 3
261f5d78 SL	36	{ "_dumpsize" },
d112e9ff BJ	37	#define X_VERSION 4
	38	{ "_version" },
	39	#define X_PANICSTR 5
	40	{ "_panicstr" },
261f5d78 SL	41	#define X_DUMPMAG 6
	42	{ "_dumpmag" },
	43	{ "" },
d112e9ff BJ	44	};
d112e9ff BJ	45
a3e4f1d7 RC	46	struct nlist dump_nl[] = { /* name list for dumped system */
	47	{ "_dumpdev" }, /* entries MUST be the same as */
	48	{ "_dumplo" }, /* those in current_nl[] */
	49	{ "_time" },
	50	{ "_dumpsize" },
	51	{ "_version" },
	52	{ "_panicstr" },
	53	{ "_dumpmag" },
	54	{ "" },
	55	};
	56
f6cc4b0d	57	char *system;
97d6da0b BJ	58	char dirname; / directory to save dumps in */
	59	char ddname; / name of dump device */
	60	char *find_dev();
	61	dev_t dumpdev; /* dump device */
	62	time_t dumptime; /* time the dump was taken */
	63	int dumplo; /* where dump starts on dumpdev */
261f5d78 SL	64	int dumpsize; /* amount of memory dumped */
261f5d78 SL	65	int dumpmag; /* magic number in dump */
97d6da0b BJ	66	time_t now; /* current date */
	67	char *path();
	68	unsigned malloc();
	69	char *ctime();
	70	char vers[80];
	71	char core_vers[80];
	72	char panic_mesg[80];
	73	int panicstr;
97d6da0b BJ	74	off_t lseek();
97d6da0b BJ	75	off_t Lseek();
a3e4f1d7	76	int Verbose;
d112e9ff BJ	77
d112e9ff BJ	78	main(argc, argv)
97d6da0b BJ	79	char **argv;
97d6da0b BJ	80	int argc;
d112e9ff	81	{
97d6da0b	82
a3e4f1d7 RC	83	while ((argc > 1) && (argv[1][0] == '-')) {
	84	switch (argv[1][1]) {
	85	case 'v':
	86	Verbose = 1;
	87	break;
	88	default:
	89	fprintf(stderr, "savecore: illegal flag -%c\n",
	90	argv[1][1]);
	91	fprintf(stderr,
	92	"usage: savecore [-v] dirname [ system ]\n");
	93	exit(1);
	94	}
	95	argc--;
	96	argv++;
	97	}
	98
f6cc4b0d	99	if (argc != 2 && argc != 3) {
a3e4f1d7	100	fprintf(stderr, "usage: savecore [-v] dirname [ system ]\n");
d112e9ff BJ	101	exit(1);
	102	}
	103	dirname = argv[1];
f6cc4b0d BJ	104	if (argc == 3)
f6cc4b0d BJ	105	system = argv[2];
97d6da0b	106	if (access(dirname, 2) < 0) {
d112e9ff	107	perror(dirname);
97d6da0b	108	exit(1);
d112e9ff	109	}
d112e9ff	110	read_kmem();
d112e9ff BJ	111	}
d112e9ff BJ	112
739955be KM	113	int
	114	dump_exists()
	115	{
	116	register int dumpfd;
	117	int word;
	118
	119	dumpfd = Open(ddname, 0);
a3e4f1d7	120	Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), 0);
739955be KM	121	Read(dumpfd, (char *)&word, sizeof word);
739955be KM	122	close(dumpfd);
a3e4f1d7 RC	123	if (Verbose && (word != dumpmag)) {
	124	printf("dumplo = %d (%d bytes)\n", dumplo/512, dumplo);
	125	printf("magic number mismatch: %x != %x\n", word, dumpmag);
	126	}
261f5d78	127	return (word == dumpmag);
739955be KM	128	}
	129
	130	clear_dump()
	131	{
	132	register int dumpfd;
	133	int zero = 0;
	134
	135	dumpfd = Open(ddname, 1);
a3e4f1d7	136	Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_DUMPMAG].n_value)), 0);
739955be KM	137	Write(dumpfd, (char *)&zero, sizeof zero);
	138	close(dumpfd);
	139	}
	140
97d6da0b BJ	141	char *
	142	find_dev(dev, type)
	143	register dev_t dev;
	144	register int type;
d112e9ff	145	{
d112e9ff	146	struct stat statb;
f0326588	147	char *dp;
d112e9ff BJ	148
d112e9ff BJ	149	strcpy(devname, "/dev/");
97d6da0b	150	if (stat(devname, &statb)) {
d112e9ff	151	perror(devname);
97d6da0b BJ	152	continue;
	153	}
	154	if ((statb.st_mode&S_IFMT) != type)
	155	continue;
	156	if (dev == statb.st_rdev) {
97d6da0b BJ	157	dp = (char *)malloc(strlen(devname)+1);
	158	strcpy(dp, devname);
	159	return dp;
d112e9ff BJ	160	}
d112e9ff BJ	161	}
261f5d78 SL	162	fprintf(stderr, "savecore: Can't find device %d,%d\n",
261f5d78 SL	163	major(dev), minor(dev));
97d6da0b BJ	164	exit(1);
97d6da0b BJ	165	/NOTREACHED/
d112e9ff BJ	166	}
d112e9ff BJ	167
d112e9ff BJ	168	read_kmem()
	169	{
	170	int kmem;
	171	FILE *fp;
	172	register char *cp;
a3e4f1d7 RC	173	char *dump_sys;
	174
	175	dump_sys = system ? system : "/vmunix";
	176
	177	nlist("/vmunix", current_nl);
	178	nlist(dump_sys, dump_nl);
	179
	180	/*
	181	* Some names we need for the currently running system,
	182	* others for the system that was running when the dump was made.
	183	* The values obtained from the current system are used
	184	* to look for things in /dev/kmem that cannot be found
	185	* in the dump_sys namelist, but are presumed to be the same
	186	* (since the disk partitions are probably the same!)
	187	*/
	188	if (current_nl[X_DUMPDEV].n_value == 0) {
261f5d78	189	fprintf(stderr, "savecore: /vmunix: dumpdev not in namelist\n");
97d6da0b	190	exit(1);
d112e9ff	191	}
a3e4f1d7	192	if (current_nl[X_DUMPLO].n_value == 0) {
261f5d78	193	fprintf(stderr, "savecore: /vmunix: dumplo not in namelist\n");
97d6da0b	194	exit(1);
d112e9ff	195	}
a3e4f1d7 RC	196	if (dump_nl[X_TIME].n_value == 0) {
	197	fprintf(stderr, "savecore: %s: time not in namelist\n",
	198	dump_sys);
97d6da0b	199	exit(1);
d112e9ff	200	}
a3e4f1d7 RC	201	if (dump_nl[X_DUMPSIZE].n_value == 0) {
	202	fprintf(stderr, "savecore: %s: dumpsize not in namelist\n",
	203	dump_sys);
97d6da0b	204	exit(1);
d112e9ff	205	}
a3e4f1d7 RC	206	/* we need VERSION in both images */
	207	if (current_nl[X_VERSION].n_value == 0) {
	208	fprintf(stderr, "savecore: /vmunix: version not in namelist\n",
	209	dump_sys);
97d6da0b	210	exit(1);
d112e9ff	211	}
a3e4f1d7 RC	212	if (dump_nl[X_VERSION].n_value == 0) {
	213	fprintf(stderr, "savecore: %s: version not in namelist\n",
	214	dump_sys);
97d6da0b	215	exit(1);
d112e9ff	216	}
a3e4f1d7 RC	217	if (dump_nl[X_PANICSTR].n_value == 0) {
	218	fprintf(stderr, "savecore: %s: panicstr not in namelist\n",
	219	dump_sys);
	220	exit(1);
	221	}
	222	/* we need DUMPMAG in both images */
	223	if (current_nl[X_DUMPMAG].n_value == 0) {
261f5d78	224	fprintf(stderr, "savecore: /vmunix: dumpmag not in namelist\n");
739955be KM	225	exit(1);
739955be KM	226	}
a3e4f1d7 RC	227	if (dump_nl[X_DUMPMAG].n_value == 0) {
	228	fprintf(stderr, "savecore: %s: dumpmag not in namelist\n",
	229	dump_sys);
	230	exit(1);
	231	}
d112e9ff	232	kmem = Open("/dev/kmem", 0);
a3e4f1d7	233	Lseek(kmem, (long)current_nl[X_DUMPDEV].n_value, 0);
261f5d78	234	Read(kmem, (char *)&dumpdev, sizeof (dumpdev));
a3e4f1d7	235	Lseek(kmem, (long)current_nl[X_DUMPLO].n_value, 0);
261f5d78	236	Read(kmem, (char *)&dumplo, sizeof (dumplo));
a3e4f1d7	237	Lseek(kmem, (long)current_nl[X_DUMPMAG].n_value, 0);
261f5d78	238	Read(kmem, (char *)&dumpmag, sizeof (dumpmag));
d112e9ff BJ	239	dumplo *= 512L;
d112e9ff BJ	240	ddname = find_dev(dumpdev, S_IFBLK);
97d6da0b	241	if ((fp = fdopen(kmem, "r")) == NULL) {
261f5d78	242	fprintf(stderr, "savecore: Couldn't fdopen kmem\n");
97d6da0b	243	exit(1);
d112e9ff	244	}
f6cc4b0d BJ	245	if (system)
f6cc4b0d BJ	246	return;
a3e4f1d7	247	fseek(fp, (long)current_nl[X_VERSION].n_value, 0);
d112e9ff BJ	248	fgets(vers, sizeof vers, fp);
d112e9ff BJ	249	fclose(fp);
798fe693 SL	250	}
798fe693 SL	251
5638c7c2 SL	252	check_kmem()
5638c7c2 SL	253	{
798fe693 SL	254	FILE *fp;
	255	register char *cp;
	256
97d6da0b	257	if ((fp = fopen(ddname, "r")) == NULL) {
d112e9ff	258	perror(ddname);
97d6da0b	259	exit(1);
d112e9ff	260	}
a3e4f1d7	261	fseek(fp, (off_t)(dumplo+ok(dump_nl[X_VERSION].n_value)), 0);
d112e9ff BJ	262	fgets(core_vers, sizeof core_vers, fp);
d112e9ff BJ	263	fclose(fp);
a3e4f1d7	264	if (!eq(vers, core_vers) && (system == 0))
261f5d78 SL	265	fprintf(stderr,
	266	"savecore: Warning: vmunix version mismatch:\n\t%sand\n\t%s",
	267	vers, core_vers);
97d6da0b	268	fp = fopen(ddname, "r");
a3e4f1d7	269	fseek(fp, (off_t)(dumplo + ok(dump_nl[X_PANICSTR].n_value)), 0);
97d6da0b BJ	270	fread((char *)&panicstr, sizeof panicstr, 1, fp);
	271	if (panicstr) {
	272	fseek(fp, dumplo + ok(panicstr), 0);
d112e9ff BJ	273	cp = panic_mesg;
	274	do
	275	*cp = getc(fp);
	276	while (*cp++);
d112e9ff	277	}
97d6da0b	278	fclose(fp);
f6cc4b0d	279	}
d112e9ff	280
97d6da0b BJ	281	get_crashtime()
97d6da0b BJ	282	{
d112e9ff	283	int dumpfd;
20f89b8d	284	time_t clobber = (time_t)0;
d112e9ff	285
f6cc4b0d BJ	286	if (system)
f6cc4b0d BJ	287	return (1);
a3e4f1d7	288	Lseek(dumpfd, (off_t)(dumplo + ok(dump_nl[X_TIME].n_value)), 0);
97d6da0b	289	Read(dumpfd, (char *)&dumptime, sizeof dumptime);
d112e9ff	290	close(dumpfd);
a3e4f1d7 RC	291	if (dumptime == 0) {
	292	if (Verbose)
	293	printf("dump time not found\n");
261f5d78	294	return (0);
a3e4f1d7	295	}
d112e9ff BJ	296	printf("System went down at %s", ctime(&dumptime));
	297	if (dumptime < now - LEEWAY \|\| dumptime > now + LEEWAY) {
	298	printf("Dump time is unreasonable\n");
261f5d78	299	return (0);
d112e9ff	300	}
261f5d78	301	return (1);
d112e9ff BJ	302	}
d112e9ff BJ	303
97d6da0b BJ	304	char *
	305	path(file)
	306	char *file;
d112e9ff	307	{
97d6da0b	308	register char cp = (char )malloc(strlen(file) + strlen(dirname) + 2);
d112e9ff	309
97d6da0b BJ	310	(void) strcpy(cp, dirname);
	311	(void) strcat(cp, "/");
	312	(void) strcat(cp, file);
261f5d78	313	return (cp);
d112e9ff BJ	314	}
d112e9ff BJ	315
d112e9ff BJ	316	check_space()
	317	{
	318	struct stat dsb;
	319	register char *ddev;
e84afc49	320	int dfd, spacefree;
798fe693	321	struct fs fs;
d112e9ff	322
97d6da0b BJ	323	if (stat(dirname, &dsb) < 0) {
	324	perror(dirname);
	325	exit(1);
	326	}
d112e9ff BJ	327	ddev = find_dev(dsb.st_dev, S_IFBLK);
d112e9ff BJ	328	dfd = Open(ddev, 0);
798fe693 SL	329	Lseek(dfd, (long)(SBLOCK * DEV_BSIZE), 0);
798fe693 SL	330	Read(dfd, (char *)&fs, sizeof fs);
d112e9ff	331	close(dfd);
e84afc49 SL	332	spacefree = fs.fs_cstotal.cs_nbfree * fs.fs_bsize / 1024;
e84afc49 SL	333	if (read_number("minfree") > spacefree) {
261f5d78 SL	334	fprintf(stderr,
261f5d78 SL	335	"savecore: Dump omitted, not enough space on device\n");
97d6da0b	336	return (0);
d112e9ff	337	}
798fe693 SL	338	if (fs.fs_cstotal.cs_nbfree * fs.fs_frag + fs.fs_cstotal.cs_nffree <
	339	fs.fs_dsize * fs.fs_minfree / 100)
	340	fprintf(stderr,
	341	"Dump performed, but free space threshold crossed\n");
97d6da0b	342	return (1);
d112e9ff BJ	343	}
d112e9ff BJ	344
d112e9ff	345	read_number(fn)
97d6da0b	346	char *fn;
d112e9ff BJ	347	{
	348	char lin[80];
	349	register FILE *fp;
	350
	351	if ((fp = fopen(path(fn), "r")) == NULL)
261f5d78	352	return (0);
97d6da0b BJ	353	if (fgets(lin, 80, fp) == NULL) {
97d6da0b BJ	354	fclose(fp);
261f5d78	355	return (0);
d112e9ff	356	}
97d6da0b	357	fclose(fp);
261f5d78	358	return (atoi(lin));
d112e9ff BJ	359	}
	360
	361	save_core()
	362	{
	363	register int n;
97d6da0b	364	char buffer[32*NBPG];
d112e9ff BJ	365	register char *cp = buffer;
	366	register int ifd, ofd, bounds;
	367	register FILE *fp;
	368
	369	bounds = read_number("bounds");
f6cc4b0d	370	ifd = Open(system?system:"/vmunix", 0);
d112e9ff BJ	371	while((n = Read(ifd, cp, BUFSIZ)) > 0)
	372	Write(ofd, cp, n);
	373	close(ifd);
	374	close(ofd);
d112e9ff	375	ifd = Open(ddname, 0);
a3e4f1d7	376	Lseek(ifd, (off_t)(dumplo + ok(dump_nl[X_DUMPSIZE].n_value)), 0);
5638c7c2	377	Read(ifd, (char *)&dumpsize, sizeof (dumpsize));
798fe693 SL	378	sprintf(cp, "vmcore.%d", bounds);
798fe693 SL	379	ofd = Create(path(cp), 0644);
97d6da0b	380	Lseek(ifd, (off_t)dumplo, 0);
261f5d78 SL	381	printf("Saving %d bytes of image in vmcore.%d\n", NBPG*dumpsize,
	382	bounds);
	383	while (dumpsize > 0) {
	384	n = Read(ifd, cp, (dumpsize > 32 ? 32 : dumpsize) * NBPG);
d112e9ff	385	Write(ofd, cp, n);
261f5d78	386	dumpsize -= n/NBPG;
d112e9ff BJ	387	}
	388	close(ifd);
	389	close(ofd);
	390	fp = fopen(path("bounds"), "w");
	391	fprintf(fp, "%d\n", bounds+1);
	392	fclose(fp);
	393	}
	394
	395	char *days[] = {
	396	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
	397	};
	398
	399	char *months[] = {
	400	"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
	401	"Oct", "Nov", "Dec"
	402	};
	403
	404	log_entry()
	405	{
	406	FILE *fp;
	407	struct tm tm, localtime();
	408
	409	tm = localtime(&now);
97d6da0b BJ	410	fp = fopen("/usr/adm/shutdownlog", "a");
	411	if (fp == 0)
	412	return;
d112e9ff BJ	413	fseek(fp, 0L, 2);
	414	fprintf(fp, "%02d:%02d %s %s %2d, %4d. Reboot", tm->tm_hour,
	415	tm->tm_min, days[tm->tm_wday], months[tm->tm_mon],
	416	tm->tm_mday, tm->tm_year + 1900);
	417	if (panicstr)
97d6da0b	418	fprintf(fp, " after panic: %s\n", panic_mesg);
d112e9ff BJ	419	else
	420	putc('\n', fp);
	421	fclose(fp);
	422	}
97d6da0b BJ	423
	424	/*
	425	* Versions of std routines that exit on error.
	426	*/
	427
	428	Open(name, rw)
	429	char *name;
	430	int rw;
	431	{
	432	int fd;
	433
	434	if ((fd = open(name, rw)) < 0) {
	435	perror(name);
	436	exit(1);
	437	}
	438	return fd;
	439	}
	440
	441	Read(fd, buff, size)
	442	int fd, size;
	443	char *buff;
	444	{
	445	int ret;
	446
	447	if ((ret = read(fd, buff, size)) < 0) {
	448	perror("read");
	449	exit(1);
	450	}
	451	return ret;
	452	}
	453
	454	off_t
	455	Lseek(fd, off, flag)
	456	int fd, flag;
	457	long off;
	458	{
	459	long ret;
	460
	461	if ((ret = lseek(fd, off, flag)) == -1L) {
	462	perror("lseek");
	463	exit(1);
	464	}
	465	return ret;
	466	}
	467
	468	Create(file, mode)
	469	char *file;
	470	int mode;
	471	{
	472	register int fd;
	473
	474	if ((fd = creat(file, mode)) < 0) {
	475	perror(file);
	476	exit(1);
	477	}
	478	return fd;
	479	}
	480
	481	Write(fd, buf, size)
	482	int fd, size;
	483	char *buf;
97d6da0b BJ	484	{
	485
	486	if (write(fd, buf, size) < size) {
	487	perror("write");
	488	exit(1);
	489	}
	490	}