/*
 * savecore, 1.1 (2.11BSD) 1995/07/15
 */

#include	<sys/param.h>
#include	<stdio.h>
#include	<nlist.h>
#include	<sys/stat.h>
#include	<sys/fs.h>
#include	<sys/time.h>

#ifdef	pdp11
#define	CLICK	ctob(1)		/* size of core units */
#define	REGLOC	0300		/* offset of saved registers in disk dump */
#define	NREGS	8		/* r0-6, KA6 */
#endif

#define	DAY		(60L*60L*24L)
#define	LEEWAY		(3*DAY)

#define	eq(a,b)		(!strcmp(a,b))
#define	ok(number)	((off_t) ((number)&0177777))

#define	SHUTDOWNLOG	"/usr/adm/shutdownlog"

struct nlist nl[] = {
#define	X_DUMPDEV	0
	{ "_dumpdev" },
#define	X_DUMPLO	1
	{ "_dumplo" },
#define	X_TIME		2
	{ "_time" },
#define	X_PANICSTR	3
	{ "_panicstr" },
#define	X_PHYSMEM	4
	{ "_physmem" },
#define	X_BOOTIME	5
	{ "_boottime" },
#define	X_VERSION	6
	{ "_version" },
	{ 0 },
};

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 */
time_t	boottime;			/* time we were rebooted */
daddr_t	dumplo;				/* where dump starts on dumpdev */
size_t	physmem;			/* amount of memory in machine */
time_t	now;				/* current date */
char	*path();
extern	char	*malloc();
extern	char	*ctime();
char	vers[80];
char	core_vers[80];
char	panic_mesg[80];
int	panicstr;
extern	off_t	lseek();
extern	char	*devname();
off_t	Lseek();
int	debug;

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

	if ((argc > 1) && (argv[1][0] == '-') && (argv[1][1] == 'd')) {
		debug = 1;
		argc--;
		argv++;
	}
	if (argc != 2 && argc != 3) {
		fprintf(stderr, "usage:  savecore [ -d ] dirname [ system ]\n");
		exit(1);
	}
	dirname = argv[1];
	if (argc == 3)
		system = argv[2];
	if (access(dirname, 2) < 0) {
		perror(dirname);
		exit(1);
	}
	(void) time(&now);
	setup = read_kmem();
	log_entry();
	if (setup && get_crashtime() && check_space())
		save_core();
	else
		exit(1);
}

char *
find_dev(dev, type)
	register dev_t dev;
	int type;
	{
	register char *dp, *cp;

	cp = devname(dev, type);
	if	(!cp)
		{
		if	(debug)
			fprintf(stderr, "Can't find device %d,%d\n",
				major(dev), minor(dev));
		return(NULL);
		}
	dp = (char *)malloc(strlen(cp) + 1 + sizeof ("/dev/"));
	(void)sprintf(dp, "/dev/%s", cp);
	return(dp);
	}

read_kmem()
{
	int kmem;
	FILE *fp;
	register char *cp;

	nlist("/unix", nl);
	if (nl[X_DUMPDEV].n_value == 0) {
		if (debug)
			fprintf(stderr, "/unix:  dumpdev not in namelist\n");
		exit(1);
	}
	if (nl[X_DUMPLO].n_value == 0) {
		fprintf(stderr, "/unix:  dumplo not in namelist\n");
		exit(1);
	}
	if (nl[X_TIME].n_value == 0) {
		fprintf(stderr, "/unix:  time not in namelist\n");
		exit(1);
	}
	if (nl[X_PHYSMEM].n_value == 0) {
		fprintf(stderr, "/unix:  physmem not in namelist\n");
		exit(1);
	}
	if (nl[X_VERSION].n_value == 0) {
		fprintf(stderr, "/unix:  version not in namelist\n");
		exit(1);
	}
	if (nl[X_PANICSTR].n_value == 0) {
		fprintf(stderr, "/unix:  panicstr not in namelist\n");
		exit(1);
	}
	kmem = Open("/dev/kmem", 0);
	Lseek(kmem, (off_t)nl[X_DUMPDEV].n_value, 0);
	Read(kmem, (char *)&dumpdev, sizeof dumpdev);
	if (dumpdev == NODEV) {
		if (debug)
			fprintf(stderr, "Dumpdev is NODEV\n");
		return(0);
	}
	Lseek(kmem, (off_t)nl[X_DUMPLO].n_value, 0);
	Read(kmem, (char *)&dumplo, sizeof dumplo);
	Lseek(kmem, (off_t)nl[X_PHYSMEM].n_value, 0);
	Read(kmem, (char *)&physmem, sizeof physmem);
	if (nl[X_BOOTIME].n_value != 0) {
		Lseek(kmem, (off_t)nl[X_BOOTIME].n_value, 0);
		Read(kmem, (char *)&boottime, sizeof boottime);
	}
	dumplo *= (long)NBPG;
	ddname = find_dev(dumpdev, S_IFBLK);
	if (ddname == NULL)
		return(0);
	if (system)
		return(1);
	if ((fp = fdopen(kmem, "r")) == NULL) {
		fprintf(stderr, "Couldn't fdopen kmem\n");
		exit(1);
	}
	fseek(fp, (long)nl[X_VERSION].n_value, 0);
	fgets(vers, sizeof vers, fp);
	fclose(fp);
	if ((fp = fopen(ddname, "r")) == NULL) {
		perror(ddname);
		exit(1);
	}
	fseek(fp, (off_t)(dumplo + ok(nl[X_VERSION].n_value)), 0);
	fgets(core_vers, sizeof core_vers, fp);
	fclose(fp);
	if (!eq(vers, core_vers)) {
		if (debug)
			fprintf(stderr, "unix version mismatch:\n\t%sand\n\t%s",
			    vers,core_vers);
		return(0);
	}
	fp = fopen(ddname, "r");
	fseek(fp, (off_t)(dumplo + ok(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 && (++cp < panic_mesg+sizeof(panic_mesg)));
	}
	fclose(fp);
	return(1);
}

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

	if (dumpdev == NODEV)
		return (0);
	if (system)
		return (1);
	dumpfd = Open(ddname, 2);
	Lseek(dumpfd, (off_t)(dumplo + ok(nl[X_TIME].n_value)), 0);
	Read(dumpfd, (char *)&dumptime, sizeof dumptime);
	if (!debug) {
		Lseek(dumpfd, (off_t)(dumplo + ok(nl[X_TIME].n_value)), 0);
		Write(dumpfd, (char *)&clobber, sizeof clobber);
	}
	close(dumpfd);
	if (dumptime == 0) {
		if (debug)
			printf("dump time is 0\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);
	}
	if (dumptime > now) {
		printf("Time was lost: was %s\n", ctime(&now));
		if (boottime != 0) {
			struct timeval	tp;
			now = now - boottime + dumptime;
			tp.tv_sec = now;
			tp.tv_usec = 0;
			if (settimeofday(&tp,(struct timezone *)NULL))
			    printf("\t-- resetting clock to %s\n", ctime(&now));
		}
	}
	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()
{
	struct stat dsb;
	register char *ddev;
	register int dfd;
	struct fs sblk;

	if (stat(dirname, &dsb) < 0) {
		perror(dirname);
		exit(1);
	}
	ddev = find_dev(dsb.st_dev, S_IFBLK);
	dfd = Open(ddev, 0);
	Lseek(dfd, (off_t)SUPERB*DEV_BSIZE, 0);
	Read(dfd, (char *)&sblk, sizeof sblk);
	close(dfd);
	if (read_number("minfree") > sblk.fs_tfree) {
		fprintf(stderr, "Dump omitted, not enough space on device\n");
		return (0);
	}
	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));
}

#define	BLOCK	32		/* buffer size, in clicks */

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

	bounds = read_number("bounds");
	ifd = Open(system ?  system : "/unix", 0);
	(void)sprintf(cp, "unix.%d", bounds);
	ofd = Create(path(cp), 0666);
	while((n = Read(ifd, buffer, sizeof buffer)) > 0)
		Write(ofd, cp, n);
	close(ifd);
	close(ofd);
	ifd = Open(ddname, 0);
	(void)sprintf(cp, "core.%d", bounds);
	ofd = Create(path(cp), 0666);
	Lseek(ifd, (off_t)dumplo, 0);
	printf("Saving %D bytes of image in core.%d\n",
		(long)CLICK*physmem, bounds);
	while (physmem) {
		n = Read(ifd, cp, (physmem>BLOCK? BLOCK: physmem) * CLICK);
		if (n<0) {
			perror("Read");
			break;
		}
		Write(ofd, cp, n);
		physmem -= n/CLICK;
	}
	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(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;
	off_t off;
{
	off_t 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);
	}
}