* 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.
+ * %sccs.include.redist.c%
*
- * @(#)ufs_inode.c 7.26 (Berkeley) %G%
+ * @(#)ufs_inode.c 7.39 (Berkeley) %G%
*/
#include "param.h"
#include "systm.h"
#include "mount.h"
-#include "user.h"
#include "proc.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 "../ufs/quota.h"
-#endif
#include "kernel.h"
#include "malloc.h"
+#include "quota.h"
+#include "inode.h"
+#include "fs.h"
+#include "ufsmount.h"
+
#define INOHSZ 512
#if ((INOHSZ&(INOHSZ-1)) == 0)
#define INOHASH(dev,ino) (((dev)+(ino))&(INOHSZ-1))
ih->ih_head[0] = ih;
ih->ih_head[1] = ih;
}
+#ifdef QUOTA
+ dqinit();
+#endif /* QUOTA */
}
/*
struct vnode *nvp;
struct buf *bp;
struct dinode *dp;
- union ihead *ih;
- int error;
+ union ihead *ih;
+ int i, error;
ih = &ihead[INOHASH(dev, ino)];
loop:
ip->i_flag = 0;
ip->i_devvp = 0;
ip->i_mode = 0;
+ ip->i_diroff = 0;
+ ip->i_lockf = 0;
#ifdef QUOTA
- ip->i_dquot = NODQUOT;
+ for (i = 0; i < MAXQUOTAS; i++)
+ ip->i_dquot[i] = NODQUOT;
#endif
/*
* Put it onto its hash chain and lock it so that other requests for
*/
if (error = bread(VFSTOUFS(mntp)->um_devvp, fsbtodb(fs, itod(fs, ino)),
(int)fs->fs_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.
*/
*/
vp = ITOV(ip);
vp->v_type = IFTOVT(ip->i_mode);
+ if (vp->v_type == VFIFO) {
+#ifdef FIFO
+ extern struct vnodeops fifo_inodeops;
+ vp->v_op = &fifo_inodeops;
+#else
+ iput(ip);
+ *ipp = 0;
+ return (EOPNOTSUPP);
+#endif /* FIFO */
+ }
if (vp->v_type == VCHR || vp->v_type == VBLK) {
vp->v_op = &spec_inodeops;
if (nvp = checkalias(vp, ip->i_rdev, mntp)) {
ip->i_fs = fs;
ip->i_devvp = VFSTOUFS(mntp)->um_devvp;
VREF(ip->i_devvp);
-#ifdef QUOTA
- if (ip->i_mode != 0)
- ip->i_dquot = inoquota(ip);
-#endif
/*
* Set up a generation number for this inode if it does not
* already have one. This should only happen on old filesystems.
if (++nextgennumber < (u_long)time.tv_sec)
nextgennumber = time.tv_sec;
ip->i_gen = nextgennumber;
- if ((vp->v_mount->m_flag & M_RDONLY) == 0)
+ if ((vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
ip->i_flag |= IMOD;
}
*ipp = ip;
* Last reference to an inode, write the inode out and if necessary,
* truncate and deallocate the file.
*/
-ufs_inactive(vp)
+ufs_inactive(vp, p)
struct vnode *vp;
+ struct proc *p;
{
register struct inode *ip = VTOI(vp);
int mode, error = 0;
return (0);
}
ILOCK(ip);
- if (ip->i_nlink <= 0 && (vp->v_mount->m_flag & M_RDONLY) == 0) {
+ if (ip->i_nlink <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
+#ifdef QUOTA
+ if (!getinoquota(ip))
+ (void) chkiq(ip, -1, NOCRED, 0);
+#endif
error = itrunc(ip, (u_long)0, 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;
-#endif
}
IUPDAT(ip, &time, &time, 0);
+ IUNLOCK(ip);
+ ip->i_flag = 0;
/*
* If we are done with the inode, reclaim it
* so that it can be reused immediately.
*/
- if (vp->v_usecount == 0 && ip->i_mode == 0) {
- vinvalbuf(vp, 0);
- IUNLOCK(ip);
- ip->i_flag = 0;
- if ((vp->v_flag & VXLOCK) == 0)
- vgone(vp);
- return (error);
- }
- IUNLOCK(ip);
- ip->i_flag = 0;
+ if (vp->v_usecount == 0 && ip->i_mode == 0)
+ vgone(vp);
return (error);
}
register struct vnode *vp;
{
register struct inode *ip = VTOI(vp);
+ int i;
if (prtactive && vp->v_usecount != 0)
vprint("ufs_reclaim: pushing active", vp);
ip->i_devvp = 0;
}
#ifdef QUOTA
- dqrele(ip->i_dquot);
- ip->i_dquot = NODQUOT;
+ for (i = 0; i < MAXQUOTAS; i++) {
+ if (ip->i_dquot[i] != NODQUOT) {
+ dqrele(vp, ip->i_dquot[i]);
+ ip->i_dquot[i] = NODQUOT;
+ }
+ }
#endif
ip->i_flag = 0;
return (0);
fs = ip->i_fs;
if ((ip->i_flag & (IUPD|IACC|ICHG|IMOD)) == 0)
return (0);
- if (vp->v_mount->m_flag & M_RDONLY)
+ if (vp->v_mount->mnt_flag & MNT_RDONLY)
return (0);
error = bread(ip->i_devvp, fsbtodb(fs, itod(fs, ip->i_number)),
(int)fs->fs_bsize, NOCRED, &bp);
int aflags, error, allerror;
struct inode tip;
+ vnode_pager_setsize(ITOV(oip), length);
if (oip->i_size <= length) {
oip->i_flag |= ICHG|IUPD;
error = iupdat(oip, &time, &time, 1);
aflags = B_CLRBUF;
if (flags & IO_SYNC)
aflags |= B_SYNC;
+#ifdef QUOTA
+ if (error = getinoquota(oip))
+ return (error);
+#endif
if (error = balloc(oip, lbn, offset, &bp, aflags))
return (error);
oip->i_size = length;
size = blksize(fs, oip, lbn);
- bn = bp->b_blkno;
- count = howmany(size, CLBYTES);
- munhash(oip->i_devvp, bn + i * CLBYTES / DEV_BSIZE);
+ (void) vnode_pager_uncache(ITOV(oip));
bzero(bp->b_un.b_addr + offset, (unsigned)(size - offset));
- brealloc(bp, size);
+ allocbuf(bp, size);
if (flags & IO_SYNC)
bwrite(bp);
else
oip->i_blocks = 0;
oip->i_flag |= ICHG;
#ifdef QUOTA
- (void) chkdq(oip, -blocksreleased, 0);
+ if (!getinoquota(oip))
+ (void) chkdq(oip, -blocksreleased, NOCRED, 0);
#endif
return (allerror);
}
*countp = 0;
return (error);
}
- if ((bp->b_flags & B_CACHE) == 0)
- reassignbuf(bp, ITOV(ip));
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);
while (ip->i_flag & ILOCKED) {
ip->i_flag |= IWANT;
- if (ip->i_spare0 == u.u_procp->p_pid)
+ if (ip->i_spare0 == curproc->p_pid)
panic("locking against myself");
- ip->i_spare1 = u.u_procp->p_pid;
+ ip->i_spare1 = curproc->p_pid;
(void) sleep((caddr_t)ip, PINOD);
}
ip->i_spare1 = 0;
- ip->i_spare0 = u.u_procp->p_pid;
- u.u_spare[0]++;
+ ip->i_spare0 = curproc->p_pid;
ip->i_flag |= ILOCKED;
}
if ((ip->i_flag & ILOCKED) == 0)
vprint("iunlock: unlocked inode", ITOV(ip));
ip->i_spare0 = 0;
- u.u_spare[0]--;
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;
- 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);
-}