date and time created 93/06/01 16:44:56 by bostic

[unix-history] / usr / src / sys / ufs / ffs / ffs_inode.c

diff --git a/usr/src/sys/ufs/ffs/ffs_inode.c b/usr/src/sys/ufs/ffs/ffs_inode.c
index 73f5136..49f9cad 100644 (file)
--- a/usr/src/sys/ufs/ffs/ffs_inode.c
+++ b/usr/src/sys/ufs/ffs/ffs_inode.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

- *     @(#)ffs_inode.c 7.48 (Berkeley) %G%
+ *     @(#)ffs_inode.c 7.70 (Berkeley) %G%

  */
 
 #include <sys/param.h>
  */
 
 #include <sys/param.h>


@@ -16,6 +16,10 @@
 #include <sys/vnode.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/vnode.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>

+#include <sys/trace.h>
+#include <sys/resourcevar.h>
+
+#include <vm/vm.h>

 
 #include <ufs/ufs/quota.h>
 #include <ufs/ufs/inode.h>
 
 #include <ufs/ufs/quota.h>
 #include <ufs/ufs/inode.h>


@@ -25,9 +29,8 @@
 #include <ufs/ffs/fs.h>
 #include <ufs/ffs/ffs_extern.h>
 
 #include <ufs/ffs/fs.h>
 #include <ufs/ffs/ffs_extern.h>
 

-static int ffs_indirtrunc __P((struct inode *, daddr_t, daddr_t, int, long *));
-
-extern u_long nextgennumber;
+static int ffs_indirtrunc __P((struct inode *, daddr_t, daddr_t, daddr_t, int,
+           long *));

 
 int
 ffs_init()
 
 int
 ffs_init()


@@ -35,114 +38,6 @@ ffs_init()
        return (ufs_init());
 }
 
        return (ufs_init());
 }
 

-/*
- * Look up a UFS dinode number to find its incore vnode.
- * If it is not in core, read it in from the specified device.
- * If it is in core, wait for the lock bit to clear, then
- * return the inode locked. Detection and handling of mount
- * points must be done by the calling routine.
- */
-ffs_vget(mntp, ino, vpp)
-       struct mount *mntp;
-       ino_t ino;
-       struct vnode **vpp;
-{
-       register struct fs *fs;
-       register struct inode *ip;
-       struct ufsmount *ump;
-       struct buf *bp;
-       struct dinode *dp;
-       struct vnode *vp;
-       union ihead *ih;
-       dev_t dev;
-       int i, type, error;
-
-       ump = VFSTOUFS(mntp);
-       dev = ump->um_dev;
-       if ((*vpp = ufs_ihashget(dev, ino)) != NULL)
-               return (0);
-
-       /* Allocate a new vnode/inode. */
-       if (error = getnewvnode(VT_UFS, mntp, &ffs_vnodeops, &vp)) {
-               *vpp = NULL;
-               return (error);
-       }
-       type = ump->um_devvp->v_tag == VT_MFS ? M_MFSNODE : M_FFSNODE; /* XXX */
-       MALLOC(ip, struct inode *, sizeof(struct inode), type, M_WAITOK);
-       vp->v_data = ip;
-       ip->i_vnode = vp;
-       ip->i_flag = 0;
-       ip->i_devvp = 0;
-       ip->i_mode = 0;
-       ip->i_diroff = 0;
-       ip->i_lockf = 0;
-       ip->i_fs = fs = ump->um_fs;
-       ip->i_dev = dev;
-       ip->i_number = ino;
-#ifdef QUOTA
-       for (i = 0; i < MAXQUOTAS; i++)
-               ip->i_dquot[i] = NODQUOT;
-#endif
-       /*
-        * Put it onto its hash chain and lock it so that other requests for
-        * this inode will block if they arrive while we are sleeping waiting
-        * for old data structures to be purged or for the contents of the
-        * disk portion of this inode to be read.
-        */
-       ufs_ihashins(ip);
-
-       /* Read in the disk contents for the inode, copy into the inode. */
-       if (error = bread(ump->um_devvp, fsbtodb(fs, itod(fs, ino)),
-           (int)fs->fs_bsize, NOCRED, &bp)) {
-               /*
-                * The inode does not contain anything useful, so it would
-                * be misleading to leave it on its hash chain. It will be
-                * returned to the free list by ufs_iput().
-                */
-               remque(ip);
-               ip->i_forw = ip;
-               ip->i_back = ip;
-
-               /* Unlock and discard unneeded inode. */
-               ufs_iput(ip);
-               brelse(bp);
-               *vpp = NULL;
-               return (error);
-       }
-       dp = bp->b_un.b_dino;
-       dp += itoo(fs, ino);
-       ip->i_din = *dp;
-       brelse(bp);
-
-       /*
-        * Initialize the vnode from the inode, check for aliases.
-        * Note that the underlying vnode may have changed.
-        */
-       if (error = ufs_vinit(mntp, &ffs_specops, FFS_FIFOOPS, &vp)) {
-               ufs_iput(ip);
-               *vpp = NULL;
-               return (error);
-       }
-       /*
-        * Finish inode initialization now that aliasing has been resolved.
-        */
-       ip->i_devvp = ump->um_devvp;
-       VREF(ip->i_devvp);
-       /*
-        * Set up a generation number for this inode if it does not
-        * already have one. This should only happen on old filesystems.
-        */
-       if (ip->i_gen == 0) {
-               if (++nextgennumber < (u_long)time.tv_sec)
-                       nextgennumber = time.tv_sec;
-               ip->i_gen = nextgennumber;
-               if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
-                       ip->i_flag |= IMOD;
-       }
-       *vpp = vp;
-       return (0);
-}
-

 /*
  * Update the access, modified, and inode change times as specified
  * by the IACC, IUPD, and ICHG flags respectively. The IMOD flag
 /*
  * Update the access, modified, and inode change times as specified
  * by the IACC, IUPD, and ICHG flags respectively. The IMOD flag


@@ -153,32 +48,44 @@ ffs_vget(mntp, ino, vpp)
  * then wait for the disk write of the inode to complete.
  */
 int
  * then wait for the disk write of the inode to complete.
  */
 int

-ffs_update(vp, ta, tm, waitfor)
-       register struct vnode *vp;
-       struct timeval *ta, *tm;
-       int waitfor;
+ffs_update(ap)
+       struct vop_update_args /* {
+               struct vnode *a_vp;
+               struct timeval *a_ta;
+               struct timeval *a_tm;
+               int a_waitfor;
+       } */ *ap;

 {
        struct buf *bp;
        struct inode *ip;
        struct dinode *dp;
        register struct fs *fs;
 
 {
        struct buf *bp;
        struct inode *ip;
        struct dinode *dp;
        register struct fs *fs;
 

-       if (vp->v_mount->mnt_flag & MNT_RDONLY)
+       ip = VTOI(ap->a_vp);
+       if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) {
+               ip->i_flag &= ~(IUPD|IACC|ICHG|IMOD);

                return (0);
                return (0);

-       ip = VTOI(vp);
+       }

        if ((ip->i_flag & (IUPD|IACC|ICHG|IMOD)) == 0)
                return (0);
        if (ip->i_flag&IACC)
        if ((ip->i_flag & (IUPD|IACC|ICHG|IMOD)) == 0)
                return (0);
        if (ip->i_flag&IACC)

-               ip->i_atime = ta->tv_sec;
+               ip->i_atime.ts_sec = ap->a_ta->tv_sec;

        if (ip->i_flag&IUPD) {
        if (ip->i_flag&IUPD) {

-               ip->i_mtime = tm->tv_sec;
-               INCRQUAD(ip->i_modrev);
+               ip->i_mtime.ts_sec = ap->a_tm->tv_sec;
+               ip->i_modrev++;

        }
        if (ip->i_flag&ICHG)
        }
        if (ip->i_flag&ICHG)

-               ip->i_ctime = time.tv_sec;
+               ip->i_ctime.ts_sec = time.tv_sec;

        ip->i_flag &= ~(IUPD|IACC|ICHG|IMOD);
        ip->i_flag &= ~(IUPD|IACC|ICHG|IMOD);

-

        fs = ip->i_fs;
        fs = ip->i_fs;

+       /*
+        * Ensure that uid and gid are correct. This is a temporary
+        * fix until fsck has been changed to do the update.
+        */
+       if (fs->fs_inodefmt < FS_44INODEFMT) {          /* XXX */
+               ip->i_din.di_ouid = ip->i_uid;          /* XXX */
+               ip->i_din.di_ogid = ip->i_gid;          /* XXX */
+       }                                               /* XXX */

        if (error = bread(ip->i_devvp, fsbtodb(fs, itod(fs, ip->i_number)),
                (int)fs->fs_bsize, NOCRED, &bp)) {
                brelse(bp);
        if (error = bread(ip->i_devvp, fsbtodb(fs, itod(fs, ip->i_number)),
                (int)fs->fs_bsize, NOCRED, &bp)) {
                brelse(bp);


@@ -186,7 +93,7 @@ ffs_update(vp, ta, tm, waitfor)
        }
        dp = bp->b_un.b_dino + itoo(fs, ip->i_number);
        *dp = ip->i_din;
        }
        dp = bp->b_un.b_dino + itoo(fs, ip->i_number);
        *dp = ip->i_din;

-       if (waitfor)
+       if (ap->a_waitfor)

                return (bwrite(bp));
        else {
                bdwrite(bp);
                return (bwrite(bp));
        else {
                bdwrite(bp);


@@ -198,49 +105,51 @@ ffs_update(vp, ta, tm, waitfor)
 #define        DOUBLE  1       /* index of double indirect block */
 #define        TRIPLE  2       /* index of triple indirect block */
 /*
 #define        DOUBLE  1       /* index of double indirect block */
 #define        TRIPLE  2       /* index of triple indirect block */
 /*

- * Truncate the inode ip to at most length size.  Free affected disk
+ * Truncate the inode oip to at most length size.  Free affected disk

  * blocks -- the blocks of the file are removed in reverse order.
  * blocks -- the blocks of the file are removed in reverse order.

- *
- * NB: triple indirect blocks are untested.

  */
  */

-ffs_truncate(ovp, length, flags, cred)
-       register struct vnode *ovp;
-       off_t length;
-       int flags;
-       struct ucred *cred;
+ffs_truncate(ap)
+       struct vop_truncate_args /* {
+               struct vnode *a_vp;
+               off_t a_length;
+               int a_flags;
+               struct ucred *a_cred;
+               struct proc *a_p;
+       } */ *ap;

 {
 {

+       register struct vnode *ovp = ap->a_vp;

        register daddr_t lastblock;
        register struct inode *oip;
        register daddr_t lastblock;
        register struct inode *oip;

-       daddr_t bn, lbn, lastiblock[NIADDR];
+       daddr_t bn, lbn, lastiblock[NIADDR], indir_lbn[NIADDR];
+       daddr_t oldblks[NDADDR + NIADDR], newblks[NDADDR + NIADDR];
+       off_t length = ap->a_length;

        register struct fs *fs;
        register struct fs *fs;

-       register struct inode *ip;

        struct buf *bp;
        int offset, size, level;
        struct buf *bp;
        int offset, size, level;

-       long count, nblocks, blocksreleased = 0;
+       long count, nblocks, vflags, blocksreleased = 0;
+       struct timeval tv;

        register int i;
        int aflags, error, allerror;
        register int i;
        int aflags, error, allerror;

-       struct inode tip;

        off_t osize;
 
        off_t osize;
 

-       vnode_pager_setsize(ovp, (u_long)length);

        oip = VTOI(ovp);
        oip = VTOI(ovp);

-       if (oip->i_size <= length) {
+       tv = time;
+       if (ovp->v_type == VLNK &&
+           oip->i_size < ovp->v_mount->mnt_maxsymlinklen) {
+#ifdef DIAGNOSTIC
+               if (length != 0)
+                       panic("ffs_truncate: partial truncate of symlink");
+#endif
+               bzero((char *)&oip->i_shortlink, (u_int)oip->i_size);
+               oip->i_size = 0;

                oip->i_flag |= ICHG|IUPD;
                oip->i_flag |= ICHG|IUPD;

-               error = ffs_update(ovp, &time, &time, 1);
-               return (error);
+               return (VOP_UPDATE(ovp, &tv, &tv, 1));

        }
        }

-       /*
-        * Calculate index into inode's block list of
-        * last direct and indirect blocks (if any)
-        * which we want to keep.  Lastblock is -1 when
-        * the file is truncated to 0.
-        */
-       fs = oip->i_fs;
-       lastblock = lblkno(fs, length + fs->fs_bsize - 1) - 1;
-       lastiblock[SINGLE] = lastblock - NDADDR;
-       lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);
-       lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);
-       nblocks = btodb(fs->fs_bsize);
+       if (oip->i_size == length) {
+               oip->i_flag |= ICHG|IUPD;
+               return (VOP_UPDATE(ovp, &tv, &tv, 0));
+       }
+       vnode_pager_setsize(ovp, (u_long)length);

        /*
         * Update the size of the file. If the file is not being
         * truncated to a block boundry, the contents of the
        /*
         * Update the size of the file. If the file is not being
         * truncated to a block boundry, the contents of the


@@ -248,39 +157,56 @@ ffs_truncate(ovp, length, flags, cred)
         * zero'ed in case it ever become accessable again because
         * of subsequent file growth.
         */
         * zero'ed in case it ever become accessable again because
         * of subsequent file growth.
         */

+       fs = oip->i_fs;

        osize = oip->i_size;
        offset = blkoff(fs, length);
        osize = oip->i_size;
        offset = blkoff(fs, length);

-       if (offset == 0) {
+       if (offset == 0 && osize > length) {

                oip->i_size = length;
        } else {
                lbn = lblkno(fs, length);
                aflags = B_CLRBUF;
                oip->i_size = length;
        } else {
                lbn = lblkno(fs, length);
                aflags = B_CLRBUF;

-               if (flags & IO_SYNC)
+               if (ap->a_flags & IO_SYNC)

                        aflags |= B_SYNC;
 #ifdef QUOTA
                if (error = getinoquota(oip))
                        return (error);
 #endif
                        aflags |= B_SYNC;
 #ifdef QUOTA
                if (error = getinoquota(oip))
                        return (error);
 #endif

-               if (error = ffs_balloc(oip, lbn, offset, cred, &bp, aflags))
+               if (error = ffs_balloc(oip, lbn, offset, ap->a_cred, &bp, aflags))

                        return (error);
                oip->i_size = length;
                size = blksize(fs, oip, lbn);
                (void) vnode_pager_uncache(ovp);
                        return (error);
                oip->i_size = length;
                size = blksize(fs, oip, lbn);
                (void) vnode_pager_uncache(ovp);

-               bzero(bp->b_un.b_addr + offset, (unsigned)(size - offset));
-               allocbuf(bp, size);
-               if (flags & IO_SYNC)
+               if (osize > length) {
+                       bzero(bp->b_un.b_addr + offset, (u_int)(size - offset));
+                       allocbuf(bp, size);
+               }
+               if (ap->a_flags & IO_SYNC)

                        bwrite(bp);
                else
                        bwrite(bp);
                else

-                       bdwrite(bp);
+                       bawrite(bp);
+               if (osize < length) {
+                       oip->i_flag |= ICHG|IUPD;
+                       return (VOP_UPDATE(ovp, &tv, &tv, 1));
+               }

        }
        }

+       /*
+        * Calculate index into inode's block list of
+        * last direct and indirect blocks (if any)
+        * which we want to keep.  Lastblock is -1 when
+        * the file is truncated to 0.
+        */
+       lastblock = lblkno(fs, length + fs->fs_bsize - 1) - 1;
+       lastiblock[SINGLE] = lastblock - NDADDR;
+       lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);
+       lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);
+       nblocks = btodb(fs->fs_bsize);

        /*
         * Update file and block pointers on disk before we start freeing
         * blocks.  If we crash before free'ing blocks below, the blocks
         * will be returned to the free list.  lastiblock values are also
         * normalized to -1 for calls to ffs_indirtrunc below.
         */
        /*
         * Update file and block pointers on disk before we start freeing
         * blocks.  If we crash before free'ing blocks below, the blocks
         * will be returned to the free list.  lastiblock values are also
         * normalized to -1 for calls to ffs_indirtrunc below.
         */

-       tip = *oip;
-       tip.i_size = osize;
+       bcopy((caddr_t)&oip->i_db[0], (caddr_t)oldblks, sizeof oldblks);

        for (level = TRIPLE; level >= SINGLE; level--)
                if (lastiblock[level] < 0) {
                        oip->i_ib[level] = 0;
        for (level = TRIPLE; level >= SINGLE; level--)
                if (lastiblock[level] < 0) {
                        oip->i_ib[level] = 0;


@@ -289,24 +215,37 @@ ffs_truncate(ovp, length, flags, cred)
        for (i = NDADDR - 1; i > lastblock; i--)
                oip->i_db[i] = 0;
        oip->i_flag |= ICHG|IUPD;
        for (i = NDADDR - 1; i > lastblock; i--)
                oip->i_db[i] = 0;
        oip->i_flag |= ICHG|IUPD;

-       vinvalbuf(ovp, (length > 0));
-       allerror = ffs_update(ovp, &time, &time, MNT_WAIT);
+       if (error = VOP_UPDATE(ovp, &tv, &tv, MNT_WAIT))
+               allerror = error;
+       /*
+        * Having written the new inode to disk, save its new configuration
+        * and put back the old block pointers long enough to process them.
+        * Note that we save the new block configuration so we can check it
+        * when we are done.
+        */
+       bcopy((caddr_t)&oip->i_db[0], (caddr_t)newblks, sizeof newblks);
+       bcopy((caddr_t)oldblks, (caddr_t)&oip->i_db[0], sizeof oldblks);
+       oip->i_size = osize;
+       vflags = ((length > 0) ? V_SAVE : 0) | V_SAVEMETA;
+       allerror = vinvalbuf(ovp, vflags, ap->a_cred, ap->a_p, 0, 0);

 
        /*
         * Indirect blocks first.
         */
 
        /*
         * Indirect blocks first.
         */

-       ip = &tip;
+       indir_lbn[SINGLE] = -NDADDR;
+       indir_lbn[DOUBLE] = indir_lbn[SINGLE] - NINDIR(fs) - 1;
+       indir_lbn[TRIPLE] = indir_lbn[DOUBLE] - NINDIR(fs) * NINDIR(fs) - 1;

        for (level = TRIPLE; level >= SINGLE; level--) {
        for (level = TRIPLE; level >= SINGLE; level--) {

-               bn = ip->i_ib[level];
+               bn = oip->i_ib[level];

                if (bn != 0) {
                if (bn != 0) {

-                       error = ffs_indirtrunc(ip,
-                           bn, lastiblock[level], level, &count);
+                       error = ffs_indirtrunc(oip, indir_lbn[level],
+                           fsbtodb(fs, bn), lastiblock[level], level, &count);

                        if (error)
                                allerror = error;
                        blocksreleased += count;
                        if (lastiblock[level] < 0) {
                        if (error)
                                allerror = error;
                        blocksreleased += count;
                        if (lastiblock[level] < 0) {

-                               ip->i_ib[level] = 0;
-                               ffs_blkfree(ip, bn, fs->fs_bsize);
+                               oip->i_ib[level] = 0;
+                               ffs_blkfree(oip, bn, fs->fs_bsize);

                                blocksreleased += nblocks;
                        }
                }
                                blocksreleased += nblocks;
                        }
                }


@@ -320,12 +259,12 @@ ffs_truncate(ovp, length, flags, cred)
        for (i = NDADDR - 1; i > lastblock; i--) {
                register long bsize;
 
        for (i = NDADDR - 1; i > lastblock; i--) {
                register long bsize;
 

-               bn = ip->i_db[i];
+               bn = oip->i_db[i];

                if (bn == 0)
                        continue;
                if (bn == 0)
                        continue;

-               ip->i_db[i] = 0;
-               bsize = blksize(fs, ip, i);
-               ffs_blkfree(ip, bn, bsize);
+               oip->i_db[i] = 0;
+               bsize = blksize(fs, oip, i);
+               ffs_blkfree(oip, bn, bsize);

                blocksreleased += btodb(bsize);
        }
        if (lastblock < 0)
                blocksreleased += btodb(bsize);
        }
        if (lastblock < 0)


@@ -335,7 +274,7 @@ ffs_truncate(ovp, length, flags, cred)
         * Finally, look for a change in size of the
         * last direct block; release any frags.
         */
         * Finally, look for a change in size of the
         * last direct block; release any frags.
         */

-       bn = ip->i_db[lastblock];
+       bn = oip->i_db[lastblock];

        if (bn != 0) {
                long oldspace, newspace;
 
        if (bn != 0) {
                long oldspace, newspace;
 


@@ -343,9 +282,9 @@ ffs_truncate(ovp, length, flags, cred)
                 * Calculate amount of space we're giving
                 * back as old block size minus new block size.
                 */
                 * Calculate amount of space we're giving
                 * back as old block size minus new block size.
                 */

-               oldspace = blksize(fs, ip, lastblock);
-               ip->i_size = length;
-               newspace = blksize(fs, ip, lastblock);
+               oldspace = blksize(fs, oip, lastblock);
+               oip->i_size = length;
+               newspace = blksize(fs, oip, lastblock);

                if (newspace == 0)
                        panic("itrunc: newspace");
                if (oldspace - newspace > 0) {
                if (newspace == 0)
                        panic("itrunc: newspace");
                if (oldspace - newspace > 0) {


@@ -355,19 +294,26 @@ ffs_truncate(ovp, length, flags, cred)
                         * required for the storage we're keeping.
                         */
                        bn += numfrags(fs, newspace);
                         * required for the storage we're keeping.
                         */
                        bn += numfrags(fs, newspace);

-                       ffs_blkfree(ip, bn, oldspace - newspace);
+                       ffs_blkfree(oip, bn, oldspace - newspace);

                        blocksreleased += btodb(oldspace - newspace);
                }
        }
 done:
                        blocksreleased += btodb(oldspace - newspace);
                }
        }
 done:

-/* BEGIN PARANOIA */
+#ifdef DIAGNOSTIC

        for (level = SINGLE; level <= TRIPLE; level++)
        for (level = SINGLE; level <= TRIPLE; level++)

-               if (ip->i_ib[level] != oip->i_ib[level])
+               if (newblks[NDADDR + level] != oip->i_ib[level])

                        panic("itrunc1");
        for (i = 0; i < NDADDR; i++)
                        panic("itrunc1");
        for (i = 0; i < NDADDR; i++)

-               if (ip->i_db[i] != oip->i_db[i])
+               if (newblks[i] != oip->i_db[i])

                        panic("itrunc2");
                        panic("itrunc2");

-/* END PARANOIA */
+       if (length == 0 &&
+           (ovp->v_dirtyblkhd.le_next || ovp->v_cleanblkhd.le_next))
+               panic("itrunc3");
+#endif /* DIAGNOSTIC */
+       /*
+        * Put back the real size.
+        */
+       oip->i_size = length;

        oip->i_blocks -= blocksreleased;
        if (oip->i_blocks < 0)                  /* sanity */
                oip->i_blocks = 0;
        oip->i_blocks -= blocksreleased;
        if (oip->i_blocks < 0)                  /* sanity */
                oip->i_blocks = 0;


@@ -389,9 +335,10 @@ done:
  * NB: triple indirect blocks are untested.
  */
 static int
  * NB: triple indirect blocks are untested.
  */
 static int

-ffs_indirtrunc(ip, bn, lastbn, level, countp)
+ffs_indirtrunc(ip, lbn, dbn, lastbn, level, countp)

        register struct inode *ip;
        register struct inode *ip;

-       daddr_t bn, lastbn;
+       daddr_t lbn, lastbn;
+       daddr_t dbn;

        int level;
        long *countp;
 {
        int level;
        long *countp;
 {


@@ -399,10 +346,11 @@ ffs_indirtrunc(ip, bn, lastbn, level, countp)
        struct buf *bp;
        register struct fs *fs = ip->i_fs;
        register daddr_t *bap;
        struct buf *bp;
        register struct fs *fs = ip->i_fs;
        register daddr_t *bap;

-       daddr_t *copy, nb, last;
+       struct vnode *vp;
+       daddr_t *copy, nb, nlbn, last;

        long blkcount, factor;
        int nblocks, blocksreleased = 0;
        long blkcount, factor;
        int nblocks, blocksreleased = 0;

-       int error, allerror = 0;
+       int error = 0, allerror = 0;

 
        /*
         * Calculate index in current block of last
 
        /*
         * Calculate index in current block of last


@@ -417,21 +365,38 @@ ffs_indirtrunc(ip, bn, lastbn, level, countp)
                last /= factor;
        nblocks = btodb(fs->fs_bsize);
        /*
                last /= factor;
        nblocks = btodb(fs->fs_bsize);
        /*

-        * Get buffer of block pointers, zero those 
-        * entries corresponding to blocks to be free'd,
-        * and update on disk copy first.
+        * Get buffer of block pointers, zero those entries corresponding
+        * to blocks to be free'd, and update on disk copy first.  Since
+        * double(triple) indirect before single(double) indirect, calls
+        * to bmap on these blocks will fail.  However, we already have
+        * the on disk address, so we have to set the b_blkno field
+        * explicitly instead of letting bread do everything for us.

         */
 #ifdef SECSIZE
        bp = bread(ip->i_dev, fsbtodb(fs, bn), (int)fs->fs_bsize,
            fs->fs_dbsize);
 #else SECSIZE
         */
 #ifdef SECSIZE
        bp = bread(ip->i_dev, fsbtodb(fs, bn), (int)fs->fs_bsize,
            fs->fs_dbsize);
 #else SECSIZE

-       error = bread(ip->i_devvp, fsbtodb(fs, bn), (int)fs->fs_bsize,
-               NOCRED, &bp);
+       vp = ITOV(ip);
+       bp = getblk(vp, lbn, (int)fs->fs_bsize, 0, 0);
+       if (bp->b_flags & (B_DONE | B_DELWRI)) {
+               /* Braces must be here in case trace evaluates to nothing. */
+               trace(TR_BREADHIT, pack(vp, fs->fs_bsize), lbn);
+       } else {
+               trace(TR_BREADMISS, pack(vp, fs->fs_bsize), lbn);
+               curproc->p_stats->p_ru.ru_inblock++;    /* pay for read */
+               bp->b_flags |= B_READ;
+               if (bp->b_bcount > bp->b_bufsize)
+                       panic("ffs_indirtrunc: bad buffer size");
+               bp->b_blkno = dbn;
+               VOP_STRATEGY(bp);
+               error = biowait(bp);
+       }

        if (error) {
                brelse(bp);
                *countp = 0;
                return (error);
        }
        if (error) {
                brelse(bp);
                *countp = 0;
                return (error);
        }

+

        bap = bp->b_un.b_daddr;
        MALLOC(copy, daddr_t *, fs->fs_bsize, M_TEMP, M_WAITOK);
        bcopy((caddr_t)bap, (caddr_t)copy, (u_int)fs->fs_bsize);
        bap = bp->b_un.b_daddr;
        MALLOC(copy, daddr_t *, fs->fs_bsize, M_TEMP, M_WAITOK);
        bcopy((caddr_t)bap, (caddr_t)copy, (u_int)fs->fs_bsize);


@@ -447,13 +412,14 @@ ffs_indirtrunc(ip, bn, lastbn, level, countp)
        /*
         * Recursively free totally unused blocks.
         */
        /*
         * Recursively free totally unused blocks.
         */

-       for (i = NINDIR(fs) - 1; i > last; i--) {
+       for (i = NINDIR(fs) - 1, nlbn = lbn + 1 - i * factor; i > last;
+           i--, nlbn += factor) {

                nb = bap[i];
                if (nb == 0)
                        continue;
                if (level > SINGLE) {
                nb = bap[i];
                if (nb == 0)
                        continue;
                if (level > SINGLE) {

-                       if (error = ffs_indirtrunc(ip,
-                           nb, (daddr_t)-1, level - 1, &blkcount))
+                       if (error = ffs_indirtrunc(ip, nlbn,
+                           fsbtodb(fs, nb), (daddr_t)-1, level - 1, &blkcount))

                                allerror = error;
                        blocksreleased += blkcount;
                }
                                allerror = error;
                        blocksreleased += blkcount;
                }


@@ -468,8 +434,8 @@ ffs_indirtrunc(ip, bn, lastbn, level, countp)
                last = lastbn % factor;
                nb = bap[i];
                if (nb != 0) {
                last = lastbn % factor;
                nb = bap[i];
                if (nb != 0) {

-                       if (error =
-                           ffs_indirtrunc(ip, nb, last, level - 1, &blkcount))
+                       if (error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
+                           last, level - 1, &blkcount))

                                allerror = error;
                        blocksreleased += blkcount;
                }
                                allerror = error;
                        blocksreleased += blkcount;
                }