return code;
thyper.HighPart = 0; thyper.LowPart = 0;
- code = buf_Get(scp, &thyper, reqp, &bufferp);
+ code = buf_Get(scp, &thyper, reqp, 0, &bufferp);
if (code)
return code;
if (code)
goto done;
- if (cm_HaveBuffer(scp, bufferp, 1))
+ if (cm_HaveBuffer(scp, bufferp, 1)) {
+ cm_SyncOpDone(scp, bufferp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ | CM_SCACHESYNC_BUFLOCKED);
break;
+ }
/* otherwise, load the buffer and try again */
lock_ReleaseMutex(&bufferp->mx);
bufferp = NULL;
}
- code = buf_Get(scp, &thyper, reqp, &bufferp);
+ code = buf_Get(scp, &thyper, reqp, 0, &bufferp);
if (code) {
/* if buf_Get() fails we do not have a buffer object to lock */
bufferp = NULL;
*/
long cm_ReadMountPoint(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
{
- long code;
+ long code = 0;
+
+ code = cm_SyncOp(scp, NULL, userp, reqp, 0, CM_SCACHESYNC_FETCHDATA);
+ if (code)
+ return code;
if (scp->mountPointStringp[0] &&
- scp->mpDataVersion == scp->dataVersion)
- return 0;
+ scp->mpDataVersion == scp->dataVersion) {
+ code = 0;
+ goto done;
+ }
#ifdef AFS_FREELANCE_CLIENT
/* File servers do not have data for freelance entries */
{
char temp[MOUNTPOINTLEN];
osi_hyper_t offset;
+ afs_uint32 bytesRead = 0;
/* otherwise, we have to read it in */
offset.LowPart = offset.HighPart = 0;
- code = cm_GetData(scp, &offset, temp, MOUNTPOINTLEN, userp, reqp);
+ code = cm_GetData(scp, &offset, temp, MOUNTPOINTLEN, &bytesRead, userp, reqp);
if (code)
- return code;
+ goto done;
/*
* scp->length is the actual length of the mount point string.
* It is current because cm_GetData merged the most up to date
* status info into scp and has not dropped the rwlock since.
*/
- if (scp->length.LowPart > MOUNTPOINTLEN - 1)
- return CM_ERROR_TOOBIG;
- if (scp->length.LowPart == 0)
- return CM_ERROR_INVAL;
+ if (scp->length.LowPart > MOUNTPOINTLEN - 1) {
+ code = CM_ERROR_TOOBIG;
+ goto done;
+ }
+
+ if (scp->length.LowPart == 0) {
+ code = CM_ERROR_INVAL;
+ goto done;
+ }
/* convert the terminating dot to a NUL */
temp[scp->length.LowPart - 1] = 0;
scp->mpDataVersion = scp->dataVersion;
}
+ done:
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_FETCHDATA);
+
return code;
}
if (targetType == BACKVOL
&& (scp->flags & (CM_SCACHEFLAG_RO | CM_SCACHEFLAG_PURERO))
== CM_SCACHEFLAG_RO) {
- code = CM_ERROR_NOSUCHVOLUME;
+ code = CM_ERROR_TOO_MANY_SYMLINKS;
goto done;
}
* that we stopped early, probably because we found the entry we're
* looking for. Any other non-zero code is an error.
*/
- if (code && code != CM_ERROR_STOPNOW && code != CM_ERROR_BPLUS_NOMATCH) {
+ if (code && code != CM_ERROR_STOPNOW) {
/* if the cm_scache_t we are searching in is not a directory
* we must return path not found because the error
* is to describe the final component not an intermediary
lock_ObtainWrite(&tscp->rw);
/*
- * Do not get status if we do not already have a callback.
+ * Do not get status if we do not already have a callback or know the type.
* The process of reading the mount point string will obtain status information
* in a single RPC. No reason to add a second round trip.
*
* current cm_user_t is not the same as the one that obtained the
* mount point string contents.
*/
- if (cm_HaveCallback(tscp)) {
+ if (cm_HaveCallback(tscp) || tscp->fileType == CM_SCACHETYPE_UNKNOWN) {
code = cm_SyncOp(tscp, NULL, userp, reqp, 0,
CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
if (code) {
&newDirStatus, &volSync);
rx_PutConnection(rxconnp);
- } while (cm_Analyze(connp, userp, reqp, &dscp->fid, NULL, 1, &volSync, NULL, NULL, code));
+ } while (cm_Analyze(connp, userp, reqp, &dscp->fid, NULL, 1, &newDirStatus, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
if (code)
lock_ObtainWrite(&dscp->rw);
cm_dnlcRemove(dscp, cnamep);
if (code == 0) {
- cm_MergeStatus(NULL, dscp, &newDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
+ code = cm_MergeStatus(NULL, dscp, &newDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
invalidate = 1;
if (cm_CheckDirOpForSingleChange(&dirop) && cnamep) {
lock_ReleaseWrite(&dscp->rw);
if (code == 0) {
lock_ObtainWrite(&scp->rw);
if (--scp->linkCount == 0) {
- scp->flags |= CM_SCACHEFLAG_DELETED;
+ _InterlockedOr(&scp->flags, CM_SCACHEFLAG_DELETED);
lock_ObtainWrite(&cm_scacheLock);
cm_AdjustScacheLRU(scp);
- cm_RemoveSCacheFromHashTable(scp);
lock_ReleaseWrite(&cm_scacheLock);
}
cm_DiscardSCache(scp);
{
char temp[MOUNTPOINTLEN];
osi_hyper_t offset;
+ afs_uint32 bytesRead = 0;
/* read the link data from the file server */
offset.LowPart = offset.HighPart = 0;
- code = cm_GetData(linkScp, &offset, temp, MOUNTPOINTLEN, userp, reqp);
+ code = cm_GetData(linkScp, &offset, temp, MOUNTPOINTLEN, &bytesRead, userp, reqp);
if (code)
return code;
/* make sure we are NUL terminated */
temp[linkScp->length.LowPart] = 0;
memcpy(linkScp->mountPointStringp, temp, linkScp->length.LowPart + 1);
+ linkScp->mpDataVersion = linkScp->dataVersion;
}
if ( !strnicmp(linkScp->mountPointStringp, "msdfs:", strlen("msdfs:")) )
*/
*cp++ = 0; /* add null termination */
extraFlag = 0;
- if ((flags & CM_FLAG_DIRSEARCH) && tc == 0)
- extraFlag = CM_FLAG_NOMOUNTCHASE;
- code = cm_Lookup(tscp, component,
- flags | extraFlag,
- userp, reqp, &nscp);
+ if (tscp == cm_RootSCachep(userp, reqp)) {
+ code = cm_Lookup(tscp, component, CM_FLAG_CHECKPATH, userp, reqp, &nscp);
+
+ if ((code == CM_ERROR_NOSUCHPATH || code == CM_ERROR_NOSUCHFILE ||
+ code == CM_ERROR_BPLUS_NOMATCH) &&
+ tscp == cm_data.rootSCachep) {
+
+ clientchar_t volref[AFSPATHMAX];
+
+ if (wcschr(component, '%') != NULL || wcschr(component, '#') != NULL) {
+ /*
+ * A volume reference: <cell>{%,#}<volume> -> @vol:<cell>{%,#}<volume>
+ */
+ cm_ClientStrCpyN(volref, AFSPATHMAX, _C(CM_PREFIX_VOL), CM_PREFIX_VOL_CCH);
+ cm_ClientStrCat(volref, AFSPATHMAX, component);
+
+ code = cm_EvaluateVolumeReference(volref, CM_FLAG_CHECKPATH, userp, reqp, &nscp);
+ }
+#ifdef AFS_FREELANCE_CLIENT
+ else if (tscp->fid.cell == AFS_FAKE_ROOT_CELL_ID && tscp->fid.volume == AFS_FAKE_ROOT_VOL_ID &&
+ tscp->fid.vnode == 1 && tscp->fid.unique == 1) {
+ /*
+ * If this is the Freelance volume root directory then treat unrecognized
+ * names as cell names and attempt to find the appropriate "root.cell".
+ */
+ cm_ClientStrCpyN(volref, AFSPATHMAX, _C(CM_PREFIX_VOL), CM_PREFIX_VOL_CCH);
+ if (component[0] == L'.') {
+ cm_ClientStrCat(volref, AFSPATHMAX, &component[1]);
+ cm_ClientStrCatN(volref, AFSPATHMAX, L"%", sizeof(WCHAR));
+ } else {
+ cm_ClientStrCat(volref, AFSPATHMAX, component);
+ cm_ClientStrCatN(volref, AFSPATHMAX, L"#", sizeof(WCHAR));
+ }
+ cm_ClientStrCatN(volref, AFSPATHMAX, L"root.cell", 9 * sizeof(WCHAR));
+
+ code = cm_EvaluateVolumeReference(volref, CM_FLAG_CHECKPATH, userp, reqp, &nscp);
+ }
+#endif
+ }
+ } else {
+ if ((flags & CM_FLAG_DIRSEARCH) && tc == 0)
+ extraFlag = CM_FLAG_NOMOUNTCHASE;
+ code = cm_Lookup(tscp, component,
+ flags | extraFlag,
+ userp, reqp, &nscp);
+ }
if (code == 0) {
if (!cm_ClientStrCmp(component,_C("..")) ||
!cm_ClientStrCmp(component,_C("."))) {
continue;
rxconnp = cm_GetRxConn(connp);
- if (!(connp->serverp->flags & CM_SERVERFLAG_NOINLINEBULK)) {
+ if (SERVERHASINLINEBULK(connp)) {
code = RXAFS_InlineBulkStatus(rxconnp, &fidStruct,
&statStruct, &callbackStruct, &volSync);
if (code == RXGEN_OPCODE) {
- cm_SetServerNoInlineBulk(connp->serverp, 0);
+ SET_SERVERHASNOINLINEBULK(connp);
} else {
inlinebulk = 1;
}
}
if (!inlinebulk) {
+ /*
+ * It is important to note that RXAFS_BulkStatus is quite braindead.
+ * The AFS 3.6 file server implementation returns arrays that are
+ * sized to hold responses for all of the requested FIDs but it only
+ * populates their contents up to the point where it detects an error.
+ * Unfortunately, it does inform the caller which entries were filled
+ * and which were not. The caller has no ability to determine which
+ * FID the RPC return code applies to or which of the FIDs valid status
+ * info and callbacks have been issued for. As a result, when an
+ * error is returned, none of the data received can be trusted.
+ */
code = RXAFS_BulkStatus(rxconnp, &fidStruct,
&statStruct, &callbackStruct, &volSync);
}
code = (&bbp->stats[0])->errorCode;
}
}
- } while (cm_Analyze(connp, userp, reqp, &tfid, NULL, 0, &volSync, NULL, &cbReq, code));
+ } while (cm_Analyze(connp, userp, reqp, &tfid, NULL, 0, &bbp->stats[0], &volSync, NULL, &cbReq, code));
code = cm_MapRPCError(code, reqp);
/*
if (code) {
osi_Log2(afsd_logp, "CALL %sBulkStatus FAILURE code 0x%x",
inlinebulk ? "Inline" : "", code);
+ if (!inlinebulk) {
+ /*
+ * Since an error occurred and it is impossible to determine
+ * the context in which the returned error code should be
+ * interpreted, we return the CM_ERROR_BULKSTAT_FAILURE error
+ * which indicates that Bulk Stat cannot be used for the
+ * current request. The caller should fallback to using
+ * individual RXAFS_FetchStatus calls.
+ */
+ code = CM_ERROR_BULKSTAT_FAILURE;
+ }
cm_EndCallbackGrantingCall(NULL, &cbReq, NULL, NULL, 0);
break;
}
if (inlinebulk && (&bbp->stats[j])->errorCode) {
cm_req_t treq = *reqp;
- cm_Analyze(NULL, userp, &treq, &tfid, NULL, 0, &volSync, NULL, &cbReq, (&bbp->stats[j])->errorCode);
+ cm_Analyze(NULL, userp, &treq, &tfid, NULL, 0, &bbp->stats[j], &volSync,
+ NULL, &cbReq, (&bbp->stats[j])->errorCode);
switch ((&bbp->stats[j])->errorCode) {
case EACCES:
case UAEACCES:
&bbp->callbacks[j],
&volSync,
CM_CALLBACK_MAINTAINCOUNT|CM_CALLBACK_BULKSTAT);
- InterlockedIncrement(&scp->activeRPCs);
- if (!lostRace)
- cm_MergeStatus(dscp, scp, &bbp->stats[j], &volSync, userp, reqp, CM_MERGEFLAG_BULKSTAT);
+ if (!lostRace) {
+ InterlockedIncrement(&scp->activeRPCs);
+ code = cm_MergeStatus(dscp, scp, &bbp->stats[j], &volSync, userp, reqp, CM_MERGEFLAG_BULKSTAT);
+ }
lock_ReleaseWrite(&scp->rw);
} else {
lock_ReleaseRead(&scp->rw);
goto _done;
}
- volp = cm_GetVolumeByFID(fidp);
+ volp = cm_FindVolumeByFID(fidp, userp, reqp);
if (!volp) {
spaceAvail = 0;
goto _done;
&volStat, &Name, &OfflineMsg, &MOTD);
rx_PutConnection(rxconnp);
- } while (cm_Analyze(connp, userp, reqp, &vfid, NULL, 0, NULL, NULL, NULL, code));
+ } while (cm_Analyze(connp, userp, reqp, &vfid, NULL, 0, NULL, NULL, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
}
{
long code;
int shrinking;
+ int available;
/* start by locking out buffer creation */
lock_ObtainWrite(&scp->bufCreateLock);
* than where we're truncating the file, set truncPos to this
* new value.
*/
- if (!shrinking)
+ if (!shrinking) {
+ cm_SyncOpDone(scp, NULL,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS
+ | CM_SCACHESYNC_SETSTATUS | CM_SCACHESYNC_SETSIZE);
goto startover;
+ }
if (!(scp->mask & CM_SCACHEMASK_TRUNCPOS)
|| LargeIntegerLessThan(*sizep, scp->length)) {
/* set trunc pos */
scp->mask |= CM_SCACHEMASK_LENGTH;
}
else if (LargeIntegerGreaterThan(*sizep, scp->length)) {
- /* really extending the file */
- /* Check to see if we have sufficient quota */
- if (cm_IsSpaceAvailable(&scp->fid, sizep, userp, reqp)) {
+ /*
+ * Really extending the file so must check to see if we
+ * have sufficient quota. cm_IsSpaceAvailable() obtains
+ * the cm_scache.rw lock on the volume root directory.
+ * vnode 1 < scp->fid.vnode therefore calling cm_IsSpaceAvailable
+ * while holding scp->rw is a lock order violation.
+ * Dropping it is ok because we are holding scp->bufCreateLock
+ * which prevents the size of the file from changing.
+ */
+ afs_uint64 nextChunk = scp->length.QuadPart;
+
+ nextChunk -= (nextChunk & 0xFFFFF);
+ nextChunk += 0x100000;
+
+ if (sizep->QuadPart > nextChunk) {
+ lock_ReleaseWrite(&scp->rw);
+ available = cm_IsSpaceAvailable(&scp->fid, sizep, userp, reqp);
+ lock_ObtainWrite(&scp->rw);
+ } else {
+ /*
+ * The file server permits 1MB quota overruns so only check
+ * when the file size increases by at least that much.
+ */
+ available = 1;
+ }
+ if (available) {
scp->length = *sizep;
scp->mask |= CM_SCACHEMASK_LENGTH;
} else {
rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp,
- &scp->fid, NULL, 1, &volSync, NULL, NULL, code));
+ &scp->fid, NULL, 1, &afsOutStatus, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
if (code)
lock_ObtainWrite(&scp->rw);
if (code == 0)
- cm_MergeStatus(NULL, scp, &afsOutStatus, &volSync, userp, reqp,
- CM_MERGEFLAG_FORCE|CM_MERGEFLAG_STOREDATA);
+ code = cm_MergeStatus( NULL, scp, &afsOutStatus, &volSync, userp, reqp,
+ CM_MERGEFLAG_FORCE|CM_MERGEFLAG_STOREDATA);
else
InterlockedDecrement(&scp->activeRPCs);
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_STORESTATUS);
rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp,
- &dscp->fid, NULL, 1, &volSync, NULL, &cbReq, code));
+ &dscp->fid, NULL, 1, &updatedDirStatus, &volSync, NULL, &cbReq, code));
code = cm_MapRPCError(code, reqp);
if (code)
}
lock_ObtainWrite(&dscp->rw);
if (code == 0) {
- cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
+ code = cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
cm_SetFid(&newFid, dscp->fid.cell, dscp->fid.volume, newAFSFid.Vnode, newAFSFid.Unique);
if (cm_CheckDirOpForSingleChange(&dirop)) {
lock_ReleaseWrite(&dscp->rw);
if (!cm_HaveCallback(scp)) {
lostRace = cm_EndCallbackGrantingCall(scp, &cbReq,
&newFileCallback, &volSync, 0);
- InterlockedIncrement(&scp->activeRPCs);
- if (!lostRace)
- cm_MergeStatus(dscp, scp, &newFileStatus, &volSync,
- userp, reqp, 0);
+ if (!lostRace) {
+ InterlockedIncrement(&scp->activeRPCs);
+ code = cm_MergeStatus( dscp, scp, &newFileStatus, &volSync,
+ userp, reqp, 0);
+ }
didEnd = 1;
}
lock_ReleaseWrite(&scp->rw);
rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp,
- &dscp->fid, NULL, 1, &volSync, NULL, &cbReq, code));
+ &dscp->fid, NULL, 1, &updatedDirStatus, &volSync, NULL, &cbReq, code));
code = cm_MapRPCError(code, reqp);
if (code)
}
lock_ObtainWrite(&dscp->rw);
if (code == 0) {
- cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
+ code = cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
cm_SetFid(&newFid, dscp->fid.cell, dscp->fid.volume, newAFSFid.Vnode, newAFSFid.Unique);
if (cm_CheckDirOpForSingleChange(&dirop)) {
lock_ReleaseWrite(&dscp->rw);
if (!cm_HaveCallback(scp)) {
lostRace = cm_EndCallbackGrantingCall(scp, &cbReq,
&newDirCallback, &volSync, 0);
- InterlockedIncrement(&scp->activeRPCs);
- if (!lostRace)
- cm_MergeStatus(dscp, scp, &newDirStatus, &volSync,
- userp, reqp, 0);
+ if (!lostRace) {
+ InterlockedIncrement(&scp->activeRPCs);
+ code = cm_MergeStatus( dscp, scp, &newDirStatus, &volSync,
+ userp, reqp, 0);
+ }
didEnd = 1;
}
lock_ReleaseWrite(&scp->rw);
rx_PutConnection(rxconnp);
osi_Log1(afsd_logp," RXAFS_Link returns 0x%x", code);
- } while (cm_Analyze(connp, userp, reqp, &dscp->fid, NULL, 1, &volSync, NULL, NULL, code));
+ } while (cm_Analyze(connp, userp, reqp, &dscp->fid, NULL, 1, &updatedDirStatus, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
}
lock_ObtainWrite(&dscp->rw);
if (code == 0) {
- cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
+ code = cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
invalidate = 1;
if (cm_CheckDirOpForSingleChange(&dirop)) {
if (code == 0) {
lock_ObtainWrite(&sscp->rw);
InterlockedIncrement(&sscp->activeRPCs);
- cm_MergeStatus(NULL, sscp, &newLinkStatus, &volSync, userp, reqp, 0);
+ code = cm_MergeStatus(NULL, sscp, &newLinkStatus, &volSync, userp, reqp, 0);
lock_ReleaseWrite(&sscp->rw);
}
rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp,
- &dscp->fid, NULL, 1, &volSync, NULL, NULL, code));
+ &dscp->fid, NULL, 1, &updatedDirStatus, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
if (code)
}
lock_ObtainWrite(&dscp->rw);
if (code == 0) {
- cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
+ code = cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
cm_SetFid(&newFid, dscp->fid.cell, dscp->fid.volume, newAFSFid.Vnode, newAFSFid.Unique);
if (cm_CheckDirOpForSingleChange(&dirop)) {
lock_ReleaseWrite(&dscp->rw);
lock_ObtainWrite(&scp->rw);
if (!cm_HaveCallback(scp)) {
InterlockedIncrement(&scp->activeRPCs);
- cm_MergeStatus(dscp, scp, &newLinkStatus, &volSync,
- userp, reqp, 0);
+ code = cm_MergeStatus( dscp, scp, &newLinkStatus, &volSync,
+ userp, reqp, 0);
}
lock_ReleaseWrite(&scp->rw);
rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp,
- &dscp->fid, NULL, 1, &volSync, NULL, NULL, code));
+ &dscp->fid, NULL, 1, &updatedDirStatus, &volSync, NULL, NULL, code));
code = cm_MapRPCErrorRmdir(code, reqp);
if (code)
lock_ObtainWrite(&dscp->rw);
if (code == 0) {
cm_dnlcRemove(dscp, cnamep);
- cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
+ code = cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
if (cm_CheckDirOpForSingleChange(&dirop) && cnamep != NULL) {
lock_ReleaseWrite(&dscp->rw);
cm_DirDeleteEntry(&dirop, fnamep);
if (scp) {
if (code == 0) {
lock_ObtainWrite(&scp->rw);
- scp->flags |= CM_SCACHEFLAG_DELETED;
+ _InterlockedOr(&scp->flags, CM_SCACHEFLAG_DELETED);
lock_ObtainWrite(&cm_scacheLock);
cm_AdjustScacheLRU(scp);
- cm_RemoveSCacheFromHashTable(scp);
lock_ReleaseWrite(&cm_scacheLock);
lock_ReleaseWrite(&scp->rw);
if (RDR_Initialized && !(reqp->flags & CM_REQ_SOURCE_REDIR))
rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp, &oldDscp->fid, NULL, 1,
- &volSync, NULL, NULL, code));
+ &updatedOldDirStatus, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
if (code)
lock_ObtainWrite(&oldDscp->rw);
if (code == 0) {
- cm_MergeStatus(NULL, oldDscp, &updatedOldDirStatus, &volSync,
- userp, reqp, CM_MERGEFLAG_DIROP);
+ code = cm_MergeStatus( NULL, oldDscp, &updatedOldDirStatus, &volSync,
+ userp, reqp, CM_MERGEFLAG_DIROP);
if (cm_CheckDirOpForSingleChange(&oldDirOp)) {
lock_ReleaseWrite(&oldDscp->rw);
if (bTargetExists && oneDir) {
}
lock_ObtainWrite(&newDscp->rw);
if (code == 0) {
- cm_MergeStatus(NULL, newDscp, &updatedNewDirStatus, &volSync,
- userp, reqp, CM_MERGEFLAG_DIROP);
+ code = cm_MergeStatus( NULL, newDscp, &updatedNewDirStatus, &volSync,
+ userp, reqp, CM_MERGEFLAG_DIROP);
/*
* we only make the local change if we successfully made
&volSync);
rx_PutConnection(rxconnp);
- } while (cm_Analyze(connp, userp, reqp, &cfid, NULL, 1, &volSync,
+ } while (cm_Analyze(connp, userp, reqp, &cfid, NULL, 1, NULL, &volSync,
NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
code = RXAFS_ReleaseLock(rxconnp, &tfid, &volSync);
rx_PutConnection(rxconnp);
- } while (cm_Analyze(connp, userp, reqp, &cfid, NULL, 1, &volSync,
+ } while (cm_Analyze(connp, userp, reqp, &cfid, NULL, 1, NULL, &volSync,
NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
if (code)
goto post_syncopdone;
code = cm_SyncOp(scp, NULL, fileLock->userp, &req, 0,
- CM_SCACHESYNC_NEEDCALLBACK
- | CM_SCACHESYNC_GETSTATUS
- | CM_SCACHESYNC_LOCK);
+ CM_SCACHESYNC_LOCK);
if (code) {
osi_Log1(afsd_logp,
osi_Log1(afsd_logp, " ExtendLock returns %d", code);
} while (cm_Analyze(connp, userp, &req,
- &cfid, NULL, 1, &volSync, NULL, NULL,
+ &cfid, NULL, 1, NULL, &volSync, NULL, NULL,
code));
code = cm_MapRPCError(code, &req);
cm_user_t * userp;
code = cm_SyncOp(scp, NULL, oldFileLock->userp, &req, 0,
- CM_SCACHESYNC_NEEDCALLBACK
- | CM_SCACHESYNC_GETSTATUS
- | CM_SCACHESYNC_LOCK);
+ CM_SCACHESYNC_LOCK);
if (code) {
osi_Log1(afsd_logp, "cm_RetryLock SyncOp failure code 0x%x", code);
lock_ReleaseWrite(&cm_scacheLock);
git://git.openafs.org / openafs.git / blobdiff