pass5()
{
int c, blk, frags, sumsize, mapsize;
daddr_t dbase, dmax, d;
register long i, j;
struct csum *cs;
time_t now;
struct csum cstotal;
struct inodesc idesc;
char buf[MAXBSIZE];
register struct cg *newcg = (struct cg *)buf;
bzero((char *)newcg, sblock.fs_cgsize);
newcg->cg_magic = CG_MAGIC;
bzero((char *)&idesc, sizeof(struct inodesc));
idesc.id_type = ADDR;
bzero((char *)&cstotal, sizeof(struct csum));
sumsize = cgrp.cg_iused - (char *)(&cgrp);
mapsize = &cgrp.cg_free[howmany(sblock.fs_fpg, NBBY)] -
(u_char *)cgrp.cg_iused;
(void)time(&now);
for (c = 0; c < sblock.fs_ncg; c++) {
getblk(&cgblk, cgtod(&sblock, c), sblock.fs_cgsize);
if (cgrp.cg_magic != CG_MAGIC)
pfatal("CG %d: BAD MAGIC NUMBER\n", c);
dbase = cgbase(&sblock, c);
dmax = dbase + sblock.fs_fpg;
if (dmax > sblock.fs_size)
dmax = sblock.fs_size;
if (now > cgrp.cg_time)
newcg->cg_time = cgrp.cg_time;
else
newcg->cg_time = now;
newcg->cg_cgx = c;
if (c == sblock.fs_ncg - 1)
newcg->cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg;
else
newcg->cg_ncyl = sblock.fs_cpg;
newcg->cg_niblk = sblock.fs_ipg;
newcg->cg_ndblk = dmax - dbase;
newcg->cg_cs.cs_ndir = 0;
newcg->cg_cs.cs_nffree = 0;
newcg->cg_cs.cs_nbfree = 0;
newcg->cg_cs.cs_nifree = sblock.fs_ipg;
if (cgrp.cg_rotor < newcg->cg_ndblk)
newcg->cg_rotor = cgrp.cg_rotor;
else
newcg->cg_rotor = 0;
if (cgrp.cg_frotor < newcg->cg_ndblk)
newcg->cg_frotor = cgrp.cg_frotor;
else
newcg->cg_frotor = 0;
if (cgrp.cg_irotor < newcg->cg_niblk)
newcg->cg_irotor = cgrp.cg_irotor;
else
newcg->cg_irotor = 0;
bzero((char *)newcg->cg_frsum, sizeof newcg->cg_frsum);
bzero((char *)newcg->cg_btot, sizeof newcg->cg_btot);
bzero((char *)newcg->cg_b, sizeof newcg->cg_b);
bzero((char *)newcg->cg_free, howmany(sblock.fs_fpg, NBBY));
bzero((char *)newcg->cg_iused, howmany(sblock.fs_ipg, NBBY));
j = sblock.fs_ipg * c;
for (i = 0; i < sblock.fs_ipg; j++, i++) {
switch (statemap[j]) {
case USTATE:
break;
case DSTATE:
case DCLEAR:
case DFOUND:
newcg->cg_cs.cs_ndir++;
/* fall through */
case FSTATE:
case FCLEAR:
newcg->cg_cs.cs_nifree--;
setbit(newcg->cg_iused, i);
break;
default:
if (j < ROOTINO)
break;
errexit("BAD STATE %d FOR INODE I=%d",
statemap[j], j);
}
}
if (c == 0)
for (i = 0; i < ROOTINO; i++) {
setbit(newcg->cg_iused, i);
newcg->cg_cs.cs_nifree--;
}
for (i = 0, d = dbase;
d <= dmax - sblock.fs_frag;
d += sblock.fs_frag, i += sblock.fs_frag) {
frags = 0;
for (j = 0; j < sblock.fs_frag; j++) {
if (getbmap(d + j))
continue;
setbit(newcg->cg_free, i + j);
frags++;
}
if (frags == sblock.fs_frag) {
newcg->cg_cs.cs_nbfree++;
j = cbtocylno(&sblock, i);
newcg->cg_btot[j]++;
newcg->cg_b[j][cbtorpos(&sblock, i)]++;
} else if (frags > 0) {
newcg->cg_cs.cs_nffree += frags;
blk = blkmap(&sblock, newcg->cg_free, i);
fragacct(&sblock, blk, newcg->cg_frsum, 1);
}
}
for (frags = d; d < dmax; d++) {
if (getbmap(d))
continue;
setbit(newcg->cg_free, d - dbase);
newcg->cg_cs.cs_nffree++;
}
if (frags != d) {
blk = blkmap(&sblock, newcg->cg_free, (frags - dbase));
fragacct(&sblock, blk, newcg->cg_frsum, 1);
}
cstotal.cs_nffree += newcg->cg_cs.cs_nffree;
cstotal.cs_nbfree += newcg->cg_cs.cs_nbfree;
cstotal.cs_nifree += newcg->cg_cs.cs_nifree;
cstotal.cs_ndir += newcg->cg_cs.cs_ndir;
if (bcmp(newcg->cg_iused, cgrp.cg_iused, mapsize) != 0 &&
dofix(&idesc, "BLK(S) MISSING IN BIT MAPS")) {
bcopy(newcg->cg_iused, cgrp.cg_iused, mapsize);
cgdirty();
}
if (bcmp((char *)newcg, (char *)&cgrp, sumsize) != 0 &&
dofix(&idesc, "SUMMARY INFORMATION BAD")) {
bcopy((char *)newcg, (char *)&cgrp, sumsize);
cgdirty();
}
cs = &sblock.fs_cs(&sblock, c);
if (bcmp((char *)&newcg->cg_cs, (char *)cs, sizeof *cs) != 0 &&
dofix(&idesc, "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
bcopy((char *)&newcg->cg_cs, (char *)cs, sizeof *cs);
sbdirty();
}
}
if (bcmp((char *)&cstotal, (char *)&sblock.fs_cstotal, sizeof *cs) != 0
&& dofix(&idesc, "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
bcopy((char *)&cstotal, (char *)&sblock.fs_cstotal, sizeof *cs);
sblock.fs_ronly = 0;
sblock.fs_fmod = 0;
sbdirty();
}
}
makefree()
{
register i, cyl, step;
int j;
char flg[MAXCYL];
short addr[MAXCYL];
daddr_t blk, baseblk;
sblock.fs_nfree = 0;
sblock.fs_flock = 0;
sblock.fs_fmod = 0;
sblock.fs_tfree = 0;
sblock.fs_ninode = 0;
sblock.fs_ilock = 0;
sblock.fs_ronly = 0;
if(cylsize == 0 || stepsize == 0) {
step = sblock.fs_step;
cyl = sblock.fs_cyl;
}
else {
step = stepsize;
cyl = cylsize;
}
if(step > cyl || step <= 0 || cyl <= 0 || cyl > MAXCYL) {
printf("Default free list spacing assumed\n");
step = STEPSIZE;
cyl = CYLSIZE;
}
sblock.fs_step = step;
sblock.fs_cyl = cyl;
bzero(flg,sizeof(flg));
i = 0;
for(j = 0; j < cyl; j++) {
while(flg[i])
i = (i + 1) % cyl;
addr[j] = i + 1;
flg[i]++;
i = (i + step) % cyl;
}
baseblk = (daddr_t)roundup(fmax,cyl);
bzero((char *)&freeblk,DEV_BSIZE);
freeblk.df_nfree++;
for( ; baseblk > 0; baseblk -= cyl)
for(i = 0; i < cyl; i++) {
blk = baseblk - addr[i];
if(!outrange(blk) && !getbmap(blk)) {
sblock.fs_tfree++;
if(freeblk.df_nfree >= NICFREE) {
fbdirty();
fileblk.b_bno = blk;
flush(&dfile,&fileblk);
bzero((char *)&freeblk,DEV_BSIZE);
}
freeblk.df_free[freeblk.df_nfree] = blk;
freeblk.df_nfree++;
}
}
sblock.fs_nfree = freeblk.df_nfree;
for(i = 0; i < NICFREE; i++)
sblock.fs_free[i] = freeblk.df_free[i];
sbdirty();
}
pass5()
{
int c, blk, frags, basesize, sumsize, mapsize, savednrpos;
register struct fs *fs = &sblock;
register struct cg *cg = &cgrp;
daddr_t dbase, dmax;
register daddr_t d;
register long i, j;
struct csum *cs;
time_t now;
struct csum cstotal;
struct inodesc idesc;
char buf[MAXBSIZE];
register struct cg *newcg = (struct cg *)buf;
struct ocg *ocg = (struct ocg *)buf;
bzero((char *)newcg, fs->fs_cgsize);
newcg->cg_niblk = fs->fs_ipg;
switch (fs->fs_postblformat) {
case FS_42POSTBLFMT:
basesize = (char *)(&ocg->cg_btot[0]) - (char *)(&ocg->cg_link);
sumsize = &ocg->cg_iused[0] - (char *)(&ocg->cg_btot[0]);
mapsize = &ocg->cg_free[howmany(fs->fs_fpg, NBBY)] -
(u_char *)&ocg->cg_iused[0];
ocg->cg_magic = CG_MAGIC;
savednrpos = fs->fs_nrpos;
fs->fs_nrpos = 8;
break;
case FS_DYNAMICPOSTBLFMT:
newcg->cg_btotoff =
&newcg->cg_space[0] - (u_char *)(&newcg->cg_link);
newcg->cg_boff =
newcg->cg_btotoff + fs->fs_cpg * sizeof(long);
newcg->cg_iusedoff = newcg->cg_boff +
fs->fs_cpg * fs->fs_nrpos * sizeof(short);
newcg->cg_freeoff =
newcg->cg_iusedoff + howmany(fs->fs_ipg, NBBY);
newcg->cg_nextfreeoff = newcg->cg_freeoff +
howmany(fs->fs_cpg * fs->fs_spc / NSPF(fs),
NBBY);
newcg->cg_magic = CG_MAGIC;
basesize = &newcg->cg_space[0] - (u_char *)(&newcg->cg_link);
sumsize = newcg->cg_iusedoff - newcg->cg_btotoff;
mapsize = newcg->cg_nextfreeoff - newcg->cg_iusedoff;
break;
default:
errexit("UNKNOWN ROTATIONAL TABLE FORMAT %d\n",
fs->fs_postblformat);
}
bzero((char *)&idesc, sizeof(struct inodesc));
idesc.id_type = ADDR;
bzero((char *)&cstotal, sizeof(struct csum));
(void)time(&now);
for (i = fs->fs_size; i < fragroundup(fs, fs->fs_size); i++)
setbmap(i);
for (c = 0; c < fs->fs_ncg; c++) {
getblk(&cgblk, cgtod(fs, c), fs->fs_cgsize);
if (!cg_chkmagic(cg))
pfatal("CG %d: BAD MAGIC NUMBER\n", c);
dbase = cgbase(fs, c);
dmax = dbase + fs->fs_fpg;
if (dmax > fs->fs_size)
dmax = fs->fs_size;
if (now > cg->cg_time)
newcg->cg_time = cg->cg_time;
else
newcg->cg_time = now;
newcg->cg_cgx = c;
if (c == fs->fs_ncg - 1)
newcg->cg_ncyl = fs->fs_ncyl % fs->fs_cpg;
else
newcg->cg_ncyl = fs->fs_cpg;
newcg->cg_ndblk = dmax - dbase;
newcg->cg_cs.cs_ndir = 0;
newcg->cg_cs.cs_nffree = 0;
newcg->cg_cs.cs_nbfree = 0;
newcg->cg_cs.cs_nifree = fs->fs_ipg;
if (cg->cg_rotor < newcg->cg_ndblk)
newcg->cg_rotor = cg->cg_rotor;
else
newcg->cg_rotor = 0;
if (cg->cg_frotor < newcg->cg_ndblk)
newcg->cg_frotor = cg->cg_frotor;
else
newcg->cg_frotor = 0;
if (cg->cg_irotor < newcg->cg_niblk)
newcg->cg_irotor = cg->cg_irotor;
else
newcg->cg_irotor = 0;
bzero((char *)&newcg->cg_frsum[0], sizeof newcg->cg_frsum);
bzero((char *)&cg_blktot(newcg)[0], sumsize + mapsize);
if (fs->fs_postblformat == FS_42POSTBLFMT)
ocg->cg_magic = CG_MAGIC;
j = fs->fs_ipg * c;
for (i = 0; i < fs->fs_ipg; j++, i++) {
switch (statemap[j]) {
case USTATE:
break;
case DSTATE:
case DCLEAR:
case DFOUND:
newcg->cg_cs.cs_ndir++;
/* fall through */
case FSTATE:
case FCLEAR:
newcg->cg_cs.cs_nifree--;
setbit(cg_inosused(newcg), i);
break;
default:
if (j < ROOTINO)
break;
errexit("BAD STATE %d FOR INODE I=%d",
statemap[j], j);
}
}
if (c == 0)
for (i = 0; i < ROOTINO; i++) {
setbit(cg_inosused(newcg), i);
newcg->cg_cs.cs_nifree--;
}
for (i = 0, d = dbase;
d < dmax;
d += fs->fs_frag, i += fs->fs_frag) {
frags = 0;
for (j = 0; j < fs->fs_frag; j++) {
if (getbmap(d + j))
continue;
setbit(cg_blksfree(newcg), i + j);
frags++;
}
if (frags == fs->fs_frag) {
newcg->cg_cs.cs_nbfree++;
j = cbtocylno(fs, i);
cg_blktot(newcg)[j]++;
cg_blks(fs, newcg, j)[cbtorpos(fs, i)]++;
} else if (frags > 0) {
newcg->cg_cs.cs_nffree += frags;
blk = blkmap(fs, cg_blksfree(newcg), i);
fragacct(fs, blk, newcg->cg_frsum, 1);
}
}
cstotal.cs_nffree += newcg->cg_cs.cs_nffree;
cstotal.cs_nbfree += newcg->cg_cs.cs_nbfree;
cstotal.cs_nifree += newcg->cg_cs.cs_nifree;
cstotal.cs_ndir += newcg->cg_cs.cs_ndir;
cs = &fs->fs_cs(fs, c);
if (bcmp((char *)&newcg->cg_cs, (char *)cs, sizeof *cs) != 0 &&
dofix(&idesc, "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
bcopy((char *)&newcg->cg_cs, (char *)cs, sizeof *cs);
sbdirty();
}
if (cvtflag) {
bcopy((char *)newcg, (char *)cg, fs->fs_cgsize);
cgdirty();
continue;
}
if (bcmp(cg_inosused(newcg),
cg_inosused(cg), mapsize) != 0 &&
dofix(&idesc, "BLK(S) MISSING IN BIT MAPS")) {
bcopy(cg_inosused(newcg), cg_inosused(cg), mapsize);
cgdirty();
}
if ((bcmp((char *)newcg, (char *)cg, basesize) != 0 ||
bcmp((char *)&cg_blktot(newcg)[0],
(char *)&cg_blktot(cg)[0], sumsize) != 0) &&
dofix(&idesc, "SUMMARY INFORMATION BAD")) {
bcopy((char *)newcg, (char *)cg, basesize);
bcopy((char *)&cg_blktot(newcg)[0],
(char *)&cg_blktot(cg)[0], sumsize);
cgdirty();
}
}
if (fs->fs_postblformat == FS_42POSTBLFMT)
fs->fs_nrpos = savednrpos;
if (bcmp((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs) != 0
&& dofix(&idesc, "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
bcopy((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs);
fs->fs_ronly = 0;
fs->fs_fmod = 0;
sbdirty();
}
}
