don't nlist /vmunix unless file changes (from dpk@brl)

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

diff --git a/usr/src/sys/ufs/ffs/ufs_inode.c b/usr/src/sys/ufs/ffs/ufs_inode.c
index 9eda051..437e3df 100644 (file)
--- a/usr/src/sys/ufs/ffs/ufs_inode.c
+++ b/usr/src/sys/ufs/ffs/ufs_inode.c
@@ -1,4 +1,4 @@
-/*     ufs_inode.c     4.12    82/06/10        */
+/*     ufs_inode.c     6.6     84/07/02        */

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


@@ -9,12 +9,24 @@
 #include "../h/fs.h"
 #include "../h/conf.h"
 #include "../h/buf.h"
 #include "../h/fs.h"
 #include "../h/conf.h"
 #include "../h/buf.h"

-#include "../h/inline.h"
+#ifdef QUOTA
+#include "../h/quota.h"
+#endif
+#include "../h/kernel.h"
+
+#define        INOHSZ  64
+#if    ((INOHSZ&(INOHSZ-1)) == 0)
+#define        INOHASH(dev,ino)        (((dev)+(ino))&(INOHSZ-1))
+#else
+#define        INOHASH(dev,ino)        (((unsigned)((dev)+(ino)))%INOHSZ)
+#endif

 
 

-#define        INOHSZ  63
-#define        INOHASH(dev,ino)        (((dev)+(ino))%INOHSZ)
-short  inohash[INOHSZ];
-short  ifreel;
+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
 
 /*
  * Initialize hash links for inodes


@@ -24,14 +36,49 @@ ihinit()
 {
        register int i;
        register struct inode *ip = inode;
 {
        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;
+{
+       register struct inode *ip;
+       register union  ihead *ih;

 
 

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

 }
 }

+#endif notdef

 
 /*
  * Look up an inode by device,inumber.
 
 /*
  * Look up an inode by device,inumber.


@@ -55,60 +102,114 @@ iget(dev, fs, ino)
        ino_t ino;
 {
        register struct inode *ip;
        ino_t ino;
 {
        register struct inode *ip;

+       register union  ihead *ih;

        register struct mount *mp;
        register struct buf *bp;
        register struct dinode *dp;
        register struct mount *mp;
        register struct buf *bp;
        register struct dinode *dp;

-       register int slot;
+       register struct inode *iq;
+       struct inode *xp;
+

 
 loop:
 
 loop:

-       if (getfs(dev) != fs)
-               panic("iget: bad fs");
-       slot = INOHASH(dev, ino);
-       ip = &inode[inohash[slot]];
-       while (ip != &inode[-1]) {
+       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 (ino == ip->i_number && dev == ip->i_dev) {

-                       if ((ip->i_flag&ILOCK) != 0) {
+                       /*
+                        * Following is essentially an inline expanded
+                        * copy of igrab(), expanded inline for speed,
+                        * and so that the test for a mounted on inode
+                        * can be deferred until after we are sure that
+                        * the inode isn't busy.
+                        */
+                       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++)
                                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;
-                               }
+                                       if(mp->m_inodp == ip) {
+                                               dev = mp->m_dev;
+                                               fs = mp->m_bufp->b_un.b_fs;
+                                               ino = ROOTINO;
+                                               goto loop;
+                                       }

                                panic("no imt");
                        }
                                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_count++;

-                       ip->i_flag |= ILOCK;
+                       ip->i_flag |= ILOCKED;

                        return(ip);
                }
                        return(ip);
                }

-               ip = &inode[ip->i_hlink];
-       }
-       if (ifreel < 0) {
+
+       if ((ip = ifreeh) == NULL) {

                tablefull("inode");
                u.u_error = ENFILE;
                return(NULL);
        }
                tablefull("inode");
                u.u_error = ENFILE;
                return(NULL);
        }

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

-       ip->i_flag = ILOCK;
+       ip->i_id = ++nextinodeid;       /* also used in rename */
+       /*
+        * At an absurd rate of 100 calls/second,
+        * this should occur once every 8 months.
+        */
+       if (nextinodeid < 0)
+               for (nextinodeid = 0, xp = inode; xp < inodeNINODE; xp++)
+                       xp->i_id = 0;
+       ip->i_flag = ILOCKED;

        ip->i_count++;
        ip->i_lastr = 0;
        ip->i_count++;
        ip->i_lastr = 0;

-       bp = bread(dev, fsbtodb(fs, itod(fs, ino)), fs->fs_bsize);
+       bp = bread(dev, fsbtodb(fs, itod(fs, ino)), (int)fs->fs_bsize);

        /*
         * Check I/O errors
         */
        if ((bp->b_flags&B_ERROR) != 0) {
                brelse(bp);
        /*
         * Check I/O errors
         */
        if ((bp->b_flags&B_ERROR) != 0) {
                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);
        }
                iput(ip);
                return(NULL);
        }


@@ -116,9 +217,45 @@ loop:
        dp += itoo(fs, ino);
        ip->i_ic = dp->di_ic;
        brelse(bp);
        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);
 }
 
        return (ip);
 }
 

+/*
+ * Convert a pointer to an inode into a reference to an inode.
+ *
+ * This is basically the internal piece of iget (after the
+ * inode pointer is located) but without the test for mounted
+ * filesystems.  It is caller's responsibility to check that
+ * the inode pointer is valid.
+ */
+igrab(ip)
+       register struct inode *ip;
+{
+       while ((ip->i_flag&ILOCKED) != 0) {
+               ip->i_flag |= IWANT;
+               sleep((caddr_t)ip, PINOD);
+       }
+       if (ip->i_count == 0) {         /* ino on free list */
+               register struct inode *iq;
+
+               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;
+}
+

 /*
  * Decrement reference count of
  * an inode structure.
 /*
  * Decrement reference count of
  * an inode structure.


@@ -130,7 +267,7 @@ iput(ip)
        register struct inode *ip;
 {
 
        register struct inode *ip;
 {
 

-       if ((ip->i_flag & ILOCK) == 0)
+       if ((ip->i_flag & ILOCKED) == 0)

                panic("iput");
        iunlock(ip);
        irele(ip);
                panic("iput");
        iunlock(ip);
        irele(ip);


@@ -139,40 +276,47 @@ iput(ip)
 irele(ip)
        register struct inode *ip;
 {
 irele(ip)
        register struct inode *ip;
 {

-       register int i, x;
-       register struct inode *jp;

        int mode;
 
        if (ip->i_count == 1) {
        int mode;
 
        if (ip->i_count == 1) {

-               ip->i_flag |= ILOCK;
+               ip->i_flag |= ILOCKED;

                if (ip->i_nlink <= 0) {
                if (ip->i_nlink <= 0) {

-                       itrunc(ip);
+                       itrunc(ip, (u_long)0);

                        mode = ip->i_mode;
                        ip->i_mode = 0;
                        mode = ip->i_mode;
                        ip->i_mode = 0;

+                       ip->i_rdev = 0;

                        ip->i_flag |= IUPD|ICHG;
                        ifree(ip, ip->i_number, mode);
                        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);
                }
                IUPDAT(ip, &time, &time, 0);
                iunlock(ip);

-               i = INOHASH(ip->i_dev, ip->i_number);
-               x = ip - inode;
-               if (inohash[i] == x) {
-                       inohash[i] = ip->i_hlink;
+               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 {
                } 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");
+                       ifreeh = ip;
+                       ip->i_freeb = &ifreeh;

                }
                }

-done:
-               ip->i_hlink = ifreel;
-               ifreel = x;
-               ip->i_flag = 0;
-               ip->i_number = 0;
-       }
+               ip->i_freef = NULL;
+               ifreet = &ip->i_freef;
+       } else if (!(ip->i_flag & ILOCKED))
+               ITIMES(ip, &time, &time);

        ip->i_count--;
 }
 
        ip->i_count--;
 }
 


@@ -186,7 +330,7 @@ done:
  */
 iupdat(ip, ta, tm, waitfor)
        register struct inode *ip;
  */
 iupdat(ip, ta, tm, waitfor)
        register struct inode *ip;

-       time_t *ta, *tm;
+       struct timeval *ta, *tm;

        int waitfor;
 {
        register struct buf *bp;
        int waitfor;
 {
        register struct buf *bp;


@@ -194,22 +338,22 @@ iupdat(ip, ta, tm, waitfor)
        register struct fs *fp;
 
        fp = ip->i_fs;
        register struct fs *fp;
 
        fp = ip->i_fs;

-       if ((ip->i_flag & (IUPD|IACC|ICHG)) != 0) {
+       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)),
                if (fp->fs_ronly)
                        return;
                bp = bread(ip->i_dev, fsbtodb(fp, itod(fp, ip->i_number)),

-                       fp->fs_bsize);
+                       (int)fp->fs_bsize);

                if (bp->b_flags & B_ERROR) {
                        brelse(bp);
                        return;
                }
                if (ip->i_flag&IACC)
                if (bp->b_flags & B_ERROR) {
                        brelse(bp);
                        return;
                }
                if (ip->i_flag&IACC)

-                       ip->i_atime = *ta;
+                       ip->i_atime = ta->tv_sec;

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

-                       ip->i_mtime = *tm;
+                       ip->i_mtime = tm->tv_sec;

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

-                       ip->i_ctime = time;
-               ip->i_flag &= ~(IUPD|IACC|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)
                dp = bp->b_un.b_dino + itoo(fp, ip->i_number);
                dp->di_ic = ip->i_ic;
                if (waitfor)


@@ -219,255 +363,291 @@ iupdat(ip, ta, tm, waitfor)
        }
 }
 
        }
 }
 

+#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;
+itrunc(oip, length)
+       struct inode *oip;
+       u_long length;

 {
        register i;
 {
        register i;

-       dev_t dev;
-       daddr_t bn;
-       struct inode itmp;
+       register daddr_t lastblock;
+       daddr_t bn, lastiblock[NIADDR];

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

+       register struct inode *ip;
+       struct inode tip;
+       long blocksreleased = 0, nblocks;
+       long indirtrunc();
+       int level;

 
 

-       i = ip->i_mode & IFMT;
-       if (i != IFREG && i != IFDIR && i != IFLNK)
+       if (oip->i_size <= length) {
+               oip->i_flag |= ICHG|IUPD;
+               iupdat(oip, &time, &time, 1);

                return;
                return;

-       /*
-        * Clean inode on disk before freeing blocks
-        * to insure no duplicates if system crashes.
-        */
-       itmp = *ip;
-       itmp.i_size = 0;
-       for (i = 0; i < NDADDR; i++)
-               itmp.i_db[i] = 0;
-       for (i = 0; i < NIADDR; i++)
-               itmp.i_ib[i] = 0;
-       itmp.i_flag |= ICHG|IUPD;
-       iupdat(&itmp, &time, &time, 1);
-       ip->i_flag &= ~(IUPD|IACC|ICHG);
-
-       /*
-        * Now return blocks to free list... if machine
-        * crashes, they will be harmless MISSING blocks.
-        */
-       dev = ip->i_dev;
-       fs = ip->i_fs;
-       /*
-        * release double indirect block first
-        */
-       bn = ip->i_ib[NIADDR-1];
-       if (bn != (daddr_t)0) {
-               ip->i_ib[NIADDR - 1] = (daddr_t)0;
-               tloop(ip, bn, 1);

        }
        /*
        }
        /*

-        * release single indirect blocks second
+        * 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.

         */
         */

-       for (i = NIADDR - 2; i >= 0; i--) {
-               bn = ip->i_ib[i];
-               if (bn != (daddr_t)0) {
-                       ip->i_ib[i] = (daddr_t)0;
-                       tloop(ip, bn, 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);

        /*
        /*

-        * finally release direct blocks
+        * 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)

         */
         */

-       for (i = NDADDR - 1; i>=0; i--) {
-               bn = ip->i_db[i];
-               if (bn == (daddr_t)0)
-                       continue;
-               ip->i_db[i] = (daddr_t)0;
-               fre(ip, bn, (off_t)blksize(fs, ip, i));
-       }
-       ip->i_size = 0;
+       tip = *oip;
+       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_size = length;
+       oip->i_flag |= ICHG|IUPD;
+       iupdat(oip, &time, &time, 1);
+       ip = &tip;
+

        /*
        /*

-        * Inode was written and flags updated above.
-        * No need to modify flags here.
+        * Indirect blocks first.

         */
         */

-}
-
-tloop(ip, bn, indflg)
-       register struct inode *ip;
-       daddr_t bn;
-       int indflg;
-{
-       register i;
-       register struct buf *bp;
-       register daddr_t *bap;
-       register struct fs *fs;
-       daddr_t nb;
-
-       bp = NULL;
-       fs = ip->i_fs;
-       for (i = NINDIR(fs) - 1; i >= 0; i--) {
-               if (bp == NULL) {
-                       bp = bread(ip->i_dev, fsbtodb(fs, bn), fs->fs_bsize);
-                       if (bp->b_flags & B_ERROR) {
-                               brelse(bp);
-                               return;
+       for (level = TRIPLE; level >= SINGLE; level--) {
+               bn = ip->i_ib[level];
+               if (bn != 0) {
+                       blocksreleased +=
+                           indirtrunc(ip, bn, lastiblock[level], level);
+                       if (lastiblock[level] < 0) {
+                               ip->i_ib[level] = 0;
+                               free(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 (indflg)
-                       tloop(ip, nb, 0);
-               else
-                       fre(ip, nb, fs->fs_bsize);
+               if (lastiblock[level] >= 0)
+                       goto done;

        }
        }

-       if (bp != NULL)
-               brelse(bp);
-       fre(ip, bn, fs->fs_bsize);
-}

 
 

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

 
 

-       if ((mode & IFMT) == IFDIR)
-               ipref = dirpref(u.u_pdir->i_fs);
-       else
-               ipref = u.u_pdir->i_number;
-       ip = ialloc(u.u_pdir, ipref, mode);
-       if (ip == NULL) {
-               iput(u.u_pdir);
-               return(NULL);
+               bn = ip->i_db[i];
+               if (bn == 0)
+                       continue;
+               ip->i_db[i] = 0;
+               size = (off_t)blksize(fs, ip, i);
+               free(ip, bn, size);
+               blocksreleased += btodb(size);

        }
        }

-       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);
-       if (u.u_error) {
+       bn = ip->i_db[lastblock];
+       if (bn != 0) {
+               int oldspace, newspace;
+

                /*
                /*

-                * write error occurred trying to update directory
-                * so must deallocate the inode
+                * Calculate amount of space we're giving
+                * back as old block size minus new block size.

                 */
                 */

-               ip->i_nlink = 0;
-               ip->i_flag |= ICHG;
-               iput(ip);
-               return(NULL);
+               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);
+                       free(ip, bn, oldspace - newspace);
+                       blocksreleased += btodb(oldspace - newspace);
+               }

        }
        }

-       return(ip);
+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
+       (void) chkdq(oip, -blocksreleased, 0);
+#endif

 }
 
 /*
 }
 
 /*

- * Write a directory entry with
- * parameters left as side effects
- * to a call to namei.
+ * 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.

  */
  */

-wdir(ip)
-       struct inode *ip;
+long
+indirtrunc(ip, bn, lastbn, level)
+       register struct inode *ip;
+       daddr_t bn, lastbn;
+       int level;

 {
 {

-       register struct direct *dp, *ndp;
-       struct fs *fs;
-       struct buf *bp;
-       int lbn, bn, base;
-       int loc, dsize, spccnt, newsize;
-       char *dirbuf;
-
-       u.u_dent.d_ino = ip->i_number;
-       u.u_segflg = 1;
-       newsize = DIRSIZ(&u.u_dent);
+       register int i;
+       struct buf *bp, *copy;
+       register daddr_t *bap;
+       register struct fs *fs = ip->i_fs;
+       daddr_t nb, last;
+       long factor;
+       int blocksreleased = 0, nblocks;
+

        /*
        /*

-        * if u.u_count == 0, a new directory block must be allocated.
+        * Calculate index in current block of last
+        * block to be kept.  -1 indicates the entire
+        * block so we need not calculate the index.

         */
         */

-       if (u.u_count == 0) {
-               u.u_dent.d_reclen = DIRBLKSIZ;
-               u.u_count = newsize;
-               u.u_base = (caddr_t)&u.u_dent;
-               writei(u.u_pdir);
-               iput(u.u_pdir);
-               return;
-       }
+       factor = 1;
+       for (i = SINGLE; i < level; i++)
+               factor *= NINDIR(fs);
+       last = lastbn;
+       if (lastbn > 0)
+               last /= factor;
+       nblocks = btodb(fs->fs_bsize);

        /*
        /*

-        * must read in an existing directory block
-        * to prepare to place the new entry into it.
+        * Get buffer of block pointers, zero those 
+        * entries corresponding to blocks to be free'd,
+        * and update on disk copy first.

         */
         */

-       fs = u.u_pdir->i_fs;
-       lbn = lblkno(fs, u.u_offset);
-       base = blkoff(fs, u.u_offset);
-       bn = fsbtodb(fs, bmap(u.u_pdir, lbn, B_WRITE, base + u.u_count));
-       if (u.u_offset + u.u_count > u.u_pdir->i_size)
-               u.u_pdir->i_size = u.u_offset + u.u_count;
-       bp = bread(u.u_pdir->i_dev, bn, blksize(fs, u.u_pdir, lbn));
-       if (bp->b_flags & B_ERROR) {
+       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);

                brelse(bp);
                brelse(bp);

-               return;
+               return (0);

        }
        }

-       dirbuf = bp->b_un.b_addr + base;
-       dp = (struct direct *)dirbuf;
-       dsize = DIRSIZ(dp);
-       spccnt = dp->d_reclen - dsize;
+       bap = bp->b_un.b_daddr;
+       bcopy((caddr_t)bap, (caddr_t)copy->b_un.b_daddr, (u_int)fs->fs_bsize);
+       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 there is insufficient room to make an entry at this point
-        * namei insures that compacting from u.u_offset for u.u_count
-        * bytes will provide the necessary space.
+        * Recursively free totally unused blocks.

         */
         */

-       for (loc = dp->d_reclen; loc < u.u_count; ) {
-               ndp = (struct direct *)(dirbuf + loc);
-               if (dp->d_ino == 0) {
-                       spccnt += dsize;
-               } else {
-                       dp->d_reclen = dsize;
-                       dp = (struct direct *)((char *)dp + dsize);
-               }
-               dsize = DIRSIZ(ndp);
-               spccnt += ndp->d_reclen - dsize;
-               loc += ndp->d_reclen;
-               bcopy(ndp, dp, dsize);
+       for (i = NINDIR(fs) - 1; i > last; i--) {
+               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);
+               blocksreleased += nblocks;

        }
        }

+

        /*
        /*

-        * Update the pointer fields in the previous entry (if any),
-        * copy in the new entry, and write out the block.
+        * Recursively free last partial block.

         */
         */

-       if (dp->d_ino == 0) {
-               if (spccnt + dsize < newsize)
-                       panic("wdir: compact failed");
-               u.u_dent.d_reclen = spccnt + dsize;
-       } else {
-               if (spccnt < newsize)
-                       panic("wdir: compact failed");
-               u.u_dent.d_reclen = spccnt;
-               dp->d_reclen = dsize;
-               dp = (struct direct *)((char *)dp + dsize);
+       if (level > SINGLE && lastbn >= 0) {
+               last = lastbn % factor;
+               nb = bap[i];
+               if (nb != 0)
+                       blocksreleased += indirtrunc(ip, nb, last, level - 1);

        }
        }

-       bcopy(&u.u_dent, dp, newsize);
-       bwrite(bp);
-       u.u_pdir->i_flag |= IUPD|ICHG;
-       iput(u.u_pdir);
+       brelse(bp);
+       return (blocksreleased);

 }
 
 }
 

-#ifdef ilock
-#undef ilock
+/*
+ * 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
 #endif

-#ifdef iunlock
-#undef iunlock
+                       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
 #endif

+                       }
+               else if (ip->i_count && (ip->i_mode&IFMT)==IFBLK &&
+                   ip->i_rdev == dev)
+                       open++;
+       }
+       return (open);
+}
+

 /*
  * Lock an inode. If its already locked, set the WANT bit and sleep.
  */
 /*
  * Lock an inode. If its already locked, set the WANT bit and sleep.
  */


@@ -475,11 +655,7 @@ ilock(ip)
        register struct inode *ip;
 {
 
        register struct inode *ip;
 {
 

-       while (ip->i_flag&ILOCK) {
-               ip->i_flag |= IWANT;
-               sleep((caddr_t)ip, PINOD);
-       }
-       ip->i_flag |= ILOCK;
+       ILOCK(ip);

 }
 
 /*
 }
 
 /*


@@ -489,9 +665,5 @@ iunlock(ip)
        register struct inode *ip;
 {
 
        register struct inode *ip;
 {
 

-       ip->i_flag &= ~ILOCK;
-       if (ip->i_flag&IWANT) {
-               ip->i_flag &= ~IWANT;
-               wakeup((caddr_t)ip);
-       }
+       IUNLOCK(ip);

 }
 }