#include <afsconfig.h>
#include <afs/param.h>
-RCSID("$Header$");
+#include <roken.h>
+
+#include <ctype.h>
#define VICE
-#include <sys/param.h>
-#include <sys/time.h>
-#ifdef AFS_OSF_ENV
-#include <sys/vnode.h>
-#include <sys/mount.h>
-#include <ufs/inode.h>
-#include <ufs/fs.h>
-#define _BSD
-#define _KERNEL
-#include <ufs/dir.h>
-#undef _KERNEL
-#undef _BSD
-#include <stdio.h>
-#else /* AFS_OSF_ENV */
#ifdef AFS_VFSINCL_ENV
#include <sys/vnode.h>
#ifdef AFS_SUN5_ENV
-#include <stdio.h>
-#include <unistd.h>
#include <sys/fs/ufs_inode.h>
#include <sys/fs/ufs_fs.h>
#define _KERNEL
#else /* AFS_VFSINCL_ENV */
#include <sys/inode.h>
#ifdef AFS_HPUX_ENV
-#include <ctype.h>
#define LONGFILENAMES 1
#include <sys/sysmacros.h>
#include <sys/ino.h>
#endif
#include <sys/fs.h>
#endif /* AFS_VFSINCL_ENV */
-#endif /* AFS_OSF_ENV */
#include <afs/osi_inode.h>
#include "fsck.h"
-#if defined(AFS_SUN_ENV) || defined(AFS_OSF_ENV)
+#if defined(AFS_SUN_ENV)
#define AFS_NEWCG_ENV
#else
#undef AFS_NEWCG_ENV
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[3];
- char buf[MAXBSIZE];
- int postype;
+ int c, blk, frags, basesize, sumsize, mapsize, savednrpos;
+ struct fs *fs = &sblock;
+ struct cg *cg = &cgrp;
+ daddr_t dbase, dmax;
+ daddr_t d;
+ long i, j;
+ struct csum *cs;
+ time_t now;
+ struct csum cstotal;
+ struct inodesc idesc[3];
+ char buf[MAXBSIZE];
+ int postype;
#ifdef AFS_NEWCG_ENV
- register struct cg *newcg = (struct cg *)buf;
- struct ocg *ocg = (struct ocg *)buf;
+ struct cg *newcg = (struct cg *)buf;
+ struct ocg *ocg = (struct ocg *)buf;
#else /* AFS_NEWCG_ENV */
- /* don't bother with newcg format yet, most systems don't support it */
- register struct cg *newcg = (struct cg *) buf;
- struct cg *ocg = (struct cg *) buf;
+ /* don't bother with newcg format yet, most systems don't support it */
+ struct cg *newcg = (struct cg *)buf;
+ struct cg *ocg = (struct cg *)buf;
#endif /* AFS_NEWCG_ENV */
- bzero((char *)newcg, (int)fs->fs_cgsize);
- newcg->cg_niblk = fs->fs_ipg;
+ memset(newcg, 0, (int)fs->fs_cgsize);
+ newcg->cg_niblk = fs->fs_ipg;
#ifdef AFS_NEWCG_ENV
- postype = (int) fs->fs_postblformat;
+ postype = (int)fs->fs_postblformat;
#else /* AFS_NEWCG_ENV */
- postype = FS_42POSTBLFMT;
+ postype = FS_42POSTBLFMT;
#endif /* AFS_NEWCG_ENV */
- switch (postype) {
+ switch (postype) {
- 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;
+ 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;
#ifdef AFS_NEWCG_ENV
- savednrpos = fs->fs_nrpos;
- fs->fs_nrpos = 8;
+ savednrpos = fs->fs_nrpos;
+ fs->fs_nrpos = 8;
#endif /* AFS_NEWCG_ENV */
- break;
+ break;
#ifdef AFS_NEWCG_ENV
- case FS_DYNAMICPOSTBLFMT:
- newcg->cg_btotoff =
+ case FS_DYNAMICPOSTBLFMT:
+ newcg->cg_btotoff =
#ifdef __alpha
- /* Matches decl in ufs/fs.h */
- &newcg->cg_space[0] - (u_char *)(&newcg->cg_link[0]);
-#else /* __alpha */
- &newcg->cg_space[0] - (u_char *)(&newcg->cg_link);
+ /* Matches decl in ufs/fs.h */
+ &newcg->cg_space[0] - (u_char *) (&newcg->cg_link[0]);
+#else /* __alpha */
+ &newcg->cg_space[0] - (u_char *) (&newcg->cg_link);
#endif
- newcg->cg_boff =
- newcg->cg_btotoff + fs->fs_cpg * sizeof(afs_int32);
- 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;
+ newcg->cg_boff = newcg->cg_btotoff + fs->fs_cpg * sizeof(afs_int32);
+ 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;
#ifdef __alpha
- /* Matches decl in ufs/fs.h */
- basesize = &newcg->cg_space[0] - (u_char *)(&newcg->cg_link[0]);
-#else /* __alpha */
- basesize = &newcg->cg_space[0] - (u_char *)(&newcg->cg_link);
+ /* Matches decl in ufs/fs.h */
+ basesize = &newcg->cg_space[0] - (u_char *) (&newcg->cg_link[0]);
+#else /* __alpha */
+ basesize = &newcg->cg_space[0] - (u_char *) (&newcg->cg_link);
#endif
- sumsize = newcg->cg_iusedoff - newcg->cg_btotoff;
- mapsize = newcg->cg_nextfreeoff - newcg->cg_iusedoff;
- break;
+ 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);
+ default:
+ errexit("UNKNOWN ROTATIONAL TABLE FORMAT %d\n", fs->fs_postblformat);
#endif /* AFS_NEWCG_ENV */
- }
- bzero((char *)&idesc[0], sizeof idesc);
- for (i = 0; i < 3; i++)
- idesc[i].id_type = ADDR;
- bzero((char *)&cstotal, sizeof(struct csum));
- (void)time(&now);
+ }
+ memset(&idesc[0], 0, sizeof idesc);
+ for (i = 0; i < 3; i++)
+ idesc[i].id_type = ADDR;
+ memset(&cstotal, 0, sizeof(struct csum));
+ (void)time(&now);
#ifdef notdef
- /* this is the original from UCB/McKusick, but it is clearly wrong. It is
- rounding the # of fragments to the next 1024 (in our case, with a 1K/8K file system),
- while instead it should be rounding to the next block.
-
- In addition, we should be sure that we allocate enough space, but that seems to be
- ensured by the fact that the bitmap is rounded up to the nearest short, and that there
- are never more than 16 frags per block.
- */
- for (i = fs->fs_size; i < fragroundup(fs, fs->fs_size); i++)
+ /* this is the original from UCB/McKusick, but it is clearly wrong. It is
+ * rounding the # of fragments to the next 1024 (in our case, with a 1K/8K file system),
+ * while instead it should be rounding to the next block.
+ *
+ * In addition, we should be sure that we allocate enough space, but that seems to be
+ * ensured by the fact that the bitmap is rounded up to the nearest short, and that there
+ * are never more than 16 frags per block.
+ */
+ for (i = fs->fs_size; i < fragroundup(fs, fs->fs_size); i++)
#else
- c = 1 << fs->fs_fragshift; /* unit to which we want to round */
- for(i=fs->fs_size; i < roundup(fs->fs_size, c); i++)
+ c = 1 << fs->fs_fragshift; /* unit to which we want to round */
+ for (i = fs->fs_size; i < roundup(fs->fs_size, c); i++)
#endif
- setbmap(i);
- for (c = 0; c < fs->fs_ncg; c++) {
- getblk(&cgblk, cgtod(fs, c), fs->fs_cgsize);
+ setbmap(i);
+ for (c = 0; c < fs->fs_ncg; c++) {
+ getblk(&cgblk, cgtod(fs, c), fs->fs_cgsize);
#ifdef AFS_NEWCG_ENV
- if (!cg_chkmagic(cg))
- pfatal("CG %d: BAD MAGIC NUMBER\n", c);
+ if (!cg_chkmagic(cg))
+ pfatal("CG %d: BAD MAGIC NUMBER\n", c);
#else /* AFS_NEWCG_ENV */
- if (cg->cg_magic != CG_MAGIC)
- pfatal("CG %d: BAD MAGIC NUMBER\n", c);
+ if (cg->cg_magic != CG_MAGIC)
+ pfatal("CG %d: BAD MAGIC NUMBER\n", c);
#endif /* AFS_NEWCG_ENV */
- 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);
+ 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;
+ memset(&newcg->cg_frsum[0], 0, sizeof newcg->cg_frsum);
#ifdef AFS_NEWCG_ENV
- bzero((char *)&cg_blktot(newcg)[0], sumsize + mapsize);
+ memset(&cg_blktot(newcg)[0], 0, sumsize + mapsize);
#else /* AFS_NEWCG_ENV */
- bzero((char *)newcg->cg_btot, sizeof(newcg->cg_btot));
- bzero((char *)newcg->cg_b, sizeof(newcg->cg_b));
- bzero((char *)newcg->cg_iused, sizeof(newcg->cg_iused));
- bzero((char *)newcg->cg_free, howmany(fs->fs_fpg, NBBY));
+ memset(newcg->cg_btot, 0, sizeof(newcg->cg_btot));
+ memset(newcg->cg_b, 0, sizeof(newcg->cg_b));
+ memset(newcg->cg_iused, 0, sizeof(newcg->cg_iused));
+ memset(newcg->cg_free, 0, howmany(fs->fs_fpg, NBBY));
#endif /* AFS_NEWCG_ENV */
#ifdef AFS_NEWCG_ENV
- if (fs->fs_postblformat == FS_42POSTBLFMT)
- ocg->cg_magic = CG_MAGIC;
+ if (fs->fs_postblformat == FS_42POSTBLFMT)
+ ocg->cg_magic = CG_MAGIC;
#endif /* AFS_NEWCG_ENV */
- j = fs->fs_ipg * c;
- for (i = 0; i < fs->fs_ipg; j++, i++) {
+ j = fs->fs_ipg * c;
+ for (i = 0; i < fs->fs_ipg; j++, i++) {
#if defined(ACLS) && defined(AFS_HPUX_ENV)
- switch (statemap[j] & STATE) {
+ switch (statemap[j] & STATE) {
#else
- switch (statemap[j]) {
+ switch (statemap[j]) {
#endif
- case USTATE:
- break;
+ case USTATE:
+ break;
- case DSTATE:
- case DCLEAR:
- case DFOUND:
- newcg->cg_cs.cs_ndir++;
- /* fall through */
+ case DSTATE:
+ case DCLEAR:
+ case DFOUND:
+ newcg->cg_cs.cs_ndir++;
+ /* fall through */
#ifdef VICE
- case VSTATE:
+ case VSTATE:
#endif /* VICE */
- case FSTATE:
- case FCLEAR:
- newcg->cg_cs.cs_nifree--;
+ case FSTATE:
+ case FCLEAR:
+ newcg->cg_cs.cs_nifree--;
#ifdef AFS_NEWCG_ENV
- setbit(cg_inosused(newcg), i);
+ setbit(cg_inosused(newcg), i);
#else
- setbit(newcg->cg_iused, i);
+ setbit(newcg->cg_iused, i);
#endif /* AFS_NEWCG_ENV */
- break;
+ break;
#if defined(ACLS) && defined(AFS_HPUX_ENV)
- /* hpux has more dynamic states (CSTATE, CRSTATE) */
- case CSTATE:
- case CRSTATE:
- break;
+ /* hpux has more dynamic states (CSTATE, CRSTATE) */
+ case CSTATE:
+ case CRSTATE:
+ break;
#endif
- 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++) {
+ 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++) {
#ifdef AFS_NEWCG_ENV
- setbit(cg_inosused(newcg), i);
+ setbit(cg_inosused(newcg), i);
#else
- setbit(newcg->cg_iused, i);
+ setbit(newcg->cg_iused, i);
#endif /* AFS_NEWCG_ENV */
- 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 (testbmap(d + j))
- continue;
+ 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 (testbmap(d + j))
+ continue;
#ifdef AFS_NEWCG_ENV
- setbit(cg_blksfree(newcg), i + j);
+ setbit(cg_blksfree(newcg), i + j);
#else /* AFS_NEWCG_ENV */
- setbit(newcg->cg_free, i+j);
+ setbit(newcg->cg_free, i + j);
#endif /* AFS_NEWCG_ENV */
- frags++;
- }
- if (frags == fs->fs_frag) {
- newcg->cg_cs.cs_nbfree++;
- j = cbtocylno(fs, i);
+ frags++;
+ }
+ if (frags == fs->fs_frag) {
+ newcg->cg_cs.cs_nbfree++;
+ j = cbtocylno(fs, i);
#ifdef AFS_NEWCG_ENV
- cg_blktot(newcg)[j]++;
- cg_blks(fs, newcg, j)[cbtorpos(fs, i)]++;
+ cg_blktot(newcg)[j]++;
+ cg_blks(fs, newcg, j)[cbtorpos(fs, i)]++;
#else /* AFS_NEWCG_ENV */
- newcg->cg_btot[j]++;
- newcg->cg_b[j][cbtorpos(fs, i)]++;
+ newcg->cg_btot[j]++;
+ newcg->cg_b[j][cbtorpos(fs, i)]++;
#endif /* AFS_NEWCG_ENV */
- } else if (frags > 0) {
- newcg->cg_cs.cs_nffree += frags;
+ } else if (frags > 0) {
+ newcg->cg_cs.cs_nffree += frags;
#ifdef AFS_NEWCG_ENV
- blk = blkmap(fs, cg_blksfree(newcg), i);
+ blk = blkmap(fs, cg_blksfree(newcg), i);
#else /* AFS_NEWCG_ENV */
- blk = blkmap(fs, newcg->cg_free, i);
+ blk = blkmap(fs, newcg->cg_free, i);
#endif /* AFS_NEWCG_ENV */
- 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[0], "FREE BLK COUNT(S) WRONG IN CYL GROUP (SUPERBLK)")) {
- bcopy((char *)&newcg->cg_cs, (char *)cs, sizeof *cs);
- sbdirty();
- }
+ 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 (memcmp((char *)&newcg->cg_cs, (char *)cs, sizeof *cs) != 0
+ && dofix(&idesc[0],
+ "FREE BLK COUNT(S) WRONG IN CYL GROUP (SUPERBLK)")) {
+ memcpy((char *)cs, (char *)&newcg->cg_cs, sizeof *cs);
+ sbdirty();
+ }
#ifdef AFS_NEWCG_ENV
- if (cvtflag) {
- bcopy((char *)newcg, (char *)cg, (int)fs->fs_cgsize);
- cgdirty();
- continue;
- }
+ if (cvtflag) {
+ memcpy((char *)cg, (char *)newcg, (int)fs->fs_cgsize);
+ cgdirty();
+ continue;
+ }
#endif /* AFS_NEWCG_ENV */
#ifdef AFS_NEWCG_ENV
- if (bcmp(cg_inosused(newcg),
- cg_inosused(cg), mapsize) != 0 &&
- dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) {
- bcopy(cg_inosused(newcg), cg_inosused(cg), mapsize);
- cgdirty();
- }
+ if (memcmp(cg_inosused(newcg), cg_inosused(cg), mapsize) != 0
+ && dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) {
+ memcpy(cg_inosused(cg), cg_inosused(newcg), mapsize);
+ cgdirty();
+ }
#else /* AFS_NEWCG_ENV */
- if (bcmp(newcg->cg_iused,
- cg->cg_iused, mapsize) != 0 &&
- dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) {
- bcopy(newcg->cg_iused, cg->cg_iused, mapsize);
- cgdirty();
- }
+ if (memcmp(newcg->cg_iused, cg->cg_iused, mapsize) != 0
+ && dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) {
+ memcpy(cg->cg_iused, newcg->cg_iused, mapsize);
+ cgdirty();
+ }
#endif /* AFS_NEWCG_ENV */
- if ((bcmp((char *)newcg, (char *)cg, basesize) != 0 ||
+ if ((memcmp((char *)newcg, (char *)cg, basesize) != 0 ||
#ifdef AFS_NEWCG_ENV
- bcmp((char *)&cg_blktot(newcg)[0],
- (char *)&cg_blktot(cg)[0], sumsize) != 0) &&
+ memcmp((char *)&cg_blktot(newcg)[0], (char *)&cg_blktot(cg)[0],
+ sumsize) != 0) &&
#else /* AFS_NEWCG_ENV */
- bcmp((char *)newcg->cg_btot,
- (char *)cg->cg_btot, sumsize) != 0) &&
+ memcmp((char *)newcg->cg_btot, (char *)cg->cg_btot,
+ sumsize) != 0) &&
#endif /* AFS_NEWCG_ENV */
- dofix(&idesc[2], "SUMMARY INFORMATION BAD")) {
+ dofix(&idesc[2], "SUMMARY INFORMATION BAD")) {
#ifdef AFS_NEWCG_ENV
- bcopy((char *)newcg, (char *)cg, basesize);
- bcopy((char *)&cg_blktot(newcg)[0],
- (char *)&cg_blktot(cg)[0], sumsize);
+ memcpy((char *)cg, (char *)newcg, basesize);
+ memcpy((char *)&cg_blktot(cg)[0], (char *)&cg_blktot(newcg)[0],
+ sumsize);
#else /* AFS_NEWCG_ENV */
- bcopy((char *)newcg, (char *)cg, basesize);
- bcopy((char *)newcg->cg_btot, (char *)cg->cg_btot, sumsize);
+ memcpy((char *)cg, (char *)newcg, basesize);
+ memcpy((char *)cg->cg_btot, (char *)newcg->cg_btot, sumsize);
#endif /* AFS_NEWCG_ENV */
- cgdirty();
- }
+ cgdirty();
}
+ }
#ifdef AFS_NEWCG_ENV
- if (fs->fs_postblformat == FS_42POSTBLFMT)
- fs->fs_nrpos = savednrpos;
+ if (fs->fs_postblformat == FS_42POSTBLFMT)
+ fs->fs_nrpos = savednrpos;
#endif /* AFS_NEWCG_ENV */
- if (bcmp((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs) != 0
- && dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
- bcopy((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs);
- fs->fs_ronly = 0;
- sbfine(fs);
- sbdirty();
- }
-#if defined(AFS_DEC_ENV)
- if (sbfine(fs)) {
- int oldmod;
- /* don't change fsmodified here, or fsck will think that modified
- mounted file system requires reboot, when it is really fine
- (since it is mounted, and thus clean flag doesn't matter) */
- oldmod = fsmodified;
- sbdirty();
- flush(fswritefd, &sblk);
- fsmodified = oldmod;
- }
-#endif
+ if (memcmp((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs) != 0
+ && dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
+ memcpy((char *)&fs->fs_cstotal, (char *)&cstotal, sizeof *cs);
+ fs->fs_ronly = 0;
+ sbfine(fs);
+ sbdirty();
+ }
}
/* returns true if sbdirty should be called */
sbfine(fs)
-register struct fs *fs; {
+ struct fs *fs;
+{
int rcode;
rcode = 0;
-#if defined(AFS_DEC_ENV)
- if (fs->fs_fmod != 0 || fs->fs_clean != FS_CLEAN) {
- fs->fs_fmod = 0;
- fs->fs_clean = FS_CLEAN;
- rcode = 1;
- }
- if(fs->fs_deftimer) {
- fs->fs_cleantimer = fs->fs_deftimer =
- (fs->fs_deftimer > 0 && fs->fs_deftimer < 255) ? fs->fs_deftimer :
- FSCLEAN_TIMEOUTFACTOR;
- rcode = 1;
- }
-#else
if (fs->fs_fmod != 0) {
fs->fs_fmod = 0;
rcode = 1;
}
-#endif /* AFS_DEC_ENV */
return rcode;
}
git://git.openafs.org / openafs.git / blobdiff