usr/src/sys/ufs/ffs/ufs_inode.c

/*
 * Copyright (c) 1991, 1993
 *      The Regents of the University of California.  All rights reserved.
 *
 * %sccs.include.redist.c%
 *
 *      @(#)ufs_inode.c 8.1 (Berkeley) %G%
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/vnode.h>
#include <sys/mount.h>
#include <sys/kernel.h>
#include <sys/malloc.h>

#include <ufs/ufs/quota.h>
#include <ufs/ufs/inode.h>
#include <ufs/ufs/ufsmount.h>
#include <ufs/ufs/ufs_extern.h>

u_long  nextgennumber;          /* Next generation number to assign. */
int     prtactive = 0;          /* 1 => print out reclaim of active vnodes */

int
ufs_init()
{
        static int first = 1;

        if (!first)
                return (0);
        first = 0;

#ifdef DIAGNOSTIC
        if ((sizeof(struct inode) - 1) & sizeof(struct inode))
                printf("ufs_init: bad size %d\n", sizeof(struct inode));
#endif
        ufs_ihashinit();
        dqinit();
        return (0);
}

/*
 * Last reference to an inode, write the inode out and if necessary,
 * truncate and deallocate the file.
 */
int
ufs_inactive(ap)
        struct vop_inactive_args /* {
                struct vnode *a_vp;
        } */ *ap;
{
        register struct vnode *vp = ap->a_vp;
        register struct inode *ip = VTOI(vp);
        struct timeval tv;
        int mode, error;
        extern int prtactive;

        if (prtactive && vp->v_usecount != 0)
                vprint("ffs_inactive: pushing active", vp);

        /* Get rid of inodes related to stale file handles. */
        if (ip->i_mode == 0) {
                if ((vp->v_flag & VXLOCK) == 0)
                        vgone(vp);
                return (0);
        }

        error = 0;
#ifdef DIAGNOSTIC
        if (VOP_ISLOCKED(vp))
                panic("ffs_inactive: locked inode");
        if (curproc)
                ip->i_lockholder = curproc->p_pid;
        else
                ip->i_lockholder = -1;
#endif
        ip->i_flag |= ILOCKED;
        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 = VOP_TRUNCATE(vp, (off_t)0, 0, NOCRED, NULL);
                mode = ip->i_mode;
                ip->i_mode = 0;
                ip->i_rdev = 0;
                ip->i_flag |= IUPD|ICHG;
                VOP_VFREE(vp, ip->i_number, mode);
        }
        if (ip->i_flag&(IUPD|IACC|ICHG|IMOD)) {
                tv = time;
                VOP_UPDATE(vp, &tv, &tv, 0);
        }
        VOP_UNLOCK(vp);
        /*
         * 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)
                vgone(vp);
        return (error);
}

/*
 * Reclaim an inode so that it can be used for other purposes.
 */
int
ufs_reclaim(ap)
        struct vop_reclaim_args /* {
                struct vnode *a_vp;
        } */ *ap;
{
        register struct vnode *vp = ap->a_vp;
        register struct inode *ip;
        int i, type;

        if (prtactive && vp->v_usecount != 0)
                vprint("ufs_reclaim: pushing active", vp);
        /*
         * Remove the inode from its hash chain.
         */
        ip = VTOI(vp);
        ufs_ihashrem(ip);
        /*
         * Purge old data structures associated with the inode.
         */
        cache_purge(vp);
        if (ip->i_devvp) {
                vrele(ip->i_devvp);
                ip->i_devvp = 0;
        }
#ifdef QUOTA
        for (i = 0; i < MAXQUOTAS; i++) {
                if (ip->i_dquot[i] != NODQUOT) {
                        dqrele(vp, ip->i_dquot[i]);
                        ip->i_dquot[i] = NODQUOT;
                }
        }
#endif
        switch (vp->v_mount->mnt_stat.f_type) {
        case MOUNT_UFS:
                type = M_FFSNODE;
                break;
        case MOUNT_MFS:
                type = M_MFSNODE;
                break;
        case MOUNT_LFS:
                type = M_LFSNODE;
                break;
        default:
                panic("ufs_reclaim: not ufs file");
        }
        FREE(vp->v_data, type);
        vp->v_data = NULL;
        return (0);
}