xref: /csrg-svn/sbin/fsck/setup.c (revision 69319)
122054Sdist /*
261492Sbostic  * Copyright (c) 1980, 1986, 1993
361492Sbostic  *	The Regents of the University of California.  All rights reserved.
439976Smckusick  *
542702Sbostic  * %sccs.include.redist.c%
622054Sdist  */
722054Sdist 
816268Smckusick #ifndef lint
9*69319Smckusick static char sccsid[] = "@(#)setup.c	8.10 (Berkeley) 05/09/95";
1039976Smckusick #endif /* not lint */
1116268Smckusick 
1230399Smckusick #define DKTYPENAMES
1316268Smckusick #include <sys/param.h>
1453703Smckusick #include <sys/time.h>
1516268Smckusick #include <sys/stat.h>
1630399Smckusick #include <sys/ioctl.h>
1730399Smckusick #include <sys/disklabel.h>
1830399Smckusick #include <sys/file.h>
1968908Smckusick 
2068908Smckusick #include <ufs/ufs/dinode.h>
2168908Smckusick #include <ufs/ffs/fs.h>
2268908Smckusick 
2368908Smckusick #include <ctype.h>
2468908Smckusick #include <err.h>
2544934Smckusick #include <errno.h>
2644934Smckusick #include <string.h>
2768908Smckusick 
2816268Smckusick #include "fsck.h"
2916268Smckusick 
3039973Smckusick struct bufarea asblk;
3134225Smckusick #define altsblock (*asblk.b_un.b_fs)
3230399Smckusick #define POWEROF2(num)	(((num) & ((num) - 1)) == 0)
3330399Smckusick 
3468908Smckusick static void badsb __P((int listerr, char *s));
3568908Smckusick static int calcsb __P((char *dev, int devfd, struct fs *fs));
3668908Smckusick static struct disklabel *getdisklabel __P((char *s, int fd));
3768908Smckusick static int readsb __P((int listerr));
3816268Smckusick 
39*69319Smckusick /*
40*69319Smckusick  * Read in a superblock finding an alternate if necessary.
41*69319Smckusick  * Return 1 if successful, 0 if unsuccessful, -1 if filesystem
42*69319Smckusick  * is already clean (preen mode only).
43*69319Smckusick  */
4468908Smckusick int
setup(dev)4516268Smckusick setup(dev)
4616268Smckusick 	char *dev;
4716268Smckusick {
4839973Smckusick 	long cg, size, asked, i, j;
49*69319Smckusick 	long skipclean, bmapsize;
5038376Smckusick 	struct disklabel *lp;
5154207Smckusick 	off_t sizepb;
5216268Smckusick 	struct stat statb;
5330399Smckusick 	struct fs proto;
5416268Smckusick 
5530859Skarels 	havesb = 0;
5656809Smckusick 	fswritefd = -1;
57*69319Smckusick 	skipclean = preen;
5816268Smckusick 	if (stat(dev, &statb) < 0) {
5944934Smckusick 		printf("Can't stat %s: %s\n", dev, strerror(errno));
6016268Smckusick 		return (0);
6116268Smckusick 	}
6241418Smckusick 	if ((statb.st_mode & S_IFMT) != S_IFCHR) {
6341418Smckusick 		pfatal("%s is not a character device", dev);
6441418Smckusick 		if (reply("CONTINUE") == 0)
6541418Smckusick 			return (0);
6641418Smckusick 	}
6739973Smckusick 	if ((fsreadfd = open(dev, O_RDONLY)) < 0) {
6844934Smckusick 		printf("Can't open %s: %s\n", dev, strerror(errno));
6916268Smckusick 		return (0);
7016268Smckusick 	}
7116268Smckusick 	if (preen == 0)
7216268Smckusick 		printf("** %s", dev);
7339973Smckusick 	if (nflag || (fswritefd = open(dev, O_WRONLY)) < 0) {
7439973Smckusick 		fswritefd = -1;
7516268Smckusick 		if (preen)
7616268Smckusick 			pfatal("NO WRITE ACCESS");
7716268Smckusick 		printf(" (NO WRITE)");
7816268Smckusick 	}
7916268Smckusick 	if (preen == 0)
8016268Smckusick 		printf("\n");
8139973Smckusick 	fsmodified = 0;
8216268Smckusick 	lfdir = 0;
8316268Smckusick 	initbarea(&sblk);
8434140Smckusick 	initbarea(&asblk);
8538376Smckusick 	sblk.b_un.b_buf = malloc(SBSIZE);
8638376Smckusick 	asblk.b_un.b_buf = malloc(SBSIZE);
8738376Smckusick 	if (sblk.b_un.b_buf == NULL || asblk.b_un.b_buf == NULL)
8868908Smckusick 		errx(EEXIT, "cannot allocate space for superblock");
8968908Smckusick 	if (lp = getdisklabel(NULL, fsreadfd))
9030859Skarels 		dev_bsize = secsize = lp->d_secsize;
9134140Smckusick 	else
9234140Smckusick 		dev_bsize = secsize = DEV_BSIZE;
9316268Smckusick 	/*
9430399Smckusick 	 * Read in the superblock, looking for alternates if necessary
9516268Smckusick 	 */
9630399Smckusick 	if (readsb(1) == 0) {
97*69319Smckusick 		skipclean = 0;
9839973Smckusick 		if (bflag || preen || calcsb(dev, fsreadfd, &proto) == 0)
9930399Smckusick 			return(0);
10030399Smckusick 		if (reply("LOOK FOR ALTERNATE SUPERBLOCKS") == 0)
10130399Smckusick 			return (0);
10230399Smckusick 		for (cg = 0; cg < proto.fs_ncg; cg++) {
10330399Smckusick 			bflag = fsbtodb(&proto, cgsblock(&proto, cg));
10430399Smckusick 			if (readsb(0) != 0)
10530399Smckusick 				break;
10630399Smckusick 		}
10730399Smckusick 		if (cg >= proto.fs_ncg) {
10830399Smckusick 			printf("%s %s\n%s %s\n%s %s\n",
10930399Smckusick 				"SEARCH FOR ALTERNATE SUPER-BLOCK",
11030399Smckusick 				"FAILED. YOU MUST USE THE",
11130399Smckusick 				"-b OPTION TO FSCK TO SPECIFY THE",
11230399Smckusick 				"LOCATION OF AN ALTERNATE",
11330399Smckusick 				"SUPER-BLOCK TO SUPPLY NEEDED",
11430399Smckusick 				"INFORMATION; SEE fsck(8).");
11530399Smckusick 			return(0);
11630399Smckusick 		}
11730399Smckusick 		pwarn("USING ALTERNATE SUPERBLOCK AT %d\n", bflag);
11830399Smckusick 	}
119*69319Smckusick 	if (skipclean && sblock.fs_clean) {
120*69319Smckusick 		pwarn("FILESYSTEM CLEAN; SKIPPING CHECKS\n");
121*69319Smckusick 		return (-1);
122*69319Smckusick 	}
12339973Smckusick 	maxfsblock = sblock.fs_size;
12439973Smckusick 	maxino = sblock.fs_ncg * sblock.fs_ipg;
12516268Smckusick 	/*
12628213Smckusick 	 * Check and potentially fix certain fields in the super block.
12728213Smckusick 	 */
12828213Smckusick 	if (sblock.fs_optim != FS_OPTTIME && sblock.fs_optim != FS_OPTSPACE) {
12928213Smckusick 		pfatal("UNDEFINED OPTIMIZATION IN SUPERBLOCK");
13028213Smckusick 		if (reply("SET TO DEFAULT") == 1) {
13128213Smckusick 			sblock.fs_optim = FS_OPTTIME;
13228213Smckusick 			sbdirty();
13328213Smckusick 		}
13428213Smckusick 	}
13528213Smckusick 	if ((sblock.fs_minfree < 0 || sblock.fs_minfree > 99)) {
13628213Smckusick 		pfatal("IMPOSSIBLE MINFREE=%d IN SUPERBLOCK",
13728213Smckusick 			sblock.fs_minfree);
13828213Smckusick 		if (reply("SET TO DEFAULT") == 1) {
13928213Smckusick 			sblock.fs_minfree = 10;
14028213Smckusick 			sbdirty();
14128213Smckusick 		}
14228213Smckusick 	}
14344941Smckusick 	if (sblock.fs_interleave < 1 ||
14444941Smckusick 	    sblock.fs_interleave > sblock.fs_nsect) {
14530597Smckusick 		pwarn("IMPOSSIBLE INTERLEAVE=%d IN SUPERBLOCK",
14630400Smckusick 			sblock.fs_interleave);
14730586Smckusick 		sblock.fs_interleave = 1;
14830597Smckusick 		if (preen)
14930597Smckusick 			printf(" (FIXED)\n");
15034140Smckusick 		if (preen || reply("SET TO DEFAULT") == 1) {
15130400Smckusick 			sbdirty();
15234140Smckusick 			dirty(&asblk);
15334140Smckusick 		}
15430400Smckusick 	}
15544941Smckusick 	if (sblock.fs_npsect < sblock.fs_nsect ||
15644941Smckusick 	    sblock.fs_npsect > sblock.fs_nsect*2) {
15730597Smckusick 		pwarn("IMPOSSIBLE NPSECT=%d IN SUPERBLOCK",
15830400Smckusick 			sblock.fs_npsect);
15930586Smckusick 		sblock.fs_npsect = sblock.fs_nsect;
16030597Smckusick 		if (preen)
16130597Smckusick 			printf(" (FIXED)\n");
16234140Smckusick 		if (preen || reply("SET TO DEFAULT") == 1) {
16330400Smckusick 			sbdirty();
16434140Smckusick 			dirty(&asblk);
16534140Smckusick 		}
16630400Smckusick 	}
16754504Smckusick 	if (sblock.fs_inodefmt >= FS_44INODEFMT) {
16855290Smckusick 		newinofmt = 1;
16954504Smckusick 	} else {
17054504Smckusick 		sblock.fs_qbmask = ~sblock.fs_bmask;
17154504Smckusick 		sblock.fs_qfmask = ~sblock.fs_fmask;
17255290Smckusick 		newinofmt = 0;
17354504Smckusick 	}
17454504Smckusick 	/*
17554504Smckusick 	 * Convert to new inode format.
17654504Smckusick 	 */
17754504Smckusick 	if (cvtlevel >= 2 && sblock.fs_inodefmt < FS_44INODEFMT) {
17854504Smckusick 		if (preen)
17954504Smckusick 			pwarn("CONVERTING TO NEW INODE FORMAT\n");
18054504Smckusick 		else if (!reply("CONVERT TO NEW INODE FORMAT"))
18154504Smckusick 			return(0);
18254504Smckusick 		doinglevel2++;
18354504Smckusick 		sblock.fs_inodefmt = FS_44INODEFMT;
18454207Smckusick 		sizepb = sblock.fs_bsize;
18554207Smckusick 		sblock.fs_maxfilesize = sblock.fs_bsize * NDADDR - 1;
18654207Smckusick 		for (i = 0; i < NIADDR; i++) {
18754207Smckusick 			sizepb *= NINDIR(&sblock);
18854207Smckusick 			sblock.fs_maxfilesize += sizepb;
18954207Smckusick 		}
19054504Smckusick 		sblock.fs_maxsymlinklen = MAXSYMLINKLEN;
19154207Smckusick 		sblock.fs_qbmask = ~sblock.fs_bmask;
19254207Smckusick 		sblock.fs_qfmask = ~sblock.fs_fmask;
19354504Smckusick 		sbdirty();
19454504Smckusick 		dirty(&asblk);
19554207Smckusick 	}
19654504Smckusick 	/*
19754504Smckusick 	 * Convert to new cylinder group format.
19854504Smckusick 	 */
19954504Smckusick 	if (cvtlevel >= 1 && sblock.fs_postblformat == FS_42POSTBLFMT) {
20054504Smckusick 		if (preen)
20154504Smckusick 			pwarn("CONVERTING TO NEW CYLINDER GROUP FORMAT\n");
20254504Smckusick 		else if (!reply("CONVERT TO NEW CYLINDER GROUP FORMAT"))
20354504Smckusick 			return(0);
20454504Smckusick 		doinglevel1++;
20554504Smckusick 		sblock.fs_postblformat = FS_DYNAMICPOSTBLFMT;
20654504Smckusick 		sblock.fs_nrpos = 8;
20754504Smckusick 		sblock.fs_postbloff =
20854504Smckusick 		    (char *)(&sblock.fs_opostbl[0][0]) -
20967669Smckusick 		    (char *)(&sblock.fs_firstfield);
21054504Smckusick 		sblock.fs_rotbloff = &sblock.fs_space[0] -
21167669Smckusick 		    (u_char *)(&sblock.fs_firstfield);
21254504Smckusick 		sblock.fs_cgsize =
21354504Smckusick 			fragroundup(&sblock, CGSIZE(&sblock));
21454504Smckusick 		sbdirty();
21554504Smckusick 		dirty(&asblk);
21634140Smckusick 	}
21768140Smckusick 	if (asblk.b_dirty && !bflag) {
21868992Sbostic 		memmove(&altsblock, &sblock, (size_t)sblock.fs_sbsize);
21939973Smckusick 		flush(fswritefd, &asblk);
22034140Smckusick 	}
22128213Smckusick 	/*
22216268Smckusick 	 * read in the summary info.
22316268Smckusick 	 */
22433979Smckusick 	asked = 0;
22516268Smckusick 	for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
22616268Smckusick 		size = sblock.fs_cssize - i < sblock.fs_bsize ?
22716268Smckusick 		    sblock.fs_cssize - i : sblock.fs_bsize;
22816268Smckusick 		sblock.fs_csp[j] = (struct csum *)calloc(1, (unsigned)size);
22939973Smckusick 		if (bread(fsreadfd, (char *)sblock.fs_csp[j],
23016268Smckusick 		    fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
23133979Smckusick 		    size) != 0 && !asked) {
23233979Smckusick 			pfatal("BAD SUMMARY INFORMATION");
23333979Smckusick 			if (reply("CONTINUE") == 0)
23468908Smckusick 				exit(EEXIT);
23533979Smckusick 			asked++;
23633979Smckusick 		}
23716268Smckusick 	}
23816268Smckusick 	/*
23916268Smckusick 	 * allocate and initialize the necessary maps
24016268Smckusick 	 */
24139973Smckusick 	bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(short));
24239973Smckusick 	blockmap = calloc((unsigned)bmapsize, sizeof (char));
24316268Smckusick 	if (blockmap == NULL) {
24444934Smckusick 		printf("cannot alloc %u bytes for blockmap\n",
24544934Smckusick 		    (unsigned)bmapsize);
24616268Smckusick 		goto badsb;
24716268Smckusick 	}
24839973Smckusick 	statemap = calloc((unsigned)(maxino + 1), sizeof(char));
24916268Smckusick 	if (statemap == NULL) {
25044934Smckusick 		printf("cannot alloc %u bytes for statemap\n",
25144934Smckusick 		    (unsigned)(maxino + 1));
25216268Smckusick 		goto badsb;
25316268Smckusick 	}
25454504Smckusick 	typemap = calloc((unsigned)(maxino + 1), sizeof(char));
25554504Smckusick 	if (typemap == NULL) {
25654504Smckusick 		printf("cannot alloc %u bytes for typemap\n",
25754504Smckusick 		    (unsigned)(maxino + 1));
25854504Smckusick 		goto badsb;
25954504Smckusick 	}
26039973Smckusick 	lncntp = (short *)calloc((unsigned)(maxino + 1), sizeof(short));
26116268Smckusick 	if (lncntp == NULL) {
26244934Smckusick 		printf("cannot alloc %u bytes for lncntp\n",
26344934Smckusick 		    (unsigned)(maxino + 1) * sizeof(short));
26416268Smckusick 		goto badsb;
26516268Smckusick 	}
26640020Smckusick 	numdirs = sblock.fs_cstotal.cs_ndir;
26740360Smckusick 	inplast = 0;
26840020Smckusick 	listmax = numdirs + 10;
26940020Smckusick 	inpsort = (struct inoinfo **)calloc((unsigned)listmax,
27040020Smckusick 	    sizeof(struct inoinfo *));
27140020Smckusick 	inphead = (struct inoinfo **)calloc((unsigned)numdirs,
27240020Smckusick 	    sizeof(struct inoinfo *));
27340020Smckusick 	if (inpsort == NULL || inphead == NULL) {
27444934Smckusick 		printf("cannot alloc %u bytes for inphead\n",
27544934Smckusick 		    (unsigned)numdirs * sizeof(struct inoinfo *));
27640020Smckusick 		goto badsb;
27740020Smckusick 	}
27834225Smckusick 	bufinit();
27916268Smckusick 	return (1);
28016268Smckusick 
28116268Smckusick badsb:
282*69319Smckusick 	ckfini(0);
28316268Smckusick 	return (0);
28430399Smckusick }
28530399Smckusick 
28630399Smckusick /*
28730399Smckusick  * Read in the super block and its summary info.
28830399Smckusick  */
28968908Smckusick static int
readsb(listerr)29030399Smckusick readsb(listerr)
29130399Smckusick 	int listerr;
29230399Smckusick {
29368548Smckusick 	ufs_daddr_t super = bflag ? bflag : SBOFF / dev_bsize;
29430399Smckusick 
29539973Smckusick 	if (bread(fsreadfd, (char *)&sblock, super, (long)SBSIZE) != 0)
29630399Smckusick 		return (0);
29730399Smckusick 	sblk.b_bno = super;
29830399Smckusick 	sblk.b_size = SBSIZE;
29930399Smckusick 	/*
30030399Smckusick 	 * run a few consistency checks of the super block
30130399Smckusick 	 */
30230399Smckusick 	if (sblock.fs_magic != FS_MAGIC)
30330399Smckusick 		{ badsb(listerr, "MAGIC NUMBER WRONG"); return (0); }
30430399Smckusick 	if (sblock.fs_ncg < 1)
30530399Smckusick 		{ badsb(listerr, "NCG OUT OF RANGE"); return (0); }
30634140Smckusick 	if (sblock.fs_cpg < 1)
30730399Smckusick 		{ badsb(listerr, "CPG OUT OF RANGE"); return (0); }
30830399Smckusick 	if (sblock.fs_ncg * sblock.fs_cpg < sblock.fs_ncyl ||
30930399Smckusick 	    (sblock.fs_ncg - 1) * sblock.fs_cpg >= sblock.fs_ncyl)
31030399Smckusick 		{ badsb(listerr, "NCYL LESS THAN NCG*CPG"); return (0); }
31130399Smckusick 	if (sblock.fs_sbsize > SBSIZE)
31230399Smckusick 		{ badsb(listerr, "SIZE PREPOSTEROUSLY LARGE"); return (0); }
31330399Smckusick 	/*
31430859Skarels 	 * Compute block size that the filesystem is based on,
31530859Skarels 	 * according to fsbtodb, and adjust superblock block number
31630859Skarels 	 * so we can tell if this is an alternate later.
31730859Skarels 	 */
31830859Skarels 	super *= dev_bsize;
31930859Skarels 	dev_bsize = sblock.fs_fsize / fsbtodb(&sblock, 1);
32030859Skarels 	sblk.b_bno = super / dev_bsize;
32153613Smckusick 	if (bflag) {
32253613Smckusick 		havesb = 1;
32353613Smckusick 		return (1);
32453613Smckusick 	}
32530859Skarels 	/*
32630399Smckusick 	 * Set all possible fields that could differ, then do check
32730399Smckusick 	 * of whole super block against an alternate super block.
32830399Smckusick 	 * When an alternate super-block is specified this check is skipped.
32930399Smckusick 	 */
33034140Smckusick 	getblk(&asblk, cgsblock(&sblock, sblock.fs_ncg - 1), sblock.fs_sbsize);
33138376Smckusick 	if (asblk.b_errs)
33234140Smckusick 		return (0);
33368140Smckusick 	altsblock.fs_firstfield = sblock.fs_firstfield;
33468140Smckusick 	altsblock.fs_unused_1 = sblock.fs_unused_1;
33530399Smckusick 	altsblock.fs_time = sblock.fs_time;
33630399Smckusick 	altsblock.fs_cstotal = sblock.fs_cstotal;
33730399Smckusick 	altsblock.fs_cgrotor = sblock.fs_cgrotor;
33830399Smckusick 	altsblock.fs_fmod = sblock.fs_fmod;
33930399Smckusick 	altsblock.fs_clean = sblock.fs_clean;
34030399Smckusick 	altsblock.fs_ronly = sblock.fs_ronly;
34130399Smckusick 	altsblock.fs_flags = sblock.fs_flags;
34230399Smckusick 	altsblock.fs_maxcontig = sblock.fs_maxcontig;
34330399Smckusick 	altsblock.fs_minfree = sblock.fs_minfree;
34430399Smckusick 	altsblock.fs_optim = sblock.fs_optim;
34530399Smckusick 	altsblock.fs_rotdelay = sblock.fs_rotdelay;
34630399Smckusick 	altsblock.fs_maxbpg = sblock.fs_maxbpg;
34768992Sbostic 	memmove(altsblock.fs_csp, sblock.fs_csp, sizeof sblock.fs_csp);
34867986Smckusick 	altsblock.fs_maxcluster = sblock.fs_maxcluster;
34968992Sbostic 	memmove(altsblock.fs_fsmnt, sblock.fs_fsmnt, sizeof sblock.fs_fsmnt);
35068992Sbostic 	memmove(altsblock.fs_sparecon,
35168992Sbostic 		sblock.fs_sparecon, sizeof sblock.fs_sparecon);
35234140Smckusick 	/*
35334140Smckusick 	 * The following should not have to be copied.
35434140Smckusick 	 */
35534140Smckusick 	altsblock.fs_fsbtodb = sblock.fs_fsbtodb;
35634140Smckusick 	altsblock.fs_interleave = sblock.fs_interleave;
35734140Smckusick 	altsblock.fs_npsect = sblock.fs_npsect;
35834140Smckusick 	altsblock.fs_nrpos = sblock.fs_nrpos;
35967103Smckusick 	altsblock.fs_state = sblock.fs_state;
36054023Smckusick 	altsblock.fs_qbmask = sblock.fs_qbmask;
36154023Smckusick 	altsblock.fs_qfmask = sblock.fs_qfmask;
36254023Smckusick 	altsblock.fs_state = sblock.fs_state;
36354023Smckusick 	altsblock.fs_maxfilesize = sblock.fs_maxfilesize;
36468992Sbostic 	if (memcmp(&sblock, &altsblock, (int)sblock.fs_sbsize)) {
36567986Smckusick 		if (debug) {
36667986Smckusick 			long *nlp, *olp, *endlp;
36767986Smckusick 
36867986Smckusick 			printf("superblock mismatches\n");
36967986Smckusick 			nlp = (long *)&altsblock;
37067986Smckusick 			olp = (long *)&sblock;
37167986Smckusick 			endlp = olp + (sblock.fs_sbsize / sizeof *olp);
37267986Smckusick 			for ( ; olp < endlp; olp++, nlp++) {
37367986Smckusick 				if (*olp == *nlp)
37467986Smckusick 					continue;
37567986Smckusick 				printf("offset %d, original %d, alternate %d\n",
37667986Smckusick 				    olp - (long *)&sblock, *olp, *nlp);
37767986Smckusick 			}
37867986Smckusick 		}
37930565Skarels 		badsb(listerr,
38030565Skarels 		"VALUES IN SUPER BLOCK DISAGREE WITH THOSE IN FIRST ALTERNATE");
38130565Skarels 		return (0);
38230565Skarels 	}
38330859Skarels 	havesb = 1;
38430399Smckusick 	return (1);
38516268Smckusick }
38616268Smckusick 
38768908Smckusick static void
badsb(listerr,s)38830399Smckusick badsb(listerr, s)
38930399Smckusick 	int listerr;
39016268Smckusick 	char *s;
39116268Smckusick {
39216268Smckusick 
39330399Smckusick 	if (!listerr)
39430399Smckusick 		return;
39516268Smckusick 	if (preen)
39661110Sbostic 		printf("%s: ", cdevname);
39730399Smckusick 	pfatal("BAD SUPER BLOCK: %s\n", s);
39816268Smckusick }
39930399Smckusick 
40030399Smckusick /*
40130399Smckusick  * Calculate a prototype superblock based on information in the disk label.
40230399Smckusick  * When done the cgsblock macro can be calculated and the fs_ncg field
40330399Smckusick  * can be used. Do NOT attempt to use other macros without verifying that
40430399Smckusick  * their needed information is available!
40530399Smckusick  */
40668908Smckusick static int
calcsb(dev,devfd,fs)40730399Smckusick calcsb(dev, devfd, fs)
40830399Smckusick 	char *dev;
40930399Smckusick 	int devfd;
41030399Smckusick 	register struct fs *fs;
41130399Smckusick {
41230399Smckusick 	register struct disklabel *lp;
41330399Smckusick 	register struct partition *pp;
41430399Smckusick 	register char *cp;
41530399Smckusick 	int i;
41630399Smckusick 
41768992Sbostic 	cp = strchr(dev, '\0') - 1;
41868908Smckusick 	if (cp == (char *)-1 || ((*cp < 'a' || *cp > 'h') && !isdigit(*cp))) {
41930399Smckusick 		pfatal("%s: CANNOT FIGURE OUT FILE SYSTEM PARTITION\n", dev);
42030399Smckusick 		return (0);
42130399Smckusick 	}
42230399Smckusick 	lp = getdisklabel(dev, devfd);
42330399Smckusick 	if (isdigit(*cp))
42430399Smckusick 		pp = &lp->d_partitions[0];
42530399Smckusick 	else
42630399Smckusick 		pp = &lp->d_partitions[*cp - 'a'];
42730399Smckusick 	if (pp->p_fstype != FS_BSDFFS) {
42830859Skarels 		pfatal("%s: NOT LABELED AS A BSD FILE SYSTEM (%s)\n",
42930399Smckusick 			dev, pp->p_fstype < FSMAXTYPES ?
43030399Smckusick 			fstypenames[pp->p_fstype] : "unknown");
43130399Smckusick 		return (0);
43230399Smckusick 	}
43368992Sbostic 	memset(fs, 0, sizeof(struct fs));
43430399Smckusick 	fs->fs_fsize = pp->p_fsize;
43530399Smckusick 	fs->fs_frag = pp->p_frag;
43630399Smckusick 	fs->fs_cpg = pp->p_cpg;
43730399Smckusick 	fs->fs_size = pp->p_size;
43830399Smckusick 	fs->fs_ntrak = lp->d_ntracks;
43930399Smckusick 	fs->fs_nsect = lp->d_nsectors;
44030399Smckusick 	fs->fs_spc = lp->d_secpercyl;
44130399Smckusick 	fs->fs_nspf = fs->fs_fsize / lp->d_secsize;
44230399Smckusick 	fs->fs_sblkno = roundup(
44330399Smckusick 		howmany(lp->d_bbsize + lp->d_sbsize, fs->fs_fsize),
44430399Smckusick 		fs->fs_frag);
44530399Smckusick 	fs->fs_cgmask = 0xffffffff;
44630399Smckusick 	for (i = fs->fs_ntrak; i > 1; i >>= 1)
44730399Smckusick 		fs->fs_cgmask <<= 1;
44830399Smckusick 	if (!POWEROF2(fs->fs_ntrak))
44930399Smckusick 		fs->fs_cgmask <<= 1;
45030399Smckusick 	fs->fs_cgoffset = roundup(
45130399Smckusick 		howmany(fs->fs_nsect, NSPF(fs)), fs->fs_frag);
45230399Smckusick 	fs->fs_fpg = (fs->fs_cpg * fs->fs_spc) / NSPF(fs);
45330399Smckusick 	fs->fs_ncg = howmany(fs->fs_size / fs->fs_spc, fs->fs_cpg);
45430399Smckusick 	for (fs->fs_fsbtodb = 0, i = NSPF(fs); i > 1; i >>= 1)
45530399Smckusick 		fs->fs_fsbtodb++;
45630859Skarels 	dev_bsize = lp->d_secsize;
45730399Smckusick 	return (1);
45830399Smckusick }
45930399Smckusick 
46068908Smckusick static struct disklabel *
getdisklabel(s,fd)46130399Smckusick getdisklabel(s, fd)
46230399Smckusick 	char *s;
46330399Smckusick 	int	fd;
46430399Smckusick {
46530399Smckusick 	static struct disklabel lab;
46630399Smckusick 
46730399Smckusick 	if (ioctl(fd, DIOCGDINFO, (char *)&lab) < 0) {
46830609Skarels 		if (s == NULL)
46930609Skarels 			return ((struct disklabel *)NULL);
47044934Smckusick 		pwarn("ioctl (GCINFO): %s\n", strerror(errno));
47168908Smckusick 		errx(EEXIT, "%s: can't read disk label", s);
47230399Smckusick 	}
47330399Smckusick 	return (&lab);
47430399Smckusick }
475