cleanups and bug fixes from John

[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 64b0029..df2c16e 100644 (file)
--- a/usr/src/sys/ufs/ffs/ffs_inode.c
+++ b/usr/src/sys/ufs/ffs/ffs_inode.c
@@ -1,443 +1,478 @@
-/*     ffs_inode.c     4.8     82/02/15        */
+/*
+ * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
+ * All rights reserved.
+ *
+ * %sccs.include.redist.c%
+ *
+ *     @(#)ffs_inode.c 7.45 (Berkeley) %G%
+ */

 
 

-#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/ino.h"
-#include "../h/filsys.h"
-#include "../h/conf.h"
-#include "../h/buf.h"
-#include "../h/inline.h"
+#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>

 
 

-#define        INOHSZ  63
-#define        INOHASH(dev,ino)        (((dev)+(ino))%INOHSZ)
-short  inohash[INOHSZ];
-short  ifreel;
+#include <ufs/ufs/quota.h>
+#include <ufs/ufs/inode.h>
+#include <ufs/ufs/ufsmount.h>
+#include <ufs/ufs/ufs_extern.h>

 
 

-/*
- * Initialize hash links for inodes
- * and build inode free list.
- */
-ihinit()
-{
-       register int i;
-       register struct inode *ip = inode;
+#include <ufs/ffs/fs.h>
+#include <ufs/ffs/ffs_extern.h>

 
 

-       ifreel = 0;
-       for (i = 0; i < ninode-1; i++, ip++)
-               ip->i_hlink = i+1;
-       ip->i_hlink = -1;
-       for (i = 0; i < INOHSZ; i++)
-               inohash[i] = -1;
-}
+static int ffs_indirtrunc __P((struct inode *, daddr_t, daddr_t, int, long *));

 
 

-/*
- * 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;
-{
-       register struct inode *ip;
+extern u_long nextgennumber;

 
 

-       for (ip = &inode[inohash[INOHASH(dev,ino)]]; ip != &inode[-1];
-           ip = &inode[ip->i_hlink])
-               if (ino==ip->i_number && dev==ip->i_dev)
-                       return (ip);
-       return ((struct inode *)0);
+int
+ffs_init()
+{
+       return (ufs_init());

 }
 
 /*
 }
 
 /*

- * 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"
+ * 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.

  */
  */

-struct inode *
-iget(dev, ino)
-       dev_t dev;
+ffs_vget(mntp, ino, vpp)
+       struct mount *mntp;

        ino_t ino;
        ino_t ino;

+       struct vnode **vpp;

 {
 {

+       register struct fs *fs;

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

-       register struct mount *mp;
-       register struct buf *bp;
-       register struct dinode *dp;
-       register int slot;
+       struct ufsmount *ump;
+       struct buf *bp;
+       struct dinode *dp;
+       struct vnode *vp;
+       union ihead *ih;
+       dev_t dev;
+       int i, type, error;

 
 

-loop:
-       slot = INOHASH(dev, ino);
-       ip = &inode[inohash[slot]];
-       while (ip != &inode[-1]) {
-               if (ino == ip->i_number && dev == ip->i_dev) {
-                       if ((ip->i_flag&ILOCK) != 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;
-                                       ino = ROOTINO;
-                                       goto loop;
-                               }
-                               panic("no imt");
-                       }
-                       ip->i_count++;
-                       ip->i_flag |= ILOCK;
-                       return(ip);
-               }
-               ip = &inode[ip->i_hlink];
-       }
-       if (ifreel < 0) {
-               tablefull("inode");
-               u.u_error = ENFILE;
-               return(NULL);
+       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);

        }
        }

-       ip = &inode[ifreel];
-       ifreel = ip->i_hlink;
-       ip->i_hlink = inohash[slot];
-       inohash[slot] = ip - inode;
+       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;
        ip->i_dev = dev;
        ip->i_number = ino;

-       ip->i_flag = ILOCK;
-       ip->i_count++;
-       ip->i_un.i_lastr = 0;
-       bp = bread(dev, itod(ino));
+#ifdef QUOTA
+       for (i = 0; i < MAXQUOTAS; i++)
+               ip->i_dquot[i] = NODQUOT;
+#endif

        /*
        /*

-        * Check I/O errors
+        * 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.

         */
         */

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

-               iput(ip);
-               return(NULL);
+               *vpp = NULL;
+               return (error);

        }
        dp = bp->b_un.b_dino;
        }
        dp = bp->b_un.b_dino;

-       dp += itoo(ino);
-       iexpand(ip, dp);
+       dp += itoo(fs, ino);
+       ip->i_din = *dp;

        brelse(bp);
        brelse(bp);

-       return(ip);
-}
-
-iexpand(ip, dp)
-       register struct inode *ip;
-       register struct dinode *dp;
-{
-       register char *p1, *p2;
-       register int i;

 
 

-       ip->i_mode = dp->di_mode;
-       ip->i_nlink = dp->di_nlink;
-       ip->i_uid = dp->di_uid;
-       ip->i_gid = dp->di_gid;
-       ip->i_size = dp->di_size;
-       p1 = (char *)ip->i_un.i_addr;
-       p2 = (char *)dp->di_addr;
-       for(i=0; i<NADDR; i++) {
-               *p1++ = *p2++;
-               *p1++ = *p2++;
-               *p1++ = *p2++;
-               *p1++ = 0;
+       /*
+        * 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);

 }
 
 /*
 }
 
 /*

- * 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;
-{
-       register int i, x;
-       register struct inode *jp;
-
-       if (ip->i_count == 1) {
-               ip->i_flag |= ILOCK;
-               if (ip->i_nlink <= 0) {
-                       itrunc(ip);
-                       ip->i_mode = 0;
-                       ip->i_flag |= IUPD|ICHG;
-                       ifree(ip->i_dev, ip->i_number);
-               }
-               IUPDAT(ip, &time, &time, 0);
-               irele(ip);
-               i = INOHASH(ip->i_dev, ip->i_number);
-               x = ip - inode;
-               if (inohash[i] == x) {
-                       inohash[i] = ip->i_hlink;
-               } else {
-                       for (jp = &inode[inohash[i]]; jp != &inode[-1];
-                           jp = &inode[jp->i_hlink])
-                               if (jp->i_hlink == x) {
-                                       jp->i_hlink = ip->i_hlink;
-                                       goto done;
-                               }
-                       panic("iput");
-               }
-done:
-               ip->i_hlink = ifreel;
-               ifreel = x;
-               ip->i_flag = 0;
-               ip->i_number = 0;
-       } else
-               irele(ip);
-       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.
+ * 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.

  */
  */

-iupdat(ip, ta, tm, waitfor)
-       register struct inode *ip;
-       time_t *ta, *tm;
+int
+ffs_update(vp, ta, tm, waitfor)
+       register struct vnode *vp;
+       struct timeval *ta, *tm;

        int waitfor;
 {
        int waitfor;
 {

-       register struct buf *bp;
+       struct buf *bp;
+       struct inode *ip;

        struct dinode *dp;
        struct dinode *dp;

-       register char *p1, *p2;
-       register int i;
+       register struct fs *fs;
+
+       if (vp->v_mount->mnt_flag & MNT_RDONLY)
+               return (0);
+       ip = VTOI(vp);
+       if ((ip->i_flag & (IUPD|IACC|ICHG|IMOD)) == 0)
+               return (0);
+       if (ip->i_flag&IACC)
+               ip->i_atime = ta->tv_sec;
+       if (ip->i_flag&IUPD) {
+               ip->i_mtime = tm->tv_sec;
+               INCRQUAD(ip->i_modrev);
+       }
+       if (ip->i_flag&ICHG)
+               ip->i_ctime = time.tv_sec;
+       ip->i_flag &= ~(IUPD|IACC|ICHG|IMOD);

 
 

-       if ((ip->i_flag&(IUPD|IACC|ICHG)) != 0) {
-               if (getfs(ip->i_dev)->s_ronly)
-                       return;
-               bp = bread(ip->i_dev, itod(ip->i_number));
-               if (bp->b_flags & B_ERROR) {
-                       brelse(bp);
-                       return;
-               }
-               dp = bp->b_un.b_dino;
-               dp += itoo(ip->i_number);
-               dp->di_mode = ip->i_mode;
-               dp->di_nlink = ip->i_nlink;
-               dp->di_uid = ip->i_uid;
-               dp->di_gid = ip->i_gid;
-               dp->di_size = ip->i_size;
-               p1 = (char *)dp->di_addr;
-               p2 = (char *)ip->i_un.i_addr;
-               for(i=0; i<NADDR; i++) {
-                       *p1++ = *p2++;
-                       *p1++ = *p2++;
-                       *p1++ = *p2++;
-                       if (*p2++ != 0)
-                               printf("iaddress > 2^24\n");
-               }
-               if (ip->i_flag&IACC)
-                       dp->di_atime = *ta;
-               if (ip->i_flag&IUPD)
-                       dp->di_mtime = *tm;
-               if (ip->i_flag&ICHG)
-                       dp->di_ctime = time;
-               ip->i_flag &= ~(IUPD|IACC|ICHG);
-               if (waitfor)
-                       bwrite(bp);
-               else
-                       bdwrite(bp);
+       fs = ip->i_fs;
+       if (error = bread(ip->i_devvp, fsbtodb(fs, itod(fs, ip->i_number)),
+               (int)fs->fs_bsize, NOCRED, &bp)) {
+               brelse(bp);
+               return (error);
+       }
+       dp = bp->b_un.b_dino + itoo(fs, ip->i_number);
+       *dp = ip->i_din;
+       if (waitfor)
+               return (bwrite(bp));
+       else {
+               bdwrite(bp);
+               return (0);

        }
 }
 
        }
 }
 

+#define        SINGLE  0       /* index of single indirect block */
+#define        DOUBLE  1       /* index of double indirect block */
+#define        TRIPLE  2       /* index of triple indirect block */

 /*
 /*

- * Free all the disk blocks associated
- * with the specified inode structure.
- * The blocks of the file are removed
- * in reverse order. This FILO
- * algorithm will tend to maintain
- * a contiguous free list much longer
- * than FIFO.
+ * 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.

  */
  */

-itrunc(ip)
-       register struct inode *ip;
+ffs_truncate(ovp, length, flags)
+       register struct vnode *ovp;
+       u_long length;
+       int flags;

 {
 {

-       register i;
-       dev_t dev;
-       daddr_t bn;
-       struct inode itmp;
-
-       i = ip->i_mode & IFMT;
-       if (i!=IFREG && i!=IFDIR)
-               return;
-
+       register daddr_t lastblock;
+       register struct inode *oip;
+       daddr_t bn, lbn, lastiblock[NIADDR];
+       register struct fs *fs;
+       register struct inode *ip;
+       struct buf *bp;
+       int offset, osize, size, level;
+       long count, nblocks, blocksreleased = 0;
+       register int i;
+       int aflags, error, allerror;
+       struct inode tip;
+
+       vnode_pager_setsize(ovp, length);
+       oip = VTOI(ovp);
+       if (oip->i_size <= length) {
+               oip->i_flag |= ICHG|IUPD;
+               error = ffs_update(ovp, &time, &time, 1);
+               return (error);
+       }

        /*
        /*

-        * Clean inode on disk before freeing blocks
-        * to insure no duplicates if system crashes.
+        * 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.

         */
         */

-       itmp = *ip;
-       itmp.i_size = 0;
-       for (i = 0; i < NADDR; i++)
-               itmp.i_un.i_addr[i] = 0;
-       itmp.i_flag |= ICHG|IUPD;
-       iupdat(&itmp, &time, &time, 1);
-       ip->i_flag &= ~(IUPD|IACC|ICHG);
-
+       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);

        /*
        /*

-        * Now return blocks to free list... if machine
-        * crashes, they will be harmless MISSING blocks.
+        * 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.

         */
         */

-       dev = ip->i_dev;
-       for(i=NADDR-1; i>=0; i--) {
-               bn = ip->i_un.i_addr[i];
-               if (bn == (daddr_t)0)
-                       continue;
-               ip->i_un.i_addr[i] = (daddr_t)0;
-               switch(i) {
-
-               default:
-                       free(dev, bn);
-                       break;
-
-               case NADDR-3:
-                       tloop(dev, bn, 0, 0);
-                       break;
-
-               case NADDR-2:
-                       tloop(dev, bn, 1, 0);
-                       break;
-
-               case NADDR-1:
-                       tloop(dev, bn, 1, 1);
-               }
+       osize = oip->i_size;
+       offset = blkoff(fs, length);
+       if (offset == 0) {
+               oip->i_size = length;
+       } else {
+               lbn = lblkno(fs, length);
+               aflags = B_CLRBUF;
+               if (flags & IO_SYNC)
+                       aflags |= B_SYNC;
+#ifdef QUOTA
+               if (error = getinoquota(oip))
+                       return (error);
+#endif
+               if (error = ffs_balloc(oip, lbn, offset, &bp, aflags))
+                       return (error);
+               oip->i_size = length;
+               size = blksize(fs, oip, lbn);
+               (void) vnode_pager_uncache(ITOV(oip));
+               bzero(bp->b_un.b_addr + offset, (unsigned)(size - offset));
+               allocbuf(bp, size);
+               if (flags & IO_SYNC)
+                       bwrite(bp);
+               else
+                       bdwrite(bp);

        }
        }

-       ip->i_size = 0;

        /*
        /*

-        * Inode was written and flags updated above.
-        * No need to modify flags here.
+        * 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.

         */
         */

-}
-
-tloop(dev, bn, f1, f2)
-dev_t dev;
-daddr_t bn;
-{
-       register i;
-       register struct buf *bp;
-       register daddr_t *bap;
-       daddr_t nb;
+       tip = *oip;
+       tip.i_size = osize;
+       for (level = TRIPLE; level >= SINGLE; level--)
+               if (lastiblock[level] < 0) {
+                       oip->i_ib[level] = 0;
+                       lastiblock[level] = -1;
+               }
+       for (i = NDADDR - 1; i > lastblock; i--)
+               oip->i_db[i] = 0;
+       oip->i_flag |= ICHG|IUPD;
+       vinvalbuf(ITOV(oip), (length > 0));
+       allerror = ffs_update(ovp, &time, &time, MNT_WAIT);

 
 

-       bp = NULL;
-       for(i=NINDIR-1; i>=0; i--) {
-               if (bp == NULL) {
-                       bp = bread(dev, bn);
-                       if (bp->b_flags & B_ERROR) {
-                               brelse(bp);
-                               return;
+       /*
+        * Indirect blocks first.
+        */
+       ip = &tip;
+       for (level = TRIPLE; level >= SINGLE; level--) {
+               bn = ip->i_ib[level];
+               if (bn != 0) {
+                       error = ffs_indirtrunc(ip,
+                           bn, lastiblock[level], level, &count);
+                       if (error)
+                               allerror = error;
+                       blocksreleased += count;
+                       if (lastiblock[level] < 0) {
+                               ip->i_ib[level] = 0;
+                               ffs_blkfree(ip, bn, (off_t)fs->fs_bsize);
+                               blocksreleased += nblocks;

                        }
                        }

-                       bap = bp->b_un.b_daddr;

                }
                }

-               nb = bap[i];
-               if (nb == (daddr_t)0)
-                       continue;
-               if (f1) {
-                       brelse(bp);
-                       bp = NULL;
-                       tloop(dev, nb, f2, 0);
-               } else
-                       free(dev, nb);
+               if (lastiblock[level] >= 0)
+                       goto done;

        }
        }

-       if (bp != NULL)
-               brelse(bp);
-       free(dev, bn);
-}

 
 

-/*
- * Make a new file.
- */
-struct inode *
-maknode(mode)
-{
-       register struct inode *ip;
+       /*
+        * All whole direct blocks or frags.
+        */
+       for (i = NDADDR - 1; i > lastblock; i--) {
+               register off_t bsize;

 
 

-       ip = ialloc(u.u_pdir->i_dev);
-       if (ip == NULL) {
-               iput(u.u_pdir);
-               return(NULL);
+               bn = ip->i_db[i];
+               if (bn == 0)
+                       continue;
+               ip->i_db[i] = 0;
+               bsize = (off_t)blksize(fs, ip, i);
+               ffs_blkfree(ip, bn, bsize);
+               blocksreleased += btodb(bsize);

        }
        }

-       ip->i_flag |= IACC|IUPD|ICHG;
-       if ((mode&IFMT) == 0)
-               mode |= IFREG;
-       ip->i_mode = mode & ~u.u_cmask;
-       ip->i_nlink = 1;
-       ip->i_uid = u.u_uid;
-       ip->i_gid = u.u_pdir->i_gid;
+       if (lastblock < 0)
+               goto done;

 
        /*
 
        /*

-        * Make sure inode goes to disk before directory entry.
+        * Finally, look for a change in size of the
+        * last direct block; release any frags.

         */
         */

-       iupdat(ip, &time, &time, 1);
-
-       wdir(ip);
-       return(ip);
-}
-
-/*
- * Write a directory entry with
- * parameters left as side effects
- * to a call to namei.
- */
-wdir(ip)
-       struct inode *ip;
-{
-
-       u.u_dent.d_ino = ip->i_number;
-       bcopy((caddr_t)u.u_dbuf, (caddr_t)u.u_dent.d_name, DIRSIZ);
-       u.u_count = sizeof(struct direct);
-       u.u_segflg = 1;
-       u.u_base = (caddr_t)&u.u_dent;
-       writei(u.u_pdir);
-       iput(u.u_pdir);
+       bn = ip->i_db[lastblock];
+       if (bn != 0) {
+               off_t oldspace, newspace;
+
+               /*
+                * 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);
+               if (newspace == 0)
+                       panic("itrunc: newspace");
+               if (oldspace - newspace > 0) {
+                       /*
+                        * Block number of space to be free'd is
+                        * the old block # plus the number of frags
+                        * required for the storage we're keeping.
+                        */
+                       bn += numfrags(fs, newspace);
+                       ffs_blkfree(ip, bn, oldspace - newspace);
+                       blocksreleased += btodb(oldspace - newspace);
+               }
+       }
+done:
+/* BEGIN PARANOIA */
+       for (level = SINGLE; level <= TRIPLE; level++)
+               if (ip->i_ib[level] != oip->i_ib[level])
+                       panic("itrunc1");
+       for (i = 0; i < NDADDR; i++)
+               if (ip->i_db[i] != oip->i_db[i])
+                       panic("itrunc2");
+/* END PARANOIA */
+       oip->i_blocks -= blocksreleased;
+       if (oip->i_blocks < 0)                  /* sanity */
+               oip->i_blocks = 0;
+       oip->i_flag |= ICHG;
+#ifdef QUOTA
+       if (!getinoquota(oip))
+               (void) chkdq(oip, -blocksreleased, NOCRED, 0);
+#endif
+       return (allerror);

 }
 
 }
 

-#ifdef ilock
-#undef ilock
-#endif
-#ifdef irele
-#undef irele
-#endif

 /*
 /*

- * Lock an inode. If its already locked, set the WANT bit and sleep.
+ * 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.

  */
  */

-ilock(ip)
+static int
+ffs_indirtrunc(ip, bn, lastbn, level, countp)

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

+       daddr_t bn, lastbn;
+       int level;
+       long *countp;

 {
 {

+       register int i;
+       struct buf *bp;
+       register struct fs *fs = ip->i_fs;
+       register daddr_t *bap;
+       daddr_t *copy, nb, last;
+       long blkcount, factor;
+       int nblocks, blocksreleased = 0;
+       int error, allerror = 0;

 
 

-       while (ip->i_flag&ILOCK) {
-               ip->i_flag |= IWANT;
-               sleep((caddr_t)ip, PINOD);
+       /*
+        * Calculate index in current block of last
+        * block to be kept.  -1 indicates the entire
+        * block so we need not calculate the index.
+        */
+       factor = 1;
+       for (i = SINGLE; i < level; i++)
+               factor *= NINDIR(fs);
+       last = lastbn;
+       if (lastbn > 0)
+               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.
+        */
+#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);
+       if (error) {
+               brelse(bp);
+               *countp = 0;
+               return (error);

        }
        }

-       ip->i_flag |= ILOCK;
-}
+       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);
+       bzero((caddr_t)&bap[last + 1],
+         (u_int)(NINDIR(fs) - (last + 1)) * sizeof (daddr_t));
+       if (last == -1)
+               bp->b_flags |= B_INVAL;
+       error = bwrite(bp);
+       if (error)
+               allerror = error;
+       bap = copy;

 
 

-/*
- * Unlock an inode.  If WANT bit is on, wakeup.
- */
-irele(ip)
-       register struct inode *ip;
-{
+       /*
+        * Recursively free totally unused blocks.
+        */
+       for (i = NINDIR(fs) - 1; i > last; i--) {
+               nb = bap[i];
+               if (nb == 0)
+                       continue;
+               if (level > SINGLE) {
+                       if (error = ffs_indirtrunc(ip,
+                           nb, (daddr_t)-1, level - 1, &blkcount))
+                               allerror = error;
+                       blocksreleased += blkcount;
+               }
+               ffs_blkfree(ip, nb, (off_t)fs->fs_bsize);
+               blocksreleased += nblocks;
+       }

 
 

-       ip->i_flag &= ~ILOCK;
-       if (ip->i_flag&IWANT) {
-               ip->i_flag &= ~IWANT;
-               wakeup((caddr_t)ip);
+       /*
+        * Recursively free last partial block.
+        */
+       if (level > SINGLE && lastbn >= 0) {
+               last = lastbn % factor;
+               nb = bap[i];
+               if (nb != 0) {
+                       if (error =
+                           ffs_indirtrunc(ip, nb, last, level - 1, &blkcount))
+                               allerror = error;
+                       blocksreleased += blkcount;
+               }

        }
        }

+       FREE(copy, M_TEMP);
+       *countp = blocksreleased;
+       return (allerror);

 }
 }