#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>
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 */
offset.LowPart = offset.HighPart = 0;
code = cm_GetData(scp, &offset, temp, MOUNTPOINTLEN, 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;
}
/* 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 */
* 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
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
&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);
dscp->fileType, AFS_INVALIDATE_DATA_VERSION);
if (scp) {
- cm_ReleaseSCache(scp);
if (code == 0) {
lock_ObtainWrite(&scp->rw);
if (--scp->linkCount == 0) {
}
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 */
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 (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:
CM_CALLBACK_MAINTAINCOUNT|CM_CALLBACK_BULKSTAT);
InterlockedIncrement(&scp->activeRPCs);
if (!lostRace)
- cm_MergeStatus(dscp, scp, &bbp->stats[j], &volSync, userp, reqp, CM_MERGEFLAG_BULKSTAT);
+ code = cm_MergeStatus(dscp, scp, &bbp->stats[j], &volSync, userp, reqp, CM_MERGEFLAG_BULKSTAT);
lock_ReleaseWrite(&scp->rw);
} else {
lock_ReleaseRead(&scp->rw);
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;
}
- Name = volName;
- OfflineMsg = offLineMsg;
- MOTD = motd;
+ 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(fidp, userp, reqp, &connp);
- if (code) continue;
+ 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);
+ 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);
+ }
- } while (cm_Analyze(connp, userp, reqp, fidp, NULL, 0, NULL, NULL, NULL, code));
- code = cm_MapRPCError(code, reqp);
if (code == 0) {
if (volStat.MaxQuota) {
freespace.QuadPart = 1024 * (afs_int64)min(volStat.MaxQuota - volStat.BlocksInUse, volStat.PartBlocksAvail);
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);
&newFileCallback, &volSync, 0);
InterlockedIncrement(&scp->activeRPCs);
if (!lostRace)
- cm_MergeStatus(dscp, scp, &newFileStatus, &volSync,
- userp, reqp, 0);
+ 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);
&newDirCallback, &volSync, 0);
InterlockedIncrement(&scp->activeRPCs);
if (!lostRace)
- cm_MergeStatus(dscp, scp, &newDirStatus, &volSync,
- userp, reqp, 0);
+ 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);
cm_EndDirOp(&dirop);
if (scp) {
- cm_ReleaseSCache(scp);
if (code == 0) {
lock_ObtainWrite(&scp->rw);
scp->flags |= CM_SCACHEFLAG_DELETED;
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:
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)
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);