void
FSNodeScrub(struct fuse_vnode_data *fvdat)
{
lck_mtx_free(fvdat->createlock, fuse_lock_group);
#if M_OSXFUSE_ENABLE_TSLOCKING
lck_rw_free(fvdat->nodelock, fuse_lock_group);
lck_rw_free(fvdat->truncatelock, fuse_lock_group);
#endif
}
void lpx_datagram_free()
{
DEBUG_PRINT(DEBUG_MASK_STREAM_TRACE, ("lpx_datagram_free: Entered\n"));
// Release Lock.
lck_rw_free(lpx_datagram_pcb.lpxp_list_rw, datagram_mtx_grp);
lck_grp_attr_free(datagram_mtx_grp_attr);
lck_grp_free(datagram_mtx_grp);
lck_attr_free(datagram_mtx_attr);
}
void _adt_xnu_rw_lock_destroy(ADT_LOCK *lockp)
{
ADT_LOCK rwlock;
if(NULL == lockp || NULL == *lockp)
{
return;
}
rwlock=*lockp;
lck_rw_free(rwlock->rw_lock, rwlock->rw_lock_grp);
lck_attr_free(rwlock->rw_lock_attr);
lck_grp_free(rwlock->rw_lock_grp);
lck_grp_attr_free(rwlock->rw_lock_grp_attr);
adt_free(rwlock);
*lockp=NULL;
}
/**
* VBoxVFS reclaim callback.
* Called when vnode is going to be deallocated. Should release
* all the VBoxVFS resources that correspond to current vnode object.
*
* @param pArgs Operation arguments passed from VFS layer.
*
* @return 0 on success, BSD error code otherwise.
*/
static int
vboxvfs_vnode_reclaim(struct vnop_reclaim_args *pArgs)
{
PDEBUG("Releasing vnode resources...");
AssertReturn(pArgs, EINVAL);
vnode_t pVnode;
vboxvfs_vnode_t *pVnodeData;
vboxvfs_mount_t *pMount;
mount_t mp;
pVnode = pArgs->a_vp;
AssertReturn(pVnode, EINVAL);
mp = vnode_mount(pVnode);
AssertReturn(mp, EINVAL);
pMount = (vboxvfs_mount_t *)vfs_fsprivate(mp);
AssertReturn(pMount, EINVAL);
pVnodeData = (vboxvfs_vnode_t *)vnode_fsnode(pVnode);
AssertReturn(pVnodeData, EINVAL);
AssertReturn(pVnodeData->pPath, EINVAL);
AssertReturn(pVnodeData->pLockAttr, EINVAL);
AssertReturn(pVnodeData->pLock, EINVAL);
RTMemFree(pVnodeData->pPath);
pVnodeData->pPath = NULL;
lck_rw_free(pVnodeData->pLock, pMount->pLockGroup);
pVnodeData->pLock = NULL;
lck_attr_free(pVnodeData->pLockAttr);
pVnodeData->pLockAttr = NULL;
return 0;
}
static int
vnop_reclaim_9p(struct vnop_reclaim_args *ap)
{
vnode_t vp;
node_9p *np;
TRACE();
vp = ap->a_vp;
np = NTO9P(vp);
nlock_9p(np, NODE_LCK_EXCLUSIVE);
{
SET(np->flags, NODE_RECL);
ndel_9p(np);
/* balance the ref added in nget_9p() */
vnode_removefsref(vp);
vnode_clearfsnode(vp);
cache_purge(vp);
}
nunlock_9p(np);
/* root gets clunk in vfs_unmount_9p() */
if (!ISSET(np->nmp->flags, F_UNMOUNTING))
clunk_9p(np->nmp, np->fid);
/* free it */
CLR(np->flags, NODE_RECL);
if (ISSET(np->flags, NODE_WAITRECL)) {
CLR(np->flags, NODE_WAITRECL);
wakeup(np);
}
lck_rw_free(np->lck, lck_grp_9p);
free_9p(np->direntries);
free_9p(np);
return 0;
}
__private_extern__ int
nget_9p(mount_9p *nmp, fid_9p fid, qid_9p qid, vnode_t dvp, vnode_t *vpp, struct componentname *cnp, vfs_context_t ctx)
{
#pragma unused(ctx)
struct vnode_fsparam fsp;
struct hnode_9p *nhp;
node_9p *np;
uint32_t vid;
int e, i;
TRACE();
nhp = HASH9P(nmp, qid.path);
loop:
lck_mtx_lock(nmp->nodelck);
LIST_FOREACH (np, nhp, next) {
if(np->dir.qid.path != qid.path)
continue;
if (ISSET(np->flags, NODE_INIT)) {
SET(np->flags, NODE_WAITINIT);
msleep(np, nmp->nodelck, PINOD|PDROP, "nget_9p_init", NULL);
goto loop;
}
if (ISSET(np->flags, NODE_RECL)) {
SET(np->flags, NODE_WAITRECL);
msleep(np, nmp->nodelck, PINOD|PDROP, "nget_9p_reclaim", NULL);
goto loop;
}
vid = vnode_vid(np->vp);
lck_mtx_unlock(nmp->nodelck);
if (vnode_getwithvid(np->vp, vid))
goto loop;
nlock_9p(np, NODE_LCK_EXCLUSIVE);
if (dvp && cnp && ISSET(cnp->cn_flags, MAKEENTRY) && np->dir.qid.vers!=0) {
// DEBUG("caching %s", np->dir->name);
cache_enter(dvp, np->vp, cnp);
} else {
// DEBUG("not in cache qid=%d %s", qid.vers, np->dir->name);
}
*vpp = np->vp;
return 0;
}
if (fid == NOFID)
return EFAULT;
np = malloc_9p(sizeof(*np));
if (np == NULL) {
err0:
lck_mtx_unlock(nmp->nodelck);
return ENOMEM;
}
np->lck = lck_rw_alloc_init(lck_grp_9p, LCK_ATTR_NULL);
if (np->lck == NULL) {
free_9p(np);
goto err0;
}
np->nmp = nmp;
np->fid = fid;
np->dir.qid = qid;
for (i=0; i<3; i++)
np->openfid[i].fid = NOFID;
SET(np->flags, NODE_INIT);
LIST_INSERT_HEAD(nhp, np, next);
nlock_9p(np, NODE_LCK_EXCLUSIVE);
lck_mtx_unlock(nmp->nodelck);
if ((e=ngetdir_9p(np))) {
err1:
nunlock_9p(np);
lck_mtx_lock(nmp->nodelck);
LIST_REMOVE(np, next);
CLR(np->flags, NODE_INIT);
if (ISSET(np->flags, NODE_WAITINIT)) {
CLR(np->flags, NODE_WAITINIT);
wakeup(np);
}
lck_mtx_unlock(nmp->nodelck);
lck_rw_free(np->lck, lck_grp_9p);
free_9p(np);
return e;
}
fsp.vnfs_mp = nmp->mp;
fsp.vnfs_str = fsname;
fsp.vnfs_dvp = dvp;
fsp.vnfs_fsnode = np;
fsp.vnfs_vops = vnode_op_9p;
fsp.vnfs_markroot = dvp==NULL? TRUE: FALSE;
fsp.vnfs_marksystem = FALSE;
fsp.vnfs_filesize = np->dir.length;
fsp.vnfs_cnp = cnp;
fsp.vnfs_flags = VNFS_ADDFSREF;
dirvtype_9p(&np->dir, ISSET(nmp->flags, F_DOTU), &fsp.vnfs_vtype, &fsp.vnfs_rdev);
if (!dvp || !cnp || !ISSET(cnp->cn_flags, MAKEENTRY) || qid.vers==0)
SET(fsp.vnfs_flags, VNFS_NOCACHE);
if ((e=vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &fsp, &np->vp)))
goto err1;
vnode_settag(np->vp, VT_OTHER);
lck_mtx_lock(nmp->nodelck);
CLR(np->flags, NODE_INIT);
if (ISSET(np->flags, NODE_WAITINIT)) {
CLR(np->flags, NODE_WAITINIT);
wakeup(np);
}
lck_mtx_unlock(nmp->nodelck);
*vpp = np->vp;
return 0;
}
void
lock_free_EXT(
lck_rw_t *lock)
{
lck_rw_free(lock, &LockCompatGroup);
}
