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