#include <afsconfig.h>
#include <afs/param.h>
+#include <afs/stds.h>
#include <roken.h>
-#include <afs/stds.h>
+#include <afs/unified_afs.h>
#include <windows.h>
#include <winsock2.h>
-#include <stddef.h>
-#include <malloc.h>
-#include <string.h>
-#include <stdlib.h>
-#include <errno.h>
#include <osi.h>
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;
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;
if (match != 0
&& sp->hasTilde
+ && cm_shortNames
&& !cm_Is8Dot3(matchName)) {
cm_Gen8Dot3NameInt(dep->name, &dep->fid, matchName, NULL);
*/
long cm_ReadMountPoint(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
{
- long code;
+ long code = 0;
- if (scp->mountPointStringp[0])
- return 0;
+ code = cm_SyncOp(scp, NULL, userp, reqp, 0, CM_SCACHESYNC_FETCHDATA);
+ if (code)
+ return code;
+
+ if (scp->mountPointStringp[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;
memcpy(scp->mountPointStringp, temp, scp->length.LowPart);
+ scp->mpDataVersion = scp->dataVersion;
}
+ done:
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_FETCHDATA);
+
return code;
}
if (scp->mountRootFid.cell != 0 && scp->mountRootGen >= cm_data.mountRootGen) {
tfid = scp->mountRootFid;
lock_ReleaseWrite(&scp->rw);
- code = cm_GetSCache(&tfid, outScpp, userp, reqp);
+ code = cm_GetSCache(&tfid, NULL, outScpp, userp, reqp);
lock_ObtainWrite(&scp->rw);
return code;
}
/* now look up the cell */
lock_ReleaseWrite(&scp->rw);
- cellp = cm_GetCell(cellNamep, CM_FLAG_CREATE);
+ cellp = cm_GetCell(cellNamep, CM_FLAG_CREATE|CM_FLAG_NOPROBE);
lock_ObtainWrite(&scp->rw);
} else {
/* normal mt pt */
tfid = scp->mountRootFid;
lock_ReleaseWrite(&scp->rw);
- code = cm_GetSCache(&tfid, outScpp, userp, reqp);
+ code = cm_GetSCache(&tfid, NULL, outScpp, userp, reqp);
lock_ObtainWrite(&scp->rw);
}
* 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
notfound:
getroot = (dscp==cm_data.rootSCachep) ;
if (!rock.found) {
- if (!cm_freelanceEnabled || !getroot) {
+ if (!(cm_freelanceEnabled && cm_freelanceDiscovery) || !getroot) {
if (flags & CM_FLAG_CHECKPATH)
code = CM_ERROR_NOSUCHPATH;
else
if ( !tscp ) /* we did not find it in the dnlc */
{
dnlcHit = 0;
- code = cm_GetSCache(&rock.fid, &tscp, userp, reqp);
+ code = cm_GetSCache(&rock.fid, &dscp->fid, &tscp, userp, reqp);
if (code)
goto done;
}
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) {
#ifdef _WIN64
int use_sysname64 = 0;
- if (cm_sysName64Count > 0 && reqp && (reqp->flags & CM_REQ_WOW64) && (reqp->flags & CM_REQ_SOURCE_REDIR))
+ if (cm_sysName64Count > 0 && reqp && !(reqp->flags & CM_REQ_WOW64) && (reqp->flags & CM_REQ_SOURCE_REDIR))
use_sysname64 = 1;
#endif
cm_SetFid(&fid, cellp->cellID, volume, 1, 1);
- code = cm_GetSCache(&fid, outScpp, userp, reqp);
+ code = cm_GetSCache(&fid, NULL, outScpp, userp, reqp);
_exit_cleanup:
if (fnamep)
&newDirStatus, &volSync);
rx_PutConnection(rxconnp);
- } while (cm_Analyze(connp, userp, reqp, &dscp->fid, &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);
+ cm_DirDeleteEntry(&dirop, fnamep);
+#ifdef USE_BPLUS
+ cm_BPlusDirDeleteEntry(&dirop, cnamep);
+#endif
+ lock_ObtainWrite(&dscp->rw);
+ }
} else {
InterlockedDecrement(&scp->activeRPCs);
if (code == CM_ERROR_NOSUCHFILE) {
dscp->cbServerp = NULL;
}
}
+
cm_SyncOpDone(dscp, NULL, sflags);
lock_ReleaseWrite(&dscp->rw);
- if (code == 0 && cm_CheckDirOpForSingleChange(&dirop) && cnamep) {
- cm_DirDeleteEntry(&dirop, fnamep);
-#ifdef USE_BPLUS
- cm_BPlusDirDeleteEntry(&dirop, cnamep);
-#endif
- }
cm_EndDirOp(&dirop);
if (invalidate && RDR_Initialized &&
dscp->fileType, AFS_INVALIDATE_DATA_VERSION);
if (scp) {
- cm_ReleaseSCache(scp);
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);
}
cm_DiscardSCache(scp);
lock_ReleaseWrite(&scp->rw);
- if (RDR_Initialized && !(reqp->flags & CM_REQ_SOURCE_REDIR) &&
- !RDR_InvalidateObject(scp->fid.cell, scp->fid.volume, scp->fid.vnode,
- scp->fid.unique, scp->fid.hash,
- scp->fileType, AFS_INVALIDATE_DELETED))
- buf_ClearRDRFlag(scp, "unlink");
+ if (RDR_Initialized && !(reqp->flags & CM_REQ_SOURCE_REDIR))
+ RDR_InvalidateObject(scp->fid.cell, scp->fid.volume, scp->fid.vnode,
+ scp->fid.unique, scp->fid.hash,
+ scp->fileType, AFS_INVALIDATE_DELETED);
}
+ cm_ReleaseSCache(scp);
}
done:
long code = 0;
lock_AssertWrite(&linkScp->rw);
- if (!linkScp->mountPointStringp[0]) {
+ if (!linkScp->mountPointStringp[0] ||
+ linkScp->mpDataVersion != linkScp->dataVersion) {
#ifdef AFS_FREELANCE_CLIENT
/* File servers do not have data for freelance entries */
{
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:")) )
int symlinkCount; /* count of # of symlinks traversed */
int extraFlag; /* avoid chasing mt pts for dir cmd */
int phase = 1; /* 1 = tidPathp, 2 = pathp */
-#define MAX_FID_COUNT 512
cm_fid_t fids[MAX_FID_COUNT]; /* array of fids processed in this path walk */
int fid_count = 0; /* number of fids processed in this path walk */
int i;
*/
*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("."))) {
if (tscp) {
if (lock_TryWrite(&tscp->rw)) {
/* we have an entry that we can look at */
- if (!(tscp->flags & CM_SCACHEFLAG_EACCESS) && cm_HaveCallback(tscp)) {
+ if (!cm_EAccesFindEntry(bsp->userp, &tscp->fid) && cm_HaveCallback(tscp)) {
/* we have a callback on it. Don't bother
* fetching this stat entry, since we're happy
* with the info we have.
!(tfid.vnode==0x1 && tfid.unique==0x1) )
{
osi_Log0(afsd_logp, "cm_TryBulkProc Freelance calls cm_SCache on root.afs mountpoint");
- return cm_GetSCache(&tfid, &tscp, NULL, NULL);
+ return cm_GetSCache(&tfid, NULL, &tscp, NULL, NULL);
}
#endif /* AFS_FREELANCE_CLIENT */
long filex;
AFSVolSync volSync;
cm_callbackRequest_t cbReq;
+ int lostRace;
long filesThisCall;
long i;
long j;
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, &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, &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:
+ case EPERM:
+ case UAEPERM:
+ cm_EAccesAddEntry(userp, &tfid, &dscp->fid);
+ }
} else {
- code = cm_GetSCache(&tfid, &scp, userp, reqp);
+ code = cm_GetSCache(&tfid, &dscp->fid, &scp, userp, reqp);
if (code != 0)
continue;
if ((scp->cbServerp == NULL &&
!(scp->flags & (CM_SCACHEFLAG_FETCHING | CM_SCACHEFLAG_STORING | CM_SCACHEFLAG_SIZESTORING))) ||
(scp->flags & CM_SCACHEFLAG_PURERO) ||
- (scp->flags & CM_SCACHEFLAG_EACCESS))
+ cm_EAccesFindEntry(userp, &scp->fid))
{
lock_ConvertRToW(&scp->rw);
- cm_EndCallbackGrantingCall(scp, &cbReq,
- &bbp->callbacks[j],
- &volSync,
- CM_CALLBACK_MAINTAINCOUNT);
+ lostRace = cm_EndCallbackGrantingCall(scp, &cbReq,
+ &bbp->callbacks[j],
+ &volSync,
+ CM_CALLBACK_MAINTAINCOUNT|CM_CALLBACK_BULKSTAT);
InterlockedIncrement(&scp->activeRPCs);
- cm_MergeStatus(dscp, scp, &bbp->stats[j], &volSync, userp, reqp, 0);
+ if (!lostRace)
+ code = cm_MergeStatus(dscp, scp, &bbp->stats[j], &volSync, userp, reqp, CM_MERGEFLAG_BULKSTAT);
lock_ReleaseWrite(&scp->rw);
} else {
lock_ReleaseRead(&scp->rw);
bbp = malloc(sizeof(cm_bulkStat_t));
memset(bbp, 0, sizeof(cm_bulkStat_t));
+ bbp->userp = userp;
bbp->bufOffset = *offsetp;
lock_ReleaseWrite(&dscp->rw);
statusp->Mask = mask;
}
+int
+cm_IsSpaceAvailable(cm_fid_t * fidp, osi_hyper_t *sizep, cm_user_t *userp, cm_req_t *reqp)
+{
+ int spaceAvail = 1;
+ afs_uint32 code;
+ cm_conn_t *connp;
+ struct rx_connection * rxconnp;
+ AFSFetchVolumeStatus volStat;
+ cm_volume_t *volp = NULL;
+ afs_uint32 volType;
+ char *Name;
+ char *OfflineMsg;
+ char *MOTD;
+ char volName[32]="(unknown)";
+ char offLineMsg[256]="server temporarily inaccessible";
+ char motd[256]="server temporarily inaccessible";
+ osi_hyper_t freespace;
+ cm_fid_t vfid;
+ cm_scache_t *vscp;
+
+ if (fidp->cell==AFS_FAKE_ROOT_CELL_ID &&
+ fidp->volume==AFS_FAKE_ROOT_VOL_ID)
+ {
+ goto _done;
+ }
+
+ volp = cm_GetVolumeByFID(fidp);
+ if (!volp) {
+ spaceAvail = 0;
+ goto _done;
+ }
+ volType = cm_VolumeType(volp, fidp->volume);
+ if (volType == ROVOL || volType == BACKVOL) {
+ spaceAvail = 0;
+ goto _done;
+ }
+
+ cm_SetFid(&vfid, fidp->cell, fidp->volume, 1, 1);
+ code = cm_GetSCache(&vfid, NULL, &vscp, userp, reqp);
+ if (code == 0) {
+ lock_ObtainWrite(&vscp->rw);
+ code = cm_SyncOp(vscp, NULL, userp, reqp, PRSFS_READ,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ lock_ReleaseWrite(&vscp->rw);
+ if (code == 0) {
+ Name = volName;
+ OfflineMsg = offLineMsg;
+ MOTD = motd;
+
+ do {
+ code = cm_ConnFromFID(&vfid, userp, reqp, &connp);
+ if (code) continue;
+
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_GetVolumeStatus(rxconnp, fidp->volume,
+ &volStat, &Name, &OfflineMsg, &MOTD);
+ rx_PutConnection(rxconnp);
+
+ } while (cm_Analyze(connp, userp, reqp, &vfid, NULL, 0, NULL, NULL, NULL, NULL, code));
+ code = cm_MapRPCError(code, reqp);
+ }
+
+ lock_ObtainWrite(&vscp->rw);
+ cm_SyncOpDone(vscp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ lock_ReleaseWrite(&vscp->rw);
+ cm_ReleaseSCache(vscp);
+ }
+
+ if (code == 0) {
+ if (volStat.MaxQuota) {
+ freespace.QuadPart = 1024 * (afs_int64)min(volStat.MaxQuota - volStat.BlocksInUse, volStat.PartBlocksAvail);
+ } else {
+ freespace.QuadPart = 1024 * (afs_int64)volStat.PartBlocksAvail;
+ }
+ spaceAvail = LargeIntegerGreaterThanOrEqualTo(freespace, *sizep);
+ }
+ /* the rpc failed, assume there is space and we can fail it later. */
+
+ _done:
+ if (volp)
+ cm_PutVolume(volp);
+
+ return spaceAvail;
+}
+
/* set the file size, and make sure that all relevant buffers have been
* truncated. Ensure that any partially truncated buffers have been zeroed
* to the end of the buffer.
{
long code;
int shrinking;
+ int available;
/* start by locking out buffer creation */
lock_ObtainWrite(&scp->bufCreateLock);
scp->mask |= CM_SCACHEMASK_LENGTH;
}
else if (LargeIntegerGreaterThan(*sizep, scp->length)) {
- /* really extending the file */
- scp->length = *sizep;
- scp->mask |= CM_SCACHEMASK_LENGTH;
+ /*
+ * 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 {
+ code = CM_ERROR_SPACE;
+ goto syncopdone;
+ }
}
/* done successfully */
code = 0;
+ syncopdone:
cm_SyncOpDone(scp, NULL,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS
| CM_SCACHESYNC_SETSTATUS | CM_SCACHESYNC_SETSIZE);
rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp,
- &scp->fid, &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);
cm_fid_t newFid;
cm_scache_t *scp = NULL;
int didEnd;
+ int lostRace;
AFSStoreStatus inStatus;
AFSFetchStatus updatedDirStatus;
AFSFetchStatus newFileStatus;
rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp,
- &dscp->fid, &volSync, NULL, &cbReq, code));
+ &dscp->fid, NULL, 1, &updatedDirStatus, &volSync, NULL, &cbReq, code));
code = cm_MapRPCError(code, reqp);
if (code)
dirop.lockType = CM_DIRLOCK_WRITE;
}
lock_ObtainWrite(&dscp->rw);
- if (code == 0)
- cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
- else
+ if (code == 0) {
+ 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);
+ cm_DirCreateEntry(&dirop, fnamep, &newFid);
+#ifdef USE_BPLUS
+ cm_BPlusDirCreateEntry(&dirop, cnamep, &newFid);
+#endif
+ lock_ObtainWrite(&dscp->rw);
+ }
+ } else {
InterlockedDecrement(&dscp->activeRPCs);
+ }
cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
lock_ReleaseWrite(&dscp->rw);
* info.
*/
if (code == 0) {
- cm_SetFid(&newFid, dscp->fid.cell, dscp->fid.volume, newAFSFid.Vnode, newAFSFid.Unique);
- code = cm_GetSCache(&newFid, &scp, userp, reqp);
+ code = cm_GetSCache(&newFid, &dscp->fid, &scp, userp, reqp);
if (code == 0) {
lock_ObtainWrite(&scp->rw);
scp->creator = userp; /* remember who created it */
if (!cm_HaveCallback(scp)) {
- cm_EndCallbackGrantingCall(scp, &cbReq,
- &newFileCallback, &volSync, 0);
+ lostRace = cm_EndCallbackGrantingCall(scp, &cbReq,
+ &newFileCallback, &volSync, 0);
InterlockedIncrement(&scp->activeRPCs);
- cm_MergeStatus(dscp, scp, &newFileStatus, &volSync,
- userp, reqp, 0);
+ if (!lostRace)
+ code = cm_MergeStatus( dscp, scp, &newFileStatus, &volSync,
+ userp, reqp, 0);
didEnd = 1;
}
lock_ReleaseWrite(&scp->rw);
if (!didEnd)
cm_EndCallbackGrantingCall(NULL, &cbReq, NULL, NULL, 0);
- if (scp && cm_CheckDirOpForSingleChange(&dirop)) {
- cm_DirCreateEntry(&dirop, fnamep, &newFid);
-#ifdef USE_BPLUS
- cm_BPlusDirCreateEntry(&dirop, cnamep, &newFid);
-#endif
- }
cm_EndDirOp(&dirop);
if (fnamep)
cm_fid_t newFid;
cm_scache_t *scp = NULL;
int didEnd;
+ int lostRace;
AFSStoreStatus inStatus;
AFSFetchStatus updatedDirStatus;
AFSFetchStatus newDirStatus;
rx_PutConnection(rxconnp);
} while (cm_Analyze(connp, userp, reqp,
- &dscp->fid, &volSync, NULL, &cbReq, code));
+ &dscp->fid, NULL, 1, &updatedDirStatus, &volSync, NULL, &cbReq, code));
code = cm_MapRPCError(code, reqp);
if (code)
dirop.lockType = CM_DIRLOCK_WRITE;
}
lock_ObtainWrite(&dscp->rw);
- if (code == 0)
- cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
- else
+ if (code == 0) {
+ 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);
+ cm_DirCreateEntry(&dirop, fnamep, &newFid);
+#ifdef USE_BPLUS
+ cm_BPlusDirCreateEntry(&dirop, cnamep, &newFid);
+#endif
+ lock_ObtainWrite(&dscp->rw);
+ }
+ } else {
InterlockedDecrement(&dscp->activeRPCs);
+ }
cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
lock_ReleaseWrite(&dscp->rw);
* info.
*/
if (code == 0) {
- cm_SetFid(&newFid, dscp->fid.cell, dscp->fid.volume, newAFSFid.Vnode, newAFSFid.Unique);
- code = cm_GetSCache(&newFid, &scp, userp, reqp);
+ code = cm_GetSCache(&newFid, &dscp->fid, &scp, userp, reqp);
if (code == 0) {
lock_ObtainWrite(&scp->rw);
if (!cm_HaveCallback(scp)) {
- cm_EndCallbackGrantingCall(scp, &cbReq,
- &newDirCallback, &volSync, 0);
+ lostRace = cm_EndCallbackGrantingCall(scp, &cbReq,
+ &newDirCallback, &volSync, 0);
InterlockedIncrement(&scp->activeRPCs);
- cm_MergeStatus(dscp, scp, &newDirStatus, &volSync,
- userp, reqp, 0);
+ if (!lostRace)
+ code = cm_MergeStatus( dscp, scp, &newDirStatus, &volSync,
+ userp, reqp, 0);
didEnd = 1;
}
lock_ReleaseWrite(&scp->rw);
if (!didEnd)
cm_EndCallbackGrantingCall(NULL, &cbReq, NULL, NULL, 0);
- if (scp && cm_CheckDirOpForSingleChange(&dirop)) {
- cm_DirCreateEntry(&dirop, fnamep, &newFid);
-#ifdef USE_BPLUS
- cm_BPlusDirCreateEntry(&dirop, cnamep, &newFid);
-#endif
- }
cm_EndDirOp(&dirop);
free(fnamep);
rx_PutConnection(rxconnp);
osi_Log1(afsd_logp," RXAFS_Link returns 0x%x", code);
- } while (cm_Analyze(connp, userp, reqp,
- &dscp->fid, &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;
- } else {
- InterlockedDecrement(&dscp->activeRPCs);
- }
- cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
- lock_ReleaseWrite(&dscp->rw);
- if (code == 0) {
if (cm_CheckDirOpForSingleChange(&dirop)) {
+ lock_ReleaseWrite(&dscp->rw);
cm_DirCreateEntry(&dirop, fnamep, &sscp->fid);
#ifdef USE_BPLUS
cm_BPlusDirCreateEntry(&dirop, cnamep, &sscp->fid);
#endif
+ lock_ObtainWrite(&dscp->rw);
}
+ } else {
+ InterlockedDecrement(&dscp->activeRPCs);
}
+ cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
+ lock_ReleaseWrite(&dscp->rw);
+
cm_EndDirOp(&dirop);
if (invalidate && RDR_Initialized)
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, &volSync, NULL, NULL, code));
+ &dscp->fid, NULL, 1, &updatedDirStatus, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
if (code)
dirop.lockType = CM_DIRLOCK_WRITE;
}
lock_ObtainWrite(&dscp->rw);
- if (code == 0)
- cm_MergeStatus(NULL, dscp, &updatedDirStatus, &volSync, userp, reqp, CM_MERGEFLAG_DIROP);
- else
- InterlockedDecrement(&dscp->activeRPCs);
- cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
- lock_ReleaseWrite(&dscp->rw);
-
if (code == 0) {
+ 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);
cm_SetFid(&newFid, dscp->fid.cell, dscp->fid.volume, newAFSFid.Vnode, newAFSFid.Unique);
cm_DirCreateEntry(&dirop, fnamep, &newFid);
#ifdef USE_BPLUS
cm_BPlusDirCreateEntry(&dirop, cnamep, &newFid);
#endif
+ lock_ObtainWrite(&dscp->rw);
}
+ } else {
+ InterlockedDecrement(&dscp->activeRPCs);
}
+ cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
+ lock_ReleaseWrite(&dscp->rw);
+
cm_EndDirOp(&dirop);
/* now try to create the new dir's entry, too, but be careful to
* info.
*/
if (code == 0) {
- cm_SetFid(&newFid, dscp->fid.cell, dscp->fid.volume, newAFSFid.Vnode, newAFSFid.Unique);
- code = cm_GetSCache(&newFid, &scp, userp, reqp);
+ code = cm_GetSCache(&newFid, &dscp->fid, &scp, userp, reqp);
if (code == 0) {
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, &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);
- } else {
- InterlockedDecrement(&dscp->activeRPCs);
- }
- cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
- lock_ReleaseWrite(&dscp->rw);
-
- if (code == 0) {
+ 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);
#ifdef USE_BPLUS
cm_BPlusDirDeleteEntry(&dirop, cnamep);
#endif
+ lock_ObtainWrite(&dscp->rw);
}
+ } else {
+ InterlockedDecrement(&dscp->activeRPCs);
}
+ cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
+ lock_ReleaseWrite(&dscp->rw);
+
cm_EndDirOp(&dirop);
if (scp) {
- cm_ReleaseSCache(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) &&
- !RDR_InvalidateObject(scp->fid.cell, scp->fid.volume, scp->fid.vnode,
- scp->fid.unique, scp->fid.hash,
- scp->fileType, AFS_INVALIDATE_DELETED))
- buf_ClearRDRFlag(scp, "rmdir");
+ if (RDR_Initialized && !(reqp->flags & CM_REQ_SOURCE_REDIR))
+ RDR_InvalidateObject(scp->fid.cell, scp->fid.volume, scp->fid.vnode,
+ scp->fid.unique, scp->fid.hash,
+ scp->fileType, AFS_INVALIDATE_DELETED);
}
+ cm_ReleaseSCache(scp);
}
done:
cm_req_t *reqp)
{
cm_conn_t *connp;
- long code;
+ long code = 0;
AFSFid oldDirAFSFid;
AFSFid newDirAFSFid;
- int didEnd;
AFSFetchStatus updatedOldDirStatus;
AFSFetchStatus updatedNewDirStatus;
AFSVolSync volSync;
- int oneDir;
+ int oneDir = 0;
+ int bTargetExists = 0;
struct rx_connection * rxconnp;
cm_dirOp_t oldDirOp;
cm_fid_t fileFid;
cm_dirOp_t newDirOp;
fschar_t * newNamep = NULL;
int free_oldNamep = FALSE;
- cm_scache_t *oldScp = NULL, *newScp = NULL;
+ cm_scache_t *oldScp = NULL, *oldTargetScp = NULL;
+ int rpc_skipped = 0;
memset(&volSync, 0, sizeof(volSync));
cm_ClientStrLen(cNewNamep) == 0)
return CM_ERROR_INVAL;
- /*
- * Before we permit the operation, make sure that we do not already have
- * an object in the destination directory that has a case-insensitive match
- * for this name UNLESS the matching object is the object we are renaming.
- */
- code = cm_Lookup(oldDscp, cOldNamep, 0, userp, reqp, &oldScp);
- if (code) {
- osi_Log2(afsd_logp, "cm_Rename oldDscp 0x%p cOldName %S old name lookup failed",
- oldDscp, osi_LogSaveStringW(afsd_logp, cOldNamep));
- goto done;
- }
-
- /* Case sensitive lookup. If this succeeds we are done. */
- code = cm_Lookup(newDscp, cNewNamep, 0, userp, reqp, &newScp);
- if (code) {
- /*
- * Case insensitive lookup. If this succeeds, it could have found the
- * same file with a name that differs only by case or it could be a
- * different file entirely.
- */
- code = cm_Lookup(newDscp, cNewNamep, CM_FLAG_CASEFOLD, userp, reqp, &newScp);
- if (code == 0) {
- /* found a matching object with the new name */
- if (cm_FidCmp(&oldScp->fid, &newScp->fid)) {
- /* and they don't match so return an error */
- osi_Log2(afsd_logp, "cm_Rename newDscp 0x%p cNewName %S new name already exists",
- newDscp, osi_LogSaveStringW(afsd_logp, cNewNamep));
- code = CM_ERROR_EXISTS;
- }
- cm_ReleaseSCache(newScp);
- newScp = NULL;
- } else if (code == CM_ERROR_AMBIGUOUS_FILENAME) {
- code = CM_ERROR_EXISTS;
- } else {
- /* The target does not exist. Clear the error and perform the rename. */
- code = 0;
- }
+ /* check for identical names */
+ if (oldDscp == newDscp &&
+ cm_ClientStrCmp(cOldNamep, cNewNamep) == 0) {
+ osi_Log2(afsd_logp, "cm_Rename oldDscp 0x%p newDscp 0x%p CM_ERROR_RENAME_IDENTICAL",
+ oldDscp, newDscp);
+ return CM_ERROR_RENAME_IDENTICAL;
}
/* Check for RO volume */
- if (code == 0 &&
- (oldDscp->flags & CM_SCACHEFLAG_RO) || (newDscp->flags & CM_SCACHEFLAG_RO)) {
- code = CM_ERROR_READONLY;
+ if ((oldDscp->flags & CM_SCACHEFLAG_RO) || (newDscp->flags & CM_SCACHEFLAG_RO)) {
+ return CM_ERROR_READONLY;
}
- if (code)
- goto done;
-
if (oldNamep == NULL) {
code = -1;
#ifdef USE_BPLUS
}
}
-
/* before starting the RPC, mark that we're changing the directory data,
* so that someone who does a chmod on the dir will wait until our call
* completes. We do this in vnode order so that we don't deadlock,
* which makes the code a little verbose.
*/
if (oldDscp == newDscp) {
- /* check for identical names */
- if (cm_ClientStrCmp(cOldNamep, cNewNamep) == 0) {
- osi_Log2(afsd_logp, "cm_Rename oldDscp 0x%p newDscp 0x%p CM_ERROR_RENAME_IDENTICAL",
- oldDscp, newDscp);
- code = CM_ERROR_RENAME_IDENTICAL;
- goto done;
- }
-
oneDir = 1;
cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_NONE,
CM_DIROP_FLAG_NONE, &oldDirOp);
if (code)
goto done;
- didEnd = 0;
+ /*
+ * The source and destination directories are now locked and no other local
+ * changes can occur.
+ *
+ * Before we permit the operation, make sure that we do not already have
+ * an object in the destination directory that has a case-insensitive match
+ * for this name UNLESS the matching object is the object we are renaming.
+ */
+ code = cm_Lookup(oldDscp, cOldNamep, 0, userp, reqp, &oldScp);
+ if (code) {
+ osi_Log2(afsd_logp, "cm_Rename oldDscp 0x%p cOldName %S old name lookup failed",
+ oldDscp, osi_LogSaveStringW(afsd_logp, cOldNamep));
+ rpc_skipped = 1;
+ goto post_rpc;
+ }
+
+ /* Case sensitive lookup. If this succeeds we are done. */
+ code = cm_Lookup(newDscp, cNewNamep, 0, userp, reqp, &oldTargetScp);
+ if (code) {
+ /*
+ * Case insensitive lookup. If this succeeds, it could have found the
+ * same file with a name that differs only by case or it could be a
+ * different file entirely.
+ */
+ code = cm_Lookup(newDscp, cNewNamep, CM_FLAG_CASEFOLD, userp, reqp, &oldTargetScp);
+ if (code == 0) {
+ /* found a matching object with the new name */
+ if (cm_FidCmp(&oldScp->fid, &oldTargetScp->fid)) {
+ /* and they don't match so return an error */
+ osi_Log2(afsd_logp, "cm_Rename newDscp 0x%p cNewName %S new name already exists",
+ newDscp, osi_LogSaveStringW(afsd_logp, cNewNamep));
+ code = CM_ERROR_EXISTS;
+ }
+ cm_ReleaseSCache(oldTargetScp);
+ oldTargetScp = NULL;
+ } else if (code == CM_ERROR_AMBIGUOUS_FILENAME) {
+ code = CM_ERROR_EXISTS;
+ } else {
+ /* The target does not exist. Clear the error and perform the rename. */
+ code = 0;
+ }
+ } else {
+ bTargetExists = 1;
+ }
+
+ if (code) {
+ rpc_skipped = 1;
+ goto post_rpc;
+ }
newNamep = cm_ClientStringToFsStringAlloc(cNewNamep, -1, NULL);
&volSync);
rx_PutConnection(rxconnp);
- } while (cm_Analyze(connp, userp, reqp, &oldDscp->fid,
- &volSync, NULL, NULL, code));
+ } while (cm_Analyze(connp, userp, reqp, &oldDscp->fid, NULL, 1,
+ &updatedOldDirStatus, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
if (code)
else
osi_Log0(afsd_logp, "CALL Rename SUCCESS");
+ post_rpc:
/* update the individual stat cache entries for the directories */
if (oldDirOp.scp) {
lock_ObtainWrite(&oldDirOp.scp->dirlock);
oldDirOp.lockType = CM_DIRLOCK_WRITE;
}
- lock_ObtainWrite(&oldDscp->rw);
- if (code == 0)
- cm_MergeStatus(NULL, oldDscp, &updatedOldDirStatus, &volSync,
- userp, reqp, CM_MERGEFLAG_DIROP);
- else
- InterlockedDecrement(&oldDscp->activeRPCs);
- cm_SyncOpDone(oldDscp, NULL, CM_SCACHESYNC_STOREDATA);
- lock_ReleaseWrite(&oldDscp->rw);
-
- if (code == 0 && cm_CheckDirOpForSingleChange(&oldDirOp)) {
+ lock_ObtainWrite(&oldDscp->rw);
+ if (code == 0) {
+ code = cm_MergeStatus( NULL, oldDscp, &updatedOldDirStatus, &volSync,
+ userp, reqp, CM_MERGEFLAG_DIROP);
+ if (cm_CheckDirOpForSingleChange(&oldDirOp)) {
+ lock_ReleaseWrite(&oldDscp->rw);
+ if (bTargetExists && oneDir) {
+ diropCode = cm_DirDeleteEntry(&oldDirOp, newNamep);
#ifdef USE_BPLUS
- diropCode = cm_BPlusDirLookup(&oldDirOp, cOldNamep, &fileFid);
- if (diropCode == CM_ERROR_INEXACT_MATCH)
- diropCode = 0;
- else if (diropCode == EINVAL)
+ cm_BPlusDirDeleteEntry(&oldDirOp, cNewNamep);
#endif
- diropCode = cm_DirLookup(&oldDirOp, oldNamep, &fileFid);
+ }
- if (diropCode == 0) {
- if (oneDir) {
- diropCode = cm_DirCreateEntry(&oldDirOp, newNamep, &fileFid);
#ifdef USE_BPLUS
- cm_BPlusDirCreateEntry(&oldDirOp, cNewNamep, &fileFid);
+ diropCode = cm_BPlusDirLookup(&oldDirOp, cOldNamep, &fileFid);
+ if (diropCode == CM_ERROR_INEXACT_MATCH)
+ diropCode = 0;
+ else if (diropCode == EINVAL)
#endif
- }
+ diropCode = cm_DirLookup(&oldDirOp, oldNamep, &fileFid);
if (diropCode == 0) {
- diropCode = cm_DirDeleteEntry(&oldDirOp, oldNamep);
+ if (oneDir) {
+ diropCode = cm_DirCreateEntry(&oldDirOp, newNamep, &fileFid);
#ifdef USE_BPLUS
- cm_BPlusDirDeleteEntry(&oldDirOp, cOldNamep);
+ cm_BPlusDirCreateEntry(&oldDirOp, cNewNamep, &fileFid);
#endif
+ }
+
+ if (diropCode == 0) {
+ diropCode = cm_DirDeleteEntry(&oldDirOp, oldNamep);
+#ifdef USE_BPLUS
+ cm_BPlusDirDeleteEntry(&oldDirOp, cOldNamep);
+#endif
+ }
}
+ lock_ObtainWrite(&oldDscp->rw);
}
+ } else {
+ if (!rpc_skipped)
+ InterlockedDecrement(&oldDscp->activeRPCs);
}
+ cm_SyncOpDone(oldDscp, NULL, CM_SCACHESYNC_STOREDATA);
+ lock_ReleaseWrite(&oldDscp->rw);
+
cm_EndDirOp(&oldDirOp);
/* and update it for the new one, too, if necessary */
newDirOp.lockType = CM_DIRLOCK_WRITE;
}
lock_ObtainWrite(&newDscp->rw);
- if (code == 0)
- cm_MergeStatus(NULL, newDscp, &updatedNewDirStatus, &volSync,
- userp, reqp, CM_MERGEFLAG_DIROP);
- else
- InterlockedIncrement(&newDscp->activeRPCs);
- cm_SyncOpDone(newDscp, NULL, CM_SCACHESYNC_STOREDATA);
- lock_ReleaseWrite(&newDscp->rw);
-
-#if 0
- /*
- * The following optimization does not work.
- * When the file server processed a RXAFS_Rename() request the
- * FID of the object being moved between directories is not
- * preserved. The client does not know the new FID nor the
- * version number of the target. Not only can we not create
- * the directory entry in the new directory, but we can't
- * preserve the cached data for the file. It must be re-read
- * from the file server. - jaltman, 2009/02/20
- */
if (code == 0) {
- /* we only make the local change if we successfully made
- the change in the old directory AND there was only one
- change in the new directory */
+ code = cm_MergeStatus( NULL, newDscp, &updatedNewDirStatus, &volSync,
+ userp, reqp, CM_MERGEFLAG_DIROP);
+
+ /*
+ * we only make the local change if we successfully made
+ * the change in the old directory AND there was only one
+ * change in the new directory
+ */
if (diropCode == 0 && cm_CheckDirOpForSingleChange(&newDirOp)) {
+ lock_ReleaseWrite(&newDscp->rw);
+
+ if (bTargetExists && !oneDir) {
+ diropCode = cm_DirDeleteEntry(&newDirOp, newNamep);
+#ifdef USE_BPLUS
+ cm_BPlusDirDeleteEntry(&newDirOp, cNewNamep);
+#endif
+ }
+
cm_DirCreateEntry(&newDirOp, newNamep, &fileFid);
#ifdef USE_BPLUS
cm_BPlusDirCreateEntry(&newDirOp, cNewNamep, &fileFid);
#endif
+ lock_ObtainWrite(&newDscp->rw);
}
+ } else {
+ if (!rpc_skipped)
+ InterlockedIncrement(&newDscp->activeRPCs);
}
-#endif /* 0 */
+ cm_SyncOpDone(newDscp, NULL, CM_SCACHESYNC_STOREDATA);
+ lock_ReleaseWrite(&newDscp->rw);
+
cm_EndDirOp(&newDirOp);
}
- /*
- * After the rename the file server has invalidated the callbacks
- * on the file that was moved nor do we have a directory reference
- * to it anymore.
- */
- lock_ObtainWrite(&oldScp->rw);
- cm_DiscardSCache(oldScp);
- lock_ReleaseWrite(&oldScp->rw);
+ if (code == 0) {
+ /*
+ * After the rename the file server has invalidated the callbacks
+ * on the file that was moved and destroyed any target file.
+ */
+ lock_ObtainWrite(&oldScp->rw);
+ cm_DiscardSCache(oldScp);
+ lock_ReleaseWrite(&oldScp->rw);
+
+ if (RDR_Initialized)
+ RDR_InvalidateObject(oldScp->fid.cell, oldScp->fid.volume, oldScp->fid.vnode, oldScp->fid.unique,
+ oldScp->fid.hash, oldScp->fileType, AFS_INVALIDATE_CALLBACK);
+
+ if (oldTargetScp) {
+ lock_ObtainWrite(&oldTargetScp->rw);
+ cm_DiscardSCache(oldTargetScp);
+ lock_ReleaseWrite(&oldTargetScp->rw);
+
+ if (RDR_Initialized)
+ RDR_InvalidateObject(oldTargetScp->fid.cell, oldTargetScp->fid.volume, oldTargetScp->fid.vnode, oldTargetScp->fid.unique,
+ oldTargetScp->fid.hash, oldTargetScp->fileType, AFS_INVALIDATE_CALLBACK);
+ }
+ }
- if (RDR_Initialized)
- RDR_InvalidateObject(oldScp->fid.cell, oldScp->fid.volume, oldScp->fid.vnode, oldScp->fid.unique,
- oldScp->fid.hash, oldScp->fileType, AFS_INVALIDATE_CALLBACK);
done:
if (oldScp)
cm_ReleaseSCache(oldScp);
+ if (oldTargetScp)
+ cm_ReleaseSCache(oldTargetScp);
+
if (free_oldNamep)
free(oldNamep);
afs_int64 int_begin;
afs_int64 int_end;
- int_begin = MAX(pos->offset, neg->offset);
- int_end = MIN(pos->offset+pos->length, neg->offset+neg->length);
+ int_begin = max(pos->offset, neg->offset);
+ int_end = min(pos->offset+pos->length, neg->offset+neg->length);
if (int_begin < int_end) {
if (int_begin == pos->offset) {
osi_Log2(afsd_logp, "CALL SetLock scp 0x%p for lock %d", scp, lockType);
- if ((lockType != LOCKING_ANDX_SHARED_LOCK && scp->fsLockCount != 0) ||
- (lockType == LOCKING_ANDX_SHARED_LOCK && scp->fsLockCount < 0))
- {
- code = CM_ERROR_LOCK_NOT_GRANTED;
+#if 0
+ /*
+ * The file server prior to 1.6.2 does not report an accurate value
+ * and callbacks are not issued if the lock is dropped due to expiration.
+ */
+ if ((lockType != LOCKING_ANDX_SHARED_LOCK && scp->fsLockCount != 0) ||
+ (lockType == LOCKING_ANDX_SHARED_LOCK && scp->fsLockCount < 0))
+ {
+ code = CM_ERROR_LOCK_NOT_GRANTED;
osi_Log2(afsd_logp, "CALL SetLock FAILURE, fsLockCount %d code 0x%x", scp->fsLockCount, code);
- return code;
- }
+ return code;
+ }
+#endif
memset(&volSync, 0, sizeof(volSync));
&volSync);
rx_PutConnection(rxconnp);
- } while (cm_Analyze(connp, userp, reqp, &cfid, &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, &volSync,
+ } while (cm_Analyze(connp, userp, reqp, &cfid, NULL, 1, NULL, &volSync,
NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
if (code)
osi_Log1(afsd_logp, " ExtendLock returns %d", code);
} while (cm_Analyze(connp, userp, &req,
- &cfid, &volSync, NULL, NULL,
+ &cfid, NULL, 1, NULL, &volSync, NULL, NULL,
code));
code = cm_MapRPCError(code, &req);
git://git.openafs.org / openafs.git / blobdiff