struct afs_conn *tc;
struct AFSFetchStatus OutDirStatus;
struct AFSVolSync tsync;
+ struct rx_connection *rxconn;
XSTATS_DECLS;
if (!AFS_IS_DISCONNECTED) {
do {
- tc = afs_Conn(&adp->f.fid, treqp, SHARED_LOCK);
+ tc = afs_Conn(&adp->f.fid, treqp, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_REMOVEFILE);
RX_AFS_GUNLOCK();
code =
- RXAFS_RemoveFile(tc->id, (struct AFSFid *)&adp->f.fid.Fid,
+ RXAFS_RemoveFile(rxconn, (struct AFSFid *)&adp->f.fid.Fid,
aname, &OutDirStatus, &tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
} else
code = -1;
} while (afs_Analyze
- (tc, code, &adp->f.fid, treqp, AFS_STATS_FS_RPCIDX_REMOVEFILE,
+ (tc, rxconn, code, &adp->f.fid, treqp, AFS_STATS_FS_RPCIDX_REMOVEFILE,
SHARED_LOCK, NULL));
}
* call FindVCache instead of GetVCache since if the file's really
* gone, we won't be able to fetch the status info anyway. */
if (tvc) {
- afs_MarinerLog("store$Removing", tvc);
-#ifdef AFS_BOZONLOCK_ENV
- afs_BozonLock(&tvc->pvnLock, tvc);
- /* Since afs_TryToSmush will do a pvn_vptrunc */
-#endif
+ if (afs_mariner)
+ afs_MarinerLog("store$Removing", tvc);
ObtainWriteLock(&tvc->lock, 141);
/* note that callback will be broken on the deleted file if there are
* still >0 links left to it, so we'll get the stat right */
afs_TryToSmush(tvc, acred, 0);
}
ReleaseWriteLock(&tvc->lock);
-#ifdef AFS_BOZONLOCK_ENV
- afs_BozonUnlock(&tvc->pvnLock, tvc);
-#endif
afs_PutVCache(tvc);
}
return (0);
int
afs_remove(OSI_VC_DECL(adp), char *aname, afs_ucred_t *acred)
{
- struct vrequest treq;
+ struct vrequest *treq = NULL;
struct dcache *tdc;
struct VenusFid unlinkFid;
afs_int32 code;
ICL_TYPE_STRING, aname);
- if ((code = afs_InitReq(&treq, acred))) {
+ if ((code = afs_CreateReq(&treq, acred))) {
return code;
}
afs_InitFakeStat(&fakestate);
AFS_DISCON_LOCK();
- code = afs_EvalFakeStat(&adp, &fakestate, &treq);
+ code = afs_EvalFakeStat(&adp, &fakestate, treq);
if (code)
goto done;
goto done;
}
tagain:
- code = afs_VerifyVCache(adp, &treq);
+ code = afs_VerifyVCache(adp, treq);
tvc = NULL;
if (code) {
- code = afs_CheckCode(code, &treq, 23);
+ code = afs_CheckCode(code, treq, 23);
goto done;
}
goto done;
}
- tdc = afs_GetDCache(adp, (afs_size_t) 0, &treq, &offset, &len, 1); /* test for error below */
+ tdc = afs_GetDCache(adp, (afs_size_t) 0, treq, &offset, &len, 1); /* test for error below */
ObtainWriteLock(&adp->lock, 142);
if (tdc)
ObtainSharedLock(&tdc->lock, 638);
unlinkFid.Fid.Volume = adp->f.fid.Fid.Volume;
if (unlinkFid.Fid.Unique == 0) {
tvc =
- afs_LookupVCache(&unlinkFid, &treq, &cached, adp,
+ afs_LookupVCache(&unlinkFid, treq, &cached, adp,
aname);
} else {
ObtainReadLock(&afs_xvcache);
if (tdc)
ReleaseSharedLock(&tdc->lock);
ObtainWriteLock(&tvc->lock, 143);
- FetchWholeEnchilada(tvc, &treq);
+ FetchWholeEnchilada(tvc, treq);
ReleaseWriteLock(&tvc->lock);
ObtainWriteLock(&adp->lock, 144);
/* Technically I don't think we need this back, but let's hold it
ReleaseWriteLock(&adp->lock);
if (tdc)
ReleaseSharedLock(&tdc->lock);
- code = afsrename(adp, aname, adp, unlname, acred, &treq);
+ code = afsrename(adp, aname, adp, unlname, acred, treq);
Tnam1 = unlname;
if (!code) {
- struct VenusFid *oldmvid = NULL;
- if (tvc->mvid)
- oldmvid = tvc->mvid;
- tvc->mvid = (struct VenusFid *)unlname;
+ void *oldmvid = NULL;
+ if (tvc->mvid.silly_name)
+ oldmvid = tvc->mvid.silly_name;
+ tvc->mvid.silly_name = unlname;
if (oldmvid)
osi_FreeSmallSpace(oldmvid);
crhold(acred);
afs_PutDCache(tdc);
afs_PutVCache(tvc);
} else {
- code = afsremove(adp, tdc, tvc, aname, acred, &treq);
+ code = afsremove(adp, tdc, tvc, aname, acred, treq);
}
done:
afs_PutFakeStat(&fakestate);
-#ifndef AFS_DARWIN80_ENV
+#if !defined(AFS_DARWIN80_ENV) && !defined(UKERNEL)
/* we can't track by thread, it's not exported in the KPI; only do
this on !macos */
osi_Assert(!WriteLocked(&adp->lock) || (adp->lock.pid_writer != MyPidxx));
#endif
AFS_DISCON_UNLOCK();
+ afs_DestroyReq(treq);
return code;
}
afs_ucred_t *cred;
char *unlname;
struct vcache *adp;
- struct vrequest treq;
struct VenusFid dirFid;
struct dcache *tdc;
afs_int32 code = 0;
}
#endif
- if (avc->mvid && (doit || (avc->f.states & CUnlinkedDel))) {
- if ((code = afs_InitReq(&treq, avc->uncred))) {
+ if (avc->mvid.silly_name && (doit || (avc->f.states & CUnlinkedDel))) {
+ struct vrequest *treq = NULL;
+
+ if ((code = afs_CreateReq(&treq, avc->uncred))) {
ReleaseWriteLock(&avc->lock);
} else {
/* Must bump the refCount because GetVCache may block.
* Also clear mvid so no other thread comes here if we block.
*/
- unlname = (char *)avc->mvid;
- avc->mvid = NULL;
+ unlname = avc->mvid.silly_name;
+ avc->mvid.silly_name = NULL;
cred = avc->uncred;
avc->uncred = NULL;
dirFid.Fid.Volume = avc->f.fid.Fid.Volume;
dirFid.Fid.Vnode = avc->f.parent.vnode;
dirFid.Fid.Unique = avc->f.parent.unique;
- adp = afs_GetVCache(&dirFid, &treq, NULL, NULL);
+ adp = afs_GetVCache(&dirFid, treq, NULL, NULL);
if (adp) {
tdc = afs_FindDCache(adp, (afs_size_t) 0);
ObtainSharedLock(&tdc->lock, 639);
/* afsremove releases the adp & tdc locks, and does vn_rele(avc) */
- code = afsremove(adp, tdc, avc, unlname, cred, &treq);
+ code = afsremove(adp, tdc, avc, unlname, cred, treq);
afs_PutVCache(adp);
} else {
/* we failed - and won't be back to try again. */
}
osi_FreeSmallSpace(unlname);
crfree(cred);
+ afs_DestroyReq(treq);
}
} else {
#if defined(AFS_DARWIN80_ENV)