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

static	char *sccsid = "@(#)savecore.c	4.6 (Berkeley) 81/05/20";
/*
 * savecore
 */

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

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

#define eq(a,b) (!strcmp(a,b))
#define ok(number) ((number)&0x7fffffff)

#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_PHYSMEM	3
	{ "_physmem" },
#define X_VERSION	4
	{ "_version" },
#define X_PANICSTR	5
	{ "_panicstr" },
	{ 0 },
};

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	physmem;			/* amount of memory in machine */
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();

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

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

char *
find_dev(dev, type)
	register dev_t dev;
	register int type;
{
	register int dfd = Open("/dev", 0);
	struct direct dir;
	struct stat statb;
	static char devname[DIRSIZ + 1];
	char *dp;

	strcpy(devname, "/dev/");
	while(Read(dfd, (char *)&dir, sizeof dir) > 0) {
		if (dir.d_ino == 0)
			continue;
		strncpy(devname + 5, dir.d_name, DIRSIZ);
		devname[DIRSIZ] = '\0';
		if (stat(devname, &statb)) {
			perror(devname);
			continue;
		}
		if ((statb.st_mode&S_IFMT) != type)
			continue;
		if (dev == statb.st_rdev) {
			close(dfd);
			dp = (char *)malloc(strlen(devname)+1);
			strcpy(dp, devname);
			return dp;
		}
	}
	close(dfd);
	fprintf(stderr, "Can't find device %d,%d\n", major(dev), minor(dev));
	exit(1);
	/*NOTREACHED*/
}

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

	nlist("/vmunix", nl);
	if (nl[X_DUMPDEV].n_value == 0) {
		fprintf(stderr, "/vmunix: dumpdev not in namelist\n");
		exit(1);
	}
	if (nl[X_DUMPLO].n_value == 0) {
		fprintf(stderr, "/vmunix: dumplo not in namelist\n");
		exit(1);
	}
	if (nl[X_TIME].n_value == 0) {
		fprintf(stderr, "/vmunix: time not in namelist\n");
		exit(1);
	}
	if (nl[X_PHYSMEM].n_value == 0) {
		fprintf(stderr, "/vmunix: physmem not in namelist\n");
		exit(1);
	}
	if (nl[X_VERSION].n_value == 0) {
		fprintf(stderr, "/vmunix: version not in namelist\n");
		exit(1);
	}
	if (nl[X_PANICSTR].n_value == 0) {
		fprintf(stderr, "/vmunix: panicstr not in namelist\n");
		exit(1);
	}
	kmem = Open("/dev/kmem", 0);
	Lseek(kmem, (long)nl[X_DUMPDEV].n_value, 0);
	Read(kmem, (char *)&dumpdev, sizeof dumpdev);
	Lseek(kmem, (long)nl[X_DUMPLO].n_value, 0);
	Read(kmem, (char *)&dumplo, sizeof dumplo);
	Lseek(kmem, (long)nl[X_PHYSMEM].n_value, 0);
	Read(kmem, (char *)&physmem, sizeof physmem);
	dumplo *= 512L;
	ddname = find_dev(dumpdev, S_IFBLK);
	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))
		fprintf(stderr, "Warning: vmunix version mismatch:\n\t%sand\n\t%s",
		    vers,core_vers);
	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++);
	}
	fclose(fp);
}	

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

	dumpfd = Open(ddname, 2);
	Lseek(dumpfd, (off_t)(dumplo + ok(nl[X_TIME].n_value)), 0);
	Read(dumpfd, (char *)&dumptime, sizeof dumptime);
	Lseek(dumpfd, (off_t)(dumplo + ok(nl[X_TIME].n_value)), 0);
	Write(dumpfd, (char *)&clobber, sizeof clobber);
	close(dumpfd);
	if (dumptime == 0) {
#ifdef DEBUG
		printf("dump time is 0\n");
#endif
		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;
	register int dfd;
	struct filsys sblk;

	if (stat(dirname, &dsb) < 0) {
		perror(dirname);
		exit(1);
	}
	ddev = find_dev(dsb.st_dev, S_IFBLK);
	dfd = Open(ddev, 0);
	Lseek(dfd, 1L<<BSHIFT, 0);
	Read(dfd, (char *)&sblk, sizeof sblk);
	close(dfd);
	if (read_number("minfree") > sblk.s_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);
}

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("/vmunix", 0);
	ofd = Create(path(sprintf(cp, "vmunix.%d", bounds)), 0666);
	while((n = Read(ifd, cp, BUFSIZ)) > 0)
		Write(ofd, cp, n);
	close(ifd);
	close(ofd);
	ifd = Open(ddname, 0);
	ofd = Create(path(sprintf(cp, "vmcore.%d", bounds)), 0666);
	Lseek(ifd, (off_t)dumplo, 0);
	printf("Saving %d bytes of image in vmcore.%d\n", NBPG*physmem, bounds);
	while(physmem > 0) {
		n = Read(ifd, cp, (physmem > 32 ? 32 : physmem) * NBPG);
		Write(ofd, cp, n);
		physmem -= 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
c190b305	1	static char *sccsid = "@(#)savecore.c 4.6 (Berkeley) 81/05/20";
d112e9ff	2	/*
97d6da0b	3	* savecore
d112e9ff BJ	4	*/
	5
	6	#include <stdio.h>
	7	#include <nlist.h>
	8	#include <sys/param.h>
	9	#include <sys/dir.h>
	10	#include <sys/stat.h>
	11	#include <sys/filsys.h>
	12	#include <time.h>
	13
97d6da0b BJ	14	#define DAY (60L60L24L)
	15	#define LEEWAY (3*DAY)
	16
	17	#define eq(a,b) (!strcmp(a,b))
	18	#define ok(number) ((number)&0x7fffffff)
	19
d112e9ff	20	#define SHUTDOWNLOG "/usr/adm/shutdownlog"
d112e9ff BJ	21
	22	struct nlist nl[] = {
	23	#define X_DUMPDEV 0
	24	{ "_dumpdev" },
	25	#define X_DUMPLO 1
	26	{ "_dumplo" },
	27	#define X_TIME 2
	28	{ "_time" },
	29	#define X_PHYSMEM 3
	30	{ "_physmem" },
	31	#define X_VERSION 4
	32	{ "_version" },
	33	#define X_PANICSTR 5
	34	{ "_panicstr" },
	35	{ 0 },
	36	};
	37
97d6da0b BJ	38	char dirname; / directory to save dumps in */
	39	char ddname; / name of dump device */
	40	char *find_dev();
	41	dev_t dumpdev; /* dump device */
	42	time_t dumptime; /* time the dump was taken */
	43	int dumplo; /* where dump starts on dumpdev */
	44	int physmem; /* amount of memory in machine */
	45	time_t now; /* current date */
	46	char *path();
	47	unsigned malloc();
	48	char *ctime();
	49	char vers[80];
	50	char core_vers[80];
	51	char panic_mesg[80];
	52	int panicstr;
97d6da0b BJ	53	off_t lseek();
97d6da0b BJ	54	off_t Lseek();
d112e9ff BJ	55
d112e9ff BJ	56	main(argc, argv)
97d6da0b BJ	57	char **argv;
97d6da0b BJ	58	int argc;
d112e9ff	59	{
97d6da0b BJ	60
97d6da0b BJ	61	if (argc != 2) {
d112e9ff BJ	62	fprintf(stderr, "usage: savecore dirname\n");
	63	exit(1);
	64	}
	65	dirname = argv[1];
97d6da0b	66	if (access(dirname, 2) < 0) {
d112e9ff	67	perror(dirname);
97d6da0b	68	exit(1);
d112e9ff	69	}
97d6da0b	70	(void) time(&now);
d112e9ff BJ	71	read_kmem();
d112e9ff BJ	72	log_entry();
c190b305	73	if (get_crashtime() && check_space())
d112e9ff	74	save_core();
c190b305 BJ	75	else
c190b305 BJ	76	exit(1);
d112e9ff BJ	77	}
d112e9ff BJ	78
97d6da0b BJ	79	char *
	80	find_dev(dev, type)
	81	register dev_t dev;
	82	register int type;
d112e9ff BJ	83	{
	84	register int dfd = Open("/dev", 0);
	85	struct direct dir;
	86	struct stat statb;
	87	static char devname[DIRSIZ + 1];
f0326588	88	char *dp;
d112e9ff BJ	89
d112e9ff BJ	90	strcpy(devname, "/dev/");
97d6da0b	91	while(Read(dfd, (char *)&dir, sizeof dir) > 0) {
d112e9ff BJ	92	if (dir.d_ino == 0)
	93	continue;
	94	strncpy(devname + 5, dir.d_name, DIRSIZ);
	95	devname[DIRSIZ] = '\0';
97d6da0b	96	if (stat(devname, &statb)) {
d112e9ff	97	perror(devname);
97d6da0b BJ	98	continue;
	99	}
	100	if ((statb.st_mode&S_IFMT) != type)
	101	continue;
	102	if (dev == statb.st_rdev) {
	103	close(dfd);
	104	dp = (char *)malloc(strlen(devname)+1);
	105	strcpy(dp, devname);
	106	return dp;
d112e9ff BJ	107	}
	108	}
	109	close(dfd);
	110	fprintf(stderr, "Can't find device %d,%d\n", major(dev), minor(dev));
97d6da0b BJ	111	exit(1);
97d6da0b BJ	112	/NOTREACHED/
d112e9ff BJ	113	}
d112e9ff BJ	114
d112e9ff BJ	115	read_kmem()
	116	{
	117	int kmem;
	118	FILE *fp;
	119	register char *cp;
	120
	121	nlist("/vmunix", nl);
97d6da0b BJ	122	if (nl[X_DUMPDEV].n_value == 0) {
	123	fprintf(stderr, "/vmunix: dumpdev not in namelist\n");
	124	exit(1);
d112e9ff	125	}
97d6da0b BJ	126	if (nl[X_DUMPLO].n_value == 0) {
	127	fprintf(stderr, "/vmunix: dumplo not in namelist\n");
	128	exit(1);
d112e9ff	129	}
97d6da0b BJ	130	if (nl[X_TIME].n_value == 0) {
	131	fprintf(stderr, "/vmunix: time not in namelist\n");
	132	exit(1);
d112e9ff	133	}
97d6da0b BJ	134	if (nl[X_PHYSMEM].n_value == 0) {
	135	fprintf(stderr, "/vmunix: physmem not in namelist\n");
	136	exit(1);
d112e9ff	137	}
97d6da0b BJ	138	if (nl[X_VERSION].n_value == 0) {
	139	fprintf(stderr, "/vmunix: version not in namelist\n");
	140	exit(1);
d112e9ff	141	}
97d6da0b BJ	142	if (nl[X_PANICSTR].n_value == 0) {
	143	fprintf(stderr, "/vmunix: panicstr not in namelist\n");
	144	exit(1);
d112e9ff BJ	145	}
d112e9ff BJ	146	kmem = Open("/dev/kmem", 0);
97d6da0b BJ	147	Lseek(kmem, (long)nl[X_DUMPDEV].n_value, 0);
	148	Read(kmem, (char *)&dumpdev, sizeof dumpdev);
	149	Lseek(kmem, (long)nl[X_DUMPLO].n_value, 0);
	150	Read(kmem, (char *)&dumplo, sizeof dumplo);
	151	Lseek(kmem, (long)nl[X_PHYSMEM].n_value, 0);
	152	Read(kmem, (char *)&physmem, sizeof physmem);
d112e9ff BJ	153	dumplo *= 512L;
d112e9ff BJ	154	ddname = find_dev(dumpdev, S_IFBLK);
97d6da0b	155	if ((fp = fdopen(kmem, "r")) == NULL) {
d112e9ff	156	fprintf(stderr, "Couldn't fdopen kmem\n");
97d6da0b	157	exit(1);
d112e9ff	158	}
97d6da0b	159	fseek(fp, (long)nl[X_VERSION].n_value, 0);
d112e9ff BJ	160	fgets(vers, sizeof vers, fp);
d112e9ff BJ	161	fclose(fp);
97d6da0b	162	if ((fp = fopen(ddname, "r")) == NULL) {
d112e9ff	163	perror(ddname);
97d6da0b	164	exit(1);
d112e9ff	165	}
97d6da0b	166	fseek(fp, (off_t)(dumplo+ok(nl[X_VERSION].n_value)), 0);
d112e9ff BJ	167	fgets(core_vers, sizeof core_vers, fp);
d112e9ff BJ	168	fclose(fp);
40dd70fc BJ	169	if (!eq(vers, core_vers))
40dd70fc BJ	170	fprintf(stderr, "Warning: vmunix version mismatch:\n\t%sand\n\t%s",
97d6da0b	171	vers,core_vers);
97d6da0b BJ	172	fp = fopen(ddname, "r");
	173	fseek(fp, (off_t)(dumplo + ok(nl[X_PANICSTR].n_value)), 0);
	174	fread((char *)&panicstr, sizeof panicstr, 1, fp);
	175	if (panicstr) {
	176	fseek(fp, dumplo + ok(panicstr), 0);
d112e9ff BJ	177	cp = panic_mesg;
	178	do
	179	*cp = getc(fp);
	180	while (*cp++);
d112e9ff	181	}
97d6da0b	182	fclose(fp);
d112e9ff BJ	183	}
d112e9ff BJ	184
97d6da0b BJ	185	get_crashtime()
97d6da0b BJ	186	{
d112e9ff	187	int dumpfd;
20f89b8d	188	time_t clobber = (time_t)0;
d112e9ff	189
20f89b8d	190	dumpfd = Open(ddname, 2);
97d6da0b BJ	191	Lseek(dumpfd, (off_t)(dumplo + ok(nl[X_TIME].n_value)), 0);
	192	Read(dumpfd, (char *)&dumptime, sizeof dumptime);
	193	Lseek(dumpfd, (off_t)(dumplo + ok(nl[X_TIME].n_value)), 0);
	194	Write(dumpfd, (char *)&clobber, sizeof clobber);
d112e9ff	195	close(dumpfd);
c190b305 BJ	196	if (dumptime == 0) {
	197	#ifdef DEBUG
	198	printf("dump time is 0\n");
	199	#endif
97d6da0b	200	return 0;
c190b305	201	}
d112e9ff BJ	202	printf("System went down at %s", ctime(&dumptime));
	203	if (dumptime < now - LEEWAY \|\| dumptime > now + LEEWAY) {
	204	printf("Dump time is unreasonable\n");
97d6da0b	205	return 0;
d112e9ff	206	}
97d6da0b	207	return 1;
d112e9ff BJ	208	}
d112e9ff BJ	209
97d6da0b BJ	210	char *
	211	path(file)
	212	char *file;
d112e9ff	213	{
97d6da0b	214	register char cp = (char )malloc(strlen(file) + strlen(dirname) + 2);
d112e9ff	215
97d6da0b BJ	216	(void) strcpy(cp, dirname);
	217	(void) strcat(cp, "/");
	218	(void) strcat(cp, file);
d112e9ff BJ	219	return cp;
	220	}
	221
d112e9ff BJ	222	check_space()
	223	{
	224	struct stat dsb;
	225	register char *ddev;
	226	register int dfd;
	227	struct filsys sblk;
	228
97d6da0b BJ	229	if (stat(dirname, &dsb) < 0) {
	230	perror(dirname);
	231	exit(1);
	232	}
d112e9ff BJ	233	ddev = find_dev(dsb.st_dev, S_IFBLK);
	234	dfd = Open(ddev, 0);
	235	Lseek(dfd, 1L<<BSHIFT, 0);
97d6da0b	236	Read(dfd, (char *)&sblk, sizeof sblk);
d112e9ff	237	close(dfd);
97d6da0b BJ	238	if (read_number("minfree") > sblk.s_tfree) {
	239	fprintf(stderr, "Dump omitted, not enough space on device\n");
	240	return (0);
d112e9ff	241	}
97d6da0b	242	return (1);
d112e9ff BJ	243	}
d112e9ff BJ	244
d112e9ff	245	read_number(fn)
97d6da0b	246	char *fn;
d112e9ff BJ	247	{
	248	char lin[80];
	249	register FILE *fp;
	250
	251	if ((fp = fopen(path(fn), "r")) == NULL)
	252	return 0;
97d6da0b BJ	253	if (fgets(lin, 80, fp) == NULL) {
	254	fclose(fp);
	255	return 0;
d112e9ff	256	}
97d6da0b BJ	257	fclose(fp);
97d6da0b BJ	258	return atoi(lin);
d112e9ff BJ	259	}
	260
	261	save_core()
	262	{
	263	register int n;
97d6da0b	264	char buffer[32*NBPG];
d112e9ff BJ	265	register char *cp = buffer;
	266	register int ifd, ofd, bounds;
	267	register FILE *fp;
	268
	269	bounds = read_number("bounds");
d112e9ff BJ	270	ifd = Open("/vmunix", 0);
	271	ofd = Create(path(sprintf(cp, "vmunix.%d", bounds)), 0666);
	272	while((n = Read(ifd, cp, BUFSIZ)) > 0)
	273	Write(ofd, cp, n);
	274	close(ifd);
	275	close(ofd);
d112e9ff BJ	276	ifd = Open(ddname, 0);
d112e9ff BJ	277	ofd = Create(path(sprintf(cp, "vmcore.%d", bounds)), 0666);
97d6da0b BJ	278	Lseek(ifd, (off_t)dumplo, 0);
	279	printf("Saving %d bytes of image in vmcore.%d\n", NBPG*physmem, bounds);
	280	while(physmem > 0) {
	281	n = Read(ifd, cp, (physmem > 32 ? 32 : physmem) * NBPG);
d112e9ff BJ	282	Write(ofd, cp, n);
	283	physmem -= n/NBPG;
	284	}
	285	close(ifd);
	286	close(ofd);
	287	fp = fopen(path("bounds"), "w");
	288	fprintf(fp, "%d\n", bounds+1);
	289	fclose(fp);
	290	}
	291
	292	char *days[] = {
	293	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
	294	};
	295
	296	char *months[] = {
	297	"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
	298	"Oct", "Nov", "Dec"
	299	};
	300
	301	log_entry()
	302	{
	303	FILE *fp;
	304	struct tm tm, localtime();
	305
	306	tm = localtime(&now);
97d6da0b BJ	307	fp = fopen("/usr/adm/shutdownlog", "a");
	308	if (fp == 0)
	309	return;
d112e9ff BJ	310	fseek(fp, 0L, 2);
	311	fprintf(fp, "%02d:%02d %s %s %2d, %4d. Reboot", tm->tm_hour,
	312	tm->tm_min, days[tm->tm_wday], months[tm->tm_mon],
	313	tm->tm_mday, tm->tm_year + 1900);
	314	if (panicstr)
97d6da0b	315	fprintf(fp, " after panic: %s\n", panic_mesg);
d112e9ff BJ	316	else
	317	putc('\n', fp);
	318	fclose(fp);
	319	}
97d6da0b BJ	320
	321	/*
	322	* Versions of std routines that exit on error.
	323	*/
	324
	325	Open(name, rw)
	326	char *name;
	327	int rw;
	328	{
	329	int fd;
	330
	331	if ((fd = open(name, rw)) < 0) {
	332	perror(name);
	333	exit(1);
	334	}
	335	return fd;
	336	}
	337
	338	Read(fd, buff, size)
	339	int fd, size;
	340	char *buff;
	341	{
	342	int ret;
	343
	344	if ((ret = read(fd, buff, size)) < 0) {
	345	perror("read");
	346	exit(1);
	347	}
	348	return ret;
	349	}
	350
	351	off_t
	352	Lseek(fd, off, flag)
	353	int fd, flag;
	354	long off;
	355	{
	356	long ret;
	357
	358	if ((ret = lseek(fd, off, flag)) == -1L) {
	359	perror("lseek");
	360	exit(1);
	361	}
	362	return ret;
	363	}
	364
	365	Create(file, mode)
	366	char *file;
	367	int mode;
	368	{
	369	register int fd;
	370
	371	if ((fd = creat(file, mode)) < 0) {
	372	perror(file);
	373	exit(1);
	374	}
	375	return fd;
	376	}
	377
	378	Write(fd, buf, size)
	379	int fd, size;
	380	char *buf;
	381
	382	{
	383
384	if (write(fd, buf, size) < size) {
385	perror("write");
386	exit(1);
387	}
388	}