BSD 4_4_Lite1 release

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

diff --git a/usr/src/sys/ufs/lfs/lfs_inode.c b/usr/src/sys/ufs/lfs/lfs_inode.c
index 1a44ea1..1a06aa2 100644 (file)
--- a/usr/src/sys/ufs/lfs/lfs_inode.c
+++ b/usr/src/sys/ufs/lfs/lfs_inode.c
@@ -1,10 +1,36 @@
 /*
 /*

- * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1986, 1989, 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.

  *
  *

- * %sccs.include.redist.c%
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.

  *
  *

- *     @(#)lfs_inode.c 7.45 (Berkeley) %G%
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)lfs_inode.c 8.5 (Berkeley) 12/30/93

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


@@ -17,15 +43,15 @@
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 

-#include <ufs/quota.h>
-#include <ufs/inode.h>
-#include <ufs/ufsmount.h>
-#include <ufs/ufs_extern.h>
+#include <vm/vm.h>

 
 

-#include <lfs/lfs.h>
-#include <lfs/lfs_extern.h>
+#include <ufs/ufs/quota.h>
+#include <ufs/ufs/inode.h>
+#include <ufs/ufs/ufsmount.h>
+#include <ufs/ufs/ufs_extern.h>

 
 

-extern int prtactive;  /* 1 => print out reclaim of active vnodes */
+#include <ufs/lfs/lfs.h>
+#include <ufs/lfs/lfs_extern.h>

 
 int
 lfs_init()
 
 int
 lfs_init()


@@ -33,149 +59,301 @@ lfs_init()
        return (ufs_init());
 }
 
        return (ufs_init());
 }
 

-/*
- * Look up an LFS dinode number to find its incore vnode.  If not already
- * in core, read it in from the specified device.  Return the inode locked.
- * Detection and handling of mount points must be done by the calling routine.
- */
-int
-lfs_iget(pip, ino, ipp)
-       struct inode *pip;
+/* Search a block for a specific dinode. */
+struct dinode *
+lfs_ifind(fs, ino, dip)
+       struct lfs *fs;

        ino_t ino;
        ino_t ino;

-       struct inode **ipp;
+       register struct dinode *dip;

 {
 {

-       register LFS *fs;
-       register struct inode *ip;
-       register struct vnode *vp;
-       struct buf *bp;
-       struct inode *nip;
-       struct mount *mntp;
-       struct vnode *nvp;
-       dev_t dev;
-       int error;
-
-printf("lfs_iget ino %d\n", ino);
-
-       if (ino < ROOTINO)
-               return (EINVAL);
-
-       dev = pip->i_dev;
-       if ((*ipp = ufs_ihashget(dev, ino)) != NULL)
-               return (0);
+       register int cnt;
+       register struct dinode *ldip;

 
 

-       /* Allocate new vnode/inode. */
-       mntp = ITOV(pip)->v_mount;
-       error = lfs_vcreate(mntp, ino, &nvp);
-       if (error) {
-               *ipp = NULL;
-               return (error);
-       }
-       ip = VTOI(nvp);
-               
-       /*
-        * Put it onto its hash chain and lock it so that other requests for
-        * this inode will block if they arrive while we are sleeping waiting
-        * for old data structures to be purged or for the contents of the
-        * disk portion of this inode to be read.
-        */
-       ufs_ihashins(ip);
-
-       /* Read in the disk contents for the inode, copy into the inode. */
-       fs = VFSTOUFS(mntp)->um_lfs;
-       if (error = bread(VFSTOUFS(mntp)->um_devvp, lfs_itod(fs, ino),
-           (int)fs->lfs_bsize, NOCRED, &bp)) {
-               /*
-                * The inode does not 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;
-
-               /* Unlock and discard unneeded inode. */
-               ufs_iput(ip);
-               brelse(bp);
-               *ipp = NULL;
-               return (error);
-       }
-       ip->i_din = *lfs_ifind(fs, ino, bp->b_un.b_dino);
-       brelse(bp);
-
-       /* Initialize the vnode from the inode, check for aliases. */
-       if (error = ufs_vinit(mntp, ip, &nip)) {
-               ufs_iput(ip);
-               *ipp = NULL;
-               return (error);
-       }
-       *ipp = nip;
-       return (0);
+       for (cnt = INOPB(fs), ldip = dip + (cnt - 1); cnt--; --ldip)
+               if (ldip->di_inumber == ino)
+                       return (ldip);
+
+       panic("lfs_ifind: dinode %u not found", ino);
+       /* NOTREACHED */

 }
 
 int
 }
 
 int

-lfs_iupdat(ip, ta, tm, waitfor)
-       register struct inode *ip;
-       struct timeval *ta, *tm;
-        int waitfor;
+lfs_update(ap)
+       struct vop_update_args /* {
+               struct vnode *a_vp;
+               struct timeval *a_access;
+               struct timeval *a_modify;
+               int a_waitfor;
+       } */ *ap;

 {
 {

-       /*
-        * XXX
-        * This isn't right, but ufs_iupdat() isn't either.
-        */
-       ITIMES(ip, ta, tm);
-       return (0);
+       struct vnode *vp = ap->a_vp;
+       struct inode *ip;
+
+       if (vp->v_mount->mnt_flag & MNT_RDONLY)
+               return (0);
+       ip = VTOI(vp);
+       if ((ip->i_flag &
+           (IN_ACCESS | IN_CHANGE | IN_MODIFIED | IN_UPDATE)) == 0)
+               return (0);
+       if (ip->i_flag & IN_ACCESS)
+               ip->i_atime.ts_sec = ap->a_access->tv_sec;
+       if (ip->i_flag & IN_UPDATE) {
+               ip->i_mtime.ts_sec = ap->a_modify->tv_sec;
+               (ip)->i_modrev++;
+       }
+       if (ip->i_flag & IN_CHANGE)
+               ip->i_ctime.ts_sec = time.tv_sec;
+       ip->i_flag &= ~(IN_ACCESS | IN_CHANGE | IN_UPDATE);
+
+       if (!(ip->i_flag & IN_MODIFIED))
+               ++(VFSTOUFS(vp->v_mount)->um_lfs->lfs_uinodes);
+       ip->i_flag |= IN_MODIFIED;
+
+       /* If sync, push back the vnode and any dirty blocks it may have. */
+       return (ap->a_waitfor & LFS_SYNC ? lfs_vflush(vp) : 0);
+}
+
+/* Update segment usage information when removing a block. */
+#define UPDATE_SEGUSE \
+       if (lastseg != -1) { \
+               LFS_SEGENTRY(sup, fs, lastseg, sup_bp); \
+               if ((num << fs->lfs_bshift) > sup->su_nbytes) \
+                       panic("lfs_truncate: negative bytes in segment %d\n", \
+                           lastseg); \
+               sup->su_nbytes -= num << fs->lfs_bshift; \
+               e1 = VOP_BWRITE(sup_bp); \
+               blocksreleased += num; \
+       }
+
+#define SEGDEC { \
+       if (daddr != 0) { \
+               if (lastseg != (seg = datosn(fs, daddr))) { \
+                       UPDATE_SEGUSE; \
+                       num = 1; \
+                       lastseg = seg; \
+               } else \
+                       ++num; \
+       } \

 }
 
 /*
 }
 
 /*

- * Truncate the inode ip to at most length size.
- *
- * NB: triple indirect blocks are untested.
+ * Truncate the inode ip to at most length size.  Update segment usage
+ * table information.

  */
 /* ARGSUSED */
 int
  */
 /* ARGSUSED */
 int

-lfs_itrunc(oip, length, flags)
-       register struct inode *oip;
-       u_long length;
-       int flags;
+lfs_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 LFS *fs;
-       struct buf *bp;
-       daddr_t lbn;
-       int error, offset, size;
+       register struct indir *inp;
+       register int i;
+       register daddr_t *daddrp;
+       register struct vnode *vp = ap->a_vp;
+       off_t length = ap->a_length;
+       struct buf *bp, *sup_bp;
+       struct timeval tv;
+       struct ifile *ifp;
+       struct inode *ip;
+       struct lfs *fs;
+       struct indir a[NIADDR + 2], a_end[NIADDR + 2];
+       SEGUSE *sup;
+       daddr_t daddr, lastblock, lbn, olastblock;
+       long off, a_released, blocksreleased, i_released;
+       int e1, e2, depth, lastseg, num, offset, seg, size;
+
+       ip = VTOI(vp);
+       tv = time;
+       if (vp->v_type == VLNK && vp->v_mount->mnt_maxsymlinklen > 0) {
+#ifdef DIAGNOSTIC
+               if (length != 0)
+                       panic("lfs_truncate: partial truncate of symlink");
+#endif
+               bzero((char *)&ip->i_shortlink, (u_int)ip->i_size);
+               ip->i_size = 0;
+               ip->i_flag |= IN_CHANGE | IN_UPDATE;
+               return (VOP_UPDATE(vp, &tv, &tv, 0));
+       }
+       vnode_pager_setsize(vp, (u_long)length);

 
 

-       vnode_pager_setsize(ITOV(oip), length);
+       fs = ip->i_lfs;

 
        /* If length is larger than the file, just update the times. */
 
        /* If length is larger than the file, just update the times. */

-       if (oip->i_size <= length) {
-               oip->i_flag |= ICHG|IUPD;
-               ITIMES(oip, &time, &time);
-               return (0);
+       if (ip->i_size <= length) {
+               ip->i_flag |= IN_CHANGE | IN_UPDATE;
+               return (VOP_UPDATE(vp, &tv, &tv, 0));

        }
 
        }
 

+       /*
+        * Calculate index into inode's block list of last direct and indirect
+        * blocks (if any) which we want to keep.  Lastblock is 0 when the
+        * file is truncated to 0.
+        */
+       lastblock = lblkno(fs, length + fs->lfs_bsize - 1);
+       olastblock = lblkno(fs, ip->i_size + fs->lfs_bsize - 1) - 1;
+

        /*
         * 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.
         */
        /*
         * 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_lfs;

        offset = blkoff(fs, length);
        if (offset == 0)
        offset = blkoff(fs, length);
        if (offset == 0)

-               oip->i_size = length;
+               ip->i_size = length;

        else {
                lbn = lblkno(fs, length);
 #ifdef QUOTA
        else {
                lbn = lblkno(fs, length);
 #ifdef QUOTA

-               if (error = getinoquota(oip))
-                       return (error);
+               if (e1 = getinoquota(ip))
+                       return (e1);

 #endif 
 #endif 

-               if (error = bread(ITOV(oip), lbn, fs->lfs_bsize, NOCRED, &bp))
-                       return (error);
-               oip->i_size = length;
-               size = blksize(fs);                             /* LFS */
-               (void) vnode_pager_uncache(ITOV(oip));
-               bzero(bp->b_un.b_addr + offset, (unsigned)(size - offset));
+               if (e1 = bread(vp, lbn, fs->lfs_bsize, NOCRED, &bp))
+                       return (e1);
+               ip->i_size = length;
+               size = blksize(fs);
+               (void)vnode_pager_uncache(vp);
+               bzero((char *)bp->b_data + offset, (u_int)(size - offset));

                allocbuf(bp, size);
                allocbuf(bp, size);

-               lfs_bwrite(bp);
+               if (e1 = VOP_BWRITE(bp))
+                       return (e1);
+       }
+       /*
+        * Modify sup->su_nbyte counters for each deleted block; keep track
+        * of number of blocks removed for ip->i_blocks.
+        */
+       blocksreleased = 0;
+       num = 0;
+       lastseg = -1;
+
+       for (lbn = olastblock; lbn >= lastblock;) {
+               /* XXX use run length from bmap array to make this faster */
+               ufs_bmaparray(vp, lbn, &daddr, a, &depth, NULL);
+               if (lbn == olastblock)
+                       for (i = NIADDR + 2; i--;)
+                               a_end[i] = a[i];
+               switch (depth) {
+               case 0:                         /* Direct block. */
+                       daddr = ip->i_db[lbn];
+                       SEGDEC;
+                       ip->i_db[lbn] = 0;
+                       --lbn;
+                       break;
+#ifdef DIAGNOSTIC
+               case 1:                         /* An indirect block. */
+                       panic("lfs_truncate: ufs_bmaparray returned depth 1");
+                       /* NOTREACHED */
+#endif
+               default:                        /* Chain of indirect blocks. */
+                       inp = a + --depth;
+                       if (inp->in_off > 0 && lbn != lastblock) {
+                               lbn -= inp->in_off < lbn - lastblock ?
+                                   inp->in_off : lbn - lastblock;
+                               break;
+                       }
+                       for (; depth && (inp->in_off == 0 || lbn == lastblock);
+                           --inp, --depth) {
+                               if (bread(vp,
+                                   inp->in_lbn, fs->lfs_bsize, NOCRED, &bp))
+                                       panic("lfs_truncate: bread bno %d",
+                                           inp->in_lbn);
+                               daddrp = (daddr_t *)bp->b_data + inp->in_off;
+                               for (i = inp->in_off;
+                                   i++ <= a_end[depth].in_off;) {
+                                       daddr = *daddrp++;
+                                       SEGDEC;
+                               }
+                               a_end[depth].in_off = NINDIR(fs) - 1;
+                               if (inp->in_off == 0)
+                                       brelse (bp);
+                               else {
+                                       bzero((daddr_t *)bp->b_data +
+                                           inp->in_off, fs->lfs_bsize - 
+                                           inp->in_off * sizeof(daddr_t));
+                                       if (e1 = VOP_BWRITE(bp)) 
+                                               return (e1);
+                               }
+                       }
+                       if (depth == 0 && a[1].in_off == 0) {
+                               off = a[0].in_off;
+                               daddr = ip->i_ib[off];
+                               SEGDEC;
+                               ip->i_ib[off] = 0;
+                       }
+                       if (lbn == lastblock || lbn <= NDADDR)
+                               --lbn;
+                       else {
+                               lbn -= NINDIR(fs);
+                               if (lbn < lastblock)
+                                       lbn = lastblock;
+                       }
+               }
+       }
+       UPDATE_SEGUSE;
+
+       /* If truncating the file to 0, update the version number. */
+       if (length == 0) {
+               LFS_IENTRY(ifp, fs, ip->i_number, bp);
+               ++ifp->if_version;
+               (void) VOP_BWRITE(bp);
+       }
+
+#ifdef DIAGNOSTIC
+       if (ip->i_blocks < fsbtodb(fs, blocksreleased)) {
+               printf("lfs_truncate: block count < 0\n");
+               blocksreleased = ip->i_blocks;
+       }
+#endif
+       ip->i_blocks -= fsbtodb(fs, blocksreleased);
+       fs->lfs_bfree +=  fsbtodb(fs, blocksreleased);
+       ip->i_flag |= IN_CHANGE | IN_UPDATE;
+       /*
+        * Traverse dirty block list counting number of dirty buffers
+        * that are being deleted out of the cache, so that the lfs_avail
+        * field can be updated.
+        */
+       a_released = 0;
+       i_released = 0;
+       for (bp = vp->v_dirtyblkhd.lh_first; bp; bp = bp->b_vnbufs.le_next)
+               if (bp->b_flags & B_LOCKED) {
+                       ++a_released;
+                       /*
+                        * XXX
+                        * When buffers are created in the cache, their block
+                        * number is set equal to their logical block number.
+                        * If that is still true, we are assuming that the
+                        * blocks are new (not yet on disk) and weren't
+                        * counted above.  However, there is a slight chance
+                        * that a block's disk address is equal to its logical
+                        * block number in which case, we'll get an overcounting
+                        * here.
+                        */
+                       if (bp->b_blkno == bp->b_lblkno)
+                               ++i_released;
+               }
+       blocksreleased = fsbtodb(fs, i_released);
+#ifdef DIAGNOSTIC
+       if (blocksreleased > ip->i_blocks) {
+               printf("lfs_inode: Warning! %s\n",
+                   "more blocks released from inode than are in inode");
+               blocksreleased = ip->i_blocks;

        }
        }

-       /* BZERO INODE BLOCK POINTERS HERE, FOR CONSISTENCY XXX */
+#endif
+       fs->lfs_bfree += blocksreleased;
+       ip->i_blocks -= blocksreleased;
+#ifdef DIAGNOSTIC
+       if (length == 0 && ip->i_blocks != 0)
+               printf("lfs_inode: Warning! %s%d%s\n",
+                   "Truncation to zero, but ", ip->i_blocks,
+                   " blocks left on inode");
+#endif
+       fs->lfs_avail += fsbtodb(fs, a_released);
+       e1 = vinvalbuf(vp, (length > 0) ? V_SAVE : 0, ap->a_cred, ap->a_p,
+           0, 0); 
+       e2 = VOP_UPDATE(vp, &tv, &tv, 0);
+       return (e1 ? e1 : e2 ? e2 : 0);

 }
 }