missing a cylinder group in brute force search

[unix-history] / usr / src / sys / ufs / lfs / lfs_alloc.c

diff --git a/usr/src/sys/ufs/lfs/lfs_alloc.c b/usr/src/sys/ufs/lfs/lfs_alloc.c
index 5ab60e3..44b7fb5 100644 (file)
--- a/usr/src/sys/ufs/lfs/lfs_alloc.c
+++ b/usr/src/sys/ufs/lfs/lfs_alloc.c
@@ -1,4 +1,4 @@
-/*     lfs_alloc.c     2.16    82/10/17        */
+/*     lfs_alloc.c     2.22    83/02/10        */

 
 #include "../h/param.h"
 #include "../h/systm.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"


@@ -13,8 +13,8 @@
 #include "../h/kernel.h"
 
 extern u_long          hashalloc();
 #include "../h/kernel.h"
 
 extern u_long          hashalloc();

-extern u_long          ialloccg();
-extern u_long          alloccg();
+extern ino_t           ialloccg();
+extern daddr_t         alloccg();

 extern daddr_t         alloccgblk();
 extern daddr_t         fragextend();
 extern daddr_t         blkpref();
 extern daddr_t         alloccgblk();
 extern daddr_t         fragextend();
 extern daddr_t         blkpref();


@@ -74,7 +74,8 @@ alloc(ip, bpref, size)
                cg = itog(fs, ip->i_number);
        else
                cg = dtog(fs, bpref);
                cg = itog(fs, ip->i_number);
        else
                cg = dtog(fs, bpref);

-       bno = (daddr_t)hashalloc(ip, cg, (long)bpref, size, alloccg);
+       bno = (daddr_t)hashalloc(ip, cg, (long)bpref, size,
+               (u_long (*)())alloccg);

        if (bno <= 0)
                goto nospace;
        bp = getblk(ip->i_dev, fsbtodb(fs, bno), size);
        if (bno <= 0)
                goto nospace;
        bp = getblk(ip->i_dev, fsbtodb(fs, bno), size);


@@ -137,12 +138,13 @@ realloccg(ip, bprev, bpref, osize, nsize)
                        }
                } while (brealloc(bp, nsize) == 0);
                bp->b_flags |= B_DONE;
                        }
                } while (brealloc(bp, nsize) == 0);
                bp->b_flags |= B_DONE;

-               bzero(bp->b_un.b_addr + osize, nsize - osize);
+               bzero(bp->b_un.b_addr + osize, (unsigned)nsize - osize);

                return (bp);
        }
        if (bpref >= fs->fs_size)
                bpref = 0;
                return (bp);
        }
        if (bpref >= fs->fs_size)
                bpref = 0;

-       bno = (daddr_t)hashalloc(ip, cg, (long)bpref, nsize, alloccg);
+       bno = (daddr_t)hashalloc(ip, cg, (long)bpref, nsize,
+               (u_long (*)())alloccg);

        if (bno > 0) {
                obp = bread(ip->i_dev, fsbtodb(fs, bprev), osize);
                if (obp->b_flags & B_ERROR) {
        if (bno > 0) {
                obp = bread(ip->i_dev, fsbtodb(fs, bprev), osize);
                if (obp->b_flags & B_ERROR) {


@@ -151,9 +153,9 @@ realloccg(ip, bprev, bpref, osize, nsize)
                }
                bp = getblk(ip->i_dev, fsbtodb(fs, bno), nsize);
                bcopy(obp->b_un.b_addr, bp->b_un.b_addr, (u_int)osize);
                }
                bp = getblk(ip->i_dev, fsbtodb(fs, bno), nsize);
                bcopy(obp->b_un.b_addr, bp->b_un.b_addr, (u_int)osize);

-               bzero(bp->b_un.b_addr + osize, nsize - osize);
+               bzero(bp->b_un.b_addr + osize, (unsigned)nsize - osize);

                brelse(obp);
                brelse(obp);

-               fre(ip, bprev, (off_t)osize);
+               free(ip, bprev, (off_t)osize);

                return (bp);
        }
 nospace:
                return (bp);
        }
 nospace:


@@ -196,7 +198,7 @@ ialloc(pip, ipref, mode)
        if (fs->fs_cstotal.cs_nifree == 0)
                goto noinodes;
 #ifdef QUOTA
        if (fs->fs_cstotal.cs_nifree == 0)
                goto noinodes;
 #ifdef QUOTA

-       if (chkiq(pip->i_dev, NULL, u.u_uid, 0))
+       if (chkiq(pip->i_dev, (struct inode *)NULL, u.u_uid, 0))

                return(NULL);
 #endif
        if (ipref >= fs->fs_ncg * fs->fs_ipg)
                return(NULL);
 #endif
        if (ipref >= fs->fs_ncg * fs->fs_ipg)


@@ -230,6 +232,7 @@ noinodes:
  * among those cylinder groups with above the average number of
  * free inodes, the one with the smallest number of directories.
  */
  * among those cylinder groups with above the average number of
  * free inodes, the one with the smallest number of directories.
  */

+ino_t

 dirpref(fs)
        register struct fs *fs;
 {
 dirpref(fs)
        register struct fs *fs;
 {


@@ -244,35 +247,85 @@ dirpref(fs)
                        mincg = cg;
                        minndir = fs->fs_cs(fs, cg).cs_ndir;
                }
                        mincg = cg;
                        minndir = fs->fs_cs(fs, cg).cs_ndir;
                }

-       return (fs->fs_ipg * mincg);
+       return ((ino_t)(fs->fs_ipg * mincg));

 }
 
 /*
 }
 
 /*

- * Select a cylinder to place a large block of data.
- *
- * The policy implemented by this algorithm is to maintain a
- * rotor that sweeps the cylinder groups. When a block is 
- * needed, the rotor is advanced until a cylinder group with
- * greater than the average number of free blocks is found.
+ * Select the desired position for the next block in a file.  The file is
+ * logically divided into sections. The first section is composed of the
+ * direct blocks. Each additional section contains fs_maxbpg blocks.
+ * 
+ * If no blocks have been allocated in the first section, the policy is to
+ * request a block in the same cylinder group as the inode that describes
+ * the file. If no blocks have been allocated in any other section, the
+ * policy is to place the section in a cylinder group with a greater than
+ * average number of free blocks.  An appropriate cylinder group is found
+ * by maintaining a rotor that sweeps the cylinder groups. When a new
+ * group of blocks is needed, the rotor is advanced until a cylinder group
+ * with greater than the average number of free blocks is found.
+ * 
+ * If a section is already partially allocated, the policy is to
+ * contiguously allocate fs_maxcontig blocks.  The end of one of these
+ * contiguous blocks and the beginning of the next is physically separated
+ * so that the disk head will be in transit between them for at least
+ * fs_rotdelay milliseconds.  This is to allow time for the processor to
+ * schedule another I/O transfer.

  */
 daddr_t
  */
 daddr_t

-blkpref(fs)
-       register struct fs *fs;
+blkpref(ip, lbn, indx, bap)
+       struct inode *ip;
+       daddr_t lbn;
+       int indx;
+       daddr_t *bap;

 {
 {

+       register struct fs *fs;

        int cg, avgbfree;
        int cg, avgbfree;

+       daddr_t nextblk;

 
 

-       avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;
-       for (cg = fs->fs_cgrotor + 1; cg < fs->fs_ncg; cg++)
-               if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
-                       fs->fs_cgrotor = cg;
-                       return (fs->fs_fpg * cg + fs->fs_frag);
-               }
-       for (cg = 0; cg <= fs->fs_cgrotor; cg++)
-               if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
-                       fs->fs_cgrotor = cg;
+       fs = ip->i_fs;
+       if (indx % fs->fs_maxbpg == 0 || bap[indx - 1] == 0) {
+               if (lbn < NDADDR) {
+                       cg = itog(fs, ip->i_number);

                        return (fs->fs_fpg * cg + fs->fs_frag);
                }
                        return (fs->fs_fpg * cg + fs->fs_frag);
                }

-       return (NULL);
+               /*
+                * Find a cylinder with greater than average number of
+                * unused data blocks.
+                */
+               avgbfree = fs->fs_cstotal.cs_nbfree / fs->fs_ncg;
+               for (cg = fs->fs_cgrotor + 1; cg < fs->fs_ncg; cg++)
+                       if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
+                               fs->fs_cgrotor = cg;
+                               return (fs->fs_fpg * cg + fs->fs_frag);
+                       }
+               for (cg = 0; cg <= fs->fs_cgrotor; cg++)
+                       if (fs->fs_cs(fs, cg).cs_nbfree >= avgbfree) {
+                               fs->fs_cgrotor = cg;
+                               return (fs->fs_fpg * cg + fs->fs_frag);
+                       }
+               return (NULL);
+       }
+       /*
+        * One or more previous blocks have been laid out. If less
+        * than fs_maxcontig previous blocks are contiguous, the
+        * next block is requested contiguously, otherwise it is
+        * requested rotationally delayed by fs_rotdelay milliseconds.
+        */
+       nextblk = bap[indx - 1] + fs->fs_frag;
+       if (indx > fs->fs_maxcontig &&
+           bap[indx - fs->fs_maxcontig] + fs->fs_frag * fs->fs_maxcontig
+           != nextblk)
+               return (nextblk);
+       if (fs->fs_rotdelay != 0)
+               /*
+                * Here we convert ms of delay to frags as:
+                * (frags) = (ms) * (rev/sec) * (sect/rev) /
+                *      ((sect/frag) * (ms/sec))
+                * then round up to the next block.
+                */
+               nextblk += roundup(fs->fs_rotdelay * fs->fs_rps * fs->fs_nsect /
+                   (NSPF(fs) * 1000), fs->fs_frag);
+       return (nextblk);

 }
 
 /*
 }
 
 /*


@@ -316,9 +369,11 @@ hashalloc(ip, cg, pref, size, allocator)
        }
        /*
         * 3: brute force search
        }
        /*
         * 3: brute force search

+        * Note that we start at i == 2, since 0 was checked initially,
+        * and 1 is always checked in the quadratic rehash.

         */
        cg = icg;
         */
        cg = icg;

-       for (i = 0; i < fs->fs_ncg; i++) {
+       for (i = 2; i < fs->fs_ncg; i++) {

                result = (*allocator)(ip, cg, 0, size);
                if (result)
                        return (result);
                result = (*allocator)(ip, cg, 0, size);
                if (result)
                        return (result);


@@ -358,7 +413,7 @@ fragextend(ip, cg, bprev, osize, nsize)
                /* cannot extend across a block boundry */
                return (NULL);
        }
                /* cannot extend across a block boundry */
                return (NULL);
        }

-       bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_bsize);
+       bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize);

        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) {
                brelse(bp);
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) {
                brelse(bp);


@@ -400,7 +455,7 @@ fragextend(ip, cg, bprev, osize, nsize)
  * Check to see if a block of the apprpriate size is available,
  * and if it is, allocate it.
  */
  * Check to see if a block of the apprpriate size is available,
  * and if it is, allocate it.
  */

-u_long
+daddr_t

 alloccg(ip, cg, bpref, size)
        struct inode *ip;
        int cg;
 alloccg(ip, cg, bpref, size)
        struct inode *ip;
        int cg;


@@ -417,12 +472,14 @@ alloccg(ip, cg, bpref, size)
        fs = ip->i_fs;
        if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)
                return (NULL);
        fs = ip->i_fs;
        if (fs->fs_cs(fs, cg).cs_nbfree == 0 && size == fs->fs_bsize)
                return (NULL);

-       bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_bsize);
+       bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize);

        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) {
                brelse(bp);
                return (NULL);
        }
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) {
                brelse(bp);
                return (NULL);
        }

+       if (cgp->cg_cs.cs_nbfree == 0 && size == fs->fs_bsize)
+               return (NULL);

        cgp->cg_time = time.tv_sec;
        if (size == fs->fs_bsize) {
                bno = alloccgblk(fs, cgp, bpref);
        cgp->cg_time = time.tv_sec;
        if (size == fs->fs_bsize) {
                bno = alloccgblk(fs, cgp, bpref);


@@ -455,6 +512,7 @@ alloccg(ip, cg, bpref, size)
                cgp->cg_cs.cs_nffree += i;
                fs->fs_cstotal.cs_nffree += i;
                fs->fs_cs(fs, cg).cs_nffree += i;
                cgp->cg_cs.cs_nffree += i;
                fs->fs_cstotal.cs_nffree += i;
                fs->fs_cs(fs, cg).cs_nffree += i;

+               fs->fs_fmod++;

                cgp->cg_frsum[i]++;
                bdwrite(bp);
                return (bno);
                cgp->cg_frsum[i]++;
                bdwrite(bp);
                return (bno);


@@ -467,6 +525,7 @@ alloccg(ip, cg, bpref, size)
        cgp->cg_cs.cs_nffree -= frags;
        fs->fs_cstotal.cs_nffree -= frags;
        fs->fs_cs(fs, cg).cs_nffree -= frags;
        cgp->cg_cs.cs_nffree -= frags;
        fs->fs_cstotal.cs_nffree -= frags;
        fs->fs_cs(fs, cg).cs_nffree -= frags;

+       fs->fs_fmod++;

        cgp->cg_frsum[allocsiz]--;
        if (frags != allocsiz)
                cgp->cg_frsum[allocsiz - frags]++;
        cgp->cg_frsum[allocsiz]--;
        if (frags != allocsiz)
                cgp->cg_frsum[allocsiz - frags]++;


@@ -505,14 +564,10 @@ alloccgblk(fs, cgp, bpref)
        /*
         * if the requested block is available, use it
         */
        /*
         * if the requested block is available, use it
         */

-/*
- * disallow sequential layout.
- *

        if (isblock(fs, cgp->cg_free, bpref/fs->fs_frag)) {
                bno = bpref;
                goto gotit;
        }
        if (isblock(fs, cgp->cg_free, bpref/fs->fs_frag)) {
                bno = bpref;
                goto gotit;
        }

- */

        /*
         * check for a block available on the same cylinder
         */
        /*
         * check for a block available on the same cylinder
         */


@@ -527,29 +582,13 @@ alloccgblk(fs, cgp, bpref)
                bpref = howmany(fs->fs_spc * cylno, NSPF(fs));
                goto norot;
        }
                bpref = howmany(fs->fs_spc * cylno, NSPF(fs));
                goto norot;
        }

-       /*
-        * find a block that is rotationally optimal
-        */
-       cylbp = cgp->cg_b[cylno];
-       if (fs->fs_rotdelay == 0) {
-               pos = cbtorpos(fs, bpref);
-       } else {
-               /*
-                * here we convert ms of delay to frags as:
-                * (frags) = (ms) * (rev/sec) * (sect/rev) /
-                *      ((sect/frag) * (ms/sec))
-                * then round up to the next rotational position
-                */
-               bpref += fs->fs_rotdelay * fs->fs_rps * fs->fs_nsect /
-                   (NSPF(fs) * 1000);
-               pos = cbtorpos(fs, bpref);
-               pos = (pos + 1) % NRPOS;
-       }

        /*
         * check the summary information to see if a block is 
         * available in the requested cylinder starting at the
        /*
         * check the summary information to see if a block is 
         * available in the requested cylinder starting at the

-        * optimal rotational position and proceeding around.
+        * requested rotational position and proceeding around.

         */
         */

+       cylbp = cgp->cg_b[cylno];
+       pos = cbtorpos(fs, bpref);

        for (i = pos; i < NRPOS; i++)
                if (cylbp[i] > 0)
                        break;
        for (i = pos; i < NRPOS; i++)
                if (cylbp[i] > 0)
                        break;


@@ -592,7 +631,7 @@ norot:
                return (NULL);
        cgp->cg_rotor = bno;
 gotit:
                return (NULL);
        cgp->cg_rotor = bno;
 gotit:

-       clrblock(fs, cgp->cg_free, (int)(bno/fs->fs_frag));
+       clrblock(fs, cgp->cg_free, (long)(bno/fs->fs_frag));

        cgp->cg_cs.cs_nbfree--;
        fs->fs_cstotal.cs_nbfree--;
        fs->fs_cs(fs, cgp->cg_cgx).cs_nbfree--;
        cgp->cg_cs.cs_nbfree--;
        fs->fs_cstotal.cs_nbfree--;
        fs->fs_cs(fs, cgp->cg_cgx).cs_nbfree--;


@@ -612,7 +651,7 @@ gotit:
  *   2) allocate the next available inode after the requested
  *      inode in the specified cylinder group.
  */
  *   2) allocate the next available inode after the requested
  *      inode in the specified cylinder group.
  */

-u_long
+ino_t

 ialloccg(ip, cg, ipref, mode)
        struct inode *ip;
        int cg;
 ialloccg(ip, cg, ipref, mode)
        struct inode *ip;
        int cg;


@@ -627,12 +666,14 @@ ialloccg(ip, cg, ipref, mode)
        fs = ip->i_fs;
        if (fs->fs_cs(fs, cg).cs_nifree == 0)
                return (NULL);
        fs = ip->i_fs;
        if (fs->fs_cs(fs, cg).cs_nifree == 0)
                return (NULL);

-       bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_bsize);
+       bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize);

        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) {
                brelse(bp);
                return (NULL);
        }
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) {
                brelse(bp);
                return (NULL);
        }

+       if (cgp->cg_cs.cs_nifree == 0)
+               return (NULL);

        cgp->cg_time = time.tv_sec;
        if (ipref) {
                ipref %= fs->fs_ipg;
        cgp->cg_time = time.tv_sec;
        if (ipref) {
                ipref %= fs->fs_ipg;


@@ -673,7 +714,7 @@ gotit:
  * free map. If a fragment is deallocated, a possible 
  * block reassembly is checked.
  */
  * free map. If a fragment is deallocated, a possible 
  * block reassembly is checked.
  */

-fre(ip, bno, size)
+free(ip, bno, size)

        register struct inode *ip;
        daddr_t bno;
        off_t size;
        register struct inode *ip;
        daddr_t bno;
        off_t size;


@@ -695,7 +736,7 @@ fre(ip, bno, size)
                printf("bad block %d, ino %d\n", bno, ip->i_number);
                return;
        }
                printf("bad block %d, ino %d\n", bno, ip->i_number);
                return;
        }

-       bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_bsize);
+       bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize);

        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) {
                brelse(bp);
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) {
                brelse(bp);


@@ -784,7 +825,7 @@ ifree(ip, ino, mode)
                panic("ifree: range");
        }
        cg = itog(fs, ino);
                panic("ifree: range");
        }
        cg = itog(fs, ino);

-       bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_bsize);
+       bp = bread(ip->i_dev, fsbtodb(fs, cgtod(fs, cg)), (int)fs->fs_cgsize);

        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) {
                brelse(bp);
        cgp = bp->b_un.b_cg;
        if (bp->b_flags & B_ERROR || cgp->cg_magic != CG_MAGIC) {
                brelse(bp);


@@ -843,12 +884,8 @@ mapsearch(fs, cgp, bpref, allocsiz)
                start = 0;
                loc = scanc(len, &cgp->cg_free[start], fragtbl[fs->fs_frag],
                        1 << (allocsiz - 1 + (fs->fs_frag % NBBY)));
                start = 0;
                loc = scanc(len, &cgp->cg_free[start], fragtbl[fs->fs_frag],
                        1 << (allocsiz - 1 + (fs->fs_frag % NBBY)));

-               if (loc == 0) {
-                       printf("start = %d, len = %d, fs = %s\n",
-                           start, len, fs->fs_fsmnt);
-                       panic("alloccg: map corrupted");
+               if (loc == 0)

                        return (-1);
                        return (-1);

-               }

        }
        bno = (start + len - loc) * NBBY;
        cgp->cg_frotor = bno;
        }
        bno = (start + len - loc) * NBBY;
        cgp->cg_frotor = bno;


@@ -873,37 +910,6 @@ mapsearch(fs, cgp, bpref, allocsiz)
        return (-1);
 }
 
        return (-1);
 }
 

-/*
- * Getfs maps a device number into a pointer to the incore super block.
- *
- * The algorithm is a linear search through the mount table. A
- * consistency check of the super block magic number is performed.
- *
- * panic: no fs -- the device is not mounted.
- *     this "cannot happen"
- */
-struct fs *
-getfs(dev)
-       dev_t dev;
-{
-       register struct mount *mp;
-       register struct fs *fs;
-
-       for (mp = &mount[0]; mp < &mount[NMOUNT]; mp++) {
-               if (mp->m_bufp == NULL || mp->m_dev != dev)
-                       continue;
-               fs = mp->m_bufp->b_un.b_fs;
-               if (fs->fs_magic != FS_MAGIC) {
-                       printf("dev = 0x%x, fs = %s\n", dev, fs->fs_fsmnt);
-                       panic("getfs: bad magic");
-               }
-               return (fs);
-       }
-       printf("dev = 0x%x\n", dev);
-       panic("getfs: no fs");
-       return (NULL);
-}
-

 /*
  * Fserr prints the name of a file system with an error diagnostic.
  * 
 /*
  * Fserr prints the name of a file system with an error diagnostic.
  * 


@@ -917,82 +923,3 @@ fserr(fs, cp)
 
        printf("%s: %s\n", fs->fs_fsmnt, cp);
 }
 
        printf("%s: %s\n", fs->fs_fsmnt, cp);
 }

-
-/*
- * Getfsx returns the index in the file system
- * table of the specified device.  The swap device
- * is also assigned a pseudo-index.  The index may
- * be used as a compressed indication of the location
- * of a block, recording
- *     <getfsx(dev),blkno>
- * rather than
- *     <dev, blkno>
- * provided the information need remain valid only
- * as long as the file system is mounted.
- */
-getfsx(dev)
-       dev_t dev;
-{
-       register struct mount *mp;
-
-       if (dev == swapdev)
-               return (MSWAPX);
-       for(mp = &mount[0]; mp < &mount[NMOUNT]; mp++)
-               if (mp->m_dev == dev)
-                       return (mp - &mount[0]);
-       return (-1);
-}
-
-/*
- * Update is the internal name of 'sync'.  It goes through the disk
- * queues to initiate sandbagged IO; goes through the inodes to write
- * modified nodes; and it goes through the mount table to initiate
- * the writing of the modified super blocks.
- */
-update()
-{
-       register struct inode *ip;
-       register struct mount *mp;
-       struct fs *fs;
-
-       if (updlock)
-               return;
-       updlock++;
-       /*
-        * Write back modified superblocks.
-        * Consistency check that the superblock
-        * of each file system is still in the buffer cache.
-        */
-       for (mp = &mount[0]; mp < &mount[NMOUNT]; mp++) {
-               if (mp->m_bufp == NULL)
-                       continue;
-               fs = mp->m_bufp->b_un.b_fs;
-               if (fs->fs_fmod == 0)
-                       continue;
-               if (fs->fs_ronly != 0) {                /* XXX */
-                       printf("fs = %s\n", fs->fs_fsmnt);
-                       panic("update: rofs mod");
-               }
-               fs->fs_fmod = 0;
-               fs->fs_time = time.tv_sec;
-               sbupdate(mp);
-       }
-       /*
-        * Write back each (modified) inode.
-        */
-       for (ip = inode; ip < inodeNINODE; ip++) {
-               if ((ip->i_flag & ILOCKED) != 0 || ip->i_count == 0)
-                       continue;
-               ip->i_flag |= ILOCKED;
-               ip->i_count++;
-               iupdat(ip, time, time, 0);
-               iput(ip);
-       }
-       updlock = 0;
-       /*
-        * Force stale buffer cache information to be flushed,
-        * for all devices.
-        */
-       bflush(NODEV);
-}
-