-/* ffs_inode.c 4.8 82/02/15 */
+/* ffs_inode.c 4.23 82/08/10 */
#include "../h/param.h"
#include "../h/systm.h"
#include "../h/dir.h"
#include "../h/user.h"
#include "../h/inode.h"
-#include "../h/ino.h"
-#include "../h/filsys.h"
+#include "../h/fs.h"
#include "../h/conf.h"
#include "../h/buf.h"
#include "../h/inline.h"
+#ifdef QUOTA
+#include "../h/quota.h"
+#endif
#define INOHSZ 63
+#if ((INOHSZ&(INOHSZ-1)) == 0)
+#define INOHASH(dev,ino) (((dev)+(ino))&(INOHSZ-1))
+#else
#define INOHASH(dev,ino) (((dev)+(ino))%INOHSZ)
-short inohash[INOHSZ];
-short ifreel;
+#endif
+
+union ihead { /* inode LRU cache, Chris Maltby */
+ union ihead *ih_head[2];
+ struct inode *ih_chain[2];
+} ihead[INOHSZ];
+
+struct inode *ifreeh, **ifreet;
/*
* Initialize hash links for inodes
{
register int i;
register struct inode *ip = inode;
+ register union ihead *ih = ihead;
- 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;
+ 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,
ino_t ino;
{
register struct inode *ip;
+ register union ihead *ih;
- for (ip = &inode[inohash[INOHASH(dev,ino)]]; ip != &inode[-1];
- ip = &inode[ip->i_hlink])
+ 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.
* "cannot happen"
*/
struct inode *
-iget(dev, ino)
+iget(dev, fs, ino)
dev_t dev;
+ register struct fs *fs;
ino_t ino;
{
register struct inode *ip;
+ register union ihead *ih;
register struct mount *mp;
register struct buf *bp;
register struct dinode *dp;
- register int slot;
+ register struct inode *iq;
loop:
- slot = INOHASH(dev, ino);
- ip = &inode[inohash[slot]];
- while (ip != &inode[-1]) {
+ if (getfs(dev) != fs)
+ panic("iget: bad fs");
+ ih = &ihead[INOHASH(dev, ino)];
+ for (ip = ih->ih_chain[0]; ip != (struct inode *)ih; ip = ip->i_forw)
if (ino == ip->i_number && dev == ip->i_dev) {
if ((ip->i_flag&ILOCK) != 0) {
ip->i_flag |= IWANT;
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;
- }
+ for (mp = &mount[0]; mp < &mount[NMOUNT]; mp++)
+ if(mp->m_inodp == ip) {
+ dev = mp->m_dev;
+ fs = mp->m_bufp->b_un.b_fs;
+ ino = ROOTINO;
+ goto loop;
+ }
panic("no imt");
}
+ if (ip->i_count == 0) { /* ino on free list */
+ if (iq = ip->i_freef)
+ iq->i_freeb = ip->i_freeb;
+ else
+ ifreet = ip->i_freeb;
+ *ip->i_freeb = iq;
+ ip->i_freef = NULL;
+ ip->i_freeb = NULL;
+ }
ip->i_count++;
ip->i_flag |= ILOCK;
return(ip);
}
- ip = &inode[ip->i_hlink];
- }
- if (ifreel < 0) {
+
+ if ((ip = ifreeh) == 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_flag = ILOCK;
ip->i_count++;
- ip->i_un.i_lastr = 0;
- bp = bread(dev, itod(ino));
+ ip->i_lastr = 0;
+ bp = bread(dev, fsbtodb(fs, itod(fs, ino)), fs->fs_bsize);
/*
* 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);
}
dp = bp->b_un.b_dino;
- dp += itoo(ino);
- iexpand(ip, dp);
+ dp += itoo(fs, ino);
+ ip->i_ic = dp->di_ic;
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;
- }
+#ifdef QUOTA
+ if (ip->i_mode == 0)
+ ip->i_dquot = NODQUOT;
+ else
+ ip->i_dquot = inoquota(ip);
+#endif
+ return (ip);
}
/*
iput(ip)
register struct inode *ip;
{
+
+ if ((ip->i_flag & ILOCK) == 0)
+ panic("iput");
+ iunlock(ip);
+ irele(ip);
+}
+
+irele(ip)
+ register struct inode *ip;
+{
register int i, x;
register struct inode *jp;
+ int mode;
if (ip->i_count == 1) {
ip->i_flag |= ILOCK;
if (ip->i_nlink <= 0) {
- itrunc(ip);
+ itrunc(ip, 0);
+ mode = ip->i_mode;
ip->i_mode = 0;
+ ip->i_rdev = 0;
ip->i_flag |= IUPD|ICHG;
- ifree(ip->i_dev, ip->i_number);
+ 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);
- irele(ip);
- i = INOHASH(ip->i_dev, ip->i_number);
- x = ip - inode;
- if (inohash[i] == x) {
- inohash[i] = ip->i_hlink;
+ iunlock(ip);
+ ip->i_flag = 0;
+ /*
+ * Put the inode on the end of the free list.
+ * Possibly in some cases it would be better to
+ * put the inode at the head of the free list,
+ * (eg: where i_mode == 0 || i_number == 0)
+ * but I will think about that later .. kre
+ * (i_number is rarely 0 - only after an i/o error in iget,
+ * where i_mode == 0, the inode will probably be wanted
+ * again soon for an ialloc, so possibly we should keep it)
+ */
+ if (ifreeh) {
+ *ifreet = ip;
+ ip->i_freeb = ifreet;
} else {
- 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;
- } else
- irele(ip);
+ ip->i_freef = NULL;
+ ifreet = &ip->i_freef;
+ }
ip->i_count--;
}
{
register struct buf *bp;
struct dinode *dp;
- register char *p1, *p2;
- register int i;
+ register struct fs *fp;
- if ((ip->i_flag&(IUPD|IACC|ICHG)) != 0) {
- if (getfs(ip->i_dev)->s_ronly)
+ fp = ip->i_fs;
+ if ((ip->i_flag & (IUPD|IACC|ICHG)) != 0) {
+ if (fp->fs_ronly)
return;
- bp = bread(ip->i_dev, itod(ip->i_number));
+ bp = bread(ip->i_dev, fsbtodb(fp, itod(fp, ip->i_number)),
+ fp->fs_bsize);
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;
+ ip->i_atime = *ta;
if (ip->i_flag&IUPD)
- dp->di_mtime = *tm;
+ ip->i_mtime = *tm;
if (ip->i_flag&ICHG)
- dp->di_ctime = time;
+ ip->i_ctime = time;
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
}
/*
- * 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 int length;
{
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)
+ if (i != IFREG && i != IFDIR && i != IFLNK)
+ return;
+ if (ip->i_size <= length)
return;
/*
* to insure no duplicates if system crashes.
*/
itmp = *ip;
- itmp.i_size = 0;
- for (i = 0; i < NADDR; i++)
- itmp.i_un.i_addr[i] = 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;
iupdat(&itmp, &time, &time, 1);
ip->i_flag &= ~(IUPD|IACC|ICHG);
* crashes, they will be harmless MISSING blocks.
*/
dev = ip->i_dev;
- for(i=NADDR-1; i>=0; i--) {
- bn = ip->i_un.i_addr[i];
+ 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;
+#ifdef QUOTA
+ cnt +=
+#endif
+ tloop(ip, bn, 1);
+ }
+ /*
+ * release single indirect blocks second
+ */
+ for (i = NIADDR - 2; i >= 0; i--) {
+ bn = ip->i_ib[i];
+ if (bn != (daddr_t)0) {
+ ip->i_ib[i] = (daddr_t)0;
+#ifdef QUOTA
+ cnt +=
+#endif
+ tloop(ip, bn, 0);
+ }
+ }
+ /*
+ * 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_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);
- }
+ ip->i_db[i] = (daddr_t)0;
+ fre(ip, bn, size = (off_t)blksize(fs, ip, i));
+#ifdef QUOTA
+ cnt += size / DEV_BSIZE;
+#endif
}
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
}
-tloop(dev, bn, f1, f2)
-dev_t dev;
-daddr_t bn;
+#ifdef QUOTA
+long
+#endif
+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;
+#ifdef QUOTA
+ register long cnt = 0;
+#endif
bp = NULL;
- for(i=NINDIR-1; i>=0; i--) {
+ fs = ip->i_fs;
+ for (i = NINDIR(fs) - 1; i >= 0; i--) {
if (bp == NULL) {
- bp = bread(dev, bn);
+ bp = bread(ip->i_dev, fsbtodb(fs, bn), fs->fs_bsize);
if (bp->b_flags & B_ERROR) {
brelse(bp);
return;
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 (indflg) {
+#ifdef QUOTA
+ cnt +=
+#endif
+ tloop(ip, nb, 0);
+ } else {
+ fre(ip, nb, fs->fs_bsize);
+#ifdef QUOTA
+ cnt += fs->fs_bsize / DEV_BSIZE;
+#endif
+ }
}
if (bp != NULL)
brelse(bp);
- free(dev, bn);
+ fre(ip, bn, fs->fs_bsize);
+#ifdef QUOTA
+ cnt += fs->fs_bsize / DEV_BSIZE;
+ return(cnt);
+#endif
}
/*
- * Make a new file.
+ * 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
*/
-struct inode *
-maknode(mode)
+#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;
- ip = ialloc(u.u_pdir->i_dev);
- if (ip == NULL) {
- iput(u.u_pdir);
- return(NULL);
+ for (ip = inode; ip < inodeNINODE; ip++) {
+#ifdef QUOTA
+ if (ip != iq && ip->i_dev == dev)
+#else
+ if (ip->i_dev == dev)
+#endif
+ if (ip->i_count)
+ return(-1);
+ else {
+ remque(ip);
+ ip->i_forw = ip;
+ ip->i_back = ip;
+ /*
+ * as i_count == 0, the inode was on the free
+ * list already, just leave it there, it will
+ * fall off the bottom eventually. We could
+ * perhaps move it to the head of the free
+ * list, but as umounts are done so
+ * infrequently, we would gain very little,
+ * while making the code bigger.
+ */
+#ifdef QUOTA
+ dqrele(ip->i_dquot);
+ ip->i_dquot = NODQUOT;
+#endif
+ }
+ else if (ip->i_count && (ip->i_mode&IFMT)==IFBLK &&
+ ip->i_rdev == dev)
+ open++;
}
- 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);
- 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);
+ return (open);
}
#ifdef ilock
#undef ilock
#endif
-#ifdef irele
-#undef irele
+#ifdef iunlock
+#undef iunlock
#endif
/*
* Lock an inode. If its already locked, set the WANT bit and sleep.
/*
* Unlock an inode. If WANT bit is on, wakeup.
*/
-irele(ip)
+iunlock(ip)
register struct inode *ip;
{