/*
* Reclaim an fnode/ntnode so that it can be used for other purposes.
*/
int
ntfs_reclaim(void *v)
{
struct vop_reclaim_args /* {
struct vnode *a_vp;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct fnode *fp = VTOF(vp);
struct ntnode *ip = FTONT(fp);
int error;
dprintf(("ntfs_reclaim: vnode: %p, ntnode: %llu\n", vp,
(unsigned long long)ip->i_number));
if (prtactive && vp->v_usecount > 1)
vprint("ntfs_reclaim: pushing active", vp);
if ((error = ntfs_ntget(ip)) != 0)
return (error);
if (ip->i_devvp) {
vrele(ip->i_devvp);
ip->i_devvp = NULL;
}
genfs_node_destroy(vp);
ntfs_frele(fp);
ntfs_ntput(ip);
vp->v_data = NULL;
return (0);
}
int
sysvbfs_reclaim(void *v)
{
extern struct pool sysvbfs_node_pool;
struct vop_reclaim_args /* {
struct vnode *a_vp;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct sysvbfs_node *bnode = vp->v_data;
struct bfs *bfs = bnode->bmp->bfs;
DPRINTF("%s:\n", __func__);
vcache_remove(vp->v_mount,
&bnode->inode->number, sizeof(bnode->inode->number));
if (bnode->removed) {
if (bfs_inode_delete(bfs, bnode->inode->number) != 0)
DPRINTF("%s: delete inode failed\n", __func__);
}
genfs_node_destroy(vp);
pool_put(&sysvbfs_node_pool, bnode);
vp->v_data = NULL;
return 0;
}
int
v7fs_reclaim(void *v)
{
/*This vnode is no longer referenced by kernel. */
extern struct pool v7fs_node_pool;
struct vop_reclaim_args /* {
struct vnode *a_vp;
} */ *a = v;
struct vnode *vp = a->a_vp;
struct v7fs_node *v7node = vp->v_data;
struct v7fs_self *fs = v7node->v7fsmount->core;
struct v7fs_inode *inode = &v7node->inode;
DPRINTF("%p #%d\n", vp, inode->inode_number);
if (v7fs_inode_nlink(inode) == 0) {
v7fs_datablock_size_change(fs, 0, inode);
DPRINTF("remove datablock\n");
v7fs_inode_deallocate(fs, inode->inode_number);
DPRINTF("remove inode\n");
}
genfs_node_destroy(vp);
pool_put(&v7fs_node_pool, v7node);
mutex_enter(vp->v_interlock);
vp->v_data = NULL;
mutex_exit(vp->v_interlock);
return 0;
}
/*
* Reclaim an inode so that it can be used for other purposes.
*/
int
ffs_reclaim(void *v)
{
struct vop_reclaim_args /* {
struct vnode *a_vp;
struct lwp *a_l;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct inode *ip = VTOI(vp);
struct mount *mp = vp->v_mount;
struct ufsmount *ump = ip->i_ump;
void *data;
int error;
fstrans_start(mp, FSTRANS_LAZY);
/*
* The inode must be freed and updated before being removed
* from its hash chain. Other threads trying to gain a hold
* on the inode will be stalled because it is locked (VI_XLOCK).
*/
error = UFS_WAPBL_BEGIN(mp);
if (error) {
fstrans_done(mp);
return error;
}
if (ip->i_nlink <= 0 && ip->i_omode != 0 &&
(vp->v_mount->mnt_flag & MNT_RDONLY) == 0)
ffs_vfree(vp, ip->i_number, ip->i_omode);
UFS_WAPBL_END(mp);
if ((error = ufs_reclaim(vp)) != 0) {
fstrans_done(mp);
return (error);
}
if (ip->i_din.ffs1_din != NULL) {
if (ump->um_fstype == UFS1)
pool_cache_put(ffs_dinode1_cache, ip->i_din.ffs1_din);
else
pool_cache_put(ffs_dinode2_cache, ip->i_din.ffs2_din);
}
/*
* To interlock with ffs_sync().
*/
genfs_node_destroy(vp);
mutex_enter(vp->v_interlock);
data = vp->v_data;
vp->v_data = NULL;
mutex_exit(vp->v_interlock);
/*
* XXX MFS ends up here, too, to free an inode. Should we create
* XXX a separate pool for MFS inodes?
*/
pool_cache_put(ffs_inode_cache, data);
fstrans_done(mp);
return (0);
}
/*
* Reclaim an nfsnode so that it can be used for other purposes.
*/
int
nfs_reclaim(void *v)
{
struct vop_reclaim_args /* {
struct vnode *a_vp;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct nfsnode *np = VTONFS(vp);
struct nfsmount *nmp = VFSTONFS(vp->v_mount);
if (prtactive && vp->v_usecount > 1)
vprint("nfs_reclaim: pushing active", vp);
rw_enter(&nmp->nm_rbtlock, RW_WRITER);
rb_tree_remove_node(&nmp->nm_rbtree, np);
rw_exit(&nmp->nm_rbtlock);
/*
* Free up any directory cookie structures and
* large file handle structures that might be associated with
* this nfs node.
*/
if (vp->v_type == VDIR && np->n_dircache != NULL) {
nfs_invaldircache(vp, NFS_INVALDIRCACHE_FORCE);
hashdone(np->n_dircache, HASH_LIST, nfsdirhashmask);
}
KASSERT(np->n_dirgens == NULL);
if (np->n_fhsize > NFS_SMALLFH)
kmem_free(np->n_fhp, np->n_fhsize);
pool_put(&nfs_vattr_pool, np->n_vattr);
if (np->n_rcred)
kauth_cred_free(np->n_rcred);
if (np->n_wcred)
kauth_cred_free(np->n_wcred);
if (vp->v_type == VREG) {
mutex_destroy(&np->n_commitlock);
}
genfs_node_destroy(vp);
pool_put(&nfs_node_pool, np);
vp->v_data = NULL;
return (0);
}
/*
* Reclaim an fnode/ntnode so that it can be used for other purposes.
*/
int
ntfs_reclaim(void *v)
{
struct vop_reclaim_args /* {
struct vnode *a_vp;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct fnode *fp = VTOF(vp);
struct ntnode *ip = FTONT(fp);
const int attrlen = strlen(fp->f_attrname);
int error;
dprintf(("ntfs_reclaim: vnode: %p, ntnode: %llu\n", vp,
(unsigned long long)ip->i_number));
if (prtactive && vp->v_usecount > 1)
vprint("ntfs_reclaim: pushing active", vp);
if ((error = ntfs_ntget(ip)) != 0)
return (error);
vcache_remove(vp->v_mount, fp->f_key, NTKEY_SIZE(attrlen));
if (ip->i_devvp) {
vrele(ip->i_devvp);
ip->i_devvp = NULL;
}
genfs_node_destroy(vp);
vp->v_data = NULL;
/* Destroy fnode. */
if (fp->f_key != &fp->f_smallkey)
kmem_free(fp->f_key, NTKEY_SIZE(attrlen));
if (fp->f_dirblbuf)
free(fp->f_dirblbuf, M_NTFSDIR);
kmem_free(fp, sizeof(*fp));
ntfs_ntrele(ip);
ntfs_ntput(ip);
return (0);
}
int
sysvbfs_reclaim(void *v)
{
extern struct pool sysvbfs_node_pool;
struct vop_reclaim_args /* {
struct vnode *a_vp;
} */ *ap = v;
struct vnode *vp = ap->a_vp;
struct sysvbfs_node *bnode = vp->v_data;
DPRINTF("%s:\n", __func__);
mutex_enter(&mntvnode_lock);
LIST_REMOVE(bnode, link);
mutex_exit(&mntvnode_lock);
genfs_node_destroy(vp);
pool_put(&sysvbfs_node_pool, bnode);
vp->v_data = NULL;
return 0;
}
/*
* the kernel wants its vnode back.
* no lock needed we are being called from vclean()
*/
int
adosfs_reclaim(void *v)
{
struct vop_reclaim_args /* {
struct vnode *a_vp;
} */ *sp = v;
struct vnode *vp;
struct anode *ap;
#ifdef ADOSFS_DIAGNOSTIC
printf("(reclaim 0)");
#endif
vp = sp->a_vp;
ap = VTOA(vp);
vcache_remove(vp->v_mount, &ap->block, sizeof(ap->block));
if (vp->v_type == VDIR && ap->tab)
free(ap->tab, M_ANODE);
else if (vp->v_type == VLNK && ap->slinkto)
free(ap->slinkto, M_ANODE);
genfs_node_destroy(vp);
pool_put(&adosfs_node_pool, ap);
vp->v_data = NULL;
return(0);
}
