/* * 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); }