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 68f61a6..49f9cad 100644 (file)
--- a/usr/src/sys/ufs/ffs/ffs_inode.c
+++ b/usr/src/sys/ufs/ffs/ffs_inode.c
@@ -1,320 +1,103 @@
-/*     ffs_inode.c     6.3     84/02/15        */
-
-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/mount.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/inode.h"
-#include "../h/fs.h"
-#include "../h/conf.h"
-#include "../h/buf.h"
-#ifdef QUOTA
-#include "../h/quota.h"
-#endif
-#include "../h/kernel.h"
-
-#define        INOHSZ  63
-#if    ((INOHSZ&(INOHSZ-1)) == 0)
-#define        INOHASH(dev,ino)        (((dev)+(ino))&(INOHSZ-1))
-#else
-#define        INOHASH(dev,ino)        (((unsigned)((dev)+(ino)))%INOHSZ)
-#endif
-
-union ihead {                          /* inode LRU cache, Chris Maltby */
-       union  ihead *ih_head[2];
-       struct inode *ih_chain[2];
-} ihead[INOHSZ];
-
-struct inode *ifreeh, **ifreet;
-

 /*
 /*

- * Initialize hash links for inodes
- * and build inode free list.
+ * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
+ * All rights reserved.
+ *
+ * %sccs.include.redist.c%
+ *
+ *     @(#)ffs_inode.c 7.70 (Berkeley) %G%

  */
  */

-ihinit()
-{
-       register int i;
-       register struct inode *ip = inode;
-       register union  ihead *ih = ihead;

 
 

-       for (i = INOHSZ; --i >= 0; ih++) {
-               ih->ih_head[0] = ih;
-               ih->ih_head[1] = ih;
-       }
-       ifreeh = ip;
-       ifreet = &ip->i_freef;
-       ip->i_freeb = &ifreeh;
-       ip->i_forw = ip;
-       ip->i_back = ip;
-       for (i = ninode; --i > 0; ) {
-               ++ip;
-               ip->i_forw = ip;
-               ip->i_back = ip;
-               *ifreet = ip;
-               ip->i_freeb = ifreet;
-               ifreet = &ip->i_freef;
-       }
-       ip->i_freef = NULL;
-}
-
-#ifdef notdef
-/*
- * Find an inode if it is incore.
- * This is the equivalent, for inodes,
- * of ``incore'' in bio.c or ``pfind'' in subr.c.
- */
-struct inode *
-ifind(dev, ino)
-       dev_t dev;
-       ino_t ino;
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/mount.h>
+#include <sys/proc.h>
+#include <sys/file.h>
+#include <sys/buf.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/ufsmount.h>
+#include <ufs/ufs/ufs_extern.h>
+
+#include <ufs/ffs/fs.h>
+#include <ufs/ffs/ffs_extern.h>
+
+static int ffs_indirtrunc __P((struct inode *, daddr_t, daddr_t, daddr_t, int,
+           long *));
+
+int
+ffs_init()

 {
 {

-       register struct inode *ip;
-       register union  ihead *ih;
-
-       ih = &ihead[INOHASH(dev, ino)];
-       for (ip = ih->ih_chain[0]; ip != (struct inode *)ih; ip = ip->i_forw)
-               if (ino==ip->i_number && dev==ip->i_dev)
-                       return (ip);
-       return ((struct inode *)0);
+       return (ufs_init());

 }
 }

-#endif notdef

 
 /*
 
 /*

- * Look up an inode by device,inumber.
- * If it is in core (in the inode structure),
- * honor the locking protocol.
- * If it is not in core, read it in from the
- * specified device.
- * If the inode is mounted on, perform
- * the indicated indirection.
- * In all cases, a pointer to a locked
- * inode structure is returned.
- *
- * panic: no imt -- if the mounted file
- *     system is not in the mount table.
- *     "cannot happen"
+ * Update the access, modified, and inode change times as specified
+ * by the IACC, IUPD, and ICHG flags respectively. The IMOD flag
+ * is used to specify that the inode needs to be updated but that
+ * the times have already been set. The access and modified times
+ * are taken from the second and third parameters; the inode change
+ * time is always taken from the current time. If waitfor is set,
+ * then wait for the disk write of the inode to complete.

  */
  */

-struct inode *
-iget(dev, fs, ino)
-       dev_t dev;
-       register struct fs *fs;
-       ino_t ino;
+int
+ffs_update(ap)
+       struct vop_update_args /* {
+               struct vnode *a_vp;
+               struct timeval *a_ta;
+               struct timeval *a_tm;
+               int a_waitfor;
+       } */ *ap;

 {
 {

-       register struct inode *ip;
-       register union  ihead *ih;
-       register struct mount *mp;
-       register struct buf *bp;
-       register struct dinode *dp;
-       register struct inode *iq;
-
-loop:
-       if (getfs(dev) != fs)
-               panic("iget: bad fs");
-       ih = &ihead[INOHASH(dev, ino)];
-       for (ip = ih->ih_chain[0]; ip != (struct inode *)ih; ip = ip->i_forw)
-               if (ino == ip->i_number && dev == ip->i_dev) {
-                       if ((ip->i_flag&ILOCKED) != 0) {
-                               ip->i_flag |= IWANT;
-                               sleep((caddr_t)ip, PINOD);
-                               goto loop;
-                       }
-                       if ((ip->i_flag&IMOUNT) != 0) {
-                               for (mp = &mount[0]; mp < &mount[NMOUNT]; mp++)
-                                       if(mp->m_inodp == ip) {
-                                               dev = mp->m_dev;
-                                               fs = mp->m_bufp->b_un.b_fs;
-                                               ino = ROOTINO;
-                                               goto loop;
-                                       }
-                               panic("no imt");
-                       }
-                       if (ip->i_count == 0) {         /* ino on free list */
-                               if (iq = ip->i_freef)
-                                       iq->i_freeb = ip->i_freeb;
-                               else
-                                       ifreet = ip->i_freeb;
-                               *ip->i_freeb = iq;
-                               ip->i_freef = NULL;
-                               ip->i_freeb = NULL;
-                       }
-                       ip->i_count++;
-                       ip->i_flag |= ILOCKED;
-                       return(ip);
-               }
+       struct buf *bp;
+       struct inode *ip;
+       struct dinode *dp;
+       register struct fs *fs;

 
 

-       if ((ip = ifreeh) == NULL) {
-               tablefull("inode");
-               u.u_error = ENFILE;
-               return(NULL);
+       ip = VTOI(ap->a_vp);
+       if (ap->a_vp->v_mount->mnt_flag & MNT_RDONLY) {
+               ip->i_flag &= ~(IUPD|IACC|ICHG|IMOD);
+               return (0);

        }
        }

-       if (iq = ip->i_freef)
-               iq->i_freeb = &ifreeh;
-       ifreeh = iq;
-       ip->i_freef = NULL;
-       ip->i_freeb = NULL;
-       /*
-        * Now to take inode off the hash chain it was on
-        * (initially, or after an iflush, it is on a "hash chain"
-        * consisting entirely of itself, and pointed to by no-one,
-        * but that doesn't matter), and put it on the chain for
-        * its new (ino, dev) pair
-        */
-       remque(ip);
-       insque(ip, ih);
-#ifdef QUOTA
-       dqrele(ip->i_dquot);
-#endif
-       ip->i_dev = dev;
-       ip->i_fs = fs;
-       ip->i_number = ino;
-       ip->i_flag = ILOCKED;
-       ip->i_count++;
-       ip->i_lastr = 0;
-       bp = bread(dev, fsbtodb(fs, itod(fs, ino)), (int)fs->fs_bsize);
+       if ((ip->i_flag & (IUPD|IACC|ICHG|IMOD)) == 0)
+               return (0);
+       if (ip->i_flag&IACC)
+               ip->i_atime.ts_sec = ap->a_ta->tv_sec;
+       if (ip->i_flag&IUPD) {
+               ip->i_mtime.ts_sec = ap->a_tm->tv_sec;
+               ip->i_modrev++;
+       }
+       if (ip->i_flag&ICHG)
+               ip->i_ctime.ts_sec = time.tv_sec;
+       ip->i_flag &= ~(IUPD|IACC|ICHG|IMOD);
+       fs = ip->i_fs;

        /*
        /*

-        * Check I/O errors
+        * Ensure that uid and gid are correct. This is a temporary
+        * fix until fsck has been changed to do the update.

         */
         */

-       if ((bp->b_flags&B_ERROR) != 0) {
+       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);
                brelse(bp);

-               /*
-                * the inode doesn't contain anything useful, so it would
-                * be misleading to leave it on its hash chain.
-                * 'iput' will take care of putting it back on the free list.
-                */
-               remque(ip);
-               ip->i_forw = ip;
-               ip->i_back = ip;
-               /*
-                * we also loose its inumber, just in case (as iput
-                * doesn't do that any more) - but as it isn't on its
-                * hash chain, I doubt if this is really necessary .. kre
-                * (probably the two methods are interchangable)
-                */
-               ip->i_number = 0;
-#ifdef QUOTA
-               ip->i_dquot = NODQUOT;
-#endif
-               iput(ip);
-               return(NULL);
+               return (error);

        }
        }

-       dp = bp->b_un.b_dino;
-       dp += itoo(fs, ino);
-       ip->i_ic = dp->di_ic;
-       brelse(bp);
-#ifdef QUOTA
-       if (ip->i_mode == 0)
-               ip->i_dquot = NODQUOT;
-       else
-               ip->i_dquot = inoquota(ip);
-#endif
-       return (ip);
-}
-
-/*
- * Decrement reference count of
- * an inode structure.
- * On the last reference,
- * write the inode out and if necessary,
- * truncate and deallocate the file.
- */
-iput(ip)
-       register struct inode *ip;
-{
-
-       if ((ip->i_flag & ILOCKED) == 0)
-               panic("iput");
-       iunlock(ip);
-       irele(ip);
-}
-
-irele(ip)
-       register struct inode *ip;
-{
-       int mode;
-
-       if (ip->i_count == 1) {
-               ip->i_flag |= ILOCKED;
-               if (ip->i_nlink <= 0) {
-                       itrunc(ip, (u_long)0);
-                       mode = ip->i_mode;
-                       ip->i_mode = 0;
-                       ip->i_rdev = 0;
-                       ip->i_flag |= IUPD|ICHG;
-                       ifree(ip, ip->i_number, mode);
-#ifdef QUOTA
-                       (void) chkiq(ip->i_dev, ip, ip->i_uid, 0);
-                       dqrele(ip->i_dquot);
-                       ip->i_dquot = NODQUOT;
-#endif
-               }
-               IUPDAT(ip, &time, &time, 0);
-               iunlock(ip);
-               ip->i_flag = 0;
-               /*
-                * Put the inode on the end of the free list.
-                * Possibly in some cases it would be better to
-                * put the inode at the head of the free list,
-                * (eg: where i_mode == 0 || i_number == 0)
-                * but I will think about that later .. kre
-                * (i_number is rarely 0 - only after an i/o error in iget,
-                * where i_mode == 0, the inode will probably be wanted
-                * again soon for an ialloc, so possibly we should keep it)
-                */
-               if (ifreeh) {
-                       *ifreet = ip;
-                       ip->i_freeb = ifreet;
-               } else {
-                       ifreeh = ip;
-                       ip->i_freeb = &ifreeh;
-               }
-               ip->i_freef = NULL;
-               ifreet = &ip->i_freef;
-       } else if (!(ip->i_flag & ILOCKED))
-               ITIMES(ip, &time, &time);
-       ip->i_count--;
-}
-
-/*
- * Check accessed and update flags on
- * an inode structure.
- * If any is on, update the inode
- * with the current time.
- * If waitfor is given, then must insure
- * i/o order so wait for write to complete.
- */
-iupdat(ip, ta, tm, waitfor)
-       register struct inode *ip;
-       struct timeval *ta, *tm;
-       int waitfor;
-{
-       register struct buf *bp;
-       struct dinode *dp;
-       register struct fs *fp;
-
-       fp = ip->i_fs;
-       if ((ip->i_flag & (IUPD|IACC|ICHG|IMOD)) != 0) {
-               if (fp->fs_ronly)
-                       return;
-               bp = bread(ip->i_dev, fsbtodb(fp, itod(fp, ip->i_number)),
-                       (int)fp->fs_bsize);
-               if (bp->b_flags & B_ERROR) {
-                       brelse(bp);
-                       return;
-               }
-               if (ip->i_flag&IACC)
-                       ip->i_atime = ta->tv_sec;
-               if (ip->i_flag&IUPD)
-                       ip->i_mtime = tm->tv_sec;
-               if (ip->i_flag&ICHG)
-                       ip->i_ctime = time.tv_sec;
-               ip->i_flag &= ~(IUPD|IACC|ICHG|IMOD);
-               dp = bp->b_un.b_dino + itoo(fp, ip->i_number);
-               dp->di_ic = ip->i_ic;
-               if (waitfor)
-                       bwrite(bp);
-               else
-                       bdwrite(bp);
+       dp = bp->b_un.b_dino + itoo(fs, ip->i_number);
+       *dp = ip->i_din;
+       if (ap->a_waitfor)
+               return (bwrite(bp));
+       else {
+               bdwrite(bp);
+               return (0);

        }
 }
 
        }
 }
 


@@ -322,31 +105,89 @@ iupdat(ip, 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
- * blocks -- the blocks of the file
- * are removed in reverse order.
- *
- * NB: triple indirect blocks are untested.
+ * Truncate the inode oip to at most length size.  Free affected disk
+ * blocks -- the blocks of the file are removed in reverse order.

  */
  */

-itrunc(oip, length)
-       struct inode *oip;
-       u_long length;
+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 i;
+       register struct vnode *ovp = ap->a_vp;

        register daddr_t lastblock;
        register daddr_t lastblock;

-       daddr_t bn, lastiblock[NIADDR];
+       register struct inode *oip;
+       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 inode tip;
-       long blocksreleased = 0, nblocks;
-       long indirtrunc();
-       int level;
-
-       if (oip->i_size <= length) {
+       struct buf *bp;
+       int offset, size, level;
+       long count, nblocks, vflags, blocksreleased = 0;
+       struct timeval tv;
+       register int i;
+       int aflags, error, allerror;
+       off_t osize;
+
+       oip = VTOI(ovp);
+       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;
+               return (VOP_UPDATE(ovp, &tv, &tv, 1));
+       }
+       if (oip->i_size == length) {

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

-               iupdat(oip, &time, &time, 1);
-               return;
+               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
+        * partial block following the end of the file must be
+        * 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);
+       if (offset == 0 && osize > length) {
+               oip->i_size = length;
+       } else {
+               lbn = lblkno(fs, length);
+               aflags = B_CLRBUF;
+               if (ap->a_flags & IO_SYNC)
+                       aflags |= B_SYNC;
+#ifdef QUOTA
+               if (error = getinoquota(oip))
+                       return (error);
+#endif
+               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);
+               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
+                       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
        }
        /*
         * Calculate index into inode's block list of


@@ -354,22 +195,18 @@ itrunc(oip, length)
         * which we want to keep.  Lastblock is -1 when
         * the file is truncated to 0.
         */
         * 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);
        /*
        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 size of 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 indirtrunc below.
-        * (? fsck doesn't check validity of pointers in indirect blocks)
+        * 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;
+       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;


@@ -377,22 +214,38 @@ itrunc(oip, length)
                }
        for (i = NDADDR - 1; i > lastblock; i--)
                oip->i_db[i] = 0;
                }
        for (i = NDADDR - 1; i > lastblock; i--)
                oip->i_db[i] = 0;

-       oip->i_size = length;

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

-       iupdat(oip, &time, &time, 1);
-       ip = &tip;
+       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.
         */

+       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) {

-                       blocksreleased +=
-                           indirtrunc(ip, bn, lastiblock[level], level);
+                       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 (lastiblock[level] < 0) {

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

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


@@ -404,15 +257,15 @@ itrunc(oip, length)
         * All whole direct blocks or frags.
         */
        for (i = NDADDR - 1; i > lastblock; i--) {
         * All whole direct blocks or frags.
         */
        for (i = NDADDR - 1; i > lastblock; i--) {

-               register int size;
+               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;
-               size = (off_t)blksize(fs, ip, i);
-               free(ip, bn, size);
-               blocksreleased += btodb(size);
+               oip->i_db[i] = 0;
+               bsize = blksize(fs, oip, i);
+               ffs_blkfree(oip, bn, bsize);
+               blocksreleased += btodb(bsize);

        }
        if (lastblock < 0)
                goto done;
        }
        if (lastblock < 0)
                goto done;


@@ -421,17 +274,17 @@ itrunc(oip, length)
         * 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) {
        if (bn != 0) {

-               int oldspace, newspace;
+               long oldspace, newspace;

 
                /*
                 * 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) {


@@ -441,51 +294,63 @@ itrunc(oip, length)
                         * required for the storage we're keeping.
                         */
                        bn += numfrags(fs, newspace);
                         * required for the storage we're keeping.
                         */
                        bn += numfrags(fs, newspace);

-                       free(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_flag |= ICHG;
 #ifdef QUOTA
        oip->i_blocks -= blocksreleased;
        if (oip->i_blocks < 0)                  /* sanity */
                oip->i_blocks = 0;
        oip->i_flag |= ICHG;
 #ifdef QUOTA

-       (void) chkdq(oip, -blocksreleased, 0);
+       if (!getinoquota(oip))
+               (void) chkdq(oip, -blocksreleased, NOCRED, 0);

 #endif
 #endif

+       return (allerror);

 }
 
 /*
 }
 
 /*

- * Release blocks associated with the inode ip and
- * stored in the indirect block bn.  Blocks are free'd
- * in LIFO order up to (but not including) lastbn.  If
- * level is greater than SINGLE, the block is an indirect
- * block and recursive calls to indirtrunc must be used to
- * cleanse other indirect blocks.
+ * Release blocks associated with the inode ip and stored in the indirect
+ * block bn.  Blocks are free'd in LIFO order up to (but not including)
+ * lastbn.  If level is greater than SINGLE, the block is an indirect block
+ * and recursive calls to indirtrunc must be used to cleanse other indirect
+ * blocks.

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

-long
-indirtrunc(ip, bn, lastbn, level)
+static int
+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;
        int level;

+       long *countp;

 {
        register int i;
 {
        register int i;

-       struct buf *bp, *copy;
-       register daddr_t *bap;
+       struct buf *bp;

        register struct fs *fs = ip->i_fs;
        register struct fs *fs = ip->i_fs;

-       daddr_t nb, last;
-       long factor;
-       int blocksreleased = 0, nblocks;
+       register daddr_t *bap;
+       struct vnode *vp;
+       daddr_t *copy, nb, nlbn, last;
+       long blkcount, factor;
+       int nblocks, blocksreleased = 0;
+       int error = 0, allerror = 0;

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


@@ -500,35 +365,65 @@ indirtrunc(ip, bn, lastbn, level)
                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.

         */
         */

-       copy = geteblk((int)fs->fs_bsize);
-       bp = bread(ip->i_dev, fsbtodb(fs, bn), (int)fs->fs_bsize);
-       if (bp->b_flags&B_ERROR) {
-               brelse(copy);
+#ifdef SECSIZE
+       bp = bread(ip->i_dev, fsbtodb(fs, bn), (int)fs->fs_bsize,
+           fs->fs_dbsize);
+#else SECSIZE
+       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);
                brelse(bp);

-               return (0);
+               *countp = 0;
+               return (error);

        }
        }

+

        bap = bp->b_un.b_daddr;
        bap = bp->b_un.b_daddr;

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

        bzero((caddr_t)&bap[last + 1],
          (u_int)(NINDIR(fs) - (last + 1)) * sizeof (daddr_t));
        bzero((caddr_t)&bap[last + 1],
          (u_int)(NINDIR(fs) - (last + 1)) * sizeof (daddr_t));

-       bwrite(bp);
-       bp = copy, bap = bp->b_un.b_daddr;
+       if (last == -1)
+               bp->b_flags |= B_INVAL;
+       error = bwrite(bp);
+       if (error)
+               allerror = error;
+       bap = copy;

 
        /*
         * 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;
                nb = bap[i];
                if (nb == 0)
                        continue;

-               if (level > SINGLE)
-                       blocksreleased +=
-                           indirtrunc(ip, nb, (daddr_t)-1, level - 1);
-               free(ip, nb, (int)fs->fs_bsize);
+               if (level > SINGLE) {
+                       if (error = ffs_indirtrunc(ip, nlbn,
+                           fsbtodb(fs, nb), (daddr_t)-1, level - 1, &blkcount))
+                               allerror = error;
+                       blocksreleased += blkcount;
+               }
+               ffs_blkfree(ip, nb, fs->fs_bsize);

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


@@ -538,87 +433,14 @@ indirtrunc(ip, bn, lastbn, level)
        if (level > SINGLE && lastbn >= 0) {
                last = lastbn % factor;
                nb = bap[i];
        if (level > SINGLE && lastbn >= 0) {
                last = lastbn % factor;
                nb = bap[i];

-               if (nb != 0)
-                       blocksreleased += indirtrunc(ip, nb, last, level - 1);
-       }
-       brelse(bp);
-       return (blocksreleased);
-}
-
-/*
- * remove any inodes in the inode cache belonging to dev
- *
- * There should not be any active ones, return error if any are found
- * (nb: this is a user error, not a system err)
- *
- * Also, count the references to dev by block devices - this really
- * has nothing to do with the object of the procedure, but as we have
- * to scan the inode table here anyway, we might as well get the
- * extra benefit.
- *
- * this is called from sumount()/sys3.c when dev is being unmounted
- */
-#ifdef QUOTA
-iflush(dev, iq)
-       dev_t dev;
-       struct inode *iq;
-#else
-iflush(dev)
-       dev_t dev;
-#endif
-{
-       register struct inode *ip;
-       register open = 0;
-
-       for (ip = inode; ip < inodeNINODE; ip++) {
-#ifdef QUOTA
-               if (ip != iq && ip->i_dev == dev)
-#else
-               if (ip->i_dev == dev)
-#endif
-                       if (ip->i_count)
-                               return(-1);
-                       else {
-                               remque(ip);
-                               ip->i_forw = ip;
-                               ip->i_back = ip;
-                               /*
-                                * as i_count == 0, the inode was on the free
-                                * list already, just leave it there, it will
-                                * fall off the bottom eventually. We could
-                                * perhaps move it to the head of the free
-                                * list, but as umounts are done so
-                                * infrequently, we would gain very little,
-                                * while making the code bigger.
-                                */
-#ifdef QUOTA
-                               dqrele(ip->i_dquot);
-                               ip->i_dquot = NODQUOT;
-#endif
-                       }
-               else if (ip->i_count && (ip->i_mode&IFMT)==IFBLK &&
-                   ip->i_rdev == dev)
-                       open++;
+               if (nb != 0) {
+                       if (error = ffs_indirtrunc(ip, nlbn, fsbtodb(fs, nb),
+                           last, level - 1, &blkcount))
+                               allerror = error;
+                       blocksreleased += blkcount;
+               }

        }
        }

-       return (open);
-}
-
-/*
- * Lock an inode. If its already locked, set the WANT bit and sleep.
- */
-ilock(ip)
-       register struct inode *ip;
-{
-
-       ILOCK(ip);
-}
-
-/*
- * Unlock an inode.  If WANT bit is on, wakeup.
- */
-iunlock(ip)
-       register struct inode *ip;
-{
-
-       IUNLOCK(ip);
+       FREE(copy, M_TEMP);
+       *countp = blocksreleased;
+       return (allerror);

 }
 }