cg_free is (u_char)
[unix-history] / usr / src / sys / ufs / ffs / ufs_inode.c
index b65a85c..34abf8a 100644 (file)
@@ -1,4 +1,4 @@
-/*     ufs_inode.c     4.15    82/07/01        */
+/*     ufs_inode.c     4.27    82/10/17        */
 
 #include "../h/param.h"
 #include "../h/systm.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"
@@ -9,7 +9,10 @@
 #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  63
 #if    ((INOHSZ&(INOHSZ-1)) == 0)
 
 #define        INOHSZ  63
 #if    ((INOHSZ&(INOHSZ-1)) == 0)
@@ -111,7 +114,7 @@ loop:
        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) {
        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&ILOCK) != 0) {
+                       if ((ip->i_flag&ILOCKED) != 0) {
                                ip->i_flag |= IWANT;
                                sleep((caddr_t)ip, PINOD);
                                goto loop;
                                ip->i_flag |= IWANT;
                                sleep((caddr_t)ip, PINOD);
                                goto loop;
@@ -136,7 +139,7 @@ loop:
                                ip->i_freeb = NULL;
                        }
                        ip->i_count++;
                                ip->i_freeb = NULL;
                        }
                        ip->i_count++;
-                       ip->i_flag |= ILOCK;
+                       ip->i_flag |= ILOCKED;
                        return(ip);
                }
 
                        return(ip);
                }
 
@@ -159,13 +162,16 @@ loop:
         */
        remque(ip);
        insque(ip, ih);
         */
        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_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
         */
        /*
         * Check I/O errors
         */
@@ -186,6 +192,9 @@ loop:
                 * (probably the two methods are interchangable)
                 */
                ip->i_number = 0;
                 * (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);
        }
@@ -193,6 +202,12 @@ 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);
 }
 
@@ -207,7 +222,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);
@@ -216,20 +231,24 @@ 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, 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
+                       chkiq(ip->i_dev, ip, ip->i_uid, 0);
+                       dqrele(ip->i_dquot);
+                       ip->i_dquot = NODQUOT;
+#endif
                }
                }
-               IUPDAT(ip, &time, &time, 0);
+               IUPDAT(ip, &time.tv_sec, &time.tv_sec, 0);
                iunlock(ip);
                ip->i_flag = 0;
                /*
                iunlock(ip);
                ip->i_flag = 0;
                /*
@@ -277,7 +296,7 @@ iupdat(ip, ta, tm, waitfor)
                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 (bp->b_flags & B_ERROR) {
                        brelse(bp);
                        return;
@@ -287,8 +306,10 @@ iupdat(ip, ta, tm, waitfor)
                if (ip->i_flag&IUPD)
                        ip->i_mtime = *tm;
                if (ip->i_flag&ICHG)
                if (ip->i_flag&IUPD)
                        ip->i_mtime = *tm;
                if (ip->i_flag&ICHG)
-                       ip->i_ctime = time;
+                       ip->i_ctime = time.tv_sec;
                ip->i_flag &= ~(IUPD|IACC|ICHG);
                ip->i_flag &= ~(IUPD|IACC|ICHG);
+               dp = bp->b_un.b_dino + itoo(fp, ip->i_number);
+               dp->di_ic = ip->i_ic;
                if (waitfor)
                        bwrite(bp);
                else
                if (waitfor)
                        bwrite(bp);
                else
@@ -297,49 +318,52 @@ iupdat(ip, ta, tm, waitfor)
 }
 
 /*
 }
 
 /*
- * 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.
  */
  */
-itrunc(ip)
+itrunc(ip, length)
        register struct inode *ip;
        register struct inode *ip;
+       register int length;
 {
        register i;
        dev_t dev;
        daddr_t bn;
        struct inode itmp;
        register struct fs *fs;
 {
        register i;
        dev_t dev;
        daddr_t bn;
        struct inode itmp;
        register struct fs *fs;
+#ifdef QUOTA
+       register long cnt = 0;
+       long tloop();
+#endif
+       /*
+        * Only plain files, directories and symbolic
+        * links contain blocks.
+        */
+       i = ip->i_mode & IFMT;
+       if (i != IFREG && i != IFDIR && i != IFLNK)
+               return;
+       if (ip->i_size <= length)
+               return;
 
        /*
         * Clean inode on disk before freeing blocks
         * to insure no duplicates if system crashes.
         */
        itmp = *ip;
 
        /*
         * Clean inode on disk before freeing blocks
         * to insure no duplicates if system crashes.
         */
        itmp = *ip;
-       itmp.i_size = 0;
+       itmp.i_size = length;
        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;
        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);
+       iupdat(&itmp, &time.tv_sec, &time.tv_sec, 1);
        ip->i_flag &= ~(IUPD|IACC|ICHG);
 
        ip->i_flag &= ~(IUPD|IACC|ICHG);
 
-       /*
-        * Only plain files, directories and symbolic
-        * links contain blocks.
-        */
-       i = ip->i_mode & IFMT;
-       if (i != IFREG && i != IFDIR && i != IFLNK)
-               return;
        /*
         * Now return blocks to free list... if machine
         * crashes, they will be harmless MISSING blocks.
         */
        /*
         * 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
        fs = ip->i_fs;
        /*
         * release double indirect block first
@@ -347,7 +371,10 @@ itrunc(ip)
        bn = ip->i_ib[NIADDR-1];
        if (bn != (daddr_t)0) {
                ip->i_ib[NIADDR - 1] = (daddr_t)0;
        bn = ip->i_ib[NIADDR-1];
        if (bn != (daddr_t)0) {
                ip->i_ib[NIADDR - 1] = (daddr_t)0;
-               tloop(ip, bn, 1);
+#ifdef QUOTA
+               cnt +=
+#endif
+                       tloop(ip, bn, 1);
        }
        /*
         * release single indirect blocks second
        }
        /*
         * release single indirect blocks second
@@ -356,26 +383,42 @@ itrunc(ip)
                bn = ip->i_ib[i];
                if (bn != (daddr_t)0) {
                        ip->i_ib[i] = (daddr_t)0;
                bn = ip->i_ib[i];
                if (bn != (daddr_t)0) {
                        ip->i_ib[i] = (daddr_t)0;
-                       tloop(ip, bn, 0);
+#ifdef QUOTA
+                       cnt +=
+#endif
+                               tloop(ip, bn, 0);
                }
        }
        /*
         * finally release direct blocks
         */
        for (i = NDADDR - 1; i>=0; i--) {
                }
        }
        /*
         * finally release direct blocks
         */
        for (i = NDADDR - 1; i>=0; i--) {
+               register size;
+
                bn = ip->i_db[i];
                if (bn == (daddr_t)0)
                        continue;
                ip->i_db[i] = (daddr_t)0;
                bn = ip->i_db[i];
                if (bn == (daddr_t)0)
                        continue;
                ip->i_db[i] = (daddr_t)0;
+#ifndef QUOTA
                fre(ip, bn, (off_t)blksize(fs, ip, i));
                fre(ip, bn, (off_t)blksize(fs, ip, i));
+#else
+               fre(ip, bn, size = (off_t)blksize(fs, ip, i));
+               cnt += size / DEV_BSIZE;
+#endif
        }
        ip->i_size = 0;
        /*
         * Inode was written and flags updated above.
         * No need to modify flags here.
         */
        }
        ip->i_size = 0;
        /*
         * Inode was written and flags updated above.
         * No need to modify flags here.
         */
+#ifdef QUOTA
+       (void) chkdq(ip, -cnt, 0);
+#endif
 }
 
 }
 
+#ifdef QUOTA
+long
+#endif
 tloop(ip, bn, indflg)
        register struct inode *ip;
        daddr_t bn;
 tloop(ip, bn, indflg)
        register struct inode *ip;
        daddr_t bn;
@@ -386,12 +429,16 @@ tloop(ip, bn, indflg)
        register daddr_t *bap;
        register struct fs *fs;
        daddr_t nb;
        register daddr_t *bap;
        register struct fs *fs;
        daddr_t nb;
+#ifdef QUOTA
+       register long cnt = 0;
+#endif
 
        bp = NULL;
        fs = ip->i_fs;
        for (i = NINDIR(fs) - 1; i >= 0; i--) {
                if (bp == NULL) {
 
        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);
+                       bp = bread(ip->i_dev, fsbtodb(fs, bn),
+                               (int)fs->fs_bsize);
                        if (bp->b_flags & B_ERROR) {
                                brelse(bp);
                                return;
                        if (bp->b_flags & B_ERROR) {
                                brelse(bp);
                                return;
@@ -401,146 +448,25 @@ tloop(ip, bn, indflg)
                nb = bap[i];
                if (nb == (daddr_t)0)
                        continue;
                nb = bap[i];
                if (nb == (daddr_t)0)
                        continue;
-               if (indflg)
-                       tloop(ip, nb, 0);
-               else
+               if (indflg) {
+#ifdef QUOTA
+                       cnt +=
+#endif
+                               tloop(ip, nb, 0);
+               } else {
                        fre(ip, nb, fs->fs_bsize);
                        fre(ip, nb, fs->fs_bsize);
+#ifdef QUOTA
+                       cnt += fs->fs_bsize / DEV_BSIZE;
+#endif
+               }
        }
        if (bp != NULL)
                brelse(bp);
        fre(ip, bn, fs->fs_bsize);
        }
        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;
-
-       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);
-       }
-       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;
-
-       /*
-        * Make sure inode goes to disk before directory entry.
-        */
-       iupdat(ip, &time, &time, 1);
-       wdir(ip);
-       if (u.u_error) {
-               /*
-                * write error occurred trying to update directory
-                * so must deallocate the inode
-                */
-               ip->i_nlink = 0;
-               ip->i_flag |= ICHG;
-               iput(ip);
-               return(NULL);
-       }
-       return(ip);
-}
-
-/*
- * Write a directory entry with
- * parameters left as side effects
- * to a call to namei.
- */
-wdir(ip)
-       struct inode *ip;
-{
-       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);
-       /*
-        * if u.u_count == 0, a new directory block must be allocated.
-        */
-       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;
-       }
-       /*
-        * must read in an existing directory block
-        * to prepare to place the new entry into it.
-        */
-       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) {
-               brelse(bp);
-               return;
-       }
-       dirbuf = bp->b_un.b_addr + base;
-       dp = (struct direct *)dirbuf;
-       dsize = DIRSIZ(dp);
-       spccnt = dp->d_reclen - dsize;
-       /*
-        * 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.
-        */
-       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);
-       }
-       /*
-        * Update the pointer fields in the previous entry (if any),
-        * copy in the new entry, and write out the 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);
-       }
-       bcopy(&u.u_dent, dp, newsize);
-       bwrite(bp);
-       u.u_pdir->i_flag |= IUPD|ICHG;
-       iput(u.u_pdir);
+#ifdef QUOTA
+       cnt += fs->fs_bsize / DEV_BSIZE;
+       return(cnt);
+#endif
 }
 
 /*
 }
 
 /*
@@ -556,14 +482,24 @@ wdir(ip)
  *
  * this is called from sumount()/sys3.c when dev is being unmounted
  */
  *
  * 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;
 iflush(dev)
        dev_t dev;
+#endif
 {
        register struct inode *ip;
        register open = 0;
 
        for (ip = inode; ip < inodeNINODE; ip++) {
 {
        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)
                if (ip->i_dev == dev)
+#endif
                        if (ip->i_count)
                                return(-1);
                        else {
                        if (ip->i_count)
                                return(-1);
                        else {
@@ -579,6 +515,10 @@ iflush(dev)
                                 * infrequently, we would gain very little,
                                 * while making the code bigger.
                                 */
                                 * 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)
                        }
                else if (ip->i_count && (ip->i_mode&IFMT)==IFBLK &&
                    ip->i_rdev == dev)
@@ -587,12 +527,6 @@ iflush(dev)
        return (open);
 }
 
        return (open);
 }
 
-#ifdef ilock
-#undef ilock
-#endif
-#ifdef iunlock
-#undef iunlock
-#endif
 /*
  * 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.
  */
@@ -600,11 +534,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);
 }
 
 /*
 }
 
 /*
@@ -614,9 +544,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);
 }
 }