savecore.c

来自「<B>Digital的Unix操作系统VAX 4.2源码</B>」· C语言 代码 · 共 1,460 行 · 第 1/3 页

	}
	else
		return(0);
}

clear_dump()
{
	register int dumpfd;
	int seektot,seekval,seekrem;
	char junkbuf[DEV_BSIZE], *rptr;

	/* Get the initial "dumpsize" from the dump device */
	dumpfd = Open(ddname, 2);
	bzero(junkbuf, DEV_BSIZE);
	seektot = (off_t)(dumplo + ok(nlsystem[X_DUMPSIZE].n_value));
	seekval = (seektot/DEV_BSIZE) * DEV_BSIZE;
	seekrem = seektot % DEV_BSIZE;
	Lseek(dumpfd, (off_t) seekval, 0);
	Read(dumpfd, rbuf, round(seekrem + sizeof(dumpsize)));
	rptr = rbuf + seekrem;
	dumpsize = *(int *)rptr;

	/* Get the additional "dumpsize2" from the dump device */
	seektot = (off_t)(dumplo + ok(nlsystem[X_DUMPSIZE2].n_value));
	seekval = (seektot/DEV_BSIZE) * DEV_BSIZE;
	seekrem = seektot % DEV_BSIZE;
	Lseek(dumpfd, (off_t) seekval, 0);
	Read(dumpfd, rbuf, round(seekrem + sizeof(dumpsize2)));
	rptr = rbuf + seekrem;
	dumpsize2 = *(int *)rptr;

	/* Get the number of "dumpdescriptors" from the dump device */
	seektot = (off_t)(dumplo + ok(nlsystem[X_NUMDUMPDESC].n_value));
	seekval = (seektot/DEV_BSIZE) * DEV_BSIZE;
	seekrem = seektot % DEV_BSIZE;
	Lseek(dumpfd, (off_t) seekval, 0);
	Read(dumpfd, rbuf, round(seekrem + sizeof(dumpdescriptors)));
	rptr = rbuf + seekrem;
	dumpdescriptors = *(int *)rptr;

	/* Clear the dump itself */
	seektot = (off_t) (dumplo + ok(nlsystem[X_DUMPMAG].n_value));
	seekval = (seektot / DEV_BSIZE) * DEV_BSIZE;
	seekrem = seektot % DEV_BSIZE;
	Lseek(dumpfd, (off_t) seekval, 0);
	Write(dumpfd, junkbuf, DEV_BSIZE);

	/* Clear the dump descriptor at the end of the dump */
	seekval = dumplo + (dumpsize+dumpsize2+dumpdescriptors) * DEV_BSIZE;
	Lseek(dumpfd, (off_t) seekval, 0);
	Write(dumpfd, junkbuf, DEV_BSIZE);
	close(dumpfd);
}

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

	strcpy(devname, "/dev/");
	while ((dir = readdir(dfd))) {
		strcpy(devname + 5, 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 = (char *)malloc(strlen(devname)+2);

			if (raw) {
				strcpy(dp, "/dev/r");
				strcat(dp, &devname[5]);
			}
			else {
				strcpy(dp, devname);
			}
			return dp;
		}
	}
	closedir(dfd);
	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;
	int seektot, seekval, seekrem;
	char *rptr;
	int dumpfd;

	/*
	 * Get the namelist lookups for the system that is running.
 	 * Savecore assumes the running system image is "/vmunix".
	 */
	nlist("/vmunix", nl);
	if (nl[X_DUMPDEV].n_value == 0) {
		fprintf(stderr, "savecore: /vmunix: dumpdev not in namelist\n");
		exit(1);
	}
	if (nl[X_DUMPLO].n_value == 0) {
		fprintf(stderr, "savecore: /vmunix: dumplo not in namelist\n");
		exit(1);
	}
	if (nl[X_FULLDUMPMAG].n_value == 0) {
		fprintf(stderr, "savecore: /vmunix: full_dumpmag not in namelist\n");
		exit(1);
	}
	if (nl[X_PARTDUMPMAG].n_value == 0) {
		fprintf(stderr, "savecore: /vmunix: partial_dumpmag not in namelist\n");
		exit(1);
	}
	if (nl[X_VERSION].n_value == 0) {
		fprintf(stderr, "savecore: /vmunix: version not in namelist\n");
		exit(1);
	}
	if (nl[X_PHYSMEM].n_value == 0) {
		fprintf(stderr, "savecore: /vmunix: physmem not in namelist\n");
		exit(1);
	}
	/*
	 * Read the dump device, the dump device offset, the full
	 * dump magic number, the partial dump magic number, the
	 * physical memory size, and the version string from the 
	 * running system image "/vmunix".
	 */
	kmem = Open("/dev/kmem", 0);
	if(!dflag) {
		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_VERSION].n_value, 0);
		Read(kmem, vers, sizeof (vers));
		if(tstdebug) {
	    	    printf("dumpdev = DEC(%d) HEX(%x)\n", dumpdev, dumpdev);
	    	    printf("dumplo  = DEC(%d) HEX(%x)\n", dumplo, dumplo);
		}
	}
	Lseek(kmem, (long)nl[X_FULLDUMPMAG].n_value, 0);
	Read(kmem, (char *)&full_dumpmag, sizeof (full_dumpmag));
	Lseek(kmem, (long)nl[X_PARTDUMPMAG].n_value, 0);
	Read(kmem, (char *)&partial_dumpmag, sizeof (partial_dumpmag));
	Lseek(kmem, (long)nl[X_PHYSMEM].n_value, 0);
	Read(kmem, (char *)&physmem, sizeof (physmem));
	close(kmem);
	/*
	 * Figure out the name of the dump device.
	 */
	if (fflag) {
		ddname = corefile;
		dumplo = 0;
	}
	else {
		ddname = find_dev(dumpdev, S_IFBLK, RAW); 
		dumplo *= DEV_BSIZE;
	}

	/*
	 * Get the namelist lookups for the system that crashed.
	 * Read all the namelist elements from the dump device.
	 */
	if (system) 
		nlist(system, nlsystem);
	else
		nlist("/vmunix", nlsystem);

	if (nlsystem[X_DUMPDEV].n_value == 0) {
		fprintf(stderr, "savecore: %s: dumpdev not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}
	if (nlsystem[X_DUMPLO].n_value == 0) {
		fprintf(stderr, "savecore: %s: dumplo not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}
	if (nlsystem[X_TIME].n_value == 0) {
		fprintf(stderr, "savecore: %s: time not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}
	if (nlsystem[X_DUMPSIZE].n_value == 0) {
		fprintf(stderr, "savecore: %s: dumpsize not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}
	if (nlsystem[X_DUMPSIZE2].n_value == 0) {
		fprintf(stderr, "savecore: %s: dumpsize2 not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}
	if (nlsystem[X_VERSION].n_value == 0) {
		fprintf(stderr, "savecore: %s: version not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}
	if (nlsystem[X_PANICSTR].n_value == 0) {
		fprintf(stderr, "savecore: %s: panicstr not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}
	if (nlsystem[X_DUMPMAG].n_value == 0) {
		fprintf(stderr, "savecore: %s: dumpmag not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}
	if (nlsystem[X_FULLDUMPMAG].n_value == 0) {
		fprintf(stderr, "savecore: %s: full_dumpmag not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}
	if (nlsystem[X_PARTDUMPMAG].n_value == 0) {
		fprintf(stderr, "savecore: %s: partial_dumpmag not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}
	if (nlsystem[X_NUMDUMPDESC].n_value == 0) {
		fprintf(stderr, "savecore: %s: dumpdescriptors not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}
	if (nlsystem[X_ELBUF].n_value == 0) {
		fprintf(stderr, "savecore: %s: elbuf not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}
	if (nlsystem[X_DUMPSOFTPGSZ].n_value == 0) {
		fprintf(stderr, "savecore: %s: dumpsoftpgsize not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}
	if (nlsystem[X_DUMPHARDPGSZ].n_value == 0) {
		fprintf(stderr, "savecore: %s: dumphardpgsize not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}
	if (nlsystem[X_PHYSMEM].n_value == 0) {
		fprintf(stderr, "savecore: %s: physmem not in namelist\n",
			system ? system : "/vmunix");
		exit(1);
	}

	/* Get the "dumpmag" value */
	dumpfd = Open(ddname, 0);
	seektot = (off_t)(dumplo + ok(nlsystem[X_DUMPMAG].n_value));
	seekval = (seektot/DEV_BSIZE) * DEV_BSIZE;
	seekrem = seektot % DEV_BSIZE;
	Lseek(dumpfd, (off_t) seekval, 0);
	Read(dumpfd, rbuf, round(seekrem + sizeof(dumpmag)));
	rptr = rbuf + seekrem;
	dumpmag = *(int *)rptr;

	/* Get the "dumpsoftpgsize" value */
	seektot = (off_t)(dumplo + ok(nlsystem[X_DUMPSOFTPGSZ].n_value));
	seekval = (seektot/DEV_BSIZE) * DEV_BSIZE;
	seekrem = seektot % DEV_BSIZE;
	Lseek(dumpfd, (off_t) seekval, 0);
	Read(dumpfd, rbuf, round(seekrem + sizeof(dumpsoftpgsize)));
	rptr = rbuf + seekrem;
	dumpsoftpgsize = *(int *)rptr;

	/* Get the "dumphardpgsize" value */
	seektot = (off_t)(dumplo + ok(nlsystem[X_DUMPHARDPGSZ].n_value));
	seekval = (seektot/DEV_BSIZE) * DEV_BSIZE;
	seekrem = seektot % DEV_BSIZE;
	Lseek(dumpfd, (off_t) seekval, 0);
	Read(dumpfd, rbuf, round(seekrem + sizeof(dumphardpgsize)));
	rptr = rbuf + seekrem;
	dumphardpgsize = *(int *)rptr;

	/* Get the "physmem" value */
	seektot = (off_t)(dumplo + ok(nlsystem[X_PHYSMEM].n_value));
	seekval = (seektot/DEV_BSIZE) * DEV_BSIZE;
	seekrem = seektot % DEV_BSIZE;
	Lseek(dumpfd, (off_t) seekval, 0);
	Read(dumpfd, rbuf, round(seekrem + sizeof(physmem)));
	rptr = rbuf + seekrem;
	physmem = *(int *)rptr;

	/* Get the "vers" string */
	if(dflag) {
		seektot = (off_t)(dumplo + ok(nlsystem[X_VERSION].n_value));
		seekval = (seektot/DEV_BSIZE) * DEV_BSIZE;
		seekrem = seektot % DEV_BSIZE;
		Lseek(dumpfd, (off_t) seekval, 0);
		Read(dumpfd, rbuf, round(seekrem + sizeof(vers)));
		rptr = rbuf + seekrem;
		strcpy(vers, rptr, sizeof(vers));
	}
	close(dumpfd);
}

check_kmem()
{
	int seektot, seekval, seekrem;
	char *rptr;
	int dumpfd;

	dumpfd = Open(ddname, 0);
	seektot = (off_t)(dumplo+ok(nlsystem[X_VERSION].n_value));
	seekval = (seektot / DEV_BSIZE) * DEV_BSIZE;
	seekrem = seektot % DEV_BSIZE;
	Lseek(dumpfd, (off_t)seekval, 0);
	Read(dumpfd, rbuf, round(sizeof(core_vers) + seekrem)); 
	rptr = rbuf + seekrem;
	strcpy(core_vers, rptr, sizeof(core_vers));
	close(dumpfd);

	if (strncmp(vers, core_vers, sizeof(vers)))
		fprintf(stderr,
		   "savecore: Warning: vmunix version mismatch:\n\t%sand\n\t%s",
		   vers, core_vers);

	dumpfd = Open(ddname, 0);
	seektot = (off_t)(dumplo + ok(nlsystem[X_PANICSTR].n_value));
	seekval = (seektot / DEV_BSIZE) * DEV_BSIZE;
	seekrem = seektot % DEV_BSIZE;
	Lseek(dumpfd, (off_t)seekval, 0);
	Read(dumpfd, rbuf, round(sizeof(panicstr) + seekrem));
	rptr = rbuf + seekrem;
	panicstr = *(int *)rptr;

	if (panicstr) {
	    close(dumpfd);
	    dumpfd = Open(ddname, 0);
	    seektot = (off_t)(dumplo + ok(panicstr));
	    seekval = (seektot / DEV_BSIZE) * DEV_BSIZE;
	    seekrem = seektot % DEV_BSIZE;
	    Lseek(dumpfd, (off_t)seekval, 0);
	    Read(dumpfd, rbuf, round(sizeof(panic_mesg) + seekrem));
	    rptr = rbuf + seekrem;
	    strcpy(panic_mesg, rptr, sizeof(panic_mesg));
	}
	close(dumpfd);
}

get_crashtime()
{
	int dumpfd;
	int seektot, seekval, seekrem;
	char *rptr;
	time_t clobber = (time_t)0;

	if (system)
		return (1);
	dumpfd = Open(ddname, 0);
	seektot = (off_t)(dumplo + ok(nlsystem[X_TIME].n_value));
	seekval = (seektot / DEV_BSIZE) * DEV_BSIZE;
	seekrem = seektot % DEV_BSIZE;
	Lseek(dumpfd, (off_t) seekval, 0);
	Read(dumpfd, rbuf, round(seekrem + sizeof(dumptime)));
	rptr = rbuf + seekrem;
	dumptime = *(int *)rptr;
	close(dumpfd);
	if (dumptime == 0)
		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()
{
	register char *ddev;
	int dfd, spacefree;
	struct fs fs;
	struct fs *fsptr;
	int seektot, seekval, seekrem;
	char *rptr;

	if (dirname_notlocal)
		return (1);
	ddev = find_dev(dsb.st_dev, S_IFBLK, BLOCK);
	dfd = Open(ddev, 0); 
	seektot = (long)(SBLOCK * DEV_BSIZE);
	seekval = (seektot/DEV_BSIZE) * DEV_BSIZE;
	seekrem = seektot % DEV_BSIZE;
	Lseek(dfd, (long) seekval, 0);
	Read(dfd, rbuf, round(sizeof(fs) + seekrem));
	rptr = rbuf + seekrem;
	fsptr = (struct fs *)rbuf;
	close(dfd);
	spacefree = fsptr->fs_cstotal.cs_nbfree * fsptr->fs_bsize / 1024;
	if (read_number("minfree") > spacefree) {
		fprintf(stderr,
		   "savecore: Dump omitted, not enough space on device\n");
		return (0);
	}
	if (fsptr->fs_cstotal.cs_nbfree * fsptr->fs_frag + fsptr->fs_cstotal.cs_nffree <
	    fsptr->fs_dsize * fsptr->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, blk, bc, i, j, myblks, totaldumpsize;
	char buffer[32*DEV_BSIZE];
	register char *cp = buffer;
	register int ifd, ofd, bounds;
	register FILE *fp;
	register blks_out;			/* count of blocks written */
	int num_to_print;			/* After this many pages are
						   written, print a message */
	int seektot, seekval, seekrem;
	char *rptr;
	short fstread = 1;
	int successflag = 1;

	old_bounds = bounds = read_number("bounds");
	ifd = Open(system?system:"/vmunix", 0);
	sprintf(cp, "vmunix.%d", bounds);
	ofd = Create(path(cp), 0644);
	while((n = Read(ifd, cp, BUFSIZ)) > 0)
		Write(ofd, cp, n);
	close(ifd);
	close(ofd);

	/* Get the initial "dumpsize" from the dump device */
	ifd = Open(ddname, 0);
	seektot = (off_t)(dumplo + ok(nlsystem[X_DUMPSIZE].n_value));
	seekval = (seektot/DEV_BSIZE) * DEV_BSIZE;
	seekrem = seektot % DEV_BSIZE;
	Lseek(ifd, (off_t) seekval, 0);
	Read(ifd, rbuf, round(seekrem + sizeof(dumpsize)));
	rptr = rbuf + seekrem;
	dumpsize = *(int *)rptr;

	/* Get the additional "dumpsize2" from the dump device */
	seektot = (off_t)(dumplo + ok(nlsystem[X_DUMPSIZE2].n_value));
	seekval = (seektot/DEV_BSIZE) * DEV_BSIZE;
	seekrem = seektot % DEV_BSIZE;
	Lseek(ifd, (off_t) seekval, 0);
	Read(ifd, rbuf, round(seekrem + sizeof(dumpsize2)));
	rptr = rbuf + seekrem;
	dumpsize2 = *(int *)rptr;

	/* Get the number of "dumpdescriptors" from the dump device */
	seektot = (off_t)(dumplo + ok(nlsystem[X_NUMDUMPDESC].n_value));
	seekval = (seektot/DEV_BSIZE) * DEV_BSIZE;