* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
- * @(#)ffs_vnops.c 7.25 (Berkeley) %G%
+ * @(#)ffs_vnops.c 7.39 (Berkeley) %G%
*/
#include "param.h"
#include "stat.h"
#include "buf.h"
#include "proc.h"
-#include "uio.h"
#include "socket.h"
#include "socketvar.h"
#include "conf.h"
#include "mount.h"
#include "vnode.h"
+#include "specdev.h"
+#include "../ufs/quota.h"
#include "../ufs/inode.h"
#include "../ufs/fs.h"
-#include "../ufs/quota.h"
/*
* Global vfs data structures for ufs
ufs_unlock(),
ufs_bmap(),
ufs_strategy(),
- ufs_print();
+ ufs_print(),
+ ufs_islocked();
struct vnodeops ufs_vnodeops = {
ufs_lookup, /* lookup */
ufs_bmap, /* bmap */
ufs_strategy, /* strategy */
ufs_print, /* print */
+ ufs_islocked, /* islocked */
};
int spec_lookup(),
spec_bmap, /* bmap */
spec_strategy, /* strategy */
ufs_print, /* print */
+ ufs_islocked, /* islocked */
+};
+
+#ifdef FIFO
+int fifo_lookup(),
+ fifo_open(),
+ ufsfifo_read(),
+ ufsfifo_write(),
+ fifo_bmap(),
+ fifo_ioctl(),
+ fifo_select(),
+ ufsfifo_close(),
+ fifo_print(),
+ fifo_badop(),
+ fifo_nullop();
+
+struct vnodeops fifo_inodeops = {
+ fifo_lookup, /* lookup */
+ fifo_badop, /* create */
+ fifo_badop, /* mknod */
+ fifo_open, /* open */
+ ufsfifo_close, /* close */
+ ufs_access, /* access */
+ ufs_getattr, /* getattr */
+ ufs_setattr, /* setattr */
+ ufsfifo_read, /* read */
+ ufsfifo_write, /* write */
+ fifo_ioctl, /* ioctl */
+ fifo_select, /* select */
+ fifo_badop, /* mmap */
+ fifo_nullop, /* fsync */
+ fifo_badop, /* seek */
+ fifo_badop, /* remove */
+ fifo_badop, /* link */
+ fifo_badop, /* rename */
+ fifo_badop, /* mkdir */
+ fifo_badop, /* rmdir */
+ fifo_badop, /* symlink */
+ fifo_badop, /* readdir */
+ fifo_badop, /* readlink */
+ fifo_badop, /* abortop */
+ ufs_inactive, /* inactive */
+ ufs_reclaim, /* reclaim */
+ ufs_lock, /* lock */
+ ufs_unlock, /* unlock */
+ fifo_bmap, /* bmap */
+ fifo_badop, /* strategy */
+ ufs_print, /* print */
+ ufs_islocked, /* islocked */
};
+#endif /* FIFO */
-enum vtype iftovt_tab[8] = {
- VNON, VCHR, VDIR, VBLK, VREG, VLNK, VSOCK, VBAD,
+enum vtype iftovt_tab[16] = {
+ VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON,
+ VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VBAD,
};
-int vttoif_tab[8] = {
- 0, IFREG, IFDIR, IFBLK, IFCHR, IFLNK, IFSOCK, IFMT,
+int vttoif_tab[9] = {
+ 0, IFREG, IFDIR, IFBLK, IFCHR, IFLNK, IFSOCK, IFIFO, IFMT,
};
/*
if (error = maknode(MAKEIMODE(vap->va_type, vap->va_mode), ndp, &ip))
return (error);
- vp = ITOV(ip);
- if (vap->va_rdev) {
+ ip->i_flag |= IACC|IUPD|ICHG;
+ if (vap->va_rdev != VNOVAL) {
/*
* Want to be able to use this to make badblock
* inodes, so don't truncate the dev number.
*/
ip->i_rdev = vap->va_rdev;
- ip->i_flag |= IACC|IUPD|ICHG;
}
/*
* Remove inode so that it will be reloaded by iget and
* checked to see if it is an alias of an existing entry
* in the inode cache.
*/
- iput(ip);
+ vp = ITOV(ip);
+ vput(vp);
vp->v_type = VNON;
vgone(vp);
return (0);
{
register struct inode *ip = VTOI(vp);
- if (vp->v_count > 1 && !(ip->i_flag & ILOCKED))
+ if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED))
ITIMES(ip, &time, &time);
return (0);
}
+/*
+ * 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.
+ */
ufs_access(vp, mode, cred)
struct vnode *vp;
- int mode;
+ register int mode;
struct ucred *cred;
{
+ register struct inode *ip = VTOI(vp);
+ register gid_t *gp;
+ int i, error;
- return (iaccess(VTOI(vp), mode, cred));
+#ifdef DIAGNOSTIC
+ if (!VOP_ISLOCKED(vp)) {
+ vprint("ufs_access: not locked", vp);
+ panic("ufs_access: not locked");
+ }
+#endif
+#ifdef QUOTA
+ if (mode & VWRITE) {
+ switch (vp->v_type) {
+ case VREG: case VDIR: case VLNK:
+ if (error = getinoquota(ip))
+ return (error);
+ }
+ }
+#endif /* QUOTA */
+ /*
+ * 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);
}
/* ARGSUSED */
vap->va_uid = ip->i_uid;
vap->va_gid = ip->i_gid;
vap->va_rdev = (dev_t)ip->i_rdev;
- vap->va_size = ip->i_din.di_qsize.val[0];
- vap->va_size1 = ip->i_din.di_qsize.val[1];
+#ifdef tahoe
+ vap->va_size = ip->i_size;
+ vap->va_size_rsv = 0;
+#else
+ vap->va_qsize = ip->i_din.di_qsize;
+#endif
vap->va_atime.tv_sec = ip->i_atime;
vap->va_atime.tv_usec = 0;
vap->va_mtime.tv_sec = ip->i_mtime;
else
vap->va_blocksize = ip->i_fs->fs_bsize;
vap->va_bytes = dbtob(ip->i_blocks);
- vap->va_bytes1 = -1;
+ vap->va_bytes_rsv = 0;
vap->va_type = vp->v_type;
return (0);
}
struct ucred *cred;
{
register struct inode *ip = VTOI(vp);
+ uid_t ouid;
+ gid_t ogid;
+ int error = 0;
#ifdef QUOTA
- register long change;
+ register int i;
+ long change;
#endif
- int error;
if (uid == (u_short)VNOVAL)
uid = ip->i_uid;
!groupmember((gid_t)gid, cred)) &&
(error = suser(cred, &u.u_acflag)))
return (error);
+ ouid = ip->i_uid;
+ ogid = ip->i_gid;
#ifdef QUOTA
- if (ip->i_uid == uid) /* this just speeds things a little */
- change = 0;
- else
- change = ip->i_blocks;
- (void) chkdq(ip, -change, 1);
- (void) chkiq(ip->i_dev, ip, ip->i_uid, 1);
- dqrele(ip->i_dquot);
+ if (error = getinoquota(ip))
+ return (error);
+ if (ouid == uid) {
+ dqrele(vp, ip->i_dquot[USRQUOTA]);
+ ip->i_dquot[USRQUOTA] = NODQUOT;
+ }
+ if (ogid == gid) {
+ dqrele(vp, ip->i_dquot[GRPQUOTA]);
+ ip->i_dquot[GRPQUOTA] = NODQUOT;
+ }
+ change = ip->i_blocks;
+ (void) chkdq(ip, -change, cred, CHOWN);
+ (void) chkiq(ip, -1, cred, CHOWN);
+ for (i = 0; i < MAXQUOTAS; i++) {
+ dqrele(vp, ip->i_dquot[i]);
+ ip->i_dquot[i] = NODQUOT;
+ }
#endif
- if (ip->i_uid != uid && cred->cr_uid != 0)
- ip->i_mode &= ~ISUID;
- if (ip->i_gid != gid && cred->cr_uid != 0)
- ip->i_mode &= ~ISGID;
ip->i_uid = uid;
ip->i_gid = gid;
- ip->i_flag |= ICHG;
#ifdef QUOTA
- ip->i_dquot = inoquota(ip);
- (void) chkdq(ip, change, 1);
- (void) chkiq(ip->i_dev, (struct inode *)NULL, (uid_t)uid, 1);
- return (u.u_error); /* should == 0 ALWAYS !! */
-#else
- return (0);
+ if ((error = getinoquota(ip)) == 0) {
+ if (ouid == uid) {
+ dqrele(vp, ip->i_dquot[USRQUOTA]);
+ ip->i_dquot[USRQUOTA] = NODQUOT;
+ }
+ if (ogid == gid) {
+ dqrele(vp, ip->i_dquot[GRPQUOTA]);
+ ip->i_dquot[GRPQUOTA] = NODQUOT;
+ }
+ if ((error = chkdq(ip, change, cred, CHOWN)) == 0) {
+ if ((error = chkiq(ip, 1, cred, CHOWN)) == 0)
+ return (0);
+ else
+ (void) chkdq(ip, -change, cred, CHOWN|FORCE);
+ }
+ for (i = 0; i < MAXQUOTAS; i++) {
+ dqrele(vp, ip->i_dquot[i]);
+ ip->i_dquot[i] = NODQUOT;
+ }
+ }
+ ip->i_uid = ouid;
+ ip->i_gid = ogid;
+ if (getinoquota(ip) == 0) {
+ if (ouid == uid) {
+ dqrele(vp, ip->i_dquot[USRQUOTA]);
+ ip->i_dquot[USRQUOTA] = NODQUOT;
+ }
+ if (ogid == gid) {
+ dqrele(vp, ip->i_dquot[GRPQUOTA]);
+ ip->i_dquot[GRPQUOTA] = NODQUOT;
+ }
+ (void) chkdq(ip, change, cred, FORCE);
+ (void) chkiq(ip, 1, cred, FORCE);
+ }
+ if (error)
+ return (error);
#endif
+ if (ouid != uid || ogid != gid)
+ ip->i_flag |= ICHG;
+ if (ouid != uid && cred->cr_uid != 0)
+ ip->i_mode &= ~ISUID;
+ if (ogid != gid && cred->cr_uid != 0)
+ ip->i_mode &= ~ISGID;
+ return (0);
}
/*
register struct fs *fs;
struct buf *bp;
daddr_t lbn, bn, rablock;
- int size, rasize, diff, error = 0;
+ int size, diff, error = 0;
long n, on, type;
if (uio->uio_rw != UIO_READ)
n = diff;
size = blksize(fs, ip, lbn);
rablock = lbn + 1;
- rasize = blksize(fs, ip, rablock);
- if (ip->i_lastr + 1 == lbn)
- error = breada(ITOV(ip), lbn, size, rablock, rasize,
- NOCRED, &bp);
+ if (vp->v_lastr + 1 == lbn &&
+ lblktosize(fs, rablock) < ip->i_size)
+ error = breada(ITOV(ip), lbn, size, rablock,
+ blksize(fs, ip, rablock), NOCRED, &bp);
else
error = bread(ITOV(ip), lbn, size, NOCRED, &bp);
- ip->i_lastr = lbn;
+ vp->v_lastr = lbn;
n = MIN(n, size - bp->b_resid);
if (error) {
brelse(bp);
}
/* ARGSUSED */
-ufs_select(vp, which, cred)
+ufs_select(vp, which, fflags, cred)
struct vnode *vp;
- int which;
+ int which, fflags;
struct ucred *cred;
{
if (oldparent != dp->i_number)
newparent = dp->i_number;
if (doingdirectory && newparent) {
- if (error = iaccess(ip, IWRITE, tndp->ni_cred))
+ VOP_LOCK(fndp->ni_vp);
+ error = ufs_access(fndp->ni_vp, VWRITE, tndp->ni_cred);
+ VOP_UNLOCK(fndp->ni_vp);
+ if (error)
goto bad;
tndp->ni_nameiop = RENAME | LOCKPARENT | LOCKLEAF | NOCACHE;
do {
* directory. The entry is made later
* after writing "." and ".." entries out.
*/
- error = ialloc(dp, dirpref(dp->i_fs), dmode, &tip);
- if (error) {
+ if (error = ialloc(dp, dirpref(dp->i_fs), dmode, ndp->ni_cred, &tip)) {
iput(dp);
return (error);
}
ip = tip;
+ ip->i_uid = ndp->ni_cred->cr_uid;
+ ip->i_gid = dp->i_gid;
#ifdef QUOTA
- if (ip->i_dquot != NODQUOT)
- panic("mkdir: dquot");
+ if ((error = getinoquota(ip)) ||
+ (error = chkiq(ip, 1, ndp->ni_cred, 0))) {
+ ifree(ip, ip->i_number, dmode);
+ iput(ip);
+ iput(dp);
+ return (error);
+ }
#endif
ip->i_flag |= IACC|IUPD|ICHG;
ip->i_mode = dmode;
ITOV(ip)->v_type = VDIR; /* Rest init'd in iget() */
ip->i_nlink = 2;
- ip->i_uid = ndp->ni_cred->cr_uid;
- ip->i_gid = dp->i_gid;
-#ifdef QUOTA
- ip->i_dquot = inoquota(ip);
-#endif
error = iupdat(ip, &time, &time, 1);
/*
/*
* Vnode op for read and write
*/
-ufs_readdir(vp, uio, cred)
+ufs_readdir(vp, uio, cred, eofflagp)
struct vnode *vp;
register struct uio *uio;
struct ucred *cred;
+ int *eofflagp;
{
int count, lost, error;
uio->uio_iov->iov_len = count;
error = ufs_read(vp, uio, 0, cred);
uio->uio_resid += lost;
+ if ((VTOI(vp)->i_size - uio->uio_offset) <= 0)
+ *eofflagp = 1;
+ else
+ *eofflagp = 0;
return (error);
}
ufs_abortop(ndp)
register struct nameidata *ndp;
{
- register struct inode *ip;
- if (ndp->ni_vp) {
- ip = VTOI(ndp->ni_vp);
- if (ip->i_flag & ILOCKED)
- IUNLOCK(ip);
- vrele(ndp->ni_vp);
- }
if (ndp->ni_dvp) {
- ip = VTOI(ndp->ni_dvp);
- if (ip->i_flag & ILOCKED)
- IUNLOCK(ip);
+ if (VOP_ISLOCKED(ndp->ni_dvp))
+ VOP_UNLOCK(ndp->ni_dvp);
vrele(ndp->ni_dvp);
}
+ if (ndp->ni_vp) {
+ if (VOP_ISLOCKED(ndp->ni_vp))
+ VOP_UNLOCK(ndp->ni_vp);
+ vrele(ndp->ni_vp);
+ }
return;
}
+/*
+ * Lock an inode.
+ */
ufs_lock(vp)
struct vnode *vp;
{
return (0);
}
+/*
+ * Unlock an inode.
+ */
ufs_unlock(vp)
struct vnode *vp;
{
return (0);
}
+/*
+ * Check for a locked inode.
+ */
+ufs_islocked(vp)
+ struct vnode *vp;
+{
+
+ if (VTOI(vp)->i_flag & ILOCKED)
+ return (1);
+ return (0);
+}
+
/*
* Get access to bmap
*/
*vpp = ip->i_devvp;
if (bnp == NULL)
return (0);
- return (bmap(ip, bn, bnp, (daddr_t *)0, (int *)0));
+ return (bmap(ip, bn, bnp));
}
/*
- * Just call the device strategy routine
+ * Calculate the logical to physical mapping if not done already,
+ * then call the device strategy routine.
*/
-int checkoverlap = 1;
+int checkoverlap = 0;
ufs_strategy(bp)
register struct buf *bp;
{
register struct inode *ip = VTOI(bp->b_vp);
- register struct buf *ep;
struct vnode *vp;
- struct buf *ebp;
- daddr_t start, last;
int error;
if (bp->b_vp->v_type == VBLK || bp->b_vp->v_type == VCHR)
if (bp->b_blkno == bp->b_lblkno) {
if (error = bmap(ip, bp->b_lblkno, &bp->b_blkno))
return (error);
- if ((long)bp->b_blkno == -1) {
+ if ((long)bp->b_blkno == -1)
clrbuf(bp);
- biodone(bp);
- }
}
- if ((long)bp->b_blkno == -1)
+ if ((long)bp->b_blkno == -1) {
+ biodone(bp);
return (0);
+ }
+#ifdef DIAGNOSTIC
if (checkoverlap) {
+ register struct buf *ep;
+ struct buf *ebp;
+ daddr_t start, last;
+
ebp = &buf[nbuf];
start = bp->b_blkno;
last = start + btodb(bp->b_bcount) - 1;
for (ep = buf; ep < ebp; ep++) {
if (ep == bp || (ep->b_flags & B_INVAL) ||
- ep->b_vp == (struct vnode *)0)
+ ep->b_vp == NULLVP)
continue;
if (VOP_BMAP(ep->b_vp, (daddr_t)0, &vp, (daddr_t)0))
continue;
if (ep->b_bcount == 0 || ep->b_blkno > last ||
ep->b_blkno + btodb(ep->b_bcount) <= start)
continue;
- panic("Disk overlap");
+ vprint("Disk overlap", vp);
+ printf("\tstart %d, end %d overlap start %d, end %d\n",
+ start, last, ep->b_blkno,
+ ep->b_blkno + btodb(ep->b_bcount) - 1);
+ panic("Disk buffer overlap");
}
}
+#endif /* DIAGNOSTIC */
vp = ip->i_devvp;
bp->b_dev = vp->v_rdev;
(*(vp->v_op->vn_strategy))(bp);
{
register struct inode *ip = VTOI(vp);
- printf("tag VT_UFS, ino %d, on dev %d, %d%s\n", ip->i_number,
- major(ip->i_dev), minor(ip->i_dev),
- (ip->i_flag & ILOCKED) ? " (LOCKED)" : "");
+ printf("tag VT_UFS, ino %d, on dev %d, %d", ip->i_number,
+ major(ip->i_dev), minor(ip->i_dev));
+#ifdef FIFO
+ if (vp->v_type == VFIFO)
+ fifo_printinfo(vp);
+#endif /* FIFO */
+ printf("%s\n", (ip->i_flag & ILOCKED) ? " (LOCKED)" : "");
+ if (ip->i_spare0 == 0)
+ return;
+ printf("\towner pid %d", ip->i_spare0);
+ if (ip->i_spare1)
+ printf(" waiting pid %d", ip->i_spare1);
+ printf("\n");
}
/*
{
register struct inode *ip = VTOI(vp);
- if (vp->v_count > 1 && !(ip->i_flag & ILOCKED))
+ if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED))
ITIMES(ip, &time, &time);
return (spec_close(vp, fflag, cred));
}
+#ifdef FIFO
+/*
+ * Read wrapper for fifo's
+ */
+ufsfifo_read(vp, uio, ioflag, cred)
+ struct vnode *vp;
+ struct uio *uio;
+ int ioflag;
+ struct ucred *cred;
+{
+
+ /*
+ * Set access flag.
+ */
+ VTOI(vp)->i_flag |= IACC;
+ return (fifo_read(vp, uio, ioflag, cred));
+}
+
+/*
+ * Write wrapper for fifo's.
+ */
+ufsfifo_write(vp, uio, ioflag, cred)
+ struct vnode *vp;
+ struct uio *uio;
+ int ioflag;
+ struct ucred *cred;
+{
+
+ /*
+ * Set update and change flags.
+ */
+ VTOI(vp)->i_flag |= IUPD|ICHG;
+ return (fifo_write(vp, uio, ioflag, cred));
+}
+
+/*
+ * Close wrapper for fifo's.
+ *
+ * Update the times on the inode then do device close.
+ */
+ufsfifo_close(vp, fflag, cred)
+ struct vnode *vp;
+ int fflag;
+ struct ucred *cred;
+{
+ register struct inode *ip = VTOI(vp);
+
+ if (vp->v_usecount > 1 && !(ip->i_flag & ILOCKED))
+ ITIMES(ip, &time, &time);
+ return (fifo_close(vp, fflag, cred));
+}
+#endif /* FIFO */
+
/*
* Make a new file.
*/
int error;
*ipp = 0;
+ if ((mode & IFMT) == 0)
+ mode |= IFREG;
if ((mode & IFMT) == IFDIR)
ipref = dirpref(pdir->i_fs);
else
ipref = pdir->i_number;
- error = ialloc(pdir, ipref, mode, &tip);
- if (error) {
+ if (error = ialloc(pdir, ipref, mode, ndp->ni_cred, &tip)) {
iput(pdir);
return (error);
}
ip = tip;
+ ip->i_uid = ndp->ni_cred->cr_uid;
+ ip->i_gid = pdir->i_gid;
#ifdef QUOTA
- if (ip->i_dquot != NODQUOT)
- panic("maknode: dquot");
+ if ((error = getinoquota(ip)) ||
+ (error = chkiq(ip, 1, ndp->ni_cred, 0))) {
+ ifree(ip, ip->i_number, mode);
+ iput(ip);
+ iput(pdir);
+ return (error);
+ }
#endif
ip->i_flag |= IACC|IUPD|ICHG;
- if ((mode & IFMT) == 0)
- mode |= IFREG;
ip->i_mode = mode;
ITOV(ip)->v_type = IFTOVT(mode); /* Rest init'd in iget() */
ip->i_nlink = 1;
- ip->i_uid = ndp->ni_cred->cr_uid;
- ip->i_gid = pdir->i_gid;
if ((ip->i_mode & ISGID) && !groupmember(ip->i_gid, ndp->ni_cred) &&
suser(ndp->ni_cred, NULL))
ip->i_mode &= ~ISGID;
-#ifdef QUOTA
- ip->i_dquot = inoquota(ip);
-#endif
/*
* Make sure inode goes to disk before directory entry.
*/
- if ((error = iupdat(ip, &time, &time, 1)) ||
- (error = direnter(ip, ndp))) {
- /*
- * Write error occurred trying to update the inode
- * or the directory so must deallocate the inode.
- */
- ip->i_nlink = 0;
- ip->i_flag |= ICHG;
- iput(ip);
- return (error);
+ if (error = iupdat(ip, &time, &time, 1))
+ goto bad;
+ if (error = direnter(ip, ndp)) {
+ pdir = NULL;
+ goto bad;
}
*ipp = ip;
return (0);
+
+bad:
+ /*
+ * Write error occurred trying to update the inode
+ * or the directory so must deallocate the inode.
+ */
+ if (pdir)
+ iput(pdir);
+ ip->i_nlink = 0;
+ ip->i_flag |= ICHG;
+ iput(ip);
+ return (error);
}