Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	sbin/savecore/savecore.c	Lines:	0	310	0.0 %
Date:	2017-11-07	Branches:	0	187	0.0 %


/*	$OpenBSD: savecore.c,v 1.57 2016/09/01 14:12:07 tedu Exp $	*/
/*	$NetBSD: savecore.c,v 1.26 1996/03/18 21:16:05 leo Exp $	*/

/*-
 * Copyright (c) 1986, 1992, 1993
 *	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. 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.
 */

#include <sys/param.h>	/* NODEV DEV_BSIZE */
#include <sys/stat.h>
#include <sys/mount.h>
#include <sys/syslog.h>
#include <sys/time.h>
#include <sys/resource.h>

#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <nlist.h>
#include <paths.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#include <zlib.h>
#include <kvm.h>
#include <vis.h>

#define MINIMUM(a, b)	(((a) < (b)) ? (a) : (b))

extern FILE *zopen(const char *fname, const char *mode, int bits);

#define KREAD(kd, addr, p)\
	(kvm_read(kd, addr, (char *)(p), sizeof(*(p))) != sizeof(*(p)))

struct nlist current_nl[] = {	/* Namelist for currently running system. */
#define X_DUMPDEV	0
	{ "_dumpdev" },
#define X_DUMPLO	1
	{ "_dumplo" },
#define X_TIME		2
	{ "_time_second" },
#define	X_DUMPSIZE	3
	{ "_dumpsize" },
#define X_VERSION	4
	{ "_version" },
#define X_PANICSTR	5
	{ "_panicstr" },
#define	X_DUMPMAG	6
	{ "_dumpmag" },
	{ NULL },
};
int cursyms[] = { X_DUMPDEV, X_DUMPLO, X_VERSION, X_DUMPMAG, -1 };
int dumpsyms[] = { X_TIME, X_DUMPSIZE, X_VERSION, X_PANICSTR, X_DUMPMAG, -1 };

struct nlist dump_nl[] = {	/* Name list for dumped system. */
	{ "_dumpdev" },		/* Entries MUST be the same as */
	{ "_dumplo" },		/*	those in current_nl[].  */
	{ "_time_second" },
	{ "_dumpsize" },
	{ "_version" },
	{ "_panicstr" },
	{ "_dumpmag" },
	{ NULL },
};

#define VERSIONSIZE 512

/* Types match kernel declarations. */
long	dumplo;			/* where dump starts on dumpdev (in blocks) */
off_t	dumpoff;		/* where dump starts on dumpdev (in bytes) */
u_long	dumpmag;		/* magic number in dump */
int	dumppages;		/* amount of memory dumped (in pages) */
u_long	dumpsize;		/* amount of memory dumped */

char	*kernel;
char	*dirn;			/* directory to save dumps in */
char	*ddname;		/* name of dump device */
dev_t	dumpdev;		/* dump device */
int	dumpfd;			/* read/write descriptor on block dev */
kvm_t	*kd_dump;		/* kvm descriptor on block dev	*/
time_t	now;			/* current date */
char	panic_mesg[1024];
int	panicstr;
char	vers[VERSIONSIZE];

int	clear, zcompress, force, verbose;	/* flags */

void	 check_kmem(void);
int	 check_space(void);
void	 clear_dump(void);
int	 dump_exists(void);
char	*find_dev(dev_t, int);
int	 get_crashtime(void);
void	 kmem_setup(void);
char	*rawname(char *s);
void	 save_core(void);
void	 usage(void);

int
main(int argc, char *argv[])
{
	struct rlimit rl;
	int ch;

	openlog("savecore", LOG_PERROR, LOG_DAEMON);

	/* Increase our data size to the max if we can. */
	if (getrlimit(RLIMIT_DATA, &rl) == 0) {
		rl.rlim_cur = rl.rlim_max;
		if (setrlimit(RLIMIT_DATA, &rl) < 0)
			syslog(LOG_WARNING, "can't set rlimit data size: %m");
	}

	while ((ch = getopt(argc, argv, "cdfN:vz")) != -1)
		switch(ch) {
		case 'c':
			clear = 1;
			break;
		case 'd':		/* Not documented. */
		case 'v':
			verbose = 1;
			break;
		case 'f':
			force = 1;
			break;
		case 'N':
			kernel = optarg;
			break;
		case 'z':
			zcompress = 1;
			break;
		case '?':
		default:
			usage();
		}
	argc -= optind;
	argv += optind;

	if (!clear) {
		if (argc != 1)
			usage();
		dirn = argv[0];
	}

	(void)time(&now);
	kmem_setup();

	if (pledge("stdio rpath wpath cpath flock", NULL) == -1) {
		syslog(LOG_ERR, "pledge: %m");
		exit(1);
	}

	if (clear) {
		clear_dump();
		return (0);
	}

	if (!dump_exists() && !force)
		return (1);

	check_kmem();

	if (panicstr)
		syslog(LOG_ALERT, "reboot after panic: %s", panic_mesg);
	else
		syslog(LOG_ALERT, "reboot");

	if ((!get_crashtime() || !check_space()) && !force)
		return (1);

	save_core();

	clear_dump();
	return (0);
}

char	*dump_sys;

void
kmem_setup(void)
{
	kvm_t	*kd_kern;
	char	errbuf[_POSIX2_LINE_MAX];
	int	i, hdrsz;

	/*
	 * 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!)
	 */
	kd_kern = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, errbuf);
	if (kd_kern == NULL) {
		syslog(LOG_ERR, "%s: kvm_openfiles: %s", _PATH_UNIX, errbuf);
		exit(1);
	}
	if (kvm_nlist(kd_kern, current_nl) == -1)
		syslog(LOG_ERR, "%s: kvm_nlist: %s", _PATH_UNIX,
			kvm_geterr(kd_kern));

	for (i = 0; cursyms[i] != -1; i++)
		if (current_nl[cursyms[i]].n_value == 0) {
			syslog(LOG_ERR, "%s: %s not in namelist",
			    _PATH_UNIX, current_nl[cursyms[i]].n_name);
			exit(1);
		}

	(void)KREAD(kd_kern, current_nl[X_DUMPDEV].n_value, &dumpdev);
	if (dumpdev == NODEV) {
		syslog(LOG_WARNING, "no core dump (no dumpdev)");
		exit(1);
	}
	(void)KREAD(kd_kern, current_nl[X_DUMPLO].n_value, &dumplo);
	dumpoff = (off_t)dumplo * DEV_BSIZE;
	if (verbose)
		(void)printf("dumpoff = %lld (%ld * %d)\n",
		    (long long)dumpoff, dumplo, DEV_BSIZE);
	(void) KREAD(kd_kern, current_nl[X_DUMPMAG].n_value, &dumpmag);

	if (kernel == NULL) {
		if (kvm_read(kd_kern, current_nl[X_VERSION].n_value,
		    vers, sizeof(vers)) == -1) {
			syslog(LOG_ERR, "%s: kvm_read: version misread", _PATH_UNIX);
			exit(1);
		}
		vers[sizeof(vers) - 1] = '\0';
	}

	ddname = find_dev(dumpdev, S_IFBLK);
	dumpfd = open(ddname, O_RDWR);
	if (dumpfd == -1) {
		syslog(LOG_ERR, "%s: %m", ddname);
		exit(1);
	}


	dump_sys = kernel ? kernel : _PATH_UNIX;
	kd_dump = kvm_openfiles(kernel, ddname, NULL, O_RDWR, errbuf);
	if (kd_dump == NULL) {
		syslog(LOG_ERR, "%s: kvm_openfiles: %s", dump_sys, errbuf);
		exit(1);
	}

	if (kvm_nlist(kd_dump, dump_nl) == -1)
		syslog(LOG_ERR, "%s: kvm_nlist: %s", dump_sys,
			kvm_geterr(kd_dump));

	for (i = 0; dumpsyms[i] != -1; i++)
		if (dump_nl[dumpsyms[i]].n_value == 0) {
			syslog(LOG_ERR, "%s: %s not in namelist",
			    dump_sys, dump_nl[dumpsyms[i]].n_name);
			exit(1);
		}
	hdrsz = kvm_dump_mkheader(kd_dump, dumpoff);
	if (hdrsz == -1) {
		if(verbose)
			syslog(LOG_ERR, "%s: kvm_dump_mkheader: %s", dump_sys,
				kvm_geterr(kd_dump));
		syslog(LOG_WARNING, "no core dump");
		exit(1);
	}
	dumpoff += hdrsz;
	kvm_close(kd_kern);
}

void
check_kmem(void)
{
	char	*cp;
	int	panicloc;
	char core_vers[VERSIONSIZE];

	if (kvm_read(kd_dump, dump_nl[X_VERSION].n_value, core_vers,
	    sizeof(core_vers)) != sizeof(core_vers)) {
		syslog(LOG_ERR, "%s: kvm_read: version misread", dump_sys);
		exit(1);
	}
	core_vers[sizeof(core_vers) - 1] = '\0';

	if (strcmp(vers, core_vers) && kernel == 0) {
		vers[strcspn(vers, "\n")] = '\0';
		core_vers[strcspn(core_vers, "\n")] = '\0';

		syslog(LOG_WARNING,
		    "warning: %s version mismatch:\n\t%s\nand\t%s\n",
		    _PATH_UNIX, vers, core_vers);
	}

	(void)KREAD(kd_dump, dump_nl[X_PANICSTR].n_value, &panicstr);
	if (panicstr) {
		char	c, visout[5];
		size_t	vislen;

		cp       = panic_mesg;
		panicloc = panicstr;
		for (;;) {
			if (KREAD(kd_dump, panicloc, &c) != 0 || c == '\0')
				break;
			panicloc++;

			vis(visout, c, VIS_SAFE|VIS_NOSLASH, 0);
			vislen = strlen(visout);
			if (cp - panic_mesg + vislen >= sizeof(panic_mesg))
				break;
			strlcat(cp, visout,
			    panic_mesg + sizeof panic_mesg - cp);
			cp += strlen(cp);
		}
	}
}

int
dump_exists(void)
{
	u_long newdumpmag;

	(void)KREAD(kd_dump, dump_nl[X_DUMPMAG].n_value, &newdumpmag);

	/* Read the dump size. */
	(void)KREAD(kd_dump, dump_nl[X_DUMPSIZE].n_value, &dumppages);
	dumpsize = (u_long)dumppages * getpagesize();

	/*
	 * Return zero if core dump doesn't seem to be there and note
	 * it for syslog.  This check and return happens after the dump size
	 * is read, so dumpsize is whether or not the core is valid (for -f).
	 */
	if (newdumpmag != dumpmag) {
		if (verbose)
			syslog(LOG_WARNING,
			    "magic number mismatch (%lx != %lx)",
			    newdumpmag, dumpmag);
		syslog(LOG_WARNING, "no core dump");
		return (0);
	}
	return (1);
}

void
clear_dump(void)
{
	if (kvm_dump_inval(kd_dump) == -1)
		syslog(LOG_ERR, "%s: kvm_clear_dump: %s", ddname,
			kvm_geterr(kd_dump));

}

char buf[1024 * 1024];

void
save_core(void)
{
	FILE *fp;
	int bounds, ifd, nr, nw, ofd = -1;
	char *rawp, path[PATH_MAX];
	mode_t um;

	um = umask(S_IRWXG|S_IRWXO);

	/*
	 * Get the current number and update the bounds file.  Do the update
	 * now, because we may fail later and don't want to overwrite anything.
	 */
	(void)snprintf(path, sizeof(path), "%s/bounds", dirn);
	if ((fp = fopen(path, "r")) == NULL)
		goto err1;
	if (fgets(buf, sizeof(buf), fp) == NULL) {
		if (ferror(fp))
err1:			syslog(LOG_WARNING, "%s: %s", path, strerror(errno));
		bounds = 0;
	} else {
		const char *errstr = NULL;
		char *p;

		if ((p = strchr(buf, '\n')) != NULL)
			*p = '\0';
		bounds = strtonum(buf, 0, INT_MAX, &errstr);
		if (errstr)
			syslog(LOG_WARNING, "bounds was corrupt: %s", errstr);
	}
	if (fp != NULL)
		(void)fclose(fp);
	if ((fp = fopen(path, "w")) == NULL)
		syslog(LOG_ERR, "%s: %m", path);
	else {
		(void)fprintf(fp, "%d\n", bounds + 1);
		(void)fclose(fp);
	}

	/* Create the core file. */
	(void)snprintf(path, sizeof(path), "%s%s.%d.core%s",
	    dirn, _PATH_UNIX, bounds, zcompress ? ".Z" : "");
	if (zcompress) {
		if ((fp = zopen(path, "w", 0)) == NULL) {
			syslog(LOG_ERR, "%s: %s", path, strerror(errno));
			exit(1);
		}
	} else {
		ofd = open(path, O_WRONLY | O_CREAT | O_TRUNC,
		    S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
		if (ofd == -1) {
			syslog(LOG_ERR, "%s: %m", path);
			exit(1);
		}

		fp  = fdopen(ofd, "w");
		if (fp == NULL) {
			syslog(LOG_ERR, "%s: fdopen: %s", path, strerror(errno));
			exit(1);
		}
	}

	/* Open the raw device. */
	rawp = rawname(ddname);
	if ((ifd = open(rawp, O_RDONLY)) == -1) {
		syslog(LOG_WARNING, "%s: %m; using block device", rawp);
		ifd = dumpfd;
	}

	/* Seek to the start of the core. */
	if (lseek(ifd, dumpoff, SEEK_SET) == -1) {
		syslog(LOG_ERR, "lseek: %m");
		exit(1);
	}

	if (kvm_dump_wrtheader(kd_dump, fp, dumpsize) == -1) {
		syslog(LOG_ERR, "kvm_dump_wrtheader: %s : %s", path,
			kvm_geterr(kd_dump));
		exit(1);
	}

	/* Copy the core file. */
	syslog(LOG_NOTICE, "writing %score to %s",
	    zcompress ? "compressed " : "", path);
	for (; dumpsize != 0; dumpsize -= nr) {
		(void)printf("%8luK\r", dumpsize / 1024);
		(void)fflush(stdout);
		nr = read(ifd, buf, MINIMUM(dumpsize, sizeof(buf)));
		if (nr <= 0) {
			if (nr == 0)
				syslog(LOG_WARNING,
				    "WARNING: EOF on dump device");
			else
				syslog(LOG_ERR, "%s: %m", rawp);
			goto err2;
		}
		nw = fwrite(buf, 1, nr, fp);
		if (nw != nr) {
			syslog(LOG_ERR, "%s: %s",
			    path, strerror(nw == 0 ? EIO : errno));
err2:			syslog(LOG_WARNING,
			    "WARNING: core may be incomplete");
			(void)printf("\n");
			exit(1);
		}
	}
	(void)close(ifd);
	(void)fclose(fp);

	/* Copy the kernel. */
	ifd = open(kernel ? kernel : _PATH_UNIX, O_RDONLY);
	if (ifd == -1) {
		syslog(LOG_ERR, "%s: %m", kernel ? kernel : _PATH_UNIX);
		exit(1);
	}
	(void)snprintf(path, sizeof(path), "%s%s.%d%s",
	    dirn, _PATH_UNIX, bounds, zcompress ? ".Z" : "");
	if (zcompress) {
		if ((fp = zopen(path, "w", 0)) == NULL) {
			syslog(LOG_ERR, "%s: %s", path, strerror(errno));
			exit(1);
		}
	} else {
		ofd = open(path, O_WRONLY | O_CREAT | O_TRUNC,
		    S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
		if (ofd == -1) {
			syslog(LOG_ERR, "%s: %m", path);
			exit(1);
		}
	}
	syslog(LOG_NOTICE, "writing %skernel to %s",
	    zcompress ? "compressed " : "", path);
	while ((nr = read(ifd, buf, sizeof(buf))) > 0) {
		if (zcompress)
			nw = fwrite(buf, 1, nr, fp);
		else
			nw = write(ofd, buf, nr);
		if (nw != nr) {
			syslog(LOG_ERR, "%s: %s",
			    path, strerror(nw == 0 ? EIO : errno));
			syslog(LOG_WARNING,
			    "WARNING: kernel may be incomplete");
			exit(1);
		}
	}
	if (nr < 0) {
		syslog(LOG_ERR, "%s: %s",
		    kernel ? kernel : _PATH_UNIX, strerror(errno));
		syslog(LOG_WARNING,
		    "WARNING: kernel may be incomplete");
		exit(1);
	}
	if (zcompress)
		(void)fclose(fp);
	else
		(void)close(ofd);
	(void)umask(um);
}

char *
find_dev(dev_t dev, int type)
{
	DIR *dfd;
	struct dirent *dir;
	struct stat sb;
	char *dp, devname[PATH_MAX];

	if ((dfd = opendir(_PATH_DEV)) == NULL) {
		syslog(LOG_ERR, "%s: %s", _PATH_DEV, strerror(errno));
		exit(1);
	}
	(void)strlcpy(devname, _PATH_DEV, sizeof devname);
	while ((dir = readdir(dfd))) {
		(void)strlcpy(devname + sizeof(_PATH_DEV) - 1, dir->d_name,
		    sizeof devname - (sizeof(_PATH_DEV) - 1));
		if (lstat(devname, &sb)) {
			syslog(LOG_ERR, "%s: %s", devname, strerror(errno));
			continue;
		}
		if ((sb.st_mode & S_IFMT) != type)
			continue;
		if (dev == sb.st_rdev) {
			closedir(dfd);
			if ((dp = strdup(devname)) == NULL) {
				syslog(LOG_ERR, "%s", strerror(errno));
				exit(1);
			}
			return (dp);
		}
	}
	closedir(dfd);
	syslog(LOG_ERR, "can't find device %d/%d", major(dev), minor(dev));
	exit(1);
}

char *
rawname(char *s)
{
	char *sl, name[PATH_MAX];

	if ((sl = strrchr(s, '/')) == NULL || sl[1] == '0') {
		syslog(LOG_ERR,
		    "can't make raw dump device name from %s", s);
		return (s);
	}
	(void)snprintf(name, sizeof(name), "%.*s/r%s", (int)(sl - s), s, sl + 1);
	if ((sl = strdup(name)) == NULL) {
		syslog(LOG_ERR, "%s", strerror(errno));
		exit(1);
	}
	return (sl);
}

int
get_crashtime(void)
{
	time_t dumptime;			/* Time the dump was taken. */

	(void)KREAD(kd_dump, dump_nl[X_TIME].n_value, &dumptime);
	if (dumptime == 0) {
		if (verbose)
			syslog(LOG_ERR, "dump time is zero");
		return (0);
	}
	(void)printf("savecore: system went down at %s", ctime(&dumptime));
#define	SECSPERDAY	(24 * 60 * 60)
#define	LEEWAY		(7 * SECSPERDAY)
	if (dumptime < now - LEEWAY || dumptime > now + LEEWAY) {
		(void)printf("dump time is unreasonable\n");
		return (0);
	}
	return (1);
}

int
check_space(void)
{
	FILE *fp;
	char *tkernel;
	off_t minfree, spacefree, kernelsize, needed;
	struct stat st;
	struct statfs fsbuf;
	char buf[100], path[PATH_MAX];
	int fd;

	tkernel = kernel ? kernel : _PATH_UNIX;
	if (stat(tkernel, &st) < 0) {
		syslog(LOG_ERR, "%s: %m", tkernel);
		exit(1);
	}
	kernelsize = st.st_blocks * S_BLKSIZE;
	if ((fd = open(dirn, O_RDONLY, 0)) < 0 || fstatfs(fd, &fsbuf) < 0) {
		syslog(LOG_ERR, "%s: %m", dirn);
		exit(1);
	}
	close(fd);
	spacefree = ((off_t)fsbuf.f_bavail * fsbuf.f_bsize) / 1024;

	(void)snprintf(path, sizeof(path), "%s/minfree", dirn);
	if ((fp = fopen(path, "r")) == NULL)
		minfree = 0;
	else {
		if (fgets(buf, sizeof(buf), fp) == NULL)
			minfree = 0;
		else {
			const char *errstr;
			char *p;

			if ((p = strchr(buf, '\n')) != NULL)
				*p = '\0';
			minfree = strtonum(buf, 0, LLONG_MAX, &errstr);
			if (errstr)
				syslog(LOG_WARNING,
				    "minfree was corrupt: %s", errstr);
		}
		(void)fclose(fp);
	}

	needed = (dumpsize + kernelsize) / 1024;
	if (minfree > 0 && spacefree - needed < minfree) {
		syslog(LOG_WARNING,
		    "no dump, not enough free space on device");
		return (0);
	}
	if (spacefree - needed < minfree)
		syslog(LOG_WARNING,
		    "dump performed, but free space threshold crossed");
	return (1);
}

void
usage(void)
{
	extern char *__progname;
	fprintf(stderr, "usage: %s [-cfvz] [-N system] directory\n",
		__progname);
	exit(1);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: savecore.c,v 1.57 2016/09/01 14:12:07 tedu Exp $ */
2			/* $NetBSD: savecore.c,v 1.26 1996/03/18 21:16:05 leo Exp $ */
3
4			/*-
5			* Copyright (c) 1986, 1992, 1993
6			* The Regents of the University of California. All rights reserved.
7			*
8			* Redistribution and use in source and binary forms, with or without
9			* modification, are permitted provided that the following conditions
10			* are met:
11			* 1. Redistributions of source code must retain the above copyright
12			* notice, this list of conditions and the following disclaimer.
13			* 2. Redistributions in binary form must reproduce the above copyright
14			* notice, this list of conditions and the following disclaimer in the
15			* documentation and/or other materials provided with the distribution.
16			* 3. Neither the name of the University nor the names of its contributors
17			* may be used to endorse or promote products derived from this software
18			* without specific prior written permission.
19			*
20			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30			* SUCH DAMAGE.
31			*/
32
33			#include <sys/param.h> /* NODEV DEV_BSIZE */
34			#include <sys/stat.h>
35			#include <sys/mount.h>
36			#include <sys/syslog.h>
37			#include <sys/time.h>
38			#include <sys/resource.h>
39
40			#include <dirent.h>
41			#include <errno.h>
42			#include <fcntl.h>
43			#include <nlist.h>
44			#include <paths.h>
45			#include <stdio.h>
46			#include <stdlib.h>
47			#include <string.h>
48			#include <unistd.h>
49			#include <limits.h>
50			#include <zlib.h>
51			#include <kvm.h>
52			#include <vis.h>
53
54			#define MINIMUM(a, b) (((a) < (b)) ? (a) : (b))
55
56			extern FILE zopen(const char fname, const char *mode, int bits);
57
58			#define KREAD(kd, addr, p)\
59			(kvm_read(kd, addr, (char )(p), sizeof((p))) != sizeof(*(p)))
60
61			struct nlist current_nl[] = { /* Namelist for currently running system. */
62			#define X_DUMPDEV 0
63			{ "_dumpdev" },
64			#define X_DUMPLO 1
65			{ "_dumplo" },
66			#define X_TIME 2
67			{ "_time_second" },
68			#define X_DUMPSIZE 3
69			{ "_dumpsize" },
70			#define X_VERSION 4
71			{ "_version" },
72			#define X_PANICSTR 5
73			{ "_panicstr" },
74			#define X_DUMPMAG 6
75			{ "_dumpmag" },
76			{ NULL },
77			};
78			int cursyms[] = { X_DUMPDEV, X_DUMPLO, X_VERSION, X_DUMPMAG, -1 };
79			int dumpsyms[] = { X_TIME, X_DUMPSIZE, X_VERSION, X_PANICSTR, X_DUMPMAG, -1 };
80
81			struct nlist dump_nl[] = { /* Name list for dumped system. */
82			{ "_dumpdev" }, /* Entries MUST be the same as */
83			{ "_dumplo" }, /* those in current_nl[]. */
84			{ "_time_second" },
85			{ "_dumpsize" },
86			{ "_version" },
87			{ "_panicstr" },
88			{ "_dumpmag" },
89			{ NULL },
90			};
91
92			#define VERSIONSIZE 512
93
94			/* Types match kernel declarations. */
95			long dumplo; /* where dump starts on dumpdev (in blocks) */
96			off_t dumpoff; /* where dump starts on dumpdev (in bytes) */
97			u_long dumpmag; /* magic number in dump */
98			int dumppages; /* amount of memory dumped (in pages) */
99			u_long dumpsize; /* amount of memory dumped */
100
101			char *kernel;
102			char dirn; / directory to save dumps in */
103			char ddname; / name of dump device */
104			dev_t dumpdev; /* dump device */
105			int dumpfd; /* read/write descriptor on block dev */
106			kvm_t kd_dump; / kvm descriptor on block dev */
107			time_t now; /* current date */
108			char panic_mesg[1024];
109			int panicstr;
110			char vers[VERSIONSIZE];
111
112			int clear, zcompress, force, verbose; /* flags */
113
114			void check_kmem(void);
115			int check_space(void);
116			void clear_dump(void);
117			int dump_exists(void);
118			char *find_dev(dev_t, int);
119			int get_crashtime(void);
120			void kmem_setup(void);
121			char rawname(char s);
122			void save_core(void);
123			void usage(void);
124
125			int
126			main(int argc, char *argv[])
127			{
128			struct rlimit rl;
129			int ch;
130
131			openlog("savecore", LOG_PERROR, LOG_DAEMON);
132
133			/* Increase our data size to the max if we can. */
134			if (getrlimit(RLIMIT_DATA, &rl) == 0) {
135			rl.rlim_cur = rl.rlim_max;
136			if (setrlimit(RLIMIT_DATA, &rl) < 0)
137			syslog(LOG_WARNING, "can't set rlimit data size: %m");
138			}
139
140			while ((ch = getopt(argc, argv, "cdfN:vz")) != -1)
141			switch(ch) {
142			case 'c':
143			clear = 1;
144			break;
145			case 'd': /* Not documented. */
146			case 'v':
147			verbose = 1;
148			break;
149			case 'f':
150			force = 1;
151			break;
152			case 'N':
153			kernel = optarg;
154			break;
155			case 'z':
156			zcompress = 1;
157			break;
158			case '?':
159			default:
160			usage();
161			}
162			argc -= optind;
163			argv += optind;
164
165			if (!clear) {
166			if (argc != 1)
167			usage();
168			dirn = argv[0];
169			}
170
171			(void)time(&now);
172			kmem_setup();
173
174			if (pledge("stdio rpath wpath cpath flock", NULL) == -1) {
175			syslog(LOG_ERR, "pledge: %m");
176			exit(1);
177			}
178
179			if (clear) {
180			clear_dump();
181			return (0);
182			}
183
184			if (!dump_exists() && !force)
185			return (1);
186
187			check_kmem();
188
189			if (panicstr)
190			syslog(LOG_ALERT, "reboot after panic: %s", panic_mesg);
191			else
192			syslog(LOG_ALERT, "reboot");
193
194			if ((!get_crashtime() \|\| !check_space()) && !force)
195			return (1);
196
197			save_core();
198
199			clear_dump();
200			return (0);
201			}
202
203			char *dump_sys;
204
205			void
206			kmem_setup(void)
207			{
208			kvm_t *kd_kern;
209			char errbuf[_POSIX2_LINE_MAX];
210			int i, hdrsz;
211
212			/*
213			* Some names we need for the currently running system, others for
214			* the system that was running when the dump was made. The values
215			* obtained from the current system are used to look for things in
216			* /dev/kmem that cannot be found in the dump_sys namelist, but are
217			* presumed to be the same (since the disk partitions are probably
218			* the same!)
219			*/
220			kd_kern = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, errbuf);
221			if (kd_kern == NULL) {
222			syslog(LOG_ERR, "%s: kvm_openfiles: %s", _PATH_UNIX, errbuf);
223			exit(1);
224			}
225			if (kvm_nlist(kd_kern, current_nl) == -1)
226			syslog(LOG_ERR, "%s: kvm_nlist: %s", _PATH_UNIX,
227			kvm_geterr(kd_kern));
228
229			for (i = 0; cursyms[i] != -1; i++)
230			if (current_nl[cursyms[i]].n_value == 0) {
231			syslog(LOG_ERR, "%s: %s not in namelist",
232			_PATH_UNIX, current_nl[cursyms[i]].n_name);
233			exit(1);
234			}
235
236			(void)KREAD(kd_kern, current_nl[X_DUMPDEV].n_value, &dumpdev);
237			if (dumpdev == NODEV) {
238			syslog(LOG_WARNING, "no core dump (no dumpdev)");
239			exit(1);
240			}
241			(void)KREAD(kd_kern, current_nl[X_DUMPLO].n_value, &dumplo);
242			dumpoff = (off_t)dumplo * DEV_BSIZE;
243			if (verbose)
244			(void)printf("dumpoff = %lld (%ld * %d)\n",
245			(long long)dumpoff, dumplo, DEV_BSIZE);
246			(void) KREAD(kd_kern, current_nl[X_DUMPMAG].n_value, &dumpmag);
247
248			if (kernel == NULL) {
249			if (kvm_read(kd_kern, current_nl[X_VERSION].n_value,
250			vers, sizeof(vers)) == -1) {
251			syslog(LOG_ERR, "%s: kvm_read: version misread", _PATH_UNIX);
252			exit(1);
253			}
254			vers[sizeof(vers) - 1] = '\0';
255			}
256
257			ddname = find_dev(dumpdev, S_IFBLK);
258			dumpfd = open(ddname, O_RDWR);
259			if (dumpfd == -1) {
260			syslog(LOG_ERR, "%s: %m", ddname);
261			exit(1);
262			}
263
264
265			dump_sys = kernel ? kernel : _PATH_UNIX;
266			kd_dump = kvm_openfiles(kernel, ddname, NULL, O_RDWR, errbuf);
267			if (kd_dump == NULL) {
268			syslog(LOG_ERR, "%s: kvm_openfiles: %s", dump_sys, errbuf);
269			exit(1);
270			}
271
272			if (kvm_nlist(kd_dump, dump_nl) == -1)
273			syslog(LOG_ERR, "%s: kvm_nlist: %s", dump_sys,
274			kvm_geterr(kd_dump));
275
276			for (i = 0; dumpsyms[i] != -1; i++)
277			if (dump_nl[dumpsyms[i]].n_value == 0) {
278			syslog(LOG_ERR, "%s: %s not in namelist",
279			dump_sys, dump_nl[dumpsyms[i]].n_name);
280			exit(1);
281			}
282			hdrsz = kvm_dump_mkheader(kd_dump, dumpoff);
283			if (hdrsz == -1) {
284			if(verbose)
285			syslog(LOG_ERR, "%s: kvm_dump_mkheader: %s", dump_sys,
286			kvm_geterr(kd_dump));
287			syslog(LOG_WARNING, "no core dump");
288			exit(1);
289			}
290			dumpoff += hdrsz;
291			kvm_close(kd_kern);
292			}
293
294			void
295			check_kmem(void)
296			{
297			char *cp;
298			int panicloc;
299			char core_vers[VERSIONSIZE];
300
301			if (kvm_read(kd_dump, dump_nl[X_VERSION].n_value, core_vers,
302			sizeof(core_vers)) != sizeof(core_vers)) {
303			syslog(LOG_ERR, "%s: kvm_read: version misread", dump_sys);
304			exit(1);
305			}
306			core_vers[sizeof(core_vers) - 1] = '\0';
307
308			if (strcmp(vers, core_vers) && kernel == 0) {
309			vers[strcspn(vers, "\n")] = '\0';
310			core_vers[strcspn(core_vers, "\n")] = '\0';
311
312			syslog(LOG_WARNING,
313			"warning: %s version mismatch:\n\t%s\nand\t%s\n",
314			_PATH_UNIX, vers, core_vers);
315			}
316
317			(void)KREAD(kd_dump, dump_nl[X_PANICSTR].n_value, &panicstr);
318			if (panicstr) {
319			char c, visout[5];
320			size_t vislen;
321
322			cp = panic_mesg;
323			panicloc = panicstr;
324			for (;;) {
325			if (KREAD(kd_dump, panicloc, &c) != 0 \|\| c == '\0')
326			break;
327			panicloc++;
328
329			vis(visout, c, VIS_SAFE\|VIS_NOSLASH, 0);
330			vislen = strlen(visout);
331			if (cp - panic_mesg + vislen >= sizeof(panic_mesg))
332			break;
333			strlcat(cp, visout,
334			panic_mesg + sizeof panic_mesg - cp);
335			cp += strlen(cp);
336			}
337			}
338			}
339
340			int
341			dump_exists(void)
342			{
343			u_long newdumpmag;
344
345			(void)KREAD(kd_dump, dump_nl[X_DUMPMAG].n_value, &newdumpmag);
346
347			/* Read the dump size. */
348			(void)KREAD(kd_dump, dump_nl[X_DUMPSIZE].n_value, &dumppages);
349			dumpsize = (u_long)dumppages * getpagesize();
350
351			/*
352			* Return zero if core dump doesn't seem to be there and note
353			* it for syslog. This check and return happens after the dump size
354			* is read, so dumpsize is whether or not the core is valid (for -f).
355			*/
356			if (newdumpmag != dumpmag) {
357			if (verbose)
358			syslog(LOG_WARNING,
359			"magic number mismatch (%lx != %lx)",
360			newdumpmag, dumpmag);
361			syslog(LOG_WARNING, "no core dump");
362			return (0);
363			}
364			return (1);
365			}
366
367			void
368			clear_dump(void)
369			{
370			if (kvm_dump_inval(kd_dump) == -1)
371			syslog(LOG_ERR, "%s: kvm_clear_dump: %s", ddname,
372			kvm_geterr(kd_dump));
373
374			}
375
376			char buf[1024 * 1024];
377
378			void
379			save_core(void)
380			{
381			FILE *fp;
382			int bounds, ifd, nr, nw, ofd = -1;
383			char *rawp, path[PATH_MAX];
384			mode_t um;
385
386			um = umask(S_IRWXG\|S_IRWXO);
387
388			/*
389			* Get the current number and update the bounds file. Do the update
390			* now, because we may fail later and don't want to overwrite anything.
391			*/
392			(void)snprintf(path, sizeof(path), "%s/bounds", dirn);
393			if ((fp = fopen(path, "r")) == NULL)
394			goto err1;
395			if (fgets(buf, sizeof(buf), fp) == NULL) {
396			if (ferror(fp))
397			err1: syslog(LOG_WARNING, "%s: %s", path, strerror(errno));
398			bounds = 0;
399			} else {
400			const char *errstr = NULL;
401			char *p;
402
403			if ((p = strchr(buf, '\n')) != NULL)
404			*p = '\0';
405			bounds = strtonum(buf, 0, INT_MAX, &errstr);
406			if (errstr)
407			syslog(LOG_WARNING, "bounds was corrupt: %s", errstr);
408			}
409			if (fp != NULL)
410			(void)fclose(fp);
411			if ((fp = fopen(path, "w")) == NULL)
412			syslog(LOG_ERR, "%s: %m", path);
413			else {
414			(void)fprintf(fp, "%d\n", bounds + 1);
415			(void)fclose(fp);
416			}
417
418			/* Create the core file. */
419			(void)snprintf(path, sizeof(path), "%s%s.%d.core%s",
420			dirn, _PATH_UNIX, bounds, zcompress ? ".Z" : "");
421			if (zcompress) {
422			if ((fp = zopen(path, "w", 0)) == NULL) {
423			syslog(LOG_ERR, "%s: %s", path, strerror(errno));
424			exit(1);
425			}
426			} else {
427			ofd = open(path, O_WRONLY \| O_CREAT \| O_TRUNC,
428			S_IRUSR \| S_IWUSR \| S_IRGRP \| S_IROTH);
429			if (ofd == -1) {
430			syslog(LOG_ERR, "%s: %m", path);
431			exit(1);
432			}
433
434			fp = fdopen(ofd, "w");
435			if (fp == NULL) {
436			syslog(LOG_ERR, "%s: fdopen: %s", path, strerror(errno));
437			exit(1);
438			}
439			}
440
441			/* Open the raw device. */
442			rawp = rawname(ddname);
443			if ((ifd = open(rawp, O_RDONLY)) == -1) {
444			syslog(LOG_WARNING, "%s: %m; using block device", rawp);
445			ifd = dumpfd;
446			}
447
448			/* Seek to the start of the core. */
449			if (lseek(ifd, dumpoff, SEEK_SET) == -1) {
450			syslog(LOG_ERR, "lseek: %m");
451			exit(1);
452			}
453
454			if (kvm_dump_wrtheader(kd_dump, fp, dumpsize) == -1) {
455			syslog(LOG_ERR, "kvm_dump_wrtheader: %s : %s", path,
456			kvm_geterr(kd_dump));
457			exit(1);
458			}
459
460			/* Copy the core file. */
461			syslog(LOG_NOTICE, "writing %score to %s",
462			zcompress ? "compressed " : "", path);
463			for (; dumpsize != 0; dumpsize -= nr) {
464			(void)printf("%8luK\r", dumpsize / 1024);
465			(void)fflush(stdout);
466			nr = read(ifd, buf, MINIMUM(dumpsize, sizeof(buf)));
467			if (nr <= 0) {
468			if (nr == 0)
469			syslog(LOG_WARNING,
470			"WARNING: EOF on dump device");
471			else
472			syslog(LOG_ERR, "%s: %m", rawp);
473			goto err2;
474			}
475			nw = fwrite(buf, 1, nr, fp);
476			if (nw != nr) {
477			syslog(LOG_ERR, "%s: %s",
478			path, strerror(nw == 0 ? EIO : errno));
479			err2: syslog(LOG_WARNING,
480			"WARNING: core may be incomplete");
481			(void)printf("\n");
482			exit(1);
483			}
484			}
485			(void)close(ifd);
486			(void)fclose(fp);
487
488			/* Copy the kernel. */
489			ifd = open(kernel ? kernel : _PATH_UNIX, O_RDONLY);
490			if (ifd == -1) {
491			syslog(LOG_ERR, "%s: %m", kernel ? kernel : _PATH_UNIX);
492			exit(1);
493			}
494			(void)snprintf(path, sizeof(path), "%s%s.%d%s",
495			dirn, _PATH_UNIX, bounds, zcompress ? ".Z" : "");
496			if (zcompress) {
497			if ((fp = zopen(path, "w", 0)) == NULL) {
498			syslog(LOG_ERR, "%s: %s", path, strerror(errno));
499			exit(1);
500			}
501			} else {
502			ofd = open(path, O_WRONLY \| O_CREAT \| O_TRUNC,
503			S_IRUSR \| S_IWUSR \| S_IRGRP \| S_IROTH);
504			if (ofd == -1) {
505			syslog(LOG_ERR, "%s: %m", path);
506			exit(1);
507			}
508			}
509			syslog(LOG_NOTICE, "writing %skernel to %s",
510			zcompress ? "compressed " : "", path);
511			while ((nr = read(ifd, buf, sizeof(buf))) > 0) {
512			if (zcompress)
513			nw = fwrite(buf, 1, nr, fp);
514			else
515			nw = write(ofd, buf, nr);
516			if (nw != nr) {
517			syslog(LOG_ERR, "%s: %s",
518			path, strerror(nw == 0 ? EIO : errno));
519			syslog(LOG_WARNING,
520			"WARNING: kernel may be incomplete");
521			exit(1);
522			}
523			}
524			if (nr < 0) {
525			syslog(LOG_ERR, "%s: %s",
526			kernel ? kernel : _PATH_UNIX, strerror(errno));
527			syslog(LOG_WARNING,
528			"WARNING: kernel may be incomplete");
529			exit(1);
530			}
531			if (zcompress)
532			(void)fclose(fp);
533			else
534			(void)close(ofd);
535			(void)umask(um);
536			}
537
538			char *
539			find_dev(dev_t dev, int type)
540			{
541			DIR *dfd;
542			struct dirent *dir;
543			struct stat sb;
544			char *dp, devname[PATH_MAX];
545
546			if ((dfd = opendir(_PATH_DEV)) == NULL) {
547			syslog(LOG_ERR, "%s: %s", _PATH_DEV, strerror(errno));
548			exit(1);
549			}
550			(void)strlcpy(devname, _PATH_DEV, sizeof devname);
551			while ((dir = readdir(dfd))) {
552			(void)strlcpy(devname + sizeof(_PATH_DEV) - 1, dir->d_name,
553			sizeof devname - (sizeof(_PATH_DEV) - 1));
554			if (lstat(devname, &sb)) {
555			syslog(LOG_ERR, "%s: %s", devname, strerror(errno));
556			continue;
557			}
558			if ((sb.st_mode & S_IFMT) != type)
559			continue;
560			if (dev == sb.st_rdev) {
561			closedir(dfd);
562			if ((dp = strdup(devname)) == NULL) {
563			syslog(LOG_ERR, "%s", strerror(errno));
564			exit(1);
565			}
566			return (dp);
567			}
568			}
569			closedir(dfd);
570			syslog(LOG_ERR, "can't find device %d/%d", major(dev), minor(dev));
571			exit(1);
572			}
573
574			char *
575			rawname(char *s)
576			{
577			char *sl, name[PATH_MAX];
578
579			if ((sl = strrchr(s, '/')) == NULL \|\| sl[1] == '0') {
580			syslog(LOG_ERR,
581			"can't make raw dump device name from %s", s);
582			return (s);
583			}
584			(void)snprintf(name, sizeof(name), "%.*s/r%s", (int)(sl - s), s, sl + 1);
585			if ((sl = strdup(name)) == NULL) {
586			syslog(LOG_ERR, "%s", strerror(errno));
587			exit(1);
588			}
589			return (sl);
590			}
591
592			int
593			get_crashtime(void)
594			{
595			time_t dumptime; /* Time the dump was taken. */
596
597			(void)KREAD(kd_dump, dump_nl[X_TIME].n_value, &dumptime);
598			if (dumptime == 0) {
599			if (verbose)
600			syslog(LOG_ERR, "dump time is zero");
601			return (0);
602			}
603			(void)printf("savecore: system went down at %s", ctime(&dumptime));
604			#define SECSPERDAY (24 * 60 * 60)
605			#define LEEWAY (7 * SECSPERDAY)
606			if (dumptime < now - LEEWAY \|\| dumptime > now + LEEWAY) {
607			(void)printf("dump time is unreasonable\n");
608			return (0);
609			}
610			return (1);
611			}
612
613			int
614			check_space(void)
615			{
616			FILE *fp;
617			char *tkernel;
618			off_t minfree, spacefree, kernelsize, needed;
619			struct stat st;
620			struct statfs fsbuf;
621			char buf[100], path[PATH_MAX];
622			int fd;
623
624			tkernel = kernel ? kernel : _PATH_UNIX;
625			if (stat(tkernel, &st) < 0) {
626			syslog(LOG_ERR, "%s: %m", tkernel);
627			exit(1);
628			}
629			kernelsize = st.st_blocks * S_BLKSIZE;
630			if ((fd = open(dirn, O_RDONLY, 0)) < 0 \|\| fstatfs(fd, &fsbuf) < 0) {
631			syslog(LOG_ERR, "%s: %m", dirn);
632			exit(1);
633			}
634			close(fd);
635			spacefree = ((off_t)fsbuf.f_bavail * fsbuf.f_bsize) / 1024;
636
637			(void)snprintf(path, sizeof(path), "%s/minfree", dirn);
638			if ((fp = fopen(path, "r")) == NULL)
639			minfree = 0;
640			else {
641			if (fgets(buf, sizeof(buf), fp) == NULL)
642			minfree = 0;
643			else {
644			const char *errstr;
645			char *p;
646
647			if ((p = strchr(buf, '\n')) != NULL)
648			*p = '\0';
649			minfree = strtonum(buf, 0, LLONG_MAX, &errstr);
650			if (errstr)
651			syslog(LOG_WARNING,
652			"minfree was corrupt: %s", errstr);
653			}
654			(void)fclose(fp);
655			}
656
657			needed = (dumpsize + kernelsize) / 1024;
658			if (minfree > 0 && spacefree - needed < minfree) {
659			syslog(LOG_WARNING,
660			"no dump, not enough free space on device");
661			return (0);
662			}
663			if (spacefree - needed < minfree)
664			syslog(LOG_WARNING,
665			"dump performed, but free space threshold crossed");
666			return (1);
667			}
668
669			void
670			usage(void)
671			{
672			extern char *__progname;
673			fprintf(stderr, "usage: %s [-cfvz] [-N system] directory\n",
674			__progname);
675			exit(1);
676			}