xref: /csrg-svn/sbin/newfs/mkfs.c (revision 34083)
121137Sdist /*
221137Sdist  * Copyright (c) 1980 Regents of the University of California.
321137Sdist  * All rights reserved.  The Berkeley software License Agreement
421137Sdist  * specifies the terms and conditions for redistribution.
521137Sdist  */
621137Sdist 
713604Ssam #ifndef lint
8*34083Sbostic static char sccsid[] = "@(#)mkfs.c	6.6 (Berkeley) 04/24/88";
921137Sdist #endif not lint
104234Smckusick 
114234Smckusick /*
124234Smckusick  * make file system for cylinder-group style file systems
134234Smckusick  */
144234Smckusick 
154234Smckusick #ifndef STANDALONE
164234Smckusick #include <stdio.h>
174234Smckusick #include <a.out.h>
184234Smckusick #endif
194234Smckusick 
206495Smckusick #include <sys/param.h>
216495Smckusick #include <sys/inode.h>
226495Smckusick #include <sys/fs.h>
2313604Ssam #include <sys/dir.h>
2430381Smckusick #include <sys/disklabel.h>
254234Smckusick 
265336Smckusic #define UMASK		0755
275346Smckusic #define MAXINOPB	(MAXBSIZE / sizeof(struct dinode))
285336Smckusic #define POWEROF2(num)	(((num) & ((num) - 1)) == 0)
294234Smckusick 
3030381Smckusick /*
3130381Smckusick  * variables set up by front end.
3230381Smckusick  */
3330386Smckusick extern int	Nflag;		/* run mkfs without writing file system */
3430386Smckusick extern int	fssize;		/* file system size */
3530386Smckusick extern int	ntracks;	/* # tracks/cylinder */
3630386Smckusick extern int	nsectors;	/* # sectors/track */
3730386Smckusick extern int	nphyssectors;	/* # sectors/track including spares */
3830386Smckusick extern int	secpercyl;	/* sectors per cylinder */
3930386Smckusick extern int	sectorsize;	/* bytes/sector */
4030386Smckusick extern int	rpm;		/* revolutions/minute of drive */
4130386Smckusick extern int	interleave;	/* hardware sector interleave */
4230386Smckusick extern int	trackskew;	/* sector 0 skew, per track */
4330386Smckusick extern int	headswitch;	/* head switch time, usec */
4430386Smckusick extern int	trackseek;	/* track-to-track seek, usec */
4530386Smckusick extern int	fsize;		/* fragment size */
4630386Smckusick extern int	bsize;		/* block size */
4730386Smckusick extern int	cpg;		/* cylinders/cylinder group */
4832120Smckusick extern int	cpgflg;		/* cylinders/cylinder group flag was given */
4930386Smckusick extern int	minfree;	/* free space threshold */
5030386Smckusick extern int	opt;		/* optimization preference (space or time) */
5130386Smckusick extern int	density;	/* number of bytes per inode */
5230386Smckusick extern int	maxcontig;	/* max contiguous blocks to allocate */
5330386Smckusick extern int	rotdelay;	/* rotational delay between blocks */
5432309Smckusick extern int	maxbpg;		/* maximum blocks per file in a cyl group */
5530691Skarels extern int	bbsize;		/* boot block size */
5630691Skarels extern int	sbsize;		/* superblock size */
5730381Smckusick 
584234Smckusick union {
594234Smckusick 	struct fs fs;
605324Smckusic 	char pad[MAXBSIZE];
614234Smckusick } fsun;
624234Smckusick #define	sblock	fsun.fs
634234Smckusick struct	csum *fscs;
644234Smckusick 
654234Smckusick union {
664234Smckusick 	struct cg cg;
675324Smckusic 	char pad[MAXBSIZE];
684234Smckusick } cgun;
694234Smckusick #define	acg	cgun.cg
704234Smckusick 
715336Smckusic struct	dinode zino[MAXIPG];
725336Smckusic 
7330381Smckusick int	fsi, fso;
745336Smckusic time_t	utime;
754234Smckusick daddr_t	alloc();
764234Smckusick 
7730381Smckusick mkfs(pp, fsys, fi, fo)
7830381Smckusick 	struct partition *pp;
7930381Smckusick 	char *fsys;
8030381Smckusick 	int fi, fo;
814234Smckusick {
8232120Smckusick 	register long i, mincpc, mincpg, inospercg;
8332120Smckusick 	long cylno, rpos, blk, j, warn = 0;
8432120Smckusick 	long used, mincpgcnt, bpcg;
8532120Smckusick 	long mapcramped, inodecramped;
864234Smckusick 
875336Smckusic #ifndef STANDALONE
884234Smckusick 	time(&utime);
895336Smckusic #endif
9030381Smckusick 	fsi = fi;
9130381Smckusick 	fso = fo;
9212252Smckusick 	/*
9312252Smckusick 	 * Validate the given file system size.
9412252Smckusick 	 * Verify that its last block can actually be accessed.
9512252Smckusick 	 */
965336Smckusic 	if (fssize <= 0)
975336Smckusic 		printf("preposterous size %d\n", fssize), exit(1);
9830381Smckusick 	wtfs(fssize - 1, sectorsize, (char *)&sblock);
995336Smckusic 	/*
1005336Smckusic 	 * collect and verify the sector and track info
1015336Smckusic 	 */
10230381Smckusick 	sblock.fs_nsect = nsectors;
10330381Smckusick 	sblock.fs_ntrak = ntracks;
1045336Smckusic 	if (sblock.fs_ntrak <= 0)
1055336Smckusic 		printf("preposterous ntrak %d\n", sblock.fs_ntrak), exit(1);
1065336Smckusic 	if (sblock.fs_nsect <= 0)
1075336Smckusic 		printf("preposterous nsect %d\n", sblock.fs_nsect), exit(1);
1085336Smckusic 	/*
1095336Smckusic 	 * collect and verify the block and fragment sizes
1105336Smckusic 	 */
11130381Smckusick 	sblock.fs_bsize = bsize;
11230381Smckusick 	sblock.fs_fsize = fsize;
1135336Smckusic 	if (!POWEROF2(sblock.fs_bsize)) {
1145336Smckusic 		printf("block size must be a power of 2, not %d\n",
1155336Smckusic 		    sblock.fs_bsize);
1164234Smckusick 		exit(1);
1174234Smckusick 	}
1185336Smckusic 	if (!POWEROF2(sblock.fs_fsize)) {
1195336Smckusic 		printf("fragment size must be a power of 2, not %d\n",
1205336Smckusic 		    sblock.fs_fsize);
1214234Smckusick 		exit(1);
1224234Smckusick 	}
12330381Smckusick 	if (sblock.fs_fsize < sectorsize) {
1245324Smckusic 		printf("fragment size %d is too small, minimum is %d\n",
12530381Smckusick 		    sblock.fs_fsize, sectorsize);
1265324Smckusic 		exit(1);
1275324Smckusic 	}
1285324Smckusic 	if (sblock.fs_bsize < MINBSIZE) {
1295324Smckusic 		printf("block size %d is too small, minimum is %d\n",
1305324Smckusic 		    sblock.fs_bsize, MINBSIZE);
1315324Smckusic 		exit(1);
1325324Smckusic 	}
1335336Smckusic 	if (sblock.fs_bsize < sblock.fs_fsize) {
1345336Smckusic 		printf("block size (%d) cannot be smaller than fragment size (%d)\n",
1355336Smckusic 		    sblock.fs_bsize, sblock.fs_fsize);
1364234Smckusick 		exit(1);
1374234Smckusick 	}
1385955Smckusic 	sblock.fs_bmask = ~(sblock.fs_bsize - 1);
1395955Smckusic 	sblock.fs_fmask = ~(sblock.fs_fsize - 1);
1405955Smckusic 	for (sblock.fs_bshift = 0, i = sblock.fs_bsize; i > 1; i >>= 1)
1415955Smckusic 		sblock.fs_bshift++;
1425955Smckusic 	for (sblock.fs_fshift = 0, i = sblock.fs_fsize; i > 1; i >>= 1)
1435955Smckusic 		sblock.fs_fshift++;
1445955Smckusic 	sblock.fs_frag = numfrags(&sblock, sblock.fs_bsize);
14510076Smckusick 	for (sblock.fs_fragshift = 0, i = sblock.fs_frag; i > 1; i >>= 1)
14610076Smckusick 		sblock.fs_fragshift++;
1475336Smckusic 	if (sblock.fs_frag > MAXFRAG) {
1485336Smckusic 		printf("fragment size %d is too small, minimum with block size %d is %d\n",
1495336Smckusic 		    sblock.fs_fsize, sblock.fs_bsize,
1505336Smckusic 		    sblock.fs_bsize / MAXFRAG);
1515336Smckusic 		exit(1);
1524234Smckusick 	}
15310076Smckusick 	sblock.fs_nindir = sblock.fs_bsize / sizeof(daddr_t);
15410076Smckusick 	sblock.fs_inopb = sblock.fs_bsize / sizeof(struct dinode);
15530381Smckusick 	sblock.fs_nspf = sblock.fs_fsize / sectorsize;
15630381Smckusick 	for (sblock.fs_fsbtodb = 0, i = NSPF(&sblock); i > 1; i >>= 1)
15710076Smckusick 		sblock.fs_fsbtodb++;
1586532Smckusick 	sblock.fs_sblkno =
15930691Skarels 	    roundup(howmany(bbsize + sbsize, sblock.fs_fsize), sblock.fs_frag);
1606532Smckusick 	sblock.fs_cblkno = (daddr_t)(sblock.fs_sblkno +
16130691Skarels 	    roundup(howmany(sbsize, sblock.fs_fsize), sblock.fs_frag));
1625362Smckusic 	sblock.fs_iblkno = sblock.fs_cblkno + sblock.fs_frag;
1636532Smckusick 	sblock.fs_cgoffset = roundup(
16430381Smckusick 	    howmany(sblock.fs_nsect, NSPF(&sblock)), sblock.fs_frag);
1656532Smckusick 	for (sblock.fs_cgmask = 0xffffffff, i = sblock.fs_ntrak; i > 1; i >>= 1)
1666532Smckusick 		sblock.fs_cgmask <<= 1;
1676532Smckusick 	if (!POWEROF2(sblock.fs_ntrak))
1686532Smckusick 		sblock.fs_cgmask <<= 1;
16932120Smckusick 	/*
17032120Smckusick 	 * Validate specified/determined secpercyl
17132120Smckusick 	 * and calculate minimum cylinders per group.
17232120Smckusick 	 */
17332120Smckusick 	sblock.fs_spc = secpercyl;
1745399Smckusic 	for (sblock.fs_cpc = NSPB(&sblock), i = sblock.fs_spc;
1755399Smckusic 	     sblock.fs_cpc > 1 && (i & 1) == 0;
1765399Smckusic 	     sblock.fs_cpc >>= 1, i >>= 1)
1775399Smckusic 		/* void */;
17832120Smckusick 	mincpc = sblock.fs_cpc;
17932120Smckusick 	if (mincpc > MAXCPG) {
18032120Smckusick 		printf("Maximum frag size with %d sectors per cylinder is %d\n",
18132120Smckusick 		    sblock.fs_spc, sblock.fs_fsize / (mincpc / MAXCPG));
1825605Smckusic 		exit(1);
1835605Smckusic 	}
18432120Smckusick 	bpcg = sblock.fs_spc * sectorsize;
18532120Smckusick 	inospercg = roundup(bpcg / sizeof(struct dinode), INOPB(&sblock));
18632120Smckusick 	if (inospercg > MAXIPG)
18732120Smckusick 		inospercg = MAXIPG;
18832120Smckusick 	used = (sblock.fs_iblkno + inospercg / INOPF(&sblock)) * NSPF(&sblock);
18932120Smckusick 	mincpgcnt = howmany(sblock.fs_cgoffset * (~sblock.fs_cgmask) + used,
19032120Smckusick 	    sblock.fs_spc);
19132120Smckusick 	mincpg = roundup(mincpgcnt, mincpc);
19232120Smckusick 	/*
19332120Smckusick 	 * Insure that cylinder group with mincpg has enough space
19432120Smckusick 	 * for block maps
19532120Smckusick 	 */
19632120Smckusick 	mapcramped = 0;
19732120Smckusick 	while (mincpg * sblock.fs_spc > MAXBPG(&sblock) * NSPB(&sblock)) {
19832120Smckusick 		mapcramped = 1;
19932120Smckusick 		if (sblock.fs_bsize < MAXBSIZE) {
20032120Smckusick 			sblock.fs_bsize <<= 1;
20132120Smckusick 			if ((i & 1) == 0) {
20232120Smckusick 				i >>= 1;
20332120Smckusick 			} else {
20432120Smckusick 				sblock.fs_cpc <<= 1;
20532120Smckusick 				mincpc <<= 1;
20632120Smckusick 				mincpg = roundup(mincpgcnt, mincpc);
20732120Smckusick 			}
20832120Smckusick 			sblock.fs_frag <<= 1;
20932120Smckusick 			sblock.fs_fragshift += 1;
21032120Smckusick 			if (sblock.fs_frag <= MAXFRAG)
21132120Smckusick 				continue;
21232120Smckusick 		}
21332120Smckusick 		if (sblock.fs_fsize == sblock.fs_bsize) {
21432120Smckusick 			printf("There is no block size that");
21532120Smckusick 			printf(" can support this disk\n");
21632120Smckusick 			exit(1);
21732120Smckusick 		}
21832120Smckusick 		sblock.fs_frag >>= 1;
21932120Smckusick 		sblock.fs_fragshift -= 1;
22032120Smckusick 		sblock.fs_fsize <<= 1;
22132120Smckusick 		sblock.fs_nspf <<= 1;
22232120Smckusick 	}
22332120Smckusick 	/*
22432120Smckusick 	 * Insure that cylinder group with mincpg has enough space for inodes
22532120Smckusick 	 */
22632120Smckusick 	inodecramped = 0;
22732120Smckusick 	used *= sectorsize;
22832120Smckusick 	inospercg = (mincpg * bpcg - used) / density;
22932120Smckusick 	while (inospercg > MAXIPG) {
23032120Smckusick 		inodecramped = 1;
23132120Smckusick 		if (mincpc == 1 || sblock.fs_frag == 1 ||
23232120Smckusick 		    sblock.fs_bsize == MINBSIZE)
23332120Smckusick 			break;
23432120Smckusick 		printf("With a block size of %d %s %d\n", sblock.fs_bsize,
23532120Smckusick 		    "minimum bytes per inode is",
23632120Smckusick 		    (mincpg * bpcg - used) / MAXIPG + 1);
23732120Smckusick 		sblock.fs_bsize >>= 1;
23832120Smckusick 		sblock.fs_frag >>= 1;
23932120Smckusick 		sblock.fs_fragshift -= 1;
24032120Smckusick 		mincpc >>= 1;
24132120Smckusick 		i = roundup(mincpgcnt, mincpc);
24232120Smckusick 		if (i * sblock.fs_spc > MAXBPG(&sblock) * NSPB(&sblock)) {
24332120Smckusick 			sblock.fs_bsize <<= 1;
24432120Smckusick 			break;
24532120Smckusick 		}
24632120Smckusick 		mincpg = i;
24732120Smckusick 		inospercg = (mincpg * bpcg - used) / density;
24832120Smckusick 	}
24932120Smckusick 	if (inodecramped) {
25032120Smckusick 		if (inospercg > MAXIPG) {
25132120Smckusick 			printf("Minimum bytes per inode is %d\n",
25232120Smckusick 			    (mincpg * bpcg - used) / MAXIPG + 1);
25332120Smckusick 		} else if (!mapcramped) {
25432120Smckusick 			printf("With %d bytes per inode, ", density);
25532120Smckusick 			printf("minimum cylinders per group is %d\n", mincpg);
25632120Smckusick 		}
25732120Smckusick 	}
25832120Smckusick 	if (mapcramped) {
25932120Smckusick 		printf("With %d sectors per cylinder, ", sblock.fs_spc);
26032120Smckusick 		printf("minimum cylinders per group is %d\n", mincpg);
26132120Smckusick 	}
26232120Smckusick 	if (inodecramped || mapcramped) {
26332120Smckusick 		if (sblock.fs_bsize != bsize)
26432120Smckusick 			printf("%s to be changed from %d to %d\n",
26532120Smckusick 			    "This requires the block size",
26632120Smckusick 			    bsize, sblock.fs_bsize);
26732120Smckusick 		if (sblock.fs_fsize != fsize)
26832120Smckusick 			printf("\t%s to be changed from %d to %d\n",
26932120Smckusick 			    "and the fragment size",
27032120Smckusick 			    bsize, sblock.fs_bsize);
27132120Smckusick 		exit(1);
27232120Smckusick 	}
2735336Smckusic 	/*
27432120Smckusick 	 * Calculate the number of cylinders per group
2754234Smckusick 	 */
27630381Smckusick 	sblock.fs_cpg = cpg;
27732120Smckusick 	if (sblock.fs_cpg % mincpc != 0) {
27830381Smckusick 		printf("%s groups must have a multiple of %d cylinders\n",
27932120Smckusick 			cpgflg ? "Cylinder" : "Warning: cylinder", mincpc);
28032120Smckusick 		sblock.fs_cpg = roundup(sblock.fs_cpg, mincpc);
28130381Smckusick 	}
28232120Smckusick 	/*
28332120Smckusick 	 * Must insure there is enough space to hold block map
28432120Smckusick 	 */
28530381Smckusick 	sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
28632120Smckusick 	while (sblock.fs_fpg > MAXBPG(&sblock) * sblock.fs_frag) {
28732120Smckusick 		mapcramped = 1;
28832120Smckusick 		sblock.fs_cpg -= mincpc;
2895336Smckusic 		sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
2904234Smckusick 	}
29132120Smckusick 	/*
29232120Smckusick 	 * Must insure there is enough space for inodes
29332120Smckusick 	 */
29432120Smckusick 	inospercg = (sblock.fs_cpg * bpcg - used) / density;
29532120Smckusick 	while (inospercg > MAXIPG) {
29632120Smckusick 		inodecramped = 1;
29732120Smckusick 		sblock.fs_cpg -= mincpc;
29832120Smckusick 		sblock.fs_fpg = (sblock.fs_cpg * sblock.fs_spc) / NSPF(&sblock);
29932120Smckusick 		inospercg = (sblock.fs_cpg * bpcg - used) / density;
30032120Smckusick 	}
30132120Smckusick 	if ((sblock.fs_cpg * sblock.fs_spc) % NSPB(&sblock) != 0) {
30232120Smckusick 		printf("newfs: panic (fs_cpg * fs_spc) % NSPF != 0");
30332120Smckusick 		exit(2);
30432120Smckusick 	}
30532120Smckusick 	if (sblock.fs_cpg < mincpg) {
30632120Smckusick 		printf("cylinder groups must have at least %d cylinders\n",
30732120Smckusick 			mincpg);
3085336Smckusic 		exit(1);
30930381Smckusick 	} else if (sblock.fs_cpg > MAXCPG) {
3105336Smckusic 		printf("cylinder groups are limited to %d cylinders\n", MAXCPG);
3115336Smckusic 		exit(1);
31232120Smckusick 	} else if (sblock.fs_cpg != cpg) {
31332120Smckusick 		if (!cpgflg)
31432120Smckusick 			printf("Warning: ");
31532120Smckusick 		if (mapcramped && inodecramped)
31632120Smckusick 			printf("Block size and bytes per inode restrict");
31732120Smckusick 		else if (mapcramped)
31832120Smckusick 			printf("Block size restricts");
31932120Smckusick 		else
32032120Smckusick 			printf("Bytes per inode restrict");
32132120Smckusick 		printf(" cylinders per group to %d.\n", sblock.fs_cpg);
32232120Smckusick 		if (cpgflg)
32332120Smckusick 			exit(1);
3245336Smckusic 	}
32532120Smckusick 	sblock.fs_cgsize = fragroundup(&sblock,
32632120Smckusick 	    sizeof(struct cg) + howmany(sblock.fs_fpg, NBBY));
3274234Smckusick 	/*
3285336Smckusic 	 * Now have size for file system and nsect and ntrak.
3295336Smckusic 	 * Determine number of cylinders and blocks in the file system.
3305336Smckusic 	 */
3315336Smckusic 	sblock.fs_size = fssize = dbtofsb(&sblock, fssize);
3325336Smckusic 	sblock.fs_ncyl = fssize * NSPF(&sblock) / sblock.fs_spc;
3335362Smckusic 	if (fssize * NSPF(&sblock) > sblock.fs_ncyl * sblock.fs_spc) {
3345362Smckusic 		sblock.fs_ncyl++;
3356532Smckusick 		warn = 1;
3365362Smckusic 	}
3375362Smckusic 	if (sblock.fs_ncyl < 1) {
3385362Smckusic 		printf("file systems must have at least one cylinder\n");
3395336Smckusic 		exit(1);
3405336Smckusic 	}
3415336Smckusic 	/*
3425362Smckusic 	 * determine feasability/values of rotational layout tables
3435362Smckusic 	 */
34432120Smckusick 	sblock.fs_interleave = interleave;
34532120Smckusick 	sblock.fs_trackskew = trackskew;
34632120Smckusick 	sblock.fs_npsect = nphyssectors;
3475362Smckusic 	if (sblock.fs_ntrak == 1) {
3485362Smckusic 		sblock.fs_cpc = 0;
3495362Smckusic 		goto next;
3505362Smckusic 	}
3515362Smckusic 	if (sblock.fs_spc * sblock.fs_cpc > MAXBPC * NSPB(&sblock) ||
3525362Smckusic 	    sblock.fs_nsect > (1 << NBBY) * NSPB(&sblock)) {
3535362Smckusic 		printf("%s %s %d %s %d.%s",
3545362Smckusic 		    "Warning: insufficient space in super block for\n",
3555362Smckusic 		    "rotational layout tables with nsect", sblock.fs_nsect,
3565362Smckusic 		    "and ntrak", sblock.fs_ntrak,
35718552Sbloom 		    "\nFile system performance may be impaired.\n");
3585362Smckusic 		sblock.fs_cpc = 0;
3595362Smckusic 		goto next;
3605362Smckusic 	}
3615362Smckusic 	/*
3625362Smckusic 	 * calculate the available blocks for each rotational position
3635362Smckusic 	 */
3645362Smckusic 	for (cylno = 0; cylno < MAXCPG; cylno++)
3655362Smckusic 		for (rpos = 0; rpos < NRPOS; rpos++)
3665362Smckusic 			sblock.fs_postbl[cylno][rpos] = -1;
3675362Smckusic 	blk = sblock.fs_spc * sblock.fs_cpc / NSPF(&sblock);
3685362Smckusic 	for (i = 0; i < blk; i += sblock.fs_frag)
3695362Smckusic 		/* void */;
3705362Smckusic 	for (i -= sblock.fs_frag; i >= 0; i -= sblock.fs_frag) {
3715362Smckusic 		cylno = cbtocylno(&sblock, i);
3725362Smckusic 		rpos = cbtorpos(&sblock, i);
3735362Smckusic 		blk = i / sblock.fs_frag;
3745362Smckusic 		if (sblock.fs_postbl[cylno][rpos] == -1)
3755362Smckusic 			sblock.fs_rotbl[blk] = 0;
3765362Smckusic 		else
3775362Smckusic 			sblock.fs_rotbl[blk] =
3785362Smckusic 			    sblock.fs_postbl[cylno][rpos] - blk;
3795362Smckusic 		sblock.fs_postbl[cylno][rpos] = blk;
3805362Smckusic 	}
3815362Smckusic next:
3825362Smckusic 	/*
3834234Smckusick 	 * Compute/validate number of cylinder groups.
3844234Smckusick 	 */
3854234Smckusick 	sblock.fs_ncg = sblock.fs_ncyl / sblock.fs_cpg;
3864234Smckusick 	if (sblock.fs_ncyl % sblock.fs_cpg)
3874234Smckusick 		sblock.fs_ncg++;
3884234Smckusick 	/*
3894234Smckusick 	 * Compute number of inode blocks per cylinder group.
3904234Smckusick 	 */
39132120Smckusick 	sblock.fs_ipg = roundup(inospercg, INOPB(&sblock));
39232120Smckusick 	if (sblock.fs_ipg > MAXIPG) {
39332120Smckusick 		printf("newfs: panic fs_ipg > MAXIPG");
39432120Smckusick 		exit(3);
39532120Smckusick 	}
3965362Smckusic 	sblock.fs_dblkno = sblock.fs_iblkno + sblock.fs_ipg / INOPF(&sblock);
3976532Smckusick 	i = MIN(~sblock.fs_cgmask, sblock.fs_ncg - 1);
3986532Smckusick 	if (cgdmin(&sblock, i) - cgbase(&sblock, i) >= sblock.fs_fpg) {
3994234Smckusick 		printf("inode blocks/cyl group (%d) >= data blocks (%d)\n",
4006532Smckusick 		    cgdmin(&sblock, i) - cgbase(&sblock, i) / sblock.fs_frag,
4015324Smckusic 		    sblock.fs_fpg / sblock.fs_frag);
40232120Smckusick 		printf("number of cylinders per cylinder group (%d) %s.\n",
40332120Smckusick 		    sblock.fs_ncg, "must be increased");
4045324Smckusic 		exit(1);
4055324Smckusic 	}
4066532Smckusick 	j = sblock.fs_ncg - 1;
4076532Smckusick 	if ((i = fssize - j * sblock.fs_fpg) < sblock.fs_fpg &&
4086532Smckusick 	    cgdmin(&sblock, j) - cgbase(&sblock, j) > i) {
4096532Smckusick 		printf("Warning: inode blocks/cyl group (%d) >= data blocks (%d) in last\n",
4106532Smckusick 		    (cgdmin(&sblock, j) - cgbase(&sblock, j)) / sblock.fs_frag,
4116532Smckusick 		    i / sblock.fs_frag);
4126532Smckusick 		printf("    cylinder group. This implies %d sector(s) cannot be allocated.\n",
4136532Smckusick 		    i * NSPF(&sblock));
4146532Smckusick 		sblock.fs_ncg--;
4156532Smckusick 		sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg;
4166532Smckusick 		sblock.fs_size = fssize = sblock.fs_ncyl * sblock.fs_spc /
4176532Smckusick 		    NSPF(&sblock);
4186532Smckusick 		warn = 0;
4196532Smckusick 	}
4206532Smckusick 	if (warn) {
4216532Smckusick 		printf("Warning: %d sector(s) in last cylinder unallocated\n",
4226532Smckusick 		    sblock.fs_spc -
4236532Smckusick 		    (fssize * NSPF(&sblock) - (sblock.fs_ncyl - 1)
4246532Smckusick 		    * sblock.fs_spc));
4256532Smckusick 	}
4265336Smckusic 	/*
4275336Smckusic 	 * fill in remaining fields of the super block
4285336Smckusic 	 */
4295383Smckusic 	sblock.fs_csaddr = cgdmin(&sblock, 0);
4306532Smckusick 	sblock.fs_cssize =
4316532Smckusick 	    fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum));
43210076Smckusick 	i = sblock.fs_bsize / sizeof(struct csum);
43310076Smckusick 	sblock.fs_csmask = ~(i - 1);
43410076Smckusick 	for (sblock.fs_csshift = 0; i > 1; i >>= 1)
43510076Smckusick 		sblock.fs_csshift++;
43610076Smckusick 	i = sizeof(struct fs) +
43710076Smckusick 		howmany(sblock.fs_spc * sblock.fs_cpc, NSPB(&sblock));
43810076Smckusick 	sblock.fs_sbsize = fragroundup(&sblock, i);
4396532Smckusick 	fscs = (struct csum *)calloc(1, sblock.fs_cssize);
4405362Smckusic 	sblock.fs_magic = FS_MAGIC;
44130381Smckusick 	sblock.fs_rotdelay = rotdelay;
44230381Smckusick 	sblock.fs_minfree = minfree;
44330381Smckusick 	sblock.fs_maxcontig = maxcontig;
44430386Smckusick 	sblock.fs_headswitch = headswitch;
44530386Smckusick 	sblock.fs_trkseek = trackseek;
44632309Smckusick 	sblock.fs_maxbpg = maxbpg;
44730381Smckusick 	sblock.fs_rps = rpm / 60;
44830381Smckusick 	sblock.fs_optim = opt;
4495336Smckusic 	sblock.fs_cgrotor = 0;
4505336Smckusic 	sblock.fs_cstotal.cs_ndir = 0;
4515336Smckusic 	sblock.fs_cstotal.cs_nbfree = 0;
4525336Smckusic 	sblock.fs_cstotal.cs_nifree = 0;
4535336Smckusic 	sblock.fs_cstotal.cs_nffree = 0;
4544234Smckusick 	sblock.fs_fmod = 0;
4554234Smckusick 	sblock.fs_ronly = 0;
4564234Smckusick 	/*
4575336Smckusic 	 * Dump out summary information about file system.
4584234Smckusick 	 */
4594234Smckusick 	printf("%s:\t%d sectors in %d cylinders of %d tracks, %d sectors\n",
4605336Smckusic 	    fsys, sblock.fs_size * NSPF(&sblock), sblock.fs_ncyl,
4615324Smckusic 	    sblock.fs_ntrak, sblock.fs_nsect);
4624234Smckusick 	printf("\t%.1fMb in %d cyl groups (%d c/g, %.2fMb/g, %d i/g)\n",
4635324Smckusic 	    (float)sblock.fs_size * sblock.fs_fsize * 1e-6, sblock.fs_ncg,
4645324Smckusic 	    sblock.fs_cpg, (float)sblock.fs_fpg * sblock.fs_fsize * 1e-6,
4655324Smckusic 	    sblock.fs_ipg);
4664234Smckusick 	/*
4674234Smckusick 	 * Now build the cylinders group blocks and
4685336Smckusic 	 * then print out indices of cylinder groups.
4694234Smckusick 	 */
4706532Smckusick 	printf("super-block backups (for fsck -b#) at:");
4716532Smckusick 	for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
4725362Smckusic 		initcg(cylno);
47332120Smckusick 		if (cylno % 9 == 0)
4746532Smckusick 			printf("\n");
4756532Smckusick 		printf(" %d,", fsbtodb(&sblock, cgsblock(&sblock, cylno)));
4766532Smckusick 	}
47711525Ssam 	printf("\n");
47816944Smckusick 	if (Nflag)
47916944Smckusick 		exit(0);
4804234Smckusick 	/*
4815336Smckusic 	 * Now construct the initial file system,
4824234Smckusick 	 * then write out the super-block.
4834234Smckusick 	 */
4845336Smckusic 	fsinit();
4854234Smckusick 	sblock.fs_time = utime;
48630691Skarels 	wtfs(SBOFF / sectorsize, sbsize, (char *)&sblock);
4875324Smckusic 	for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize)
4885955Smckusic 		wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)),
4896532Smckusick 			sblock.fs_cssize - i < sblock.fs_bsize ?
4906532Smckusick 			    sblock.fs_cssize - i : sblock.fs_bsize,
4916532Smckusick 			((char *)fscs) + i);
4925336Smckusic 	/*
4935336Smckusic 	 * Write out the duplicate super blocks
4945336Smckusic 	 */
4958295Smckusick 	for (cylno = 0; cylno < sblock.fs_ncg; cylno++)
4966532Smckusick 		wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
49730691Skarels 		    sbsize, (char *)&sblock);
49830381Smckusick 	/*
49930381Smckusick 	 * Update information about this partion in pack
50030381Smckusick 	 * label, to that it may be updated on disk.
50130381Smckusick 	 */
50230381Smckusick 	pp->p_fstype = FS_BSDFFS;
50330381Smckusick 	pp->p_fsize = sblock.fs_fsize;
50430381Smckusick 	pp->p_frag = sblock.fs_frag;
50530381Smckusick 	pp->p_cpg = sblock.fs_cpg;
5064234Smckusick }
5074234Smckusick 
5084234Smckusick /*
5094234Smckusick  * Initialize a cylinder group.
5104234Smckusick  */
5115362Smckusic initcg(cylno)
5125362Smckusic 	int cylno;
5134234Smckusick {
5146532Smckusick 	daddr_t cbase, d, dlower, dupper, dmax;
5154234Smckusick 	long i, j, s;
5164234Smckusick 	register struct csum *cs;
5174234Smckusick 
5184234Smckusick 	/*
5194234Smckusick 	 * Determine block bounds for cylinder group.
5204234Smckusick 	 * Allow space for super block summary information in first
5214234Smckusick 	 * cylinder group.
5224234Smckusick 	 */
5235383Smckusic 	cbase = cgbase(&sblock, cylno);
5244234Smckusick 	dmax = cbase + sblock.fs_fpg;
5254234Smckusick 	if (dmax > sblock.fs_size)
5264234Smckusick 		dmax = sblock.fs_size;
5276532Smckusick 	dlower = cgsblock(&sblock, cylno) - cbase;
5286532Smckusick 	dupper = cgdmin(&sblock, cylno) - cbase;
5295362Smckusic 	cs = fscs + cylno;
5304234Smckusick 	acg.cg_time = utime;
5314234Smckusick 	acg.cg_magic = CG_MAGIC;
5325362Smckusic 	acg.cg_cgx = cylno;
5338139Smckusick 	if (cylno == sblock.fs_ncg - 1)
5348139Smckusick 		acg.cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg;
5358139Smckusick 	else
5368139Smckusick 		acg.cg_ncyl = sblock.fs_cpg;
5374234Smckusick 	acg.cg_niblk = sblock.fs_ipg;
5384234Smckusick 	acg.cg_ndblk = dmax - cbase;
5394788Smckusic 	acg.cg_cs.cs_ndir = 0;
5404788Smckusic 	acg.cg_cs.cs_nffree = 0;
5414788Smckusic 	acg.cg_cs.cs_nbfree = 0;
5424788Smckusic 	acg.cg_cs.cs_nifree = 0;
5436532Smckusick 	acg.cg_rotor = 0;
5446532Smckusick 	acg.cg_frotor = 0;
5454257Smckusic 	acg.cg_irotor = 0;
5465324Smckusic 	for (i = 0; i < sblock.fs_frag; i++) {
5474465Smckusic 		acg.cg_frsum[i] = 0;
5484465Smckusic 	}
5494465Smckusic 	for (i = 0; i < sblock.fs_ipg; ) {
5505324Smckusic 		for (j = INOPB(&sblock); j > 0; j--) {
5514234Smckusick 			clrbit(acg.cg_iused, i);
5524234Smckusick 			i++;
5534234Smckusick 		}
5545324Smckusic 		acg.cg_cs.cs_nifree += INOPB(&sblock);
5554234Smckusick 	}
5565362Smckusic 	if (cylno == 0)
5575336Smckusic 		for (i = 0; i < ROOTINO; i++) {
5585336Smckusic 			setbit(acg.cg_iused, i);
5595336Smckusic 			acg.cg_cs.cs_nifree--;
5605336Smckusic 		}
5614234Smckusick 	while (i < MAXIPG) {
5624234Smckusick 		clrbit(acg.cg_iused, i);
5634234Smckusick 		i++;
5644234Smckusick 	}
56516944Smckusick 	wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno)),
56616944Smckusick 	    sblock.fs_ipg * sizeof (struct dinode), (char *)zino);
5675370Smckusic 	for (i = 0; i < MAXCPG; i++) {
5685370Smckusic 		acg.cg_btot[i] = 0;
5694234Smckusick 		for (j = 0; j < NRPOS; j++)
5704234Smckusick 			acg.cg_b[i][j] = 0;
5715370Smckusic 	}
5725362Smckusic 	if (cylno == 0) {
5736532Smckusick 		/*
5746532Smckusick 		 * reserve space for summary info and Boot block
5756532Smckusick 		 */
5766532Smckusick 		dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
5776532Smckusick 		for (d = 0; d < dlower; d += sblock.fs_frag)
5786532Smckusick 			clrblock(&sblock, acg.cg_free, d/sblock.fs_frag);
5796532Smckusick 	} else {
5806532Smckusick 		for (d = 0; d < dlower; d += sblock.fs_frag) {
5816532Smckusick 			setblock(&sblock, acg.cg_free, d/sblock.fs_frag);
5826532Smckusick 			acg.cg_cs.cs_nbfree++;
5836532Smckusick 			acg.cg_btot[cbtocylno(&sblock, d)]++;
5846532Smckusick 			acg.cg_b[cbtocylno(&sblock, d)][cbtorpos(&sblock, d)]++;
5856532Smckusick 		}
5866532Smckusick 		sblock.fs_dsize += dlower;
5874234Smckusick 	}
5886532Smckusick 	sblock.fs_dsize += acg.cg_ndblk - dupper;
5896532Smckusick 	for (; d < dupper; d += sblock.fs_frag)
5905324Smckusic 		clrblock(&sblock, acg.cg_free, d/sblock.fs_frag);
5916532Smckusick 	if (d > dupper) {
5926532Smckusick 		acg.cg_frsum[d - dupper]++;
5936532Smckusick 		for (i = d - 1; i >= dupper; i--) {
5946532Smckusick 			setbit(acg.cg_free, i);
5956532Smckusick 			acg.cg_cs.cs_nffree++;
5966532Smckusick 		}
5976532Smckusick 	}
5986532Smckusick 	while ((d + sblock.fs_frag) <= dmax - cbase) {
5995324Smckusic 		setblock(&sblock, acg.cg_free, d/sblock.fs_frag);
6004788Smckusic 		acg.cg_cs.cs_nbfree++;
6015370Smckusic 		acg.cg_btot[cbtocylno(&sblock, d)]++;
6025362Smckusic 		acg.cg_b[cbtocylno(&sblock, d)][cbtorpos(&sblock, d)]++;
6035324Smckusic 		d += sblock.fs_frag;
6044234Smckusick 	}
6056532Smckusick 	if (d < dmax - cbase) {
6065362Smckusic 		acg.cg_frsum[dmax - cbase - d]++;
6074251Smckusic 		for (; d < dmax - cbase; d++) {
6084251Smckusic 			setbit(acg.cg_free, d);
6094788Smckusic 			acg.cg_cs.cs_nffree++;
6104251Smckusic 		}
6118139Smckusick 		for (; d % sblock.fs_frag != 0; d++)
6128139Smckusick 			clrbit(acg.cg_free, d);
6136532Smckusick 	}
6148139Smckusick 	for (d /= sblock.fs_frag; d < MAXBPG(&sblock); d ++)
6158139Smckusick 		clrblock(&sblock, acg.cg_free, d);
6164788Smckusic 	sblock.fs_cstotal.cs_ndir += acg.cg_cs.cs_ndir;
6174788Smckusic 	sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree;
6184788Smckusic 	sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;
6194788Smckusic 	sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
6204788Smckusic 	*cs = acg.cg_cs;
6215383Smckusic 	wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
6225324Smckusic 		sblock.fs_bsize, (char *)&acg);
6234234Smckusick }
6244234Smckusick 
6255336Smckusic /*
6265336Smckusic  * initialize the file system
6275336Smckusic  */
6285336Smckusic struct inode node;
62930381Smckusick 
63030381Smckusick #ifdef LOSTDIR
6315336Smckusic #define PREDEFDIR 3
63230381Smckusick #else
63330381Smckusick #define PREDEFDIR 2
63430381Smckusick #endif
63530381Smckusick 
6365934Smckusic struct direct root_dir[] = {
6375934Smckusic 	{ ROOTINO, sizeof(struct direct), 1, "." },
6385934Smckusic 	{ ROOTINO, sizeof(struct direct), 2, ".." },
63930381Smckusick #ifdef LOSTDIR
6405934Smckusic 	{ LOSTFOUNDINO, sizeof(struct direct), 10, "lost+found" },
64130381Smckusick #endif
6425336Smckusic };
64330381Smckusick #ifdef LOSTDIR
6445934Smckusic struct direct lost_found_dir[] = {
6455934Smckusic 	{ LOSTFOUNDINO, sizeof(struct direct), 1, "." },
6465934Smckusic 	{ ROOTINO, sizeof(struct direct), 2, ".." },
6475934Smckusic 	{ 0, DIRBLKSIZ, 0, 0 },
6485336Smckusic };
64930381Smckusick #endif
6505934Smckusic char buf[MAXBSIZE];
6515336Smckusic 
6525336Smckusic fsinit()
6534234Smckusick {
6545934Smckusic 	int i;
6555934Smckusic 
6564234Smckusick 	/*
6575336Smckusic 	 * initialize the node
6584234Smckusick 	 */
6595336Smckusic 	node.i_atime = utime;
6605336Smckusic 	node.i_mtime = utime;
6615336Smckusic 	node.i_ctime = utime;
66230381Smckusick #ifdef LOSTDIR
6634234Smckusick 	/*
6645336Smckusic 	 * create the lost+found directory
6654234Smckusick 	 */
6665934Smckusic 	(void)makedir(lost_found_dir, 2);
6675934Smckusic 	for (i = DIRBLKSIZ; i < sblock.fs_bsize; i += DIRBLKSIZ)
6685934Smckusic 		bcopy(&lost_found_dir[2], &buf[i], DIRSIZ(&lost_found_dir[2]));
6695336Smckusic 	node.i_number = LOSTFOUNDINO;
6705336Smckusic 	node.i_mode = IFDIR | UMASK;
6715336Smckusic 	node.i_nlink = 2;
6725336Smckusic 	node.i_size = sblock.fs_bsize;
6735336Smckusic 	node.i_db[0] = alloc(node.i_size, node.i_mode);
67414323Smckusick 	node.i_blocks = btodb(fragroundup(&sblock, node.i_size));
6755934Smckusic 	wtfs(fsbtodb(&sblock, node.i_db[0]), node.i_size, buf);
6765336Smckusic 	iput(&node);
67730381Smckusick #endif
6785336Smckusic 	/*
6795336Smckusic 	 * create the root directory
6805336Smckusic 	 */
6815336Smckusic 	node.i_number = ROOTINO;
6825336Smckusic 	node.i_mode = IFDIR | UMASK;
6835336Smckusic 	node.i_nlink = PREDEFDIR;
6845934Smckusic 	node.i_size = makedir(root_dir, PREDEFDIR);
6855336Smckusic 	node.i_db[0] = alloc(sblock.fs_fsize, node.i_mode);
68614323Smckusick 	node.i_blocks = btodb(fragroundup(&sblock, node.i_size));
6875934Smckusic 	wtfs(fsbtodb(&sblock, node.i_db[0]), sblock.fs_fsize, buf);
6885336Smckusic 	iput(&node);
6894234Smckusick }
6904234Smckusick 
6915336Smckusic /*
6925934Smckusic  * construct a set of directory entries in "buf".
6935934Smckusic  * return size of directory.
6945934Smckusic  */
6955934Smckusic makedir(protodir, entries)
6965934Smckusic 	register struct direct *protodir;
6975934Smckusic 	int entries;
6985934Smckusic {
6995934Smckusic 	char *cp;
7005934Smckusic 	int i, spcleft;
7015934Smckusic 
7025934Smckusic 	spcleft = DIRBLKSIZ;
7035934Smckusic 	for (cp = buf, i = 0; i < entries - 1; i++) {
7045934Smckusic 		protodir[i].d_reclen = DIRSIZ(&protodir[i]);
7055934Smckusic 		bcopy(&protodir[i], cp, protodir[i].d_reclen);
7065934Smckusic 		cp += protodir[i].d_reclen;
7075934Smckusic 		spcleft -= protodir[i].d_reclen;
7085934Smckusic 	}
7095934Smckusic 	protodir[i].d_reclen = spcleft;
7105934Smckusic 	bcopy(&protodir[i], cp, DIRSIZ(&protodir[i]));
71123848Smckusick 	return (DIRBLKSIZ);
7125934Smckusic }
7135934Smckusic 
7145934Smckusic /*
7155336Smckusic  * allocate a block or frag
7165336Smckusic  */
7174234Smckusick daddr_t
7184427Smckusic alloc(size, mode)
7194427Smckusic 	int size;
7204427Smckusic 	int mode;
7214234Smckusick {
7225362Smckusic 	int i, frag;
7234234Smckusick 	daddr_t d;
7244234Smckusick 
7255955Smckusic 	rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
7265955Smckusic 	    (char *)&acg);
7276532Smckusick 	if (acg.cg_magic != CG_MAGIC) {
7286532Smckusick 		printf("cg 0: bad magic number\n");
7296532Smckusick 		return (0);
7306532Smckusick 	}
7314788Smckusic 	if (acg.cg_cs.cs_nbfree == 0) {
7324234Smckusick 		printf("first cylinder group ran out of space\n");
7334234Smckusick 		return (0);
7344234Smckusick 	}
7355324Smckusic 	for (d = 0; d < acg.cg_ndblk; d += sblock.fs_frag)
7365324Smckusic 		if (isblock(&sblock, acg.cg_free, d / sblock.fs_frag))
7374234Smckusick 			goto goth;
7384234Smckusick 	printf("internal error: can't find block in cyl 0\n");
7394234Smckusick 	return (0);
7404234Smckusick goth:
7415324Smckusic 	clrblock(&sblock, acg.cg_free, d / sblock.fs_frag);
7424788Smckusic 	acg.cg_cs.cs_nbfree--;
7434788Smckusic 	sblock.fs_cstotal.cs_nbfree--;
7444234Smckusick 	fscs[0].cs_nbfree--;
7454427Smckusic 	if (mode & IFDIR) {
7464788Smckusic 		acg.cg_cs.cs_ndir++;
7474788Smckusic 		sblock.fs_cstotal.cs_ndir++;
7484427Smckusic 		fscs[0].cs_ndir++;
7494427Smckusic 	}
7505370Smckusic 	acg.cg_btot[cbtocylno(&sblock, d)]--;
7515362Smckusic 	acg.cg_b[cbtocylno(&sblock, d)][cbtorpos(&sblock, d)]--;
7525324Smckusic 	if (size != sblock.fs_bsize) {
7535324Smckusic 		frag = howmany(size, sblock.fs_fsize);
7545324Smckusic 		fscs[0].cs_nffree += sblock.fs_frag - frag;
7555324Smckusic 		sblock.fs_cstotal.cs_nffree += sblock.fs_frag - frag;
7565324Smckusic 		acg.cg_cs.cs_nffree += sblock.fs_frag - frag;
7575324Smckusic 		acg.cg_frsum[sblock.fs_frag - frag]++;
7585324Smckusic 		for (i = frag; i < sblock.fs_frag; i++)
7596532Smckusick 			setbit(acg.cg_free, d + i);
7604234Smckusick 	}
7615955Smckusic 	wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
7625955Smckusic 	    (char *)&acg);
7634234Smckusick 	return (d);
7644234Smckusick }
7654234Smckusick 
7665336Smckusic /*
7675336Smckusic  * Allocate an inode on the disk
7685336Smckusic  */
7695336Smckusic iput(ip)
7705336Smckusic 	register struct inode *ip;
7714234Smckusick {
7725336Smckusic 	struct dinode buf[MAXINOPB];
7735336Smckusic 	daddr_t d;
7745336Smckusic 	int c;
7754234Smckusick 
7765383Smckusic 	c = itog(&sblock, ip->i_number);
7775955Smckusic 	rdfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
7785955Smckusic 	    (char *)&acg);
7796532Smckusick 	if (acg.cg_magic != CG_MAGIC) {
7806532Smckusick 		printf("cg 0: bad magic number\n");
7816532Smckusick 		exit(1);
7826532Smckusick 	}
7835336Smckusic 	acg.cg_cs.cs_nifree--;
7845336Smckusic 	setbit(acg.cg_iused, ip->i_number);
7855955Smckusic 	wtfs(fsbtodb(&sblock, cgtod(&sblock, 0)), sblock.fs_cgsize,
7865955Smckusic 	    (char *)&acg);
7875336Smckusic 	sblock.fs_cstotal.cs_nifree--;
7885336Smckusic 	fscs[0].cs_nifree--;
7895336Smckusic 	if(ip->i_number >= sblock.fs_ipg * sblock.fs_ncg) {
7905336Smckusic 		printf("fsinit: inode value out of range (%d).\n",
7915336Smckusic 		    ip->i_number);
7925336Smckusic 		exit(1);
7935336Smckusic 	}
7945383Smckusic 	d = fsbtodb(&sblock, itod(&sblock, ip->i_number));
7955336Smckusic 	rdfs(d, sblock.fs_bsize, buf);
7965383Smckusic 	buf[itoo(&sblock, ip->i_number)].di_ic = ip->i_ic;
7975336Smckusic 	wtfs(d, sblock.fs_bsize, buf);
7984234Smckusick }
7994234Smckusick 
8005336Smckusic /*
8015336Smckusic  * read a block from the file system
8025336Smckusic  */
8035336Smckusic rdfs(bno, size, bf)
8045336Smckusic 	daddr_t bno;
8054427Smckusic 	int size;
8065336Smckusic 	char *bf;
8074234Smckusick {
8085336Smckusic 	int n;
8094234Smckusick 
81030381Smckusick 	if (lseek(fsi, bno * sectorsize, 0) < 0) {
8115346Smckusic 		printf("seek error: %ld\n", bno);
8125346Smckusic 		perror("rdfs");
8135346Smckusic 		exit(1);
8145346Smckusic 	}
8155336Smckusic 	n = read(fsi, bf, size);
8165336Smckusic 	if(n != size) {
8175336Smckusic 		printf("read error: %ld\n", bno);
8185346Smckusic 		perror("rdfs");
8195336Smckusic 		exit(1);
8204234Smckusick 	}
8214234Smckusick }
8224234Smckusick 
8235336Smckusic /*
8245336Smckusic  * write a block to the file system
8255336Smckusic  */
8265336Smckusic wtfs(bno, size, bf)
8275336Smckusic 	daddr_t bno;
8285336Smckusic 	int size;
8295336Smckusic 	char *bf;
8304234Smckusick {
8315336Smckusic 	int n;
8324234Smckusick 
83316944Smckusick 	if (Nflag)
83416944Smckusick 		return;
83530381Smckusick 	if (lseek(fso, bno * sectorsize, 0) < 0) {
8365346Smckusic 		printf("seek error: %ld\n", bno);
8375346Smckusic 		perror("wtfs");
8385346Smckusic 		exit(1);
8395346Smckusic 	}
8405336Smckusic 	n = write(fso, bf, size);
8415336Smckusic 	if(n != size) {
8425336Smckusic 		printf("write error: %D\n", bno);
8435346Smckusic 		perror("wtfs");
8444234Smckusick 		exit(1);
8454234Smckusick 	}
8464234Smckusick }
8475324Smckusic 
8485324Smckusic /*
8495336Smckusic  * check if a block is available
8505324Smckusic  */
8515324Smckusic isblock(fs, cp, h)
8525324Smckusic 	struct fs *fs;
8535324Smckusic 	unsigned char *cp;
8545324Smckusic 	int h;
8555324Smckusic {
8565324Smckusic 	unsigned char mask;
8575324Smckusic 
8585324Smckusic 	switch (fs->fs_frag) {
8595324Smckusic 	case 8:
8605324Smckusic 		return (cp[h] == 0xff);
8615324Smckusic 	case 4:
8625324Smckusic 		mask = 0x0f << ((h & 0x1) << 2);
8635324Smckusic 		return ((cp[h >> 1] & mask) == mask);
8645324Smckusic 	case 2:
8655324Smckusic 		mask = 0x03 << ((h & 0x3) << 1);
8665324Smckusic 		return ((cp[h >> 2] & mask) == mask);
8675324Smckusic 	case 1:
8685324Smckusic 		mask = 0x01 << (h & 0x7);
8695324Smckusic 		return ((cp[h >> 3] & mask) == mask);
8705324Smckusic 	default:
8718140Smckusick #ifdef STANDALONE
8728140Smckusick 		printf("isblock bad fs_frag %d\n", fs->fs_frag);
8738140Smckusick #else
8745324Smckusic 		fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
8758140Smckusick #endif
876*34083Sbostic 		return (0);
8775324Smckusic 	}
8785324Smckusic }
8795324Smckusic 
8805336Smckusic /*
8815336Smckusic  * take a block out of the map
8825336Smckusic  */
8835324Smckusic clrblock(fs, cp, h)
8845324Smckusic 	struct fs *fs;
8855324Smckusic 	unsigned char *cp;
8865324Smckusic 	int h;
8875324Smckusic {
8885324Smckusic 	switch ((fs)->fs_frag) {
8895324Smckusic 	case 8:
8905324Smckusic 		cp[h] = 0;
8915324Smckusic 		return;
8925324Smckusic 	case 4:
8935324Smckusic 		cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2));
8945324Smckusic 		return;
8955324Smckusic 	case 2:
8965324Smckusic 		cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1));
8975324Smckusic 		return;
8985324Smckusic 	case 1:
8995324Smckusic 		cp[h >> 3] &= ~(0x01 << (h & 0x7));
9005324Smckusic 		return;
9015324Smckusic 	default:
9028140Smckusick #ifdef STANDALONE
9038140Smckusick 		printf("clrblock bad fs_frag %d\n", fs->fs_frag);
9048140Smckusick #else
9055324Smckusic 		fprintf(stderr, "clrblock bad fs_frag %d\n", fs->fs_frag);
9068140Smckusick #endif
9075324Smckusic 		return;
9085324Smckusic 	}
9095324Smckusic }
9105324Smckusic 
9115336Smckusic /*
9125336Smckusic  * put a block into the map
9135336Smckusic  */
9145324Smckusic setblock(fs, cp, h)
9155324Smckusic 	struct fs *fs;
9165324Smckusic 	unsigned char *cp;
9175324Smckusic 	int h;
9185324Smckusic {
9195324Smckusic 	switch (fs->fs_frag) {
9205324Smckusic 	case 8:
9215324Smckusic 		cp[h] = 0xff;
9225324Smckusic 		return;
9235324Smckusic 	case 4:
9245324Smckusic 		cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
9255324Smckusic 		return;
9265324Smckusic 	case 2:
9275324Smckusic 		cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
9285324Smckusic 		return;
9295324Smckusic 	case 1:
9305324Smckusic 		cp[h >> 3] |= (0x01 << (h & 0x7));
9315324Smckusic 		return;
9325324Smckusic 	default:
9338140Smckusick #ifdef STANDALONE
9348140Smckusick 		printf("setblock bad fs_frag %d\n", fs->fs_frag);
9358140Smckusick #else
9365324Smckusic 		fprintf(stderr, "setblock bad fs_frag %d\n", fs->fs_frag);
9378140Smckusick #endif
9385324Smckusic 		return;
9395324Smckusic 	}
9405324Smckusic }
941