-/* lfs_inode.c 4.31 82/11/13 */
-
-#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/fs.h"
-#include "../h/conf.h"
-#include "../h/buf.h"
+/*
+ * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley. The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * @(#)lfs_inode.c 7.7 (Berkeley) %G%
+ */
+
+#include "param.h"
+#include "systm.h"
+#include "mount.h"
+#include "user.h"
+#include "file.h"
+#include "buf.h"
+#include "cmap.h"
+#include "vnode.h"
+#include "../ufs/inode.h"
+#include "../ufs/fs.h"
+#include "../ufs/ufsmount.h"
#ifdef QUOTA
-#include "../h/quota.h"
+#include "../ufs/quota.h"
#endif
-#include "../h/kernel.h"
+#include "kernel.h"
+#include "malloc.h"
-#define INOHSZ 63
+#define INOHSZ 512
#if ((INOHSZ&(INOHSZ-1)) == 0)
#define INOHASH(dev,ino) (((dev)+(ino))&(INOHSZ-1))
#else
-#define INOHASH(dev,ino) (((dev)+(ino))%INOHSZ)
+#define INOHASH(dev,ino) (((unsigned)((dev)+(ino)))%INOHSZ)
#endif
+#define INSFREE(ip) {\
+ if (ifreeh) { \
+ *ifreet = (ip); \
+ (ip)->i_freeb = ifreet; \
+ } else { \
+ ifreeh = (ip); \
+ (ip)->i_freeb = &ifreeh; \
+ } \
+ (ip)->i_freef = NULL; \
+ ifreet = &(ip)->i_freef; \
+}
+
union ihead { /* inode LRU cache, Chris Maltby */
union ihead *ih_head[2];
struct inode *ih_chain[2];
} ihead[INOHSZ];
-struct inode *ifreeh, **ifreet;
+struct inode *ifreeh, **ifreet, *bdevlisth;
/*
* Initialize hash links for inodes
ip->i_freeb = &ifreeh;
ip->i_forw = ip;
ip->i_back = ip;
+ ITOV(ip)->v_data = (qaddr_t)ip;
for (i = ninode; --i > 0; ) {
++ip;
ip->i_forw = ip;
ip->i_back = ip;
+ ITOV(ip)->v_data = (qaddr_t)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;
-
- 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 vnode/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.
+ * Callers must check for mount points!!
* 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"
*/
-struct inode *
-iget(dev, fs, ino)
- dev_t dev;
- register struct fs *fs;
+iget(xp, ino, ipp)
+ struct inode *xp;
ino_t ino;
+ struct inode **ipp;
{
- register struct inode *ip;
- register union ihead *ih;
- register struct mount *mp;
- register struct buf *bp;
- register struct dinode *dp;
- register struct inode *iq;
+ dev_t dev = xp->i_dev;
+ struct mount *mntp = ITOV(xp)->v_mount;
+ register struct fs *fs = VFSTOUFS(mntp)->um_fs;
+ register struct inode *ip, *iq;
+ register struct vnode *vp;
+ struct inode *nip;
+ struct buf *bp;
+ struct dinode tdip, *dp;
+ union ihead *ih;
+ int error;
loop:
- 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) {
+ /*
+ * 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++)
- 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 */
+ vp = ITOV(ip);
+ if (vp->v_count == 0) { /* ino on free list */
if (iq = ip->i_freef)
iq->i_freeb = ip->i_freeb;
else
ip->i_freef = NULL;
ip->i_freeb = NULL;
}
- ip->i_count++;
- ip->i_flag |= ILOCKED;
- return(ip);
+ ILOCK(ip);
+ vp->v_count++;
+ *ipp = ip;
+ return(0);
}
+ if (error = getnewino(dev, ino, &nip)) {
+ *ipp = 0;
+ return (error);
+ }
+ ip = nip;
+ /*
+ * Read in the disk contents for the inode.
+ */
+ if (error = bread(VFSTOUFS(mntp)->um_devvp, fsbtodb(fs, itod(fs, ino)),
+ (int)fs->fs_bsize, &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. We also
+ * lose its inumber, just in case.
+ */
+ remque(ip);
+ ip->i_forw = ip;
+ ip->i_back = ip;
+ ip->i_number = 0;
+ INSFREE(ip);
+ iunlock(ip);
+ ip->i_flag = 0;
+ brelse(bp);
+ *ipp = 0;
+ return(error);
+ }
+ /*
+ * Check to see if the new inode represents a block device
+ * for which we already have an inode (either because of
+ * bdevvp() or because of a different inode representing
+ * the same block device). If such an alias exists, put the
+ * just allocated inode back on the free list, and replace
+ * the contents of the existing inode with the contents of
+ * the new inode.
+ */
+ dp = bp->b_un.b_dino;
+ dp += itoo(fs, ino);
+ if ((dp->di_mode & IFMT) != IFBLK) {
+ ip->i_ic = dp->di_ic;
+ brelse(bp);
+ } else {
+again:
+ for (iq = bdevlisth; iq; iq = iq->i_devlst) {
+ if (dp->di_rdev != ITOV(iq)->v_rdev)
+ continue;
+ igrab(iq);
+ if (dp->di_rdev != ITOV(iq)->v_rdev) {
+ iput(iq);
+ goto again;
+ }
+ /*
+ * Discard unneeded inode.
+ */
+ remque(ip);
+ ip->i_forw = ip;
+ ip->i_back = ip;
+ ip->i_number = 0;
+ INSFREE(ip);
+ iunlock(ip);
+ ip->i_flag = 0;
+ /*
+ * Reinitialize aliased inode.
+ * We must release the buffer that we just read
+ * before doing the iupdat() to avoid a possible
+ * deadlock with updating an inode in the same
+ * disk block.
+ */
+ ip = iq;
+ vp = ITOV(iq);
+ tdip.di_ic = dp->di_ic;
+ brelse(bp);
+ error = iupdat(ip, &time, &time, 1);
+ ip->i_ic = tdip.di_ic;
+ remque(ip);
+ insque(ip, ih);
+ ip->i_dev = dev;
+ ip->i_number = ino;
+ if (ip->i_devvp) {
+ vrele(ip->i_devvp);
+ ip->i_devvp = 0;
+ }
+ cache_purge(vp);
+ break;
+ }
+ if (iq == 0) {
+ ip->i_ic = dp->di_ic;
+ brelse(bp);
+ ip->i_devlst = bdevlisth;
+ bdevlisth = ip;
+ }
+ }
+ /*
+ * Finish inode initialization.
+ */
+ ip->i_fs = fs;
+ ip->i_devvp = VFSTOUFS(mntp)->um_devvp;
+ ip->i_devvp->v_count++;
+ /*
+ * Initialize the associated vnode
+ */
+ vp = ITOV(ip);
+ vinit(vp, mntp, IFTOVT(ip->i_mode), &ufs_vnodeops);
+ if (vp->v_type == VCHR || vp->v_type == VBLK) {
+ vp->v_rdev = ip->i_rdev;
+ vp->v_op = &blk_vnodeops;
+ }
+ if (ino == ROOTINO)
+ vp->v_flag |= VROOT;
+#ifdef QUOTA
+ if (ip->i_mode != 0)
+ ip->i_dquot = inoquota(ip);
+#endif
+ *ipp = ip;
+ return (0);
+}
+/*
+ * Allocate a new inode.
+ *
+ * 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.
+ */
+getnewino(dev, ino, ipp)
+ dev_t dev;
+ ino_t ino;
+ struct inode **ipp;
+{
+ union ihead *ih;
+ register struct inode *ip, *iq;
+ register struct vnode *vp;
+
+ /*
+ * Remove the next inode from the free list.
+ */
if ((ip = ifreeh) == NULL) {
tablefull("inode");
- u.u_error = ENFILE;
- return(NULL);
+ *ipp = 0;
+ return(ENFILE);
}
+ vp = ITOV(ip);
+ if (vp->v_count)
+ panic("free inode isn't");
if (iq = ip->i_freef)
iq->i_freeb = &ifreeh;
ifreeh = iq;
/*
* 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
+ * consisting entirely of itself, and pointed to by no-one)
+ * 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 = ILOCKED;
- ip->i_count++;
+ if (dev != NODEV) {
+ ih = &ihead[INOHASH(dev, ino)];
+ insque(ip, ih);
+ }
+ ip->i_flag = 0;
+ ILOCK(ip);
ip->i_lastr = 0;
- bp = bread(dev, fsbtodb(fs, itod(fs, ino)), (int)fs->fs_bsize);
+#endif SECSIZE
/*
- * Check I/O errors
+ * Purge old data structures associated with the inode.
*/
- 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);
+ cache_purge(vp);
+ if (ip->i_devvp) {
+ vrele(ip->i_devvp);
+ ip->i_devvp = 0;
}
- dp = bp->b_un.b_dino;
- 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);
+ dqrele(ip->i_dquot);
+ ip->i_dquot = NODQUOT;
#endif
- return (ip);
+ if (vp->v_type == VBLK) {
+ if (bdevlisth == ip) {
+ bdevlisth = ip->i_devlst;
+ } else {
+ for (iq = bdevlisth; iq; iq = iq->i_devlst) {
+ if (iq->i_devlst != ip)
+ continue;
+ iq->i_devlst = ip->i_devlst;
+ break;
+ }
+ if (iq == NULL)
+ panic("missing bdev");
+ }
+ }
+ *ipp = ip;
+ return (0);
+}
+
+/*
+ * 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;
+{
+ register struct vnode *vp = ITOV(ip);
+
+ while ((ip->i_flag&ILOCKED) != 0) {
+ ip->i_flag |= IWANT;
+ sleep((caddr_t)ip, PINOD);
+ }
+ if (vp->v_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;
+ }
+ vp->v_count++;
+ ILOCK(ip);
+}
+
+/*
+ * Create a vnode for a block device.
+ * Used for root filesystem, argdev, and swap areas.
+ */
+bdevvp(dev, vpp)
+ dev_t dev;
+ struct vnode **vpp;
+{
+ register struct inode *ip;
+ register struct vnode *vp;
+ struct inode *nip;
+ int error;
+
+ /*
+ * Check for the existence of an existing vnode.
+ */
+again:
+ for (ip = bdevlisth; ip; ip = ip->i_devlst) {
+ vp = ITOV(ip);
+ if (dev != vp->v_rdev)
+ continue;
+ igrab(ip);
+ if (dev != vp->v_rdev) {
+ iput(ip);
+ goto again;
+ }
+ IUNLOCK(ip);
+ *vpp = vp;
+ return (0);
+ }
+ if (error = getnewino(NODEV, (ino_t)0, &nip)) {
+ *vpp = 0;
+ return (error);
+ }
+ ip = nip;
+ ip->i_fs = 0;
+ ip->i_devlst = bdevlisth;
+ bdevlisth = ip;
+ vp = ITOV(ip);
+ vinit(vp, 0, VBLK, &blk_vnodeops);
+ vp->v_rdev = dev;
+ IUNLOCK(ip);
+ *vpp = vp;
+ return (0);
}
/*
if ((ip->i_flag & ILOCKED) == 0)
panic("iput");
- iunlock(ip);
- irele(ip);
+ IUNLOCK(ip);
+ vrele(ITOV(ip));
}
-irele(ip)
- register struct inode *ip;
+
+ufs_inactive(vp)
+ struct vnode *vp;
{
- int mode;
-
- if (ip->i_count == 1) {
- ip->i_flag |= ILOCKED;
- if (ip->i_nlink <= 0) {
- itrunc(ip, (u_long)0);
- mode = ip->i_mode;
- ip->i_mode = 0;
- ip->i_rdev = 0;
- ip->i_flag |= IUPD|ICHG;
- ifree(ip, ip->i_number, mode);
+ register struct inode *ip = VTOI(vp);
+ int mode, error;
+
+ if (ITOV(ip)->v_count != 0)
+ panic("ufs_inactive: not inactive");
+ ILOCK(ip);
+ if (ip->i_nlink <= 0 && (ITOV(ip)->v_mount->m_flag&M_RDONLY) == 0) {
+ error = itrunc(ip, (u_long)0);
+ mode = ip->i_mode;
+ ip->i_mode = 0;
+ ip->i_rdev = 0;
+ 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;
+ (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);
- 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 {
- ifreeh = ip;
- ip->i_freeb = &ifreeh;
- }
- ip->i_freef = NULL;
- ifreet = &ip->i_freef;
}
- ip->i_count--;
+ IUPDAT(ip, &time, &time, 0);
+ 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).
+ */
+ INSFREE(ip);
+ return (error);
}
/*
struct timeval *ta, *tm;
int waitfor;
{
- register struct buf *bp;
+ struct buf *bp;
+ struct vnode *vp = ITOV(ip);
struct dinode *dp;
- register struct fs *fp;
-
- fp = ip->i_fs;
- if ((ip->i_flag & (IUPD|IACC|ICHG)) != 0) {
- if (fp->fs_ronly)
- return;
- bp = bread(ip->i_dev, fsbtodb(fp, itod(fp, ip->i_number)),
- (int)fp->fs_bsize);
- if (bp->b_flags & B_ERROR) {
- brelse(bp);
- return;
- }
- if (ip->i_flag&IACC)
- ip->i_atime = ta->tv_sec;
- if (ip->i_flag&IUPD)
- ip->i_mtime = tm->tv_sec;
- if (ip->i_flag&ICHG)
- ip->i_ctime = time.tv_sec;
- 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
- bdwrite(bp);
+ register struct fs *fs;
+
+ fs = ip->i_fs;
+ if ((ip->i_flag & (IUPD|IACC|ICHG|IMOD)) == 0)
+ return (0);
+ if (vp->v_mount->m_flag & M_RDONLY)
+ return (0);
+ error = bread(ip->i_devvp, fsbtodb(fs, itod(fs, ip->i_number)),
+ (int)fs->fs_bsize, &bp);
+ if (error) {
+ brelse(bp);
+ return (error);
+ }
+ if (ip->i_flag&IACC)
+ ip->i_atime = ta->tv_sec;
+ if (ip->i_flag&IUPD)
+ ip->i_mtime = tm->tv_sec;
+ if (ip->i_flag&ICHG)
+ ip->i_ctime = time.tv_sec;
+ ip->i_flag &= ~(IUPD|IACC|ICHG|IMOD);
+ dp = bp->b_un.b_dino + itoo(fs, ip->i_number);
+ dp->di_ic = ip->i_ic;
+ 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 */
/*
* 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, length)
- register struct inode *ip;
+itrunc(oip, length)
+ register struct inode *oip;
u_long length;
{
- register i;
register daddr_t lastblock;
- daddr_t bn, lastdiblock, lastsiblock;
+ daddr_t bn, lbn, lastiblock[NIADDR];
register struct fs *fs;
- int j;
-#ifdef QUOTA
- long blocksreleased = 0, nblocks;
- long indirtrunc();
-#endif
+ register struct inode *ip;
+ struct buf *bp;
+ int offset, osize, size, level;
+ long count, nblocks, blocksreleased = 0;
+ register int i;
+ int error, allerror = 0;
+ struct inode tip;
- if (ip->i_size <= length)
- return;
-#ifdef notdef
- /* this is superfluous given size check above */
- i = ip->i_mode & IFMT;
- if (i != IFREG && i != IFDIR && i != IFLNK) {
- printf("itrunc: i# %d, size %d\n", ip->i_number, ip->i_size);
- return;
+ if (oip->i_size <= length) {
+ oip->i_flag |= ICHG|IUPD;
+ error = iupdat(oip, &time, &time, 1);
+ return (error);
}
-#endif
- /*
- * Update size of file on disk before
- * we start freeing blocks. If we crash
- * while free'ing blocks below, the file
- * size will be believed and the blocks
- * returned to the free list.
- * After updating the copy on disk we
- * put the old size back so macros like
- * blksize will work.
- */
- j = ip->i_size;
- ip->i_size = length;
- ip->i_flag |= ICHG|IUPD;
- iupdat(ip, &time, &time, 1);
- ip->i_size = j;
-
/*
- * Calculate last direct, single indirect and
- * double indirect block (if any) which we want
- * to keep. Lastblock is -1 when the file is
- * truncated to 0.
+ * 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.
*/
- fs = ip->i_fs;
+ fs = oip->i_fs;
lastblock = lblkno(fs, length + fs->fs_bsize - 1) - 1;
- lastsiblock = lastblock - NDADDR;
- lastdiblock = lastsiblock - NINDIR(fs);
-#ifdef QUOTA
- nblocks = fs->fs_bsize / DEV_BSIZE;
-#endif
+ lastiblock[SINGLE] = lastblock - NDADDR;
+ lastiblock[DOUBLE] = lastiblock[SINGLE] - NINDIR(fs);
+ lastiblock[TRIPLE] = lastiblock[DOUBLE] - NINDIR(fs) * NINDIR(fs);
+ nblocks = btodb(fs->fs_bsize);
/*
- * Double indirect block first
+ * 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.
*/
- bn = ip->i_ib[NIADDR - 1];
- if (bn != 0) {
- /*
- * If lastdiblock is negative, it's value
- * is meaningless; in this case we set it to
- * -NINDIR(fs) so calculations performed in
- * indirtrunc come out right.
- */
- if (lastdiblock < 0)
- lastdiblock -= lastsiblock;
-#ifdef QUOTA
- blocksreleased +=
-#endif
- indirtrunc(ip, bn, lastdiblock, 1);
- if (lastdiblock < 0) {
- ip->i_ib[NIADDR - 1] = 0;
- free(ip, bn, (off_t)fs->fs_bsize);
-#ifdef QUOTA
- blocksreleased += nblocks;
-#endif
+ osize = oip->i_size;
+ offset = blkoff(fs, length);
+ if (offset == 0) {
+ oip->i_size = length;
+ } else {
+ lbn = lblkno(fs, length);
+ error = balloc(oip, lbn, offset, &bn, B_CLRBUF);
+ if (error)
+ return (error);
+ if ((long)bn < 0)
+ panic("itrunc: hole");
+ oip->i_size = length;
+ size = blksize(fs, oip, lbn);
+ count = howmany(size, CLBYTES);
+ munhash(oip->i_devvp, bn + i * CLBYTES / DEV_BSIZE);
+ error = bread(oip->i_devvp, bn, size, &bp);
+ if (error) {
+ oip->i_size = osize;
+ brelse(bp);
+ return (error);
}
+ bzero(bp->b_un.b_addr + offset, (unsigned)(size - offset));
+ bdwrite(bp);
}
- if (lastdiblock >= 0)
- goto done;
/*
- * Single indirect blocks second.
- * First, those which can be totally
- * zapped, then possibly one which
- * needs to be partially cleared.
+ * 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 indirtrunc below.
+ */
+ 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;
+ allerror = syncip(oip);
+
+ /*
+ * Indirect blocks first.
*/
- j = lastsiblock < 0 ? -1 : lastsiblock / NINDIR(fs);
- for (i = NIADDR - 2; i > j; i--) {
- bn = ip->i_ib[i];
+ ip = &tip;
+ for (level = TRIPLE; level >= SINGLE; level--) {
+ bn = ip->i_ib[level];
if (bn != 0) {
-#ifdef QUOTA
- blocksreleased += nblocks +
-#endif
- indirtrunc(ip, bn, (daddr_t)-1, 0);
- ip->i_ib[i] = 0;
- free(ip, bn, (off_t)fs->fs_bsize);
+ error = indirtrunc(ip, bn, lastiblock[level], level,
+ &count);
+ if (error)
+ allerror = error;
+ blocksreleased += count;
+ if (lastiblock[level] < 0) {
+ ip->i_ib[level] = 0;
+ blkfree(ip, bn, (off_t)fs->fs_bsize);
+ blocksreleased += nblocks;
+ }
}
+ if (lastiblock[level] >= 0)
+ goto done;
}
- if (lastsiblock >= 0) {
- bn = ip->i_ib[j];
- if (bn != 0)
-#ifdef QUOTA
- blocksreleased +=
-#endif
- indirtrunc(ip, bn, lastsiblock, 0);
- goto done;
- }
+
/*
- * All whole direct blocks.
+ * All whole direct blocks or frags.
*/
for (i = NDADDR - 1; i > lastblock; i--) {
- register int size;
+ register off_t bsize;
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);
-#ifdef QUOTA
- blocksreleased += size / DEV_BSIZE;
-#endif
+ bsize = (off_t)blksize(fs, ip, i);
+ blkfree(ip, bn, bsize);
+ blocksreleased += btodb(bsize);
}
+ if (lastblock < 0)
+ goto done;
+
/*
* Finally, look for a change in size of the
* last direct block; release any frags.
*/
- if (lastblock >= 0 && ip->i_db[lastblock] != 0) {
+ 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.
*/
- i = blksize(fs, ip, lastblock);
+ oldspace = blksize(fs, ip, lastblock);
ip->i_size = length;
- i = i - blksize(fs, ip, lastblock);
- if (i > 0) {
+ 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 = ip->i_db[lastblock] +
- numfrags(fs, fs->fs_bsize - i);
- free(ip, bn, i);
-#ifdef QUOTA
- blocksreleased += i / DEV_BSIZE;
-#endif
+ bn += numfrags(fs, newspace);
+ blkfree(ip, bn, oldspace - newspace);
+ blocksreleased += btodb(oldspace - newspace);
}
}
done:
- /*
- * Finished free'ing blocks, complete
- * inode update to reflect new length.
- */
+/* 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(ip, -blocksreleased, 0);
+ (void) chkdq(oip, -blocksreleased, 0);
#endif
- ip->i_size = length;
- ip->i_flag |= ICHG|IUPD;
- iupdat(ip, &time, &time, 1);
+ return (allerror);
}
/*
* 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
- * doubleindirect is indicated, this block is a double
- * indirect block and recursive calls to indirtrunc must
- * be used to cleanse single indirect blocks instead of
- * a simple free.
+ * 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.
*/
-#ifdef QUOTA
-long
-#endif
-indirtrunc(ip, bn, lastbn, doubleindirect)
+indirtrunc(ip, bn, lastbn, level, countp)
register struct inode *ip;
daddr_t bn, lastbn;
- int doubleindirect;
+ int level;
+ long *countp;
{
register int i;
struct buf *bp;
+ register struct fs *fs = ip->i_fs;
register daddr_t *bap;
- register struct fs *fs;
- daddr_t nb, last;
-#ifdef QUOTA
- int blocksreleased = 0, nblocks;
-#endif
+ daddr_t *copy, nb, last;
+ long blkcount, factor;
+ int nblocks, blocksreleased = 0;
+ int error, allerror = 0;
- bp = NULL;
- fs = ip->i_fs;
+ /*
+ * 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 (doubleindirect)
- last /= NINDIR(fs);
-#ifdef QUOTA
- nblocks = fs->fs_bsize / DEV_BSIZE;
-#endif
+ 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, &bp);
+ if (error) {
+ brelse(bp);
+ *countp = 0;
+ return (error);
+ }
+ 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));
+ error = bwrite(bp);
+ if (error)
+ allerror = error;
+ bap = copy;
+
+ /*
+ * Recursively free totally unused blocks.
+ */
for (i = NINDIR(fs) - 1; i > last; i--) {
- if (bp == NULL) {
- struct buf *copy;
-
- 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);
- return (NULL);
- }
- bap = bp->b_un.b_daddr;
- /*
- * Update pointers before freeing blocks.
- * If we crash before freeing the blocks
- * they'll be recovered as missing.
- */
- 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;
- }
nb = bap[i];
if (nb == 0)
continue;
- if (doubleindirect)
-#ifdef QUOTA
- blocksreleased +=
-#endif
- indirtrunc(ip, nb, (daddr_t)-1, 0);
- free(ip, nb, (int)fs->fs_bsize);
-#ifdef QUOTA
+ if (level > SINGLE) {
+ error = indirtrunc(ip, nb, (daddr_t)-1, level - 1,
+ &blkcount);
+ if (error)
+ allerror = error;
+ blocksreleased += blkcount;
+ }
+ blkfree(ip, nb, (off_t)fs->fs_bsize);
blocksreleased += nblocks;
-#endif
}
- if (doubleindirect && lastbn >= 0) {
- last = lastbn % NINDIR(fs);
- if (bp == NULL)
- panic("indirtrunc");
+
+ /*
+ * Recursively free last partial block.
+ */
+ if (level > SINGLE && lastbn >= 0) {
+ last = lastbn % factor;
nb = bap[i];
- if (nb != 0)
-#ifdef QUOTA
- blocksreleased +=
-#endif
- indirtrunc(ip, nb, last, 0);
+ if (nb != 0) {
+ error = indirtrunc(ip, nb, last, level - 1, &blkcount);
+ if (error)
+ allerror = error;
+ blocksreleased += blkcount;
+ }
}
- if (bp != NULL)
- brelse(bp);
-#ifdef QUOTA
- return (blocksreleased);
-#endif
+ FREE(copy, M_TEMP);
+ *countp = blocksreleased;
+ return (allerror);
}
/*
- * remove any inodes in the inode cache belonging to dev
+ * 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
+ * (nb: this is a user error, not a system err).
*/
#ifdef QUOTA
iflush(dev, iq)
#endif
{
register struct inode *ip;
- register open = 0;
for (ip = inode; ip < inodeNINODE; ip++) {
#ifdef QUOTA
#else
if (ip->i_dev == dev)
#endif
- if (ip->i_count)
- return(-1);
+ if (ITOV(ip)->v_count)
+ return (EBUSY);
else {
remque(ip);
ip->i_forw = ip;
ip->i_back = ip;
/*
- * as i_count == 0, the inode was on the free
+ * as v_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
dqrele(ip->i_dquot);
ip->i_dquot = NODQUOT;
#endif
+ if (ip->i_devvp) {
+ vrele(ip->i_devvp);
+ ip->i_devvp = 0;
+ }
}
- else if (ip->i_count && (ip->i_mode&IFMT)==IFBLK &&
- ip->i_rdev == dev)
- open++;
}
- return (open);
+ return (0);
}
/*
register struct inode *ip;
{
- ILOCK(ip);
+ while (ip->i_flag & ILOCKED) {
+ ip->i_flag |= IWANT;
+ (void) sleep((caddr_t)ip, PINOD);
+ }
+ ip->i_flag |= ILOCKED;
}
/*
register struct inode *ip;
{
- IUNLOCK(ip);
+ if ((ip->i_flag & ILOCKED) == 0)
+ printf("unlocking unlocked inode %d on dev 0x%x\n",
+ ip->i_number, ip->i_dev);
+ ip->i_flag &= ~ILOCKED;
+ if (ip->i_flag&IWANT) {
+ ip->i_flag &= ~IWANT;
+ wakeup((caddr_t)ip);
+ }
+}
+
+/*
+ * Check mode permission on inode pointer. Mode is READ, WRITE or EXEC.
+ * The mode is shifted to select the owner/group/other fields. The
+ * super user is granted all permissions.
+ *
+ * NB: Called from vnode op table. It seems this could all be done
+ * using vattr's but...
+ */
+iaccess(ip, mode, cred)
+ register struct inode *ip;
+ register int mode;
+ struct ucred *cred;
+{
+ register gid_t *gp;
+ register struct vnode *vp = ITOV(ip);
+ int i;
+
+ /*
+ * If you're the super-user,
+ * you always get access.
+ */
+ if (cred->cr_uid == 0)
+ return (0);
+ /*
+ * Access check is based on only one of owner, group, public.
+ * If not owner, then check group. If not a member of the
+ * group, then check public access.
+ */
+ if (cred->cr_uid != ip->i_uid) {
+ mode >>= 3;
+ gp = cred->cr_groups;
+ for (i = 0; i < cred->cr_ngroups; i++, gp++)
+ if (ip->i_gid == *gp)
+ goto found;
+ mode >>= 3;
+found:
+ ;
+ }
+ if ((ip->i_mode & mode) != 0)
+ return (0);
+ return (EACCES);
}