#endif
{
afs_int32 code;
- struct vrequest treq;
+ struct vrequest *treq = NULL;
struct afs_fakestat_state fakestate;
OSI_VC_CONVERT(avc);
afs_Trace3(afs_iclSetp, CM_TRACE_ACCESS, ICL_TYPE_POINTER, avc,
ICL_TYPE_INT32, amode, ICL_TYPE_OFFSET,
ICL_HANDLE_OFFSET(avc->f.m.Length));
+
afs_InitFakeStat(&fakestate);
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred))) {
return code;
+ }
AFS_DISCON_LOCK();
if (afs_fakestat_enable && avc->mvstat == 1) {
- code = afs_TryEvalFakeStat(&avc, &fakestate, &treq);
+ code = afs_TryEvalFakeStat(&avc, &fakestate, treq);
if (code == 0 && avc->mvstat == 1) {
afs_PutFakeStat(&fakestate);
AFS_DISCON_UNLOCK();
+ afs_DestroyReq(treq);
return 0;
}
} else {
- code = afs_EvalFakeStat(&avc, &fakestate, &treq);
+ code = afs_EvalFakeStat(&avc, &fakestate, treq);
}
if (code) {
afs_PutFakeStat(&fakestate);
AFS_DISCON_UNLOCK();
+ afs_DestroyReq(treq);
return code;
}
if (vType(avc) != VDIR || !afs_InReadDir(avc)) {
- code = afs_VerifyVCache(avc, &treq);
+ code = afs_VerifyVCache(avc, treq);
if (code) {
afs_PutFakeStat(&fakestate);
AFS_DISCON_UNLOCK();
- code = afs_CheckCode(code, &treq, 16);
+ code = afs_CheckCode(code, treq, 16);
+ afs_DestroyReq(treq);
return code;
}
}
if ((amode & VWRITE) && (avc->f.states & CRO)) {
afs_PutFakeStat(&fakestate);
AFS_DISCON_UNLOCK();
+ afs_DestroyReq(treq);
return EROFS;
}
afs_PutFakeStat(&fakestate);
AFS_DISCON_UNLOCK();
/* printf("Network is down in afs_vnop_access\n"); */
+ afs_DestroyReq(treq);
return ENETDOWN;
}
if (avc->f.states & CForeign) {
/* In the dfs xlator the EXEC bit is mapped to LOOKUP */
if (amode & VEXEC)
- code = afs_AccessOK(avc, PRSFS_LOOKUP, &treq, CHECK_MODE_BITS);
+ code = afs_AccessOK(avc, PRSFS_LOOKUP, treq, CHECK_MODE_BITS);
if (code && (amode & VWRITE)) {
- code = afs_AccessOK(avc, PRSFS_WRITE, &treq, CHECK_MODE_BITS);
+ code = afs_AccessOK(avc, PRSFS_WRITE, treq, CHECK_MODE_BITS);
if (code && (vType(avc) == VDIR)) {
if (code)
code =
- afs_AccessOK(avc, PRSFS_INSERT, &treq,
+ afs_AccessOK(avc, PRSFS_INSERT, treq,
CHECK_MODE_BITS);
if (!code)
code =
- afs_AccessOK(avc, PRSFS_DELETE, &treq,
+ afs_AccessOK(avc, PRSFS_DELETE, treq,
CHECK_MODE_BITS);
}
}
if (code && (amode & VREAD))
- code = afs_AccessOK(avc, PRSFS_READ, &treq, CHECK_MODE_BITS);
+ code = afs_AccessOK(avc, PRSFS_READ, treq, CHECK_MODE_BITS);
} else {
if (vType(avc) == VDIR) {
if (amode & VEXEC)
code =
- afs_AccessOK(avc, PRSFS_LOOKUP, &treq, CHECK_MODE_BITS);
+ afs_AccessOK(avc, PRSFS_LOOKUP, treq, CHECK_MODE_BITS);
if (code && (amode & VWRITE)) {
code =
- afs_AccessOK(avc, PRSFS_INSERT, &treq, CHECK_MODE_BITS);
+ afs_AccessOK(avc, PRSFS_INSERT, treq, CHECK_MODE_BITS);
if (!code)
code =
- afs_AccessOK(avc, PRSFS_DELETE, &treq,
+ afs_AccessOK(avc, PRSFS_DELETE, treq,
CHECK_MODE_BITS);
}
if (code && (amode & VREAD))
code =
- afs_AccessOK(avc, PRSFS_LOOKUP, &treq, CHECK_MODE_BITS);
+ afs_AccessOK(avc, PRSFS_LOOKUP, treq, CHECK_MODE_BITS);
} else {
if (amode & VEXEC) {
- code = afs_AccessOK(avc, PRSFS_READ, &treq, CHECK_MODE_BITS);
+ code = afs_AccessOK(avc, PRSFS_READ, treq, CHECK_MODE_BITS);
if (code) {
if ((avc->f.m.Mode & 0100) == 0)
code = 0;
code = 1;
}
if (code && (amode & VWRITE)) {
- code = afs_AccessOK(avc, PRSFS_WRITE, &treq, CHECK_MODE_BITS);
+ code = afs_AccessOK(avc, PRSFS_WRITE, treq, CHECK_MODE_BITS);
/* The above call fails when the NFS translator tries to copy
** a file with r--r--r-- permissions into a directory which
if (!code && AFS_NFSXLATORREQ(acred)
&& avc->f.m.Owner == ANONYMOUSID)
code =
- afs_AccessOK(avc, PRSFS_WRITE, &treq,
+ afs_AccessOK(avc, PRSFS_WRITE, treq,
DONT_CHECK_MODE_BITS);
}
if (code && (amode & VREAD))
- code = afs_AccessOK(avc, PRSFS_READ, &treq, CHECK_MODE_BITS);
+ code = afs_AccessOK(avc, PRSFS_READ, treq, CHECK_MODE_BITS);
}
}
afs_PutFakeStat(&fakestate);
AFS_DISCON_UNLOCK();
if (code) {
+ afs_DestroyReq(treq);
return 0; /* if access is ok */
} else {
- code = afs_CheckCode(EACCES, &treq, 17); /* failure code */
+ code = afs_CheckCode(EACCES, treq, 17); /* failure code */
+ afs_DestroyReq(treq);
return code;
}
}
afs_ucred_t *acred)
{
afs_int32 code;
- struct vrequest treq;
+ struct vrequest *treq = NULL;
OSI_VC_CONVERT(avc);
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred)))
return code;
- code = afs_VerifyVCache(avc, &treq);
+ code = afs_VerifyVCache(avc, treq);
if (code) {
- code = afs_CheckCode(code, &treq, 18);
+ code = afs_CheckCode(code, treq, 18);
+ afs_DestroyReq(treq);
return code;
}
- return afs_GetAccessBits(avc, arights, &treq);
+ code = afs_GetAccessBits(avc, arights, treq);
+ afs_DestroyReq(treq);
+ return code;
}
#endif /* defined(UKERNEL) */
#endif
{
afs_int32 code;
- struct vrequest treq;
+ struct vrequest *treq = NULL;
struct unixuser *au;
int inited = 0;
OSI_VC_CONVERT(avc);
if (afs_fakestat_enable && avc->mvstat == 1) {
struct afs_fakestat_state fakestat;
+ struct vrequest *ureq = NULL;
- code = afs_InitReq(&treq, acred);
- if (code)
+ code = afs_CreateReq(&ureq, acred);
+ if (code) {
return code;
+ }
afs_InitFakeStat(&fakestat);
- code = afs_TryEvalFakeStat(&avc, &fakestat, &treq);
+ code = afs_TryEvalFakeStat(&avc, &fakestat, ureq);
if (code) {
afs_PutFakeStat(&fakestat);
+ afs_DestroyReq(ureq);
return code;
}
code = afs_CopyOutAttrs(avc, attrs);
afs_PutFakeStat(&fakestat);
+ afs_DestroyReq(ureq);
return code;
}
#if defined(AFS_SUN5_ENV)
}
if (!(avc->f.states & CStatd)) {
- if (!(code = afs_InitReq(&treq, acred))) {
- code = afs_VerifyVCache2(avc, &treq);
+ if (!(code = afs_CreateReq(&treq, acred))) {
+ code = afs_VerifyVCache2(avc, treq);
inited = 1;
}
} else
if (afs_nfsexporter) {
if (!inited) {
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred))) {
return code;
+ }
inited = 1;
}
if (AFS_NFSXLATORREQ(acred)) {
if ((vType(avc) != VDIR)
- && !afs_AccessOK(avc, PRSFS_READ, &treq,
+ && !afs_AccessOK(avc, PRSFS_READ, treq,
CHECK_MODE_BITS |
CMB_ALLOW_EXEC_AS_READ)) {
+ afs_DestroyReq(treq);
return EACCES;
}
}
- if ((au = afs_FindUser(treq.uid, -1, READ_LOCK))) {
+ if ((au = afs_FindUser(treq->uid, -1, READ_LOCK))) {
struct afs_exporter *exporter = au->exporter;
if (exporter && !(afs_nfsexporter->exp_states & EXP_UNIXMODE)) {
AFS_DISCON_UNLOCK();
- if (!code)
+ if (!code) {
+ afs_DestroyReq(treq);
return 0;
- code = afs_CheckCode(code, &treq, 14);
+ }
+ code = afs_CheckCode(code, treq, 14);
+ afs_DestroyReq(treq);
return code;
}
afs_ucred_t *acred)
#endif
{
- struct vrequest treq;
+ struct vrequest *treq = NULL;
struct AFSStoreStatus astat;
afs_int32 code;
#if defined(AFS_FBSD_ENV) || defined(AFS_DFBSD_ENV)
ICL_HANDLE_OFFSET(attrs->va_size), ICL_TYPE_OFFSET,
ICL_HANDLE_OFFSET(avc->f.m.Length));
#endif
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred)))
return code;
AFS_DISCON_LOCK();
afs_InitFakeStat(&fakestate);
- code = afs_EvalFakeStat(&avc, &fakestate, &treq);
+ code = afs_EvalFakeStat(&avc, &fakestate, treq);
if (code)
goto done;
#else
if (attrs->va_size != ~0) {
#endif
- if (!afs_AccessOK(avc, PRSFS_WRITE, &treq, DONT_CHECK_MODE_BITS)) {
+ if (!afs_AccessOK(avc, PRSFS_WRITE, treq, DONT_CHECK_MODE_BITS)) {
code = EACCES;
goto done;
}
if (AFS_IS_DISCONNECTED && tsize >=avc->f.m.Length) {
/* If we're growing the file, and we're disconnected, we need
* to make the relevant dcache chunks appear ourselves. */
- code = afs_ExtendSegments(avc, tsize, &treq);
+ code = afs_ExtendSegments(avc, tsize, treq);
} else {
- code = afs_TruncateAllSegments(avc, tsize, &treq, acred);
+ code = afs_TruncateAllSegments(avc, tsize, treq, acred);
}
#ifdef AFS_LINUX26_ENV
/* We must update the Linux kernel's idea of file size as soon as
/* Store files now if not disconnected. */
/* XXX: AFS_IS_DISCON_RW handled. */
if (!AFS_IS_DISCONNECTED) {
- code = afs_StoreAllSegments(avc, &treq, AFS_ASYNC);
+ code = afs_StoreAllSegments(avc, treq, AFS_ASYNC);
if (!code)
avc->f.states &= ~CDirty;
}
if (!AFS_IS_DISCONNECTED) {
if (code == 0) {
ObtainSharedLock(&avc->lock, 16); /* lock entry */
- code = afs_WriteVCache(avc, &astat, &treq); /* send request */
+ code = afs_WriteVCache(avc, &astat, treq); /* send request */
ReleaseSharedLock(&avc->lock); /* release lock */
}
if (code) {
afs_PutFakeStat(&fakestate);
AFS_DISCON_UNLOCK();
- code = afs_CheckCode(code, &treq, 15);
+ code = afs_CheckCode(code, treq, 15);
+ afs_DestroyReq(treq);
return code;
}
#endif /* AFS_SGI64_ENV */
{
afs_int32 origCBs, origZaps, finalZaps;
- struct vrequest treq;
+ struct vrequest *treq = NULL;
afs_int32 code;
struct afs_conn *tc;
struct VenusFid newFid;
OutFidStatus = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
OutDirStatus = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred)))
goto done2;
afs_Trace3(afs_iclSetp, CM_TRACE_CREATE, ICL_TYPE_POINTER, adp,
}
AFS_DISCON_LOCK();
- code = afs_EvalFakeStat(&adp, &fakestate, &treq);
+ code = afs_EvalFakeStat(&adp, &fakestate, treq);
if (code)
goto done;
tagain:
- code = afs_VerifyVCache(adp, &treq);
+ code = afs_VerifyVCache(adp, treq);
if (code)
goto done;
goto done;
}
- tdc = afs_GetDCache(adp, (afs_size_t) 0, &treq, &offset, &len, 1);
+ tdc = afs_GetDCache(adp, (afs_size_t) 0, treq, &offset, &len, 1);
ObtainWriteLock(&adp->lock, 135);
if (tdc)
ObtainSharedLock(&tdc->lock, 630);
newFid.Fid.Volume = adp->f.fid.Fid.Volume;
tvc = NULL;
if (newFid.Fid.Unique == 0) {
- tvc = afs_LookupVCache(&newFid, &treq, NULL, adp, aname);
+ tvc = afs_LookupVCache(&newFid, treq, NULL, adp, aname);
}
if (!tvc) /* lookup failed or wasn't called */
- tvc = afs_GetVCache(&newFid, &treq, NULL, NULL);
+ tvc = afs_GetVCache(&newFid, treq, NULL, NULL);
if (tvc) {
/* if the thing exists, we need the right access to open it.
* has mode -w-w-w, which is wrong.
*/
if ((amode & VREAD)
- && !afs_AccessOK(tvc, PRSFS_READ, &treq, CHECK_MODE_BITS)) {
+ && !afs_AccessOK(tvc, PRSFS_READ, treq, CHECK_MODE_BITS)) {
afs_PutVCache(tvc);
code = EACCES;
goto done;
tvc->f.parent.unique = adp->f.fid.Fid.Unique;
/* need write mode for these guys */
if (!afs_AccessOK
- (tvc, PRSFS_WRITE, &treq, CHECK_MODE_BITS)) {
+ (tvc, PRSFS_WRITE, treq, CHECK_MODE_BITS)) {
afs_PutVCache(tvc);
code = EACCES;
goto done;
InStatus.UnixModeBits = attrs->va_mode & 0xffff; /* only care about protection bits */
do {
- tc = afs_Conn(&adp->f.fid, &treq, SHARED_LOCK, &rxconn);
+ tc = afs_Conn(&adp->f.fid, treq, SHARED_LOCK, &rxconn);
if (tc) {
hostp = tc->parent->srvr->server; /* remember for callback processing */
now = osi_Time();
} else
code = -1;
} while (afs_Analyze
- (tc, rxconn, code, &adp->f.fid, &treq, AFS_STATS_FS_RPCIDX_CREATEFILE,
+ (tc, rxconn, code, &adp->f.fid, treq, AFS_STATS_FS_RPCIDX_CREATEFILE,
SHARED_LOCK, NULL));
if ((code == EEXIST || code == UAEEXIST) &&
ReleaseWriteLock(&afs_xcbhash);
if (AFS_IS_DISCON_RW) {
afs_DisconAddDirty(tvc, VDisconCreate, 0);
- afs_GenDisconStatus(adp, tvc, &newFid, attrs, &treq, VREG);
+ afs_GenDisconStatus(adp, tvc, &newFid, attrs, treq, VREG);
} else {
- afs_ProcessFS(tvc, OutFidStatus, &treq);
+ afs_ProcessFS(tvc, OutFidStatus, treq);
}
tvc->f.parent.vnode = adp->f.fid.Fid.Vnode;
}
afs_PutFakeStat(&fakestate);
- code = afs_CheckCode(code, &treq, 20);
+ code = afs_CheckCode(code, treq, 20);
+ afs_DestroyReq(treq);
done2:
osi_FreeSmallSpace(OutFidStatus);
afs_mkdir(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
struct vcache **avcp, afs_ucred_t *acred)
{
- struct vrequest treq;
+ struct vrequest *treq = NULL;
afs_int32 code;
struct afs_conn *tc;
struct rx_connection *rxconn;
OutFidStatus = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
OutDirStatus = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred)))
goto done2;
afs_InitFakeStat(&fakestate);
AFS_DISCON_LOCK();
- code = afs_EvalFakeStat(&adp, &fakestate, &treq);
+ code = afs_EvalFakeStat(&adp, &fakestate, treq);
if (code)
goto done;
- code = afs_VerifyVCache(adp, &treq);
+ code = afs_VerifyVCache(adp, treq);
if (code)
goto done;
InStatus.ClientModTime = osi_Time();
InStatus.UnixModeBits = attrs->va_mode & 0xffff; /* only care about protection bits */
InStatus.Group = (afs_int32) afs_cr_gid(acred);
- tdc = afs_GetDCache(adp, (afs_size_t) 0, &treq, &offset, &len, 1);
+ tdc = afs_GetDCache(adp, (afs_size_t) 0, treq, &offset, &len, 1);
ObtainWriteLock(&adp->lock, 153);
if (!AFS_IS_DISCON_RW) {
do {
- tc = afs_Conn(&adp->f.fid, &treq, SHARED_LOCK, &rxconn);
+ tc = afs_Conn(&adp->f.fid, treq, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_MAKEDIR);
now = osi_Time();
} else
code = -1;
} while (afs_Analyze
- (tc, rxconn, code, &adp->f.fid, &treq, AFS_STATS_FS_RPCIDX_MAKEDIR,
+ (tc, rxconn, code, &adp->f.fid, treq, AFS_STATS_FS_RPCIDX_MAKEDIR,
SHARED_LOCK, NULL));
if (code) {
}
ObtainWriteLock(&tvc->lock, 738);
- afs_GenDisconStatus(adp, tvc, &newFid, attrs, &treq, VDIR);
+ afs_GenDisconStatus(adp, tvc, &newFid, attrs, treq, VDIR);
ReleaseWriteLock(&tvc->lock);
/* And now make an empty dir, containing . and .. : */
/* Get a new dcache for it first. */
- new_dc = afs_GetDCache(tvc, (afs_size_t) 0, &treq, &offset, &len, 1);
+ new_dc = afs_GetDCache(tvc, (afs_size_t) 0, treq, &offset, &len, 1);
if (!new_dc) {
/* printf("afs_mkdir: can't get new dcache for dir.\n"); */
code = ENOENT;
ReleaseWriteLock(&tvc->lock);
} else {
/* now we're done with parent dir, create the real dir's cache entry */
- tvc = afs_GetVCache(&newFid, &treq, NULL, NULL);
+ tvc = afs_GetVCache(&newFid, treq, NULL, NULL);
if (tvc) {
code = 0;
*avcp = tvc;
AFS_DISCON_UNLOCK();
done3:
afs_PutFakeStat(&fakestate);
- code = afs_CheckCode(code, &treq, 26);
+ code = afs_CheckCode(code, treq, 26);
+ afs_DestroyReq(treq);
done2:
osi_FreeSmallSpace(OutFidStatus);
osi_FreeSmallSpace(OutDirStatus);
afs_rmdir(OSI_VC_DECL(adp), char *aname, afs_ucred_t *acred)
#endif
{
- struct vrequest treq;
+ struct vrequest *treq = NULL;
struct dcache *tdc;
struct vcache *tvc = NULL;
afs_int32 code;
afs_Trace2(afs_iclSetp, CM_TRACE_RMDIR, ICL_TYPE_POINTER, adp,
ICL_TYPE_STRING, aname);
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred)))
goto done2;
afs_InitFakeStat(&fakestate);
AFS_DISCON_LOCK();
- code = afs_EvalFakeStat(&adp, &fakestate, &treq);
+ code = afs_EvalFakeStat(&adp, &fakestate, treq);
if (code)
goto done;
- code = afs_VerifyVCache(adp, &treq);
+ code = afs_VerifyVCache(adp, treq);
if (code)
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, 154);
if (tdc)
ObtainSharedLock(&tdc->lock, 633);
unlinkFid.Fid.Volume = adp->f.fid.Fid.Volume;
if (unlinkFid.Fid.Unique == 0) {
tvc =
- afs_LookupVCache(&unlinkFid, &treq, &cached, adp, aname);
+ afs_LookupVCache(&unlinkFid, treq, &cached, adp, aname);
} else {
ObtainReadLock(&afs_xvcache);
tvc = afs_FindVCache(&unlinkFid, 0, 1 /* do xstats */ );
if (!AFS_IS_DISCON_RW) {
/* Not disconnected, can connect to server. */
do {
- tc = afs_Conn(&adp->f.fid, &treq, SHARED_LOCK, &rxconn);
+ tc = afs_Conn(&adp->f.fid, treq, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_REMOVEDIR);
RX_AFS_GUNLOCK();
} else
code = -1;
} while (afs_Analyze
- (tc, rxconn, code, &adp->f.fid, &treq, AFS_STATS_FS_RPCIDX_REMOVEDIR,
+ (tc, rxconn, code, &adp->f.fid, treq, AFS_STATS_FS_RPCIDX_REMOVEDIR,
SHARED_LOCK, NULL));
if (code) {
done:
AFS_DISCON_UNLOCK();
afs_PutFakeStat(&fakestate);
- code = afs_CheckCode(code, &treq, 27);
+ code = afs_CheckCode(code, treq, 27);
+ afs_DestroyReq(treq);
done2:
return code;
}
afs_ucred_t * acred)
#endif
{
- struct vrequest treq;
+ struct vrequest *treq = NULL;
afs_int32 code;
struct afs_fakestat_state fakestate;
AFS_STATCNT(afs_lockctl);
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred)))
return code;
afs_InitFakeStat(&fakestate);
AFS_DISCON_LOCK();
- code = afs_EvalFakeStat(&avc, &fakestate, &treq);
+ code = afs_EvalFakeStat(&avc, &fakestate, treq);
if (code) {
goto done;
}
code = 0;
goto done;
}
- code = HandleGetLock(avc, af, &treq, clid);
- code = afs_CheckCode(code, &treq, 2); /* defeat buggy AIX optimz */
+ code = HandleGetLock(avc, af, treq, clid);
+ code = afs_CheckCode(code, treq, 2); /* defeat buggy AIX optimz */
goto done;
} else if ((acmd == F_SETLK) || (acmd == F_SETLKW)
#if defined(AFS_SGI_ENV)
) && code != LOCK_UN)
code |= LOCK_NB; /* non-blocking, s.v.p. */
#if defined(AFS_DARWIN_ENV)
- code = HandleFlock(avc, code, &treq, clid, 0 /*!onlymine */ );
+ code = HandleFlock(avc, code, treq, clid, 0 /*!onlymine */ );
#elif defined(AFS_SGI_ENV)
AFS_RWLOCK((vnode_t *) avc, VRWLOCK_WRITE);
- code = HandleFlock(avc, code, &treq, clid, 0 /*!onlymine */ );
+ code = HandleFlock(avc, code, treq, clid, 0 /*!onlymine */ );
AFS_RWUNLOCK((vnode_t *) avc, VRWLOCK_WRITE);
#else
- code = HandleFlock(avc, code, &treq, 0, 0 /*!onlymine */ );
+ code = HandleFlock(avc, code, treq, 0, 0 /*!onlymine */ );
#endif
- code = afs_CheckCode(code, &treq, 3); /* defeat AIX -O bug */
+ code = afs_CheckCode(code, treq, 3); /* defeat AIX -O bug */
goto done;
}
code = EINVAL;
done:
afs_PutFakeStat(&fakestate);
AFS_DISCON_UNLOCK();
+ afs_DestroyReq(treq);
return code;
}
afs_ucred_t *acred)
#endif
{
- struct vrequest treq;
+ struct vrequest *treq = NULL;
struct dcache *tdc;
afs_int32 code;
struct afs_conn *tc;
OutDirStatus = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
/* create a hard link; new entry is aname in dir adp */
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred)))
goto done2;
afs_InitFakeStat(&vfakestate);
AFS_DISCON_LOCK();
- code = afs_EvalFakeStat(&avc, &vfakestate, &treq);
+ code = afs_EvalFakeStat(&avc, &vfakestate, treq);
if (code)
goto done;
- code = afs_EvalFakeStat(&adp, &dfakestate, &treq);
+ code = afs_EvalFakeStat(&adp, &dfakestate, treq);
if (code)
goto done;
code = ENAMETOOLONG;
goto done;
}
- code = afs_VerifyVCache(adp, &treq);
+ code = afs_VerifyVCache(adp, treq);
if (code)
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, 145);
do {
- tc = afs_Conn(&adp->f.fid, &treq, SHARED_LOCK, &rxconn);
+ tc = afs_Conn(&adp->f.fid, treq, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_LINK);
RX_AFS_GUNLOCK();
} else
code = -1;
} while (afs_Analyze
- (tc, rxconn, code, &adp->f.fid, &treq, AFS_STATS_FS_RPCIDX_LINK,
+ (tc, rxconn, code, &adp->f.fid, treq, AFS_STATS_FS_RPCIDX_LINK,
SHARED_LOCK, NULL));
if (code) {
ReleaseWriteLock(&avc->lock);
code = 0;
done:
- code = afs_CheckCode(code, &treq, 24);
+ code = afs_CheckCode(code, treq, 24);
+ afs_DestroyReq(treq);
afs_PutFakeStat(&vfakestate);
afs_PutFakeStat(&dfakestate);
AFS_DISCON_UNLOCK();
afs_lookup(OSI_VC_DECL(adp), char *aname, struct vcache **avcp, afs_ucred_t *acred)
#endif
{
- struct vrequest treq;
+ struct vrequest *treq = NULL;
char *tname = NULL;
struct vcache *tvc = 0;
afs_int32 code;
afs_InitFakeStat(&fakestate);
AFS_DISCON_LOCK();
-
- if ((code = afs_InitReq(&treq, acred)))
+
+ if ((code = afs_CreateReq(&treq, acred)))
goto done;
if (afs_fakestat_enable && adp->mvstat == 1) {
#endif
if (tryEvalOnly)
- code = afs_TryEvalFakeStat(&adp, &fakestate, &treq);
+ code = afs_TryEvalFakeStat(&adp, &fakestate, treq);
else
- code = afs_EvalFakeStat(&adp, &fakestate, &treq);
+ code = afs_EvalFakeStat(&adp, &fakestate, treq);
/*printf("Code is %d\n", code);*/
bulkcode = 0;
if (!(adp->f.states & CStatd) && !afs_InReadDir(adp)) {
- if ((code = afs_VerifyVCache2(adp, &treq))) {
+ if ((code = afs_VerifyVCache2(adp, treq))) {
goto done;
}
} else
}
/* otherwise we have the fid here, so we use it */
/*printf("Getting vcache\n");*/
- tvc = afs_GetVCache(adp->mvid, &treq, NULL, NULL);
+ tvc = afs_GetVCache(adp->mvid, treq, NULL, NULL);
afs_Trace3(afs_iclSetp, CM_TRACE_GETVCDOTDOT, ICL_TYPE_FID, adp->mvid,
ICL_TYPE_POINTER, tvc, ICL_TYPE_INT32, code);
*avcp = tvc;
}
/* now check the access */
- if (treq.uid != adp->last_looker) {
- if (!afs_AccessOK(adp, PRSFS_LOOKUP, &treq, CHECK_MODE_BITS)) {
+ if (treq->uid != adp->last_looker) {
+ if (!afs_AccessOK(adp, PRSFS_LOOKUP, treq, CHECK_MODE_BITS)) {
*avcp = NULL;
code = EACCES;
goto done;
} else
- adp->last_looker = treq.uid;
+ adp->last_looker = treq->uid;
}
/* Check for read access as well. We need read access in order to
* stat files, but not to stat subdirectories. */
- if (!afs_AccessOK(adp, PRSFS_READ, &treq, CHECK_MODE_BITS))
+ if (!afs_AccessOK(adp, PRSFS_READ, treq, CHECK_MODE_BITS))
no_read_access = 1;
/* special case lookup of ".". Can we check for it sooner in this code,
struct VenusFid tfid;
afs_uint32 cellidx, volid, vnoid, uniq;
- code = EvalMountData('%', aname, 0, 0, NULL, &treq, &cellidx, &volid, &vnoid, &uniq);
+ code = EvalMountData('%', aname, 0, 0, NULL, treq, &cellidx, &volid, &vnoid, &uniq);
if (code)
goto done;
/* If a vnode was returned, it's not a real mount point */
tfid.Fid.Vnode = VNUM_FROM_TYPEID(VN_TYPE_MOUNT, cellidx << 2);
tfid.Fid.Unique = volid;
}
- *avcp = tvc = afs_GetVCache(&tfid, &treq, NULL, NULL);
+ *avcp = tvc = afs_GetVCache(&tfid, treq, NULL, NULL);
code = (tvc ? 0 : ENOENT);
hit = 1;
goto done;
struct VenusFid tfid;
afs_GetDynrootMountFid(&tfid);
- *avcp = tvc = afs_GetVCache(&tfid, &treq, NULL, NULL);
+ *avcp = tvc = afs_GetVCache(&tfid, treq, NULL, NULL);
code = 0;
hit = 1;
goto done;
}
#endif
- Check_AtSys(adp, aname, &sysState, &treq);
+ Check_AtSys(adp, aname, &sysState, treq);
tname = sysState.name;
/* 1st Check_AtSys and lookup by tname is required here, for now,
if (afs_InReadDir(adp))
tdc = adp->dcreaddir;
else
- tdc = afs_GetDCache(adp, (afs_size_t) 0, &treq,
+ tdc = afs_GetDCache(adp, (afs_size_t) 0, treq,
&dirOffset, &dirLen, 1);
if (!tdc) {
*avcp = NULL; /* redundant, but harmless */
&dirCookie);
/* If the first lookup doesn't succeed, maybe it's got @sys in the name */
- while (code == ENOENT && Next_AtSys(adp, &treq, &sysState))
+ while (code == ENOENT && Next_AtSys(adp, treq, &sysState))
code =
afs_dir_LookupOffset(tdc, sysState.name, &tfid.Fid,
&dirCookie);
} while (tvc && retry);
if (!tvc || !(tvc->f.states & CStatd))
- bulkcode = afs_DoBulkStat(adp, dirCookie, &treq);
+ bulkcode = afs_DoBulkStat(adp, dirCookie, treq);
else
bulkcode = 0;
if (!tvc) {
afs_int32 cached = 0;
if (!tfid.Fid.Unique && (adp->f.states & CForeign)) {
- tvc = afs_LookupVCache(&tfid, &treq, &cached, adp, tname);
+ tvc = afs_LookupVCache(&tfid, treq, &cached, adp, tname);
}
if (!tvc && !bulkcode) { /* lookup failed or wasn't called */
- tvc = afs_GetVCache(&tfid, &treq, &cached, NULL);
+ tvc = afs_GetVCache(&tfid, treq, &cached, NULL);
}
} /* if !tvc */
} /* sub-block just to reduce stack usage */
ObtainSharedLock(&tvc->lock, 680);
if (!tvc->linkData) {
UpgradeSToWLock(&tvc->lock, 681);
- code = afs_HandleLink(tvc, &treq);
+ code = afs_HandleLink(tvc, treq);
ConvertWToRLock(&tvc->lock);
} else {
ConvertSToRLock(&tvc->lock);
struct volume *tvolp;
ObtainWriteLock(&tvc->lock, 133);
- code = EvalMountPoint(tvc, adp, &tvolp, &treq);
+ code = EvalMountPoint(tvc, adp, &tvolp, treq);
ReleaseWriteLock(&tvc->lock);
if (code) {
if (tvolp && (tvolp->states & VForeign)) {
/* XXXX tvolp has ref cnt on but not locked! XXX */
tvc =
- afs_GetRootVCache(tvc->mvid, &treq, NULL, tvolp);
+ afs_GetRootVCache(tvc->mvid, treq, NULL, tvolp);
} else {
- tvc = afs_GetVCache(tvc->mvid, &treq, NULL, NULL);
+ tvc = afs_GetVCache(tvc->mvid, treq, NULL, NULL);
}
afs_PutVCache(uvc); /* we're done with it */
if (!AFS_IS_DISCONNECTED) {
if (pass == 0) {
struct volume *tv;
- tv = afs_GetVolume(&adp->f.fid, &treq, READ_LOCK);
+ tv = afs_GetVolume(&adp->f.fid, treq, READ_LOCK);
if (tv) {
if (tv->states & VRO) {
pass = 1; /* try this *once* */
} else {
#ifdef AFS_LINUX20_ENV
/* So Linux inode cache is up to date. */
- code = afs_VerifyVCache(tvc, &treq);
+ code = afs_VerifyVCache(tvc, treq);
#else
afs_PutFakeStat(&fakestate);
AFS_DISCON_UNLOCK();
if (bulkcode)
code = bulkcode;
- code = afs_CheckCode(code, &treq, 19);
+ code = afs_CheckCode(code, treq, 19);
if (code) {
/* If there is an error, make sure *avcp is null.
* Alphas panic otherwise - defect 10719.
}
afs_PutFakeStat(&fakestate);
+ afs_DestroyReq(treq);
AFS_DISCON_UNLOCK();
return code;
}
#endif
{
afs_int32 code;
- struct vrequest treq;
+ struct vrequest *treq = NULL;
struct vcache *tvc;
int writing;
struct afs_fakestat_state fakestate;
AFS_STATCNT(afs_open);
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred)))
return code;
#ifdef AFS_SGI64_ENV
/* avcpp can be, but is not necesarily, bhp's vnode. */
AFS_DISCON_LOCK();
- code = afs_EvalFakeStat(&tvc, &fakestate, &treq);
+ code = afs_EvalFakeStat(&tvc, &fakestate, treq);
if (code)
goto done;
- code = afs_VerifyVCache(tvc, &treq);
+ code = afs_VerifyVCache(tvc, treq);
if (code)
goto done;
} else {
if (!afs_AccessOK
(tvc, ((tvc->f.states & CForeign) ? PRSFS_READ : PRSFS_LOOKUP),
- &treq, CHECK_MODE_BITS)) {
+ treq, CHECK_MODE_BITS)) {
code = EACCES;
/* printf("afs_Open: no access for dir\n"); */
goto done;
#ifdef AFS_SUN5_ENV
if (AFS_NFSXLATORREQ(acred) && (aflags & FREAD)) {
if (!afs_AccessOK
- (tvc, PRSFS_READ, &treq,
+ (tvc, PRSFS_READ, treq,
CHECK_MODE_BITS | CMB_ALLOW_EXEC_AS_READ)) {
code = EACCES;
goto done;
struct dcache *tdc;
afs_size_t offset, len;
- tdc = afs_GetDCache(tvc, 0, &treq, &offset, &len, 1);
+ tdc = afs_GetDCache(tvc, 0, treq, &offset, &len, 1);
if (tdc) {
ObtainSharedLock(&tdc->mflock, 865);
if (!(tdc->mflags & DFFetchReq)) {
afs_PutFakeStat(&fakestate);
AFS_DISCON_UNLOCK();
- code = afs_CheckCode(code, &treq, 4); /* avoid AIX -O bug */
+ code = afs_CheckCode(code, treq, 4); /* avoid AIX -O bug */
+ afs_DestroyReq(treq);
afs_Trace2(afs_iclSetp, CM_TRACE_OPEN, ICL_TYPE_POINTER, tvc,
ICL_TYPE_INT32, 999999);
afs_int32 error, trybusy = 1;
struct uio *tuiop = NULL;
afs_int32 code;
- struct vrequest treq;
+ struct vrequest *treq = NULL;
AFS_STATCNT(afs_read);
AFS_DISCON_LOCK();
/* check that we have the latest status info in the vnode cache */
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred)))
goto out;
if (!noLock) {
if (!avc)
osi_Panic("null avc in afs_GenericRead");
- code = afs_VerifyVCache(avc, &treq);
+ code = afs_VerifyVCache(avc, treq);
if (code) {
- code = afs_CheckCode(code, &treq, 8); /* failed to get it */
+ code = afs_CheckCode(code, treq, 8); /* failed to get it */
goto out;
}
}
#ifndef AFS_VM_RDWR_ENV
if (AFS_NFSXLATORREQ(acred)) {
if (!afs_AccessOK
- (avc, PRSFS_READ, &treq,
+ (avc, PRSFS_READ, treq,
CHECK_MODE_BITS | CMB_ALLOW_EXEC_AS_READ)) {
- code = afs_CheckCode(EACCES, &treq, 9);
+ code = afs_CheckCode(EACCES, treq, 9);
goto out;
}
}
ReleaseReadLock(&tdc->lock);
afs_PutDCache(tdc); /* before reusing tdc */
}
- tdc = afs_GetDCache(avc, filePos, &treq, &offset, &len, 2);
+ tdc = afs_GetDCache(avc, filePos, treq, &offset, &len, 2);
if (!tdc) {
error = ENETDOWN;
break;
* does the FetchData rpc synchronously.
*/
ReleaseReadLock(&avc->lock);
- tdc = afs_GetDCache(avc, filePos, &treq, &offset, &len, 1);
+ tdc = afs_GetDCache(avc, filePos, treq, &offset, &len, 1);
ObtainReadLock(&avc->lock);
if (tdc)
ObtainReadLock(&tdc->lock);
/* try to queue prefetch, if needed */
if (!noLock) {
if (!(tdc->mflags &DFNextStarted))
- afs_PrefetchChunk(avc, tdc, acred, &treq);
+ afs_PrefetchChunk(avc, tdc, acred, treq);
}
#endif
afs_PutDCache(tdc);
if (!noLock)
ReleaseReadLock(&avc->lock);
- code = afs_CheckCode(error, &treq, 10);
+ code = afs_CheckCode(error, treq, 10);
if (tuiop)
afsio_free(tuiop);
out:
AFS_DISCON_UNLOCK();
+ afs_DestroyReq(treq);
return code;
}
#endif
#endif
{
- struct vrequest treq;
+ struct vrequest *treq = NULL;
struct dcache *tdc;
afs_size_t origOffset, tlen;
afs_int32 len;
return EFBIG;
#endif
- if ((code = afs_InitReq(&treq, acred))) {
+ if ((code = afs_CreateReq(&treq, acred))) {
#ifdef AFS_HPUX_ENV
osi_FreeSmallSpace((char *)sdirEntry);
#endif
AFS_DISCON_LOCK();
- code = afs_EvalFakeStat(&avc, &fakestate, &treq);
+ code = afs_EvalFakeStat(&avc, &fakestate, treq);
if (code)
goto done;
tagain:
- code = afs_VerifyVCache(avc, &treq);
+ code = afs_VerifyVCache(avc, treq);
if (code)
goto done;
/* get a reference to the entire directory */
- tdc = afs_GetDCache(avc, (afs_size_t) 0, &treq, &origOffset, &tlen, 1);
+ tdc = afs_GetDCache(avc, (afs_size_t) 0, treq, &origOffset, &tlen, 1);
if (!tdc) {
code = ENOENT;
goto done;
#endif
AFS_DISCON_UNLOCK();
afs_PutFakeStat(&fakestate);
- code = afs_CheckCode(code, &treq, 28);
+ code = afs_CheckCode(code, treq, 28);
+ afs_DestroyReq(treq);
return code;
}
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;
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);
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))) {
+ struct vrequest *treq = NULL;
+
+ if ((code = afs_CreateReq(&treq, avc->uncred))) {
ReleaseWriteLock(&avc->lock);
} else {
/* Must bump the refCount because GetVCache may block.
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)
afs_int32 code;
struct afs_fakestat_state ofakestate;
struct afs_fakestat_state nfakestate;
- struct vrequest treq;
+ struct vrequest *treq = NULL;
OSI_VC_CONVERT(aodp);
- code = afs_InitReq(&treq, acred);
+ code = afs_CreateReq(&treq, acred);
if (code)
return code;
+
afs_InitFakeStat(&ofakestate);
afs_InitFakeStat(&nfakestate);
AFS_DISCON_LOCK();
- code = afs_EvalFakeStat(&aodp, &ofakestate, &treq);
+ code = afs_EvalFakeStat(&aodp, &ofakestate, treq);
if (code)
goto done;
- code = afs_EvalFakeStat(&andp, &nfakestate, &treq);
+ code = afs_EvalFakeStat(&andp, &nfakestate, treq);
if (code)
goto done;
- code = afsrename(aodp, aname1, andp, aname2, acred, &treq);
+ code = afsrename(aodp, aname1, andp, aname2, acred, treq);
done:
afs_PutFakeStat(&ofakestate);
afs_PutFakeStat(&nfakestate);
AFS_DISCON_UNLOCK();
- code = afs_CheckCode(code, &treq, 25);
+ code = afs_CheckCode(code, treq, 25);
+ afs_DestroyReq(treq);
return code;
}
char *atargetName, struct vcache **tvcp, afs_ucred_t *acred)
{
afs_uint32 now = 0;
- struct vrequest treq;
+ struct vrequest *treq = NULL;
afs_int32 code = 0;
struct afs_conn *tc;
struct VenusFid newFid;
OutFidStatus = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
OutDirStatus = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred)))
goto done2;
afs_InitFakeStat(&fakestate);
AFS_DISCON_LOCK();
- code = afs_EvalFakeStat(&adp, &fakestate, &treq);
+ code = afs_EvalFakeStat(&adp, &fakestate, treq);
if (code)
goto done;
goto done;
}
- code = afs_VerifyVCache(adp, &treq);
+ code = afs_VerifyVCache(adp, treq);
if (code) {
- code = afs_CheckCode(code, &treq, 30);
+ code = afs_CheckCode(code, treq, 30);
goto done;
}
InStatus.UnixModeBits = 0755;
alen++; /* add in the null */
}
- tdc = afs_GetDCache(adp, (afs_size_t) 0, &treq, &offset, &len, 1);
+ tdc = afs_GetDCache(adp, (afs_size_t) 0, treq, &offset, &len, 1);
volp = afs_FindVolume(&adp->f.fid, READ_LOCK); /*parent is also in same vol */
ObtainWriteLock(&adp->lock, 156);
if (tdc)
* the copy will be invalidated */
if (!AFS_IS_DISCON_RW) {
do {
- tc = afs_Conn(&adp->f.fid, &treq, SHARED_LOCK, &rxconn);
+ tc = afs_Conn(&adp->f.fid, treq, SHARED_LOCK, &rxconn);
if (tc) {
hostp = tc->parent->srvr->server;
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_SYMLINK);
} else
code = -1;
} while (afs_Analyze
- (tc, rxconn, code, &adp->f.fid, &treq, AFS_STATS_FS_RPCIDX_SYMLINK,
+ (tc, rxconn, code, &adp->f.fid, treq, AFS_STATS_FS_RPCIDX_SYMLINK,
SHARED_LOCK, NULL));
} else {
newFid.Cell = adp->f.fid.Cell;
if (AFS_IS_DISCON_RW) {
attrs->va_mode = InStatus.UnixModeBits;
- afs_GenDisconStatus(adp, tvc, &newFid, attrs, &treq, VLNK);
- code = afs_DisconCreateSymlink(tvc, atargetName, &treq);
+ afs_GenDisconStatus(adp, tvc, &newFid, attrs, treq, VLNK);
+ code = afs_DisconCreateSymlink(tvc, atargetName, treq);
if (code) {
/* XXX - When this goes wrong, we need to tidy up the changes we made to
* the parent, and get rid of the vcache we just created */
}
afs_DisconAddDirty(tvc, VDisconCreate, 0);
} else {
- afs_ProcessFS(tvc, OutFidStatus, &treq);
+ afs_ProcessFS(tvc, OutFidStatus, treq);
}
if (!tvc->linkData) {
if (volp)
afs_PutVolume(volp, READ_LOCK);
AFS_DISCON_UNLOCK();
- code = afs_CheckCode(code, &treq, 31);
+ code = afs_CheckCode(code, treq, 31);
+ afs_DestroyReq(treq);
done2:
osi_FreeSmallSpace(OutFidStatus);
osi_FreeSmallSpace(OutDirStatus);
afs_readlink(OSI_VC_DECL(avc), struct uio *auio, afs_ucred_t *acred)
{
afs_int32 code;
- struct vrequest treq;
+ struct vrequest *treq = NULL;
char *tp;
struct afs_fakestat_state fakestat;
OSI_VC_CONVERT(avc);
AFS_STATCNT(afs_readlink);
afs_Trace1(afs_iclSetp, CM_TRACE_READLINK, ICL_TYPE_POINTER, avc);
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred)))
return code;
afs_InitFakeStat(&fakestat);
AFS_DISCON_LOCK();
- code = afs_EvalFakeStat(&avc, &fakestat, &treq);
+ code = afs_EvalFakeStat(&avc, &fakestat, treq);
if (code)
goto done;
- code = afs_VerifyVCache(avc, &treq);
+ code = afs_VerifyVCache(avc, treq);
if (code)
goto done;
if (vType(avc) != VLNK) {
goto done;
}
ObtainWriteLock(&avc->lock, 158);
- code = afs_HandleLink(avc, &treq);
+ code = afs_HandleLink(avc, treq);
/* finally uiomove it to user-land */
if (code == 0) {
tp = avc->linkData;
done:
afs_PutFakeStat(&fakestat);
AFS_DISCON_UNLOCK();
- code = afs_CheckCode(code, &treq, 32);
+ code = afs_CheckCode(code, treq, 32);
+ afs_DestroyReq(treq);
return code;
}
#endif
struct uio *tuiop = NULL;
afs_int32 code;
- struct vrequest treq;
+ struct vrequest *treq = NULL;
AFS_STATCNT(afs_write);
return ENETDOWN;
startDate = osi_Time();
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred)))
return code;
/* otherwise we read */
totalLength = AFS_UIO_RESID(auio);
#endif
if (!noLock)
ReleaseWriteLock(&avc->lock);
+ afs_DestroyReq(treq);
return (EFBIG);
}
#endif
avc->f.states |= CDirty;
while (totalLength > 0) {
- tdc = afs_ObtainDCacheForWriting(avc, filePos, totalLength, &treq,
+ tdc = afs_ObtainDCacheForWriting(avc, filePos, totalLength, treq,
noLock);
if (!tdc) {
error = EIO;
#else
if (filePos > avc->f.m.Length) {
if (AFS_IS_DISCON_RW)
- afs_PopulateDCache(avc, filePos, &treq);
+ afs_PopulateDCache(avc, filePos, treq);
afs_Trace4(afs_iclSetp, CM_TRACE_SETLENGTH, ICL_TYPE_STRING,
__FILE__, ICL_TYPE_LONG, __LINE__, ICL_TYPE_OFFSET,
ICL_HANDLE_OFFSET(avc->f.m.Length), ICL_TYPE_OFFSET,
* the high-level write op.
*/
if (!noLock) {
- code = afs_DoPartialWrite(avc, &treq);
+ code = afs_DoPartialWrite(avc, treq);
if (code) {
error = code;
break;
#if !defined(AFS_VM_RDWR_ENV) || defined(AFS_FAKEOPEN_ENV)
afs_FakeClose(avc, acred);
#endif
- error = afs_CheckCode(error, &treq, 7);
+ error = afs_CheckCode(error, treq, 7);
/* This set is here so we get the CheckCode. */
if (error && !avc->vc_error)
avc->vc_error = error;
afs_fsync(avc, acred);
}
#endif
+ afs_DestroyReq(treq);
return error;
}
afs_int32 code;
afs_int32 code_checkcode = 0;
struct brequest *tb;
- struct vrequest treq;
+ struct vrequest *treq = NULL;
#ifdef AFS_SGI65_ENV
struct flid flid;
#endif
AFS_STATCNT(afs_close);
afs_Trace2(afs_iclSetp, CM_TRACE_CLOSE, ICL_TYPE_POINTER, avc,
ICL_TYPE_INT32, aflags);
- code = afs_InitReq(&treq, acred);
+ code = afs_CreateReq(&treq, acred);
if (code)
return code;
afs_InitFakeStat(&fakestat);
- code = afs_EvalFakeStat(&avc, &fakestat, &treq);
+ code = afs_EvalFakeStat(&avc, &fakestat, treq);
if (code) {
afs_PutFakeStat(&fakestat);
+ afs_DestroyReq(treq);
return code;
}
AFS_DISCON_LOCK();
#ifdef AFS_SUN5_ENV
if (avc->flockCount) {
- HandleFlock(avc, LOCK_UN, &treq, 0, 1 /*onlymine */ );
+ HandleFlock(avc, LOCK_UN, treq, 0, 1 /*onlymine */ );
}
#endif
#if defined(AFS_SGI_ENV)
if (!lastclose) {
afs_PutFakeStat(&fakestat);
AFS_DISCON_UNLOCK();
+ afs_DestroyReq(treq);
return 0;
}
/* unlock any locks for pid - could be wrong for child .. */
# ifdef AFS_SGI65_ENV
get_current_flid(&flid);
cleanlocks((vnode_t *) avc, flid.fl_pid, flid.fl_sysid);
- HandleFlock(avc, LOCK_UN, &treq, flid.fl_pid, 1 /*onlymine */ );
+ HandleFlock(avc, LOCK_UN, treq, flid.fl_pid, 1 /*onlymine */ );
# else
# ifdef AFS_SGI64_ENV
cleanlocks((vnode_t *) avc, flp);
# else /* AFS_SGI64_ENV */
cleanlocks((vnode_t *) avc, u.u_procp->p_epid, u.u_procp->p_sysid);
# endif /* AFS_SGI64_ENV */
- HandleFlock(avc, LOCK_UN, &treq, OSI_GET_CURRENT_PID(), 1 /*onlymine */ );
+ HandleFlock(avc, LOCK_UN, treq, OSI_GET_CURRENT_PID(), 1 /*onlymine */ );
# endif /* AFS_SGI65_ENV */
/* afs_chkpgoob will drop and re-acquire the global lock. */
afs_chkpgoob(&avc->v, btoc(avc->f.m.Length));
* with the close. */
afs_PutFakeStat(&fakestat);
AFS_DISCON_UNLOCK();
+ afs_DestroyReq(treq);
return 0;
}
#else
if (avc->flockCount) { /* Release Lock */
- HandleFlock(avc, LOCK_UN, &treq, 0, 1 /*onlymine */ );
+ HandleFlock(avc, LOCK_UN, treq, 0, 1 /*onlymine */ );
}
#endif
if (aflags & (FWRITE | FTRUNC)) {
if (afs_BBusy() || (AFS_NFSXLATORREQ(acred)) || AFS_IS_DISCONNECTED) {
/* do it yourself if daemons are all busy */
ObtainWriteLock(&avc->lock, 124);
- code = afs_StoreOnLastReference(avc, &treq);
+ code = afs_StoreOnLastReference(avc, treq);
ReleaseWriteLock(&avc->lock);
#if defined(AFS_SGI_ENV)
AFS_RWUNLOCK((vnode_t *) avc, VRWLOCK_WRITE);
if (code_checkcode) {
code = code_checkcode;
} else {
- code = afs_CheckCode(code, &treq, 5);
+ code = afs_CheckCode(code, treq, 5);
}
+ afs_DestroyReq(treq);
return code;
}
#endif
{
afs_int32 code;
- struct vrequest treq;
+ struct vrequest *treq = NULL;
OSI_VC_CONVERT(avc);
if (avc->vc_error)
AFS_STATCNT(afs_fsync);
afs_Trace1(afs_iclSetp, CM_TRACE_FSYNC, ICL_TYPE_POINTER, avc);
- if ((code = afs_InitReq(&treq, acred)))
+ if ((code = afs_CreateReq(&treq, acred)))
return code;
AFS_DISCON_LOCK();
#if defined(AFS_SGI_ENV)
/* put the file back */
UpgradeSToWLock(&avc->lock, 41);
- code = afs_StoreAllSegments(avc, &treq, AFS_SYNC);
+ code = afs_StoreAllSegments(avc, treq, AFS_SYNC);
ConvertWToSLock(&avc->lock);
} else {
UpgradeSToWLock(&avc->lock, 711);
}
#endif
AFS_DISCON_UNLOCK();
- code = afs_CheckCode(code, &treq, 33);
+ code = afs_CheckCode(code, treq, 33);
+ afs_DestroyReq(treq);
ReleaseSharedLock(&avc->lock);
return code;
}
git://git.openafs.org / openafs.git / commitdiff