[unix-history] / usr / src / sbin / fsck / setup.c

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 */

#ifndef lint
static char sccsid[] = "@(#)setup.c	5.19 (Berkeley) %G%";
#endif not lint

#define DKTYPENAMES
#include <sys/param.h>
#include <sys/inode.h>
#include <sys/fs.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/disklabel.h>
#include <sys/file.h>
#include <machine/endian.h>
#include <ctype.h>
#include "fsck.h"

BUFAREA asblk;
#define altsblock (*asblk.b_un.b_fs)
#define POWEROF2(num)	(((num) & ((num) - 1)) == 0)

char	*calloc();
char	*index();

setup(dev)
	char *dev;
{
	dev_t rootdev;
	long cg, ncg, size, asked, i, j;
	struct disklabel *getdisklabel(), *lp;
	struct stat statb;
	struct fs proto;

	havesb = 0;
	if (stat("/", &statb) < 0)
		errexit("Can't stat root\n");
	rootdev = statb.st_dev;
	if (stat(dev, &statb) < 0) {
		perror(dev);
		printf("Can't stat %s\n", dev);
		return (0);
	}
	rawflg = 0;
	if ((statb.st_mode & S_IFMT) == S_IFBLK)
		;
	else if ((statb.st_mode & S_IFMT) == S_IFCHR)
		rawflg++;
	else {
		if (reply("file is not a block or character device; OK") == 0)
			return (0);
	}
	if (rootdev == statb.st_rdev)
		hotroot++;
	if ((dfile.rfdes = open(dev, O_RDONLY)) < 0) {
		perror(dev);
		printf("Can't open %s\n", dev);
		return (0);
	}
	if (preen == 0)
		printf("** %s", dev);
	if (nflag || (dfile.wfdes = open(dev, O_WRONLY)) < 0) {
		dfile.wfdes = -1;
		if (preen)
			pfatal("NO WRITE ACCESS");
		printf(" (NO WRITE)");
	}
	if (preen == 0)
		printf("\n");
	dfile.mod = 0;
	lfdir = 0;
	initbarea(&sblk);
	initbarea(&asblk);
	sblk.b_un.b_buf = (char *)malloc(SBSIZE);
	asblk.b_un.b_buf = (char *)malloc(SBSIZE);
	if (sblk.b_un.b_buf == 0 || asblk.b_un.b_buf == 0)
		errexit("cannot allocate space for superblock\n");
	if (lp = getdisklabel((char *)NULL, dfile.rfdes))
		dev_bsize = secsize = lp->d_secsize;
	else
		dev_bsize = secsize = DEV_BSIZE;
	/*
	 * Read in the superblock, looking for alternates if necessary
	 */
	if (readsb(1) == 0) {
		if (bflag || preen || calcsb(dev, dfile.rfdes, &proto) == 0)
			return(0);
		if (reply("LOOK FOR ALTERNATE SUPERBLOCKS") == 0)
			return (0);
		for (cg = 0; cg < proto.fs_ncg; cg++) {
			bflag = fsbtodb(&proto, cgsblock(&proto, cg));
			if (readsb(0) != 0)
				break;
		}
		if (cg >= proto.fs_ncg) {
			printf("%s %s\n%s %s\n%s %s\n",
				"SEARCH FOR ALTERNATE SUPER-BLOCK",
				"FAILED. YOU MUST USE THE",
				"-b OPTION TO FSCK TO SPECIFY THE",
				"LOCATION OF AN ALTERNATE",
				"SUPER-BLOCK TO SUPPLY NEEDED",
				"INFORMATION; SEE fsck(8).");
			return(0);
		}
		pwarn("USING ALTERNATE SUPERBLOCK AT %d\n", bflag);
	}
	fmax = sblock.fs_size;
	imax = sblock.fs_ncg * sblock.fs_ipg;
	/*
	 * Check and potentially fix certain fields in the super block.
	 */
	if (sblock.fs_optim != FS_OPTTIME && sblock.fs_optim != FS_OPTSPACE) {
		pfatal("UNDEFINED OPTIMIZATION IN SUPERBLOCK");
		if (reply("SET TO DEFAULT") == 1) {
			sblock.fs_optim = FS_OPTTIME;
			sbdirty();
		}
	}
	if ((sblock.fs_minfree < 0 || sblock.fs_minfree > 99)) {
		pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
			sblock.fs_minfree);
		if (reply("SET TO DEFAULT") == 1) {
			sblock.fs_minfree = 10;
			sbdirty();
		}
	}
	if (sblock.fs_interleave < 1) {
			sblock.fs_interleave);
		sblock.fs_interleave = 1;
			sbdirty();
			dirty(&asblk);
		}
	}
	if (sblock.fs_npsect < sblock.fs_nsect) {
			sblock.fs_npsect);
		sblock.fs_npsect = sblock.fs_nsect;
			sbdirty();
			dirty(&asblk);
		}
	}
	if (cvtflag) {
		if (sblock.fs_postblformat == FS_42POSTBLFMT) {
			/*
			 * Requested to convert from old format to new format
			 */
			if (preen)
				pwarn("CONVERTING TO NEW FILE SYSTEM FORMAT\n");
			else if (!reply("CONVERT TO NEW FILE SYSTEM FORMAT"))
				return(0);
			sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT;
			sblock.fs_nrpos = 8;
			sblock.fs_postbloff =
			    (char *)(&sblock.fs_opostbl[0][0]) -
			    (char *)(&sblock.fs_link);
			sblock.fs_rotbloff = &sblock.fs_space[0] -
			    (u_char *)(&sblock.fs_link);
			/*
			 * Planning now for future expansion.
			 */
#			if (BYTE_ORDER == BIG_ENDIAN)
				sblock.fs_qbmask.val[0] = 0;
				sblock.fs_qbmask.val[1] = ~sblock.fs_bmask;
				sblock.fs_qfmask.val[0] = 0;
				sblock.fs_qfmask.val[1] = ~sblock.fs_fmask;
#			endif /* BIG_ENDIAN */
#			if (BYTE_ORDER == LITTLE_ENDIAN)
				sblock.fs_qbmask.val[0] = ~sblock.fs_bmask;
				sblock.fs_qbmask.val[1] = 0;
				sblock.fs_qfmask.val[0] = ~sblock.fs_fmask;
				sblock.fs_qfmask.val[1] = 0;
#			endif /* LITTLE_ENDIAN */
			sbdirty();
			dirty(&asblk);
		} else if (sblock.fs_postblformat == FS_DYNAMICPOSTBLFMT) {
			/*
			 * Requested to convert from new format to old format
			 */
			if (sblock.fs_nrpos != 8 || sblock.fs_ipg > 2048 ||
			    sblock.fs_cpg > 32 || sblock.fs_cpc > 16) {
				printf(
				"PARAMETERS OF CURRENT FILE SYSTEM DO NOT\n\t");
				errexit(
				"ALLOW CONVERSION TO OLD FILE SYSTEM FORMAT\n");
			}
			if (preen)
				pwarn("CONVERTING TO OLD FILE SYSTEM FORMAT\n");
			else if (!reply("CONVERT TO OLD FILE SYSTEM FORMAT"))
				return(0);
			sblock.fs_postblformat = FS_42POSTBLFMT;
			sbdirty();
			dirty(&asblk);
		} else {
			errexit("UNKNOWN FILE SYSTEM FORMAT\n");
		}
	}
	if (asblk.b_dirty) {
		bcopy((char *)&sblock, (char *)&altsblock, sblock.fs_sbsize);
		flush(&dfile, &asblk);
	}
	/*
	 * read in the summary info.
	 */
	asked = 0;
	for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
		size = sblock.fs_cssize - i < sblock.fs_bsize ?
		    sblock.fs_cssize - i : sblock.fs_bsize;
		sblock.fs_csp[j] = (struct csum *)calloc(1, (unsigned)size);
		if (bread(&dfile, (char *)sblock.fs_csp[j],
		    fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
		    size) != 0 && !asked) {
			pfatal("BAD SUMMARY INFORMATION");
			if (reply("CONTINUE") == 0)
				errexit("");
			asked++;
		}
	}
	/*
	 * allocate and initialize the necessary maps
	 */
	bmapsz = roundup(howmany(fmax, NBBY), sizeof(short));
	blockmap = calloc((unsigned)bmapsz, sizeof (char));
	if (blockmap == NULL) {
		printf("cannot alloc %d bytes for blockmap\n", bmapsz);
		goto badsb;
	}
	statemap = calloc((unsigned)(imax + 1), sizeof(char));
	if (statemap == NULL) {
		printf("cannot alloc %d bytes for statemap\n", imax + 1);
		goto badsb;
	}
	lncntp = (short *)calloc((unsigned)(imax + 1), sizeof(short));
	if (lncntp == NULL) {
		printf("cannot alloc %d bytes for lncntp\n", 
		    (imax + 1) * sizeof(short));
		goto badsb;
	}

	bufinit();
	return (1);

badsb:
	ckfini();
	return (0);
}

/*
 * Read in the super block and its summary info.
 */
readsb(listerr)
	int listerr;
{
	off_t sboff;
	daddr_t super = bflag ? bflag : SBOFF / dev_bsize;

	if (bread(&dfile, (char *)&sblock, super, (long)SBSIZE) != 0)
		return (0);
	sblk.b_bno = super;
	sblk.b_size = SBSIZE;
	/*
	 * run a few consistency checks of the super block
	 */
	if (sblock.fs_magic != FS_MAGIC)
		{ badsb(listerr, "MAGIC NUMBER WRONG"); return (0); }
	if (sblock.fs_ncg < 1)
		{ badsb(listerr, "NCG OUT OF RANGE"); return (0); }
	if (sblock.fs_cpg < 1)
		{ badsb(listerr, "CPG OUT OF RANGE"); return (0); }
	if (sblock.fs_ncg * sblock.fs_cpg < sblock.fs_ncyl ||
	    (sblock.fs_ncg - 1) * sblock.fs_cpg >= sblock.fs_ncyl)
		{ badsb(listerr, "NCYL LESS THAN NCG*CPG"); return (0); }
	if (sblock.fs_sbsize > SBSIZE)
		{ badsb(listerr, "SIZE PREPOSTEROUSLY LARGE"); return (0); }
	/*
	 * Compute block size that the filesystem is based on,
	 * according to fsbtodb, and adjust superblock block number
	 * so we can tell if this is an alternate later.
	 */
	super *= dev_bsize;
	dev_bsize = sblock.fs_fsize / fsbtodb(&sblock, 1);
	sblk.b_bno = super / dev_bsize;
	/*
	 * Set all possible fields that could differ, then do check
	 * of whole super block against an alternate super block.
	 * When an alternate super-block is specified this check is skipped.
	 */
	getblk(&asblk, cgsblock(&sblock, sblock.fs_ncg - 1), sblock.fs_sbsize);
	if (asblk.b_errs != NULL)
		return (0);
	if (bflag) {
		havesb = 1;
		return (1);
	}
	altsblock.fs_link = sblock.fs_link;
	altsblock.fs_rlink = sblock.fs_rlink;
	altsblock.fs_time = sblock.fs_time;
	altsblock.fs_cstotal = sblock.fs_cstotal;
	altsblock.fs_cgrotor = sblock.fs_cgrotor;
	altsblock.fs_fmod = sblock.fs_fmod;
	altsblock.fs_clean = sblock.fs_clean;
	altsblock.fs_ronly = sblock.fs_ronly;
	altsblock.fs_flags = sblock.fs_flags;
	altsblock.fs_maxcontig = sblock.fs_maxcontig;
	altsblock.fs_minfree = sblock.fs_minfree;
	altsblock.fs_optim = sblock.fs_optim;
	altsblock.fs_rotdelay = sblock.fs_rotdelay;
	altsblock.fs_maxbpg = sblock.fs_maxbpg;
	bcopy((char *)sblock.fs_csp, (char *)altsblock.fs_csp,
		sizeof sblock.fs_csp);
	bcopy((char *)sblock.fs_fsmnt, (char *)altsblock.fs_fsmnt,
		sizeof sblock.fs_fsmnt);
	bcopy((char *)sblock.fs_sparecon, (char *)altsblock.fs_sparecon,
		sizeof sblock.fs_sparecon);
	/*
	 * The following should not have to be copied.
	 */
	altsblock.fs_fsbtodb = sblock.fs_fsbtodb;
	altsblock.fs_interleave = sblock.fs_interleave;
	altsblock.fs_npsect = sblock.fs_npsect;
	altsblock.fs_nrpos = sblock.fs_nrpos;
	if (bcmp((char *)&sblock, (char *)&altsblock, (int)sblock.fs_sbsize)) {
		badsb(listerr,
		"VALUES IN SUPER BLOCK DISAGREE WITH THOSE IN FIRST ALTERNATE");
		return (0);
	}
	havesb = 1;
	return (1);
}

badsb(listerr, s)
	int listerr;
	char *s;
{

	if (!listerr)
		return;
	if (preen)
		printf("%s: ", devname);
	pfatal("BAD SUPER BLOCK: %s\n", s);
}

/*
 * Calculate a prototype superblock based on information in the disk label.
 * When done the cgsblock macro can be calculated and the fs_ncg field
 * can be used. Do NOT attempt to use other macros without verifying that
 * their needed information is available!
 */
calcsb(dev, devfd, fs)
	char *dev;
	int devfd;
	register struct fs *fs;
{
	register struct disklabel *lp;
	register struct partition *pp;
	register char *cp;
	int i;
	struct disklabel *getdisklabel();

	cp = index(dev, '\0') - 1;
	if (cp == (char *)-1 || (*cp < 'a' || *cp > 'h') && !isdigit(*cp)) {
		pfatal("%s: CANNOT FIGURE OUT FILE SYSTEM PARTITION\n", dev);
		return (0);
	}
	lp = getdisklabel(dev, devfd);
	if (isdigit(*cp))
		pp = &lp->d_partitions[0];
	else
		pp = &lp->d_partitions[*cp - 'a'];
	if (pp->p_fstype != FS_BSDFFS) {
		pfatal("%s: NOT LABELED AS A BSD FILE SYSTEM (%s)\n",
			dev, pp->p_fstype < FSMAXTYPES ?
			fstypenames[pp->p_fstype] : "unknown");
		return (0);
	}
	bzero(fs, sizeof(struct fs));
	fs->fs_fsize = pp->p_fsize;
	fs->fs_frag = pp->p_frag;
	fs->fs_cpg = pp->p_cpg;
	fs->fs_size = pp->p_size;
	fs->fs_ntrak = lp->d_ntracks;
	fs->fs_nsect = lp->d_nsectors;
	fs->fs_spc = lp->d_secpercyl;
	fs->fs_nspf = fs->fs_fsize / lp->d_secsize;
	fs->fs_sblkno = roundup(
		howmany(lp->d_bbsize + lp->d_sbsize, fs->fs_fsize),
		fs->fs_frag);
	fs->fs_cgmask = 0xffffffff;
	for (i = fs->fs_ntrak; i > 1; i >>= 1)
		fs->fs_cgmask <<= 1;
	if (!POWEROF2(fs->fs_ntrak))
		fs->fs_cgmask <<= 1;
	fs->fs_cgoffset = roundup(
		howmany(fs->fs_nsect, NSPF(fs)), fs->fs_frag);
	fs->fs_fpg = (fs->fs_cpg * fs->fs_spc) / NSPF(fs);
	fs->fs_ncg = howmany(fs->fs_size / fs->fs_spc, fs->fs_cpg);
	for (fs->fs_fsbtodb = 0, i = NSPF(fs); i > 1; i >>= 1)
		fs->fs_fsbtodb++;
	dev_bsize = lp->d_secsize;
	return (1);
}

struct disklabel *
getdisklabel(s, fd)
	char *s;
	int	fd;
{
	static struct disklabel lab;

	if (ioctl(fd, DIOCGDINFO, (char *)&lab) < 0) {
		if (s == NULL)
			return ((struct disklabel *)NULL);
		pwarn("");
		perror("ioctl (GDINFO)");
		errexit("%s: can't read disk label", s);
	}
	return (&lab);
}
Commit	Line	Data
76797561 DF	1	/*
	2	* Copyright (c) 1980 Regents of the University of California.
	3	* All rights reserved. The Berkeley software License Agreement
	4	* specifies the terms and conditions for redistribution.
	5	*/
	6
eb93b62a	7	#ifndef lint
adc5a10c	8	static char sccsid[] = "@(#)setup.c 5.19 (Berkeley) %G%";
76797561	9	#endif not lint
eb93b62a	10
c7aed003	11	#define DKTYPENAMES
eb93b62a KM	12	#include <sys/param.h>
	13	#include <sys/inode.h>
	14	#include <sys/fs.h>
	15	#include <sys/stat.h>
c7aed003 KM	16	#include <sys/ioctl.h>
	17	#include <sys/disklabel.h>
	18	#include <sys/file.h>
7beeecfc	19	#include <machine/endian.h>
c7aed003	20	#include <ctype.h>
eb93b62a KM	21	#include "fsck.h"
eb93b62a KM	22
7beeecfc	23	BUFAREA asblk;
adc5a10c	24	#define altsblock (*asblk.b_un.b_fs)
c7aed003 KM	25	#define POWEROF2(num) (((num) & ((num) - 1)) == 0)
c7aed003 KM	26
eb93b62a	27	char *calloc();
c7aed003	28	char *index();
eb93b62a KM	29
	30	setup(dev)
	31	char *dev;
	32	{
	33	dev_t rootdev;
05d069d3	34	long cg, ncg, size, asked, i, j;
55f8bbd7	35	struct disklabel getdisklabel(), lp;
eb93b62a	36	struct stat statb;
c7aed003	37	struct fs proto;
eb93b62a	38
55f8bbd7	39	havesb = 0;
eb93b62a KM	40	if (stat("/", &statb) < 0)
	41	errexit("Can't stat root\n");
	42	rootdev = statb.st_dev;
	43	if (stat(dev, &statb) < 0) {
cfbff64d	44	perror(dev);
7718c0e6	45	printf("Can't stat %s\n", dev);
eb93b62a KM	46	return (0);
	47	}
	48	rawflg = 0;
	49	if ((statb.st_mode & S_IFMT) == S_IFBLK)
	50	;
	51	else if ((statb.st_mode & S_IFMT) == S_IFCHR)
	52	rawflg++;
	53	else {
	54	if (reply("file is not a block or character device; OK") == 0)
	55	return (0);
	56	}
	57	if (rootdev == statb.st_rdev)
	58	hotroot++;
c7aed003	59	if ((dfile.rfdes = open(dev, O_RDONLY)) < 0) {
cfbff64d	60	perror(dev);
7718c0e6	61	printf("Can't open %s\n", dev);
eb93b62a KM	62	return (0);
	63	}
	64	if (preen == 0)
	65	printf("** %s", dev);
c7aed003	66	if (nflag \|\| (dfile.wfdes = open(dev, O_WRONLY)) < 0) {
eb93b62a KM	67	dfile.wfdes = -1;
	68	if (preen)
	69	pfatal("NO WRITE ACCESS");
	70	printf(" (NO WRITE)");
	71	}
	72	if (preen == 0)
	73	printf("\n");
eb93b62a	74	dfile.mod = 0;
eb93b62a	75	lfdir = 0;
eb93b62a	76	initbarea(&sblk);
7beeecfc	77	initbarea(&asblk);
adc5a10c KM	78	sblk.b_un.b_buf = (char *)malloc(SBSIZE);
	79	asblk.b_un.b_buf = (char *)malloc(SBSIZE);
	80	if (sblk.b_un.b_buf == 0 \|\| asblk.b_un.b_buf == 0)
	81	errexit("cannot allocate space for superblock\n");
55f8bbd7 MK	82	if (lp = getdisklabel((char *)NULL, dfile.rfdes))
55f8bbd7 MK	83	dev_bsize = secsize = lp->d_secsize;
7beeecfc KM	84	else
7beeecfc KM	85	dev_bsize = secsize = DEV_BSIZE;
eb93b62a	86	/*
c7aed003	87	* Read in the superblock, looking for alternates if necessary
eb93b62a	88	*/
c7aed003	89	if (readsb(1) == 0) {
55f8bbd7	90	if (bflag \|\| preen \|\| calcsb(dev, dfile.rfdes, &proto) == 0)
c7aed003 KM	91	return(0);
	92	if (reply("LOOK FOR ALTERNATE SUPERBLOCKS") == 0)
	93	return (0);
	94	for (cg = 0; cg < proto.fs_ncg; cg++) {
	95	bflag = fsbtodb(&proto, cgsblock(&proto, cg));
	96	if (readsb(0) != 0)
	97	break;
	98	}
	99	if (cg >= proto.fs_ncg) {
	100	printf("%s %s\n%s %s\n%s %s\n",
	101	"SEARCH FOR ALTERNATE SUPER-BLOCK",
	102	"FAILED. YOU MUST USE THE",
	103	"-b OPTION TO FSCK TO SPECIFY THE",
	104	"LOCATION OF AN ALTERNATE",
	105	"SUPER-BLOCK TO SUPPLY NEEDED",
	106	"INFORMATION; SEE fsck(8).");
	107	return(0);
	108	}
	109	pwarn("USING ALTERNATE SUPERBLOCK AT %d\n", bflag);
	110	}
	111	fmax = sblock.fs_size;
	112	imax = sblock.fs_ncg * sblock.fs_ipg;
d9f38d60 KM	113	/*
	114	* Check and potentially fix certain fields in the super block.
	115	*/
	116	if (sblock.fs_optim != FS_OPTTIME && sblock.fs_optim != FS_OPTSPACE) {
	117	pfatal("UNDEFINED OPTIMIZATION IN SUPERBLOCK");
	118	if (reply("SET TO DEFAULT") == 1) {
	119	sblock.fs_optim = FS_OPTTIME;
	120	sbdirty();
	121	}
	122	}
	123	if ((sblock.fs_minfree < 0 \|\| sblock.fs_minfree > 99)) {
	124	pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
	125	sblock.fs_minfree);
	126	if (reply("SET TO DEFAULT") == 1) {
	127	sblock.fs_minfree = 10;
	128	sbdirty();
	129	}
	130	}
d4af1a46	131	if (sblock.fs_interleave < 1) {
d4af1a46	132	sblock.fs_interleave);
43171015	133	sblock.fs_interleave = 1;
d4af1a46	134	sbdirty();
7beeecfc KM	135	dirty(&asblk);
7beeecfc KM	136	}
d4af1a46 KM	137	}
d4af1a46 KM	138	if (sblock.fs_npsect < sblock.fs_nsect) {
d4af1a46	139	sblock.fs_npsect);
43171015	140	sblock.fs_npsect = sblock.fs_nsect;
d4af1a46	141	sbdirty();
7beeecfc KM	142	dirty(&asblk);
	143	}
	144	}
a747b5d4 KM	145	if (cvtflag) {
	146	if (sblock.fs_postblformat == FS_42POSTBLFMT) {
	147	/*
	148	* Requested to convert from old format to new format
	149	*/
	150	if (preen)
	151	pwarn("CONVERTING TO NEW FILE SYSTEM FORMAT\n");
	152	else if (!reply("CONVERT TO NEW FILE SYSTEM FORMAT"))
	153	return(0);
7beeecfc KM	154	sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT;
	155	sblock.fs_nrpos = 8;
	156	sblock.fs_postbloff =
	157	(char *)(&sblock.fs_opostbl[0][0]) -
	158	(char *)(&sblock.fs_link);
	159	sblock.fs_rotbloff = &sblock.fs_space[0] -
	160	(u_char *)(&sblock.fs_link);
	161	/*
	162	* Planning now for future expansion.
	163	*/
	164	# if (BYTE_ORDER == BIG_ENDIAN)
	165	sblock.fs_qbmask.val[0] = 0;
	166	sblock.fs_qbmask.val[1] = ~sblock.fs_bmask;
	167	sblock.fs_qfmask.val[0] = 0;
	168	sblock.fs_qfmask.val[1] = ~sblock.fs_fmask;
	169	# endif /* BIG_ENDIAN */
	170	# if (BYTE_ORDER == LITTLE_ENDIAN)
	171	sblock.fs_qbmask.val[0] = ~sblock.fs_bmask;
	172	sblock.fs_qbmask.val[1] = 0;
	173	sblock.fs_qfmask.val[0] = ~sblock.fs_fmask;
	174	sblock.fs_qfmask.val[1] = 0;
	175	# endif /* LITTLE_ENDIAN */
	176	sbdirty();
	177	dirty(&asblk);
a747b5d4 KM	178	} else if (sblock.fs_postblformat == FS_DYNAMICPOSTBLFMT) {
	179	/*
	180	* Requested to convert from new format to old format
	181	*/
	182	if (sblock.fs_nrpos != 8 \|\| sblock.fs_ipg > 2048 \|\|
	183	sblock.fs_cpg > 32 \|\| sblock.fs_cpc > 16) {
	184	printf(
	185	"PARAMETERS OF CURRENT FILE SYSTEM DO NOT\n\t");
	186	errexit(
	187	"ALLOW CONVERSION TO OLD FILE SYSTEM FORMAT\n");
	188	}
	189	if (preen)
	190	pwarn("CONVERTING TO OLD FILE SYSTEM FORMAT\n");
	191	else if (!reply("CONVERT TO OLD FILE SYSTEM FORMAT"))
	192	return(0);
	193	sblock.fs_postblformat = FS_42POSTBLFMT;
	194	sbdirty();
	195	dirty(&asblk);
	196	} else {
	197	errexit("UNKNOWN FILE SYSTEM FORMAT\n");
7beeecfc	198	}
7beeecfc KM	199	}
	200	if (asblk.b_dirty) {
	201	bcopy((char )&sblock, (char )&altsblock, sblock.fs_sbsize);
	202	flush(&dfile, &asblk);
d4af1a46	203	}
eb93b62a KM	204	/*
	205	* read in the summary info.
	206	*/
05d069d3	207	asked = 0;
eb93b62a KM	208	for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
	209	size = sblock.fs_cssize - i < sblock.fs_bsize ?
	210	sblock.fs_cssize - i : sblock.fs_bsize;
	211	sblock.fs_csp[j] = (struct csum *)calloc(1, (unsigned)size);
	212	if (bread(&dfile, (char *)sblock.fs_csp[j],
	213	fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
05d069d3 KM	214	size) != 0 && !asked) {
	215	pfatal("BAD SUMMARY INFORMATION");
	216	if (reply("CONTINUE") == 0)
	217	errexit("");
	218	asked++;
	219	}
eb93b62a KM	220	}
	221	/*
	222	* allocate and initialize the necessary maps
	223	*/
	224	bmapsz = roundup(howmany(fmax, NBBY), sizeof(short));
	225	blockmap = calloc((unsigned)bmapsz, sizeof (char));
	226	if (blockmap == NULL) {
	227	printf("cannot alloc %d bytes for blockmap\n", bmapsz);
	228	goto badsb;
	229	}
eb93b62a KM	230	statemap = calloc((unsigned)(imax + 1), sizeof(char));
	231	if (statemap == NULL) {
	232	printf("cannot alloc %d bytes for statemap\n", imax + 1);
	233	goto badsb;
	234	}
	235	lncntp = (short *)calloc((unsigned)(imax + 1), sizeof(short));
	236	if (lncntp == NULL) {
	237	printf("cannot alloc %d bytes for lncntp\n",
	238	(imax + 1) * sizeof(short));
	239	goto badsb;
	240	}
eb93b62a	241
adc5a10c	242	bufinit();
eb93b62a KM	243	return (1);
	244
	245	badsb:
	246	ckfini();
	247	return (0);
c7aed003 KM	248	}
	249
	250	/*
	251	* Read in the super block and its summary info.
	252	*/
	253	readsb(listerr)
	254	int listerr;
	255	{
55f8bbd7 MK	256	off_t sboff;
55f8bbd7 MK	257	daddr_t super = bflag ? bflag : SBOFF / dev_bsize;
c7aed003	258
c7aed003 KM	259	if (bread(&dfile, (char *)&sblock, super, (long)SBSIZE) != 0)
	260	return (0);
	261	sblk.b_bno = super;
	262	sblk.b_size = SBSIZE;
	263	/*
	264	* run a few consistency checks of the super block
	265	*/
	266	if (sblock.fs_magic != FS_MAGIC)
	267	{ badsb(listerr, "MAGIC NUMBER WRONG"); return (0); }
	268	if (sblock.fs_ncg < 1)
	269	{ badsb(listerr, "NCG OUT OF RANGE"); return (0); }
7beeecfc	270	if (sblock.fs_cpg < 1)
c7aed003 KM	271	{ badsb(listerr, "CPG OUT OF RANGE"); return (0); }
	272	if (sblock.fs_ncg * sblock.fs_cpg < sblock.fs_ncyl \|\|
	273	(sblock.fs_ncg - 1) * sblock.fs_cpg >= sblock.fs_ncyl)
	274	{ badsb(listerr, "NCYL LESS THAN NCG*CPG"); return (0); }
	275	if (sblock.fs_sbsize > SBSIZE)
	276	{ badsb(listerr, "SIZE PREPOSTEROUSLY LARGE"); return (0); }
55f8bbd7 MK	277	/*
	278	* Compute block size that the filesystem is based on,
	279	* according to fsbtodb, and adjust superblock block number
	280	* so we can tell if this is an alternate later.
	281	*/
55f8bbd7 MK	282	super *= dev_bsize;
	283	dev_bsize = sblock.fs_fsize / fsbtodb(&sblock, 1);
	284	sblk.b_bno = super / dev_bsize;
c7aed003 KM	285	/*
	286	* Set all possible fields that could differ, then do check
	287	* of whole super block against an alternate super block.
	288	* When an alternate super-block is specified this check is skipped.
	289	*/
7beeecfc KM	290	getblk(&asblk, cgsblock(&sblock, sblock.fs_ncg - 1), sblock.fs_sbsize);
	291	if (asblk.b_errs != NULL)
	292	return (0);
55f8bbd7 MK	293	if (bflag) {
55f8bbd7 MK	294	havesb = 1;
c7aed003	295	return (1);
55f8bbd7	296	}
c7aed003 KM	297	altsblock.fs_link = sblock.fs_link;
	298	altsblock.fs_rlink = sblock.fs_rlink;
	299	altsblock.fs_time = sblock.fs_time;
	300	altsblock.fs_cstotal = sblock.fs_cstotal;
	301	altsblock.fs_cgrotor = sblock.fs_cgrotor;
	302	altsblock.fs_fmod = sblock.fs_fmod;
	303	altsblock.fs_clean = sblock.fs_clean;
	304	altsblock.fs_ronly = sblock.fs_ronly;
	305	altsblock.fs_flags = sblock.fs_flags;
	306	altsblock.fs_maxcontig = sblock.fs_maxcontig;
	307	altsblock.fs_minfree = sblock.fs_minfree;
	308	altsblock.fs_optim = sblock.fs_optim;
	309	altsblock.fs_rotdelay = sblock.fs_rotdelay;
	310	altsblock.fs_maxbpg = sblock.fs_maxbpg;
	311	bcopy((char )sblock.fs_csp, (char )altsblock.fs_csp,
	312	sizeof sblock.fs_csp);
	313	bcopy((char )sblock.fs_fsmnt, (char )altsblock.fs_fsmnt,
	314	sizeof sblock.fs_fsmnt);
cfbff64d MK	315	bcopy((char )sblock.fs_sparecon, (char )altsblock.fs_sparecon,
cfbff64d MK	316	sizeof sblock.fs_sparecon);
7beeecfc KM	317	/*
	318	* The following should not have to be copied.
	319	*/
	320	altsblock.fs_fsbtodb = sblock.fs_fsbtodb;
	321	altsblock.fs_interleave = sblock.fs_interleave;
	322	altsblock.fs_npsect = sblock.fs_npsect;
	323	altsblock.fs_nrpos = sblock.fs_nrpos;
cfbff64d MK	324	if (bcmp((char )&sblock, (char )&altsblock, (int)sblock.fs_sbsize)) {
	325	badsb(listerr,
	326	"VALUES IN SUPER BLOCK DISAGREE WITH THOSE IN FIRST ALTERNATE");
	327	return (0);
	328	}
55f8bbd7	329	havesb = 1;
c7aed003	330	return (1);
eb93b62a KM	331	}
eb93b62a KM	332
c7aed003 KM	333	badsb(listerr, s)
c7aed003 KM	334	int listerr;
eb93b62a KM	335	char *s;
	336	{
	337
c7aed003 KM	338	if (!listerr)
c7aed003 KM	339	return;
eb93b62a KM	340	if (preen)
eb93b62a KM	341	printf("%s: ", devname);
c7aed003 KM	342	pfatal("BAD SUPER BLOCK: %s\n", s);
	343	}
	344
	345	/*
	346	* Calculate a prototype superblock based on information in the disk label.
	347	* When done the cgsblock macro can be calculated and the fs_ncg field
	348	* can be used. Do NOT attempt to use other macros without verifying that
	349	* their needed information is available!
	350	*/
	351	calcsb(dev, devfd, fs)
	352	char *dev;
	353	int devfd;
	354	register struct fs *fs;
	355	{
	356	register struct disklabel *lp;
	357	register struct partition *pp;
	358	register char *cp;
c7aed003	359	int i;
f10a0ae9	360	struct disklabel *getdisklabel();
c7aed003 KM	361
	362	cp = index(dev, '\0') - 1;
	363	if (cp == (char )-1 \|\| (cp < 'a' \|\| cp > 'h') && !isdigit(cp)) {
	364	pfatal("%s: CANNOT FIGURE OUT FILE SYSTEM PARTITION\n", dev);
	365	return (0);
	366	}
	367	lp = getdisklabel(dev, devfd);
	368	if (isdigit(*cp))
	369	pp = &lp->d_partitions[0];
	370	else
	371	pp = &lp->d_partitions[*cp - 'a'];
	372	if (pp->p_fstype != FS_BSDFFS) {
55f8bbd7	373	pfatal("%s: NOT LABELED AS A BSD FILE SYSTEM (%s)\n",
c7aed003 KM	374	dev, pp->p_fstype < FSMAXTYPES ?
	375	fstypenames[pp->p_fstype] : "unknown");
	376	return (0);
	377	}
	378	bzero(fs, sizeof(struct fs));
	379	fs->fs_fsize = pp->p_fsize;
	380	fs->fs_frag = pp->p_frag;
	381	fs->fs_cpg = pp->p_cpg;
	382	fs->fs_size = pp->p_size;
	383	fs->fs_ntrak = lp->d_ntracks;
	384	fs->fs_nsect = lp->d_nsectors;
	385	fs->fs_spc = lp->d_secpercyl;
	386	fs->fs_nspf = fs->fs_fsize / lp->d_secsize;
	387	fs->fs_sblkno = roundup(
	388	howmany(lp->d_bbsize + lp->d_sbsize, fs->fs_fsize),
	389	fs->fs_frag);
	390	fs->fs_cgmask = 0xffffffff;
	391	for (i = fs->fs_ntrak; i > 1; i >>= 1)
	392	fs->fs_cgmask <<= 1;
	393	if (!POWEROF2(fs->fs_ntrak))
	394	fs->fs_cgmask <<= 1;
	395	fs->fs_cgoffset = roundup(
	396	howmany(fs->fs_nsect, NSPF(fs)), fs->fs_frag);
	397	fs->fs_fpg = (fs->fs_cpg * fs->fs_spc) / NSPF(fs);
	398	fs->fs_ncg = howmany(fs->fs_size / fs->fs_spc, fs->fs_cpg);
	399	for (fs->fs_fsbtodb = 0, i = NSPF(fs); i > 1; i >>= 1)
	400	fs->fs_fsbtodb++;
55f8bbd7	401	dev_bsize = lp->d_secsize;
c7aed003 KM	402	return (1);
	403	}
	404
c7aed003 KM	405	struct disklabel *
	406	getdisklabel(s, fd)
	407	char *s;
	408	int fd;
	409	{
	410	static struct disklabel lab;
	411
	412	if (ioctl(fd, DIOCGDINFO, (char *)&lab) < 0) {
919c85da MK	413	if (s == NULL)
919c85da MK	414	return ((struct disklabel *)NULL);
cfbff64d	415	pwarn("");
c7aed003	416	perror("ioctl (GDINFO)");
cfbff64d	417	errexit("%s: can't read disk label", s);
c7aed003 KM	418	}
	419	return (&lab);
	420	}