static CHAR * RDR_extentBaseAddress = NULL;
void
-RDR_InitReq(cm_req_t *reqp)
+RDR_InitReq(cm_req_t *reqp, BOOL bWow64)
{
cm_InitReq(reqp);
reqp->flags |= CM_REQ_SOURCE_REDIR;
+ if (bWow64)
+ reqp->flags |= CM_REQ_WOW64;
}
void
*pRedirInitInfoLen = (DWORD) (sizeof(AFSRedirectorInitInfo) + (cm_CachePathLen + TempPathLen) * sizeof(WCHAR));
*ppRedirInitInfo = (AFSRedirectorInitInfo *)malloc(*pRedirInitInfoLen);
(*ppRedirInitInfo)->Flags = smb_hideDotFiles ? AFS_REDIR_INIT_FLAG_HIDE_DOT_FILES : 0;
+ (*ppRedirInitInfo)->Flags |= cm_shortNames ? 0 : AFS_REDIR_INIT_FLAG_DISABLE_SHORTNAMES;
(*ppRedirInitInfo)->MaximumChunkLength = cm_data.chunkSize;
(*ppRedirInitInfo)->GlobalFileId.Cell = cm_data.rootFid.cell;
(*ppRedirInitInfo)->GlobalFileId.Volume = cm_data.rootFid.volume;
cm_scache_t * dscp = NULL;
cm_req_t req;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
osi_Log4(afsd_logp, "RDR_EnumerateDirectory FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
DirID.Cell, DirID.Volume, DirID.Vnode, DirID.Unique);
code = RDR_PopulateCurrentEntry( pCurrentEntry, dwMaxEntryLength,
dscp, scp, userp, &req,
entryp->name,
- cm_Is8Dot3(entryp->name) ? NULL : entryp->shortName,
+ cm_shortNames && cm_Is8Dot3(entryp->name) ? NULL : entryp->shortName,
(bWow64 ? RDR_POP_WOW64 : 0) |
(bSkipStatus ? RDR_POP_NO_GETSTATUS : 0),
code,
code = RDR_PopulateCurrentEntryNoScp( pCurrentEntry, dwMaxEntryLength,
dscp, &entryp->fid, userp, &req,
entryp->name,
- cm_Is8Dot3(entryp->name) ? NULL : entryp->shortName,
+ cm_shortNames && cm_Is8Dot3(entryp->name) ? NULL : entryp->shortName,
(bWow64 ? RDR_POP_WOW64 : 0),
code,
&pCurrentEntry, &dwMaxEntryLength);
StringCchCopyNW(FileName, 260, FileNameCounted, FileNameLength / sizeof(WCHAR));
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
osi_Log4(afsd_logp, "RDR_EvaluateNodeByName parent FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
ParentID.Cell, ParentID.Volume, ParentID.Vnode, ParentID.Unique);
if (code == 0 && scp) {
wchar_t shortName[13]=L"";
- if (bVol) {
+ if (!cm_shortNames) {
+ shortName[0] = L'\0';
+ } else if (bVol) {
cm_Gen8Dot3VolNameW(scp->fid.cell, scp->fid.volume, shortName, NULL);
} else if (!cm_Is8Dot3(wszName)) {
cm_dirFid_t dfid;
cm_Gen8Dot3NameIntW(FileName, &dfid, shortName, NULL);
} else {
- shortName[0] = '\0';
+ shortName[0] = L'\0';
}
code = RDR_PopulateCurrentEntry(pCurrentEntry, dwRemaining,
dwRemaining -= (sizeof( AFSFileEvalResultCB) - sizeof( AFSDirEnumEntry));
}
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
if (SourceID.Cell != 0) {
cm_SetFid(&Fid, SourceID.Cell, SourceID.Volume, SourceID.Vnode, SourceID.Unique);
CreateCB->ParentId.Vnode, CreateCB->ParentId.Unique);
osi_Log1(afsd_logp, "... name=%S", osi_LogSaveStringW(afsd_logp, FileName));
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
memset(&setAttr, 0, sizeof(cm_attr_t));
*ResultCB = (AFSCommResult *)malloc(size);
cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
lock_ReleaseWrite(&dscp->rw);
- dfid.vnode = htonl(scp->fid.vnode);
- dfid.unique = htonl(scp->fid.unique);
+ if (cm_shortNames) {
+ dfid.vnode = htonl(scp->fid.vnode);
+ dfid.unique = htonl(scp->fid.unique);
- if (!cm_Is8Dot3(FileName))
- cm_Gen8Dot3NameIntW(FileName, &dfid, shortName, NULL);
- else
- shortName[0] = '\0';
+ if (!cm_Is8Dot3(FileName))
+ cm_Gen8Dot3NameIntW(FileName, &dfid, shortName, NULL);
+ else
+ shortName[0] = '\0';
+ }
code = RDR_PopulateCurrentEntry(&pResultCB->DirEnum, dwRemaining,
dscp, scp, userp, &req, FileName, shortName,
DWORD status;
BOOL bScpLocked = FALSE;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
memset(&setAttr, 0, sizeof(cm_attr_t));
osi_Log4(afsd_logp, "RDR_UpdateFileEntry parent FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
BOOL bFlushFile = FALSE;
cm_key_t key;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
memset(&setAttr, 0, sizeof(cm_attr_t));
osi_Log4(afsd_logp, "RDR_CleanupFileEntry parent FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
osi_LogSaveStringW(afsd_logp, FileName),
bCheckOnly);
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
memset(&setAttr, 0, sizeof(cm_attr_t));
*ResultCB = (AFSCommResult *)malloc( size);
afs_uint32 code;
DWORD status;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
StringCchCopyNW(SourceFileName, 260, SourceFileNameCounted, SourceFileNameLength / sizeof(WCHAR));
StringCchCopyNW(TargetFileName, 260, TargetFileNameCounted, TargetFileNameLength / sizeof(WCHAR));
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
lock_ReleaseWrite(&scp->rw);
- dfid.vnode = htonl(scp->fid.vnode);
- dfid.unique = htonl(scp->fid.unique);
+ if (cm_shortNames) {
+ dfid.vnode = htonl(scp->fid.vnode);
+ dfid.unique = htonl(scp->fid.unique);
- if (!cm_Is8Dot3(TargetFileName))
- cm_Gen8Dot3NameIntW(TargetFileName, &dfid, shortName, NULL);
- else
- shortName[0] = '\0';
+ if (!cm_Is8Dot3(TargetFileName))
+ cm_Gen8Dot3NameIntW(TargetFileName, &dfid, shortName, NULL);
+ else
+ shortName[0] = '\0';
+ }
RDR_PopulateCurrentEntry(&pResultCB->DirEnum, dwRemaining,
newDscp, scp, userp, &req, TargetFileName, shortName,
char dbgstr[1024];
#endif
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
osi_Log4(afsd_logp, "RDR_FlushFileEntry File FID cell 0x%x vol 0x%x vno 0x%x uniq 0x%x",
FileId.Cell, FileId.Volume,
cm_req_t req;
DWORD status;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
osi_Log4(afsd_logp, "RDR_OpenFileEntry File FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
FileId.Cell, FileId.Volume,
cm_req_t req;
DWORD status;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
osi_Log4(afsd_logp, "RDR_ReleaseFileAccess File FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
FileId.Cell, FileId.Volume,
}
lock_ReleaseWrite(&scp->rw);
- dwResultBufferLength = (DWORD)(sizeof( AFSSetFileExtentsCB) + sizeof( AFSSetFileExtentsCB) * (length.QuadPart / cm_data.blockSize + 1));
+ dwResultBufferLength = (DWORD)(sizeof( AFSSetFileExtentsCB) + sizeof( AFSFileExtentCB) * (length.QuadPart / cm_data.blockSize + 1));
pResultCB = (AFSSetFileExtentsCB *)malloc( dwResultBufferLength );
if (!pResultCB)
return CM_ERROR_RETRY;
cm_req_t req;
BOOLEAN bBufRelease = TRUE;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
req.flags |= CM_REQ_NORETRY;
osi_Log4(afsd_logp, "RDR_RequestFileExtentsAsync File FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
char dbgstr[1024];
#endif
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
osi_Log4(afsd_logp, "RDR_ReleaseFileExtents File FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
FileId.Cell, FileId.Volume,
pExtent->CacheOffset.LowPart);
osi_Log5( afsd_logp, "... belongs to bp 0x%p vol 0x%x vno 0x%x foffset 0x%x:%x",
wbp, wbp->fid.volume, wbp->fid.vnode, wbp->offset.HighPart, wbp->offset.LowPart);
-#ifdef DEBUG
- DebugBreak();
-#endif
}
buf_Release(bufp);
}
#endif
char dbgstr[1024];
#endif
- RDR_InitReq(&req);
+ RDR_InitReq(&req, FALSE);
for ( fileno = 0, pNextFileCB = &ReleaseFileExtentsResultCB->Files[0];
fileno < ReleaseFileExtentsResultCB->FileCount;
osi_Log2(afsd_logp, "... coffset 0x%x:%x",
pExtent->CacheOffset.HighPart,
pExtent->CacheOffset.LowPart);
-#ifdef DEBUG
- DebugBreak();
-#endif
- if (!deleted) {
+
+ if (!deleted) {
buf_SetDirty(bufp, &req, pExtent->DirtyOffset, pExtent->DirtyLength, userp);
dirty++;
}
wbp, wbp->fid.volume, wbp->fid.vnode, wbp->offset.HighPart, wbp->offset.LowPart);
else
osi_Log0(afsd_logp, "... coffset cannot be found");
-#ifdef DEBUG
- DebugBreak();
-#endif
}
buf_Release(bufp);
} else {
cm_scache_t * scp = NULL;
int dirty = 0;
- RDR_InitReq(&req);
+ RDR_InitReq(&req, FALSE);
osi_Log4(afsd_logp, "RDR_ReleaseFailedSetFileExtents %d.%d.%d.%d",
SetFileExtentsResultCB->FileId.Cell, SetFileExtentsResultCB->FileId.Volume,
{
cm_fid_t ParentFid;
cm_fid_t RootFid;
+ cm_req_t req;
+
+ RDR_InitReq(&req, bWow64);
*ResultCB = (AFSCommResult *)malloc( sizeof( AFSCommResult));
if (!(*ResultCB))
RootFid.hash = pPioctlCB->RootId.Hash;
/* Create the pioctl index */
- RDR_SetupIoctl(pPioctlCB->RequestId, &ParentFid, &RootFid, userp);
+ RDR_SetupIoctl(pPioctlCB->RequestId, &ParentFid, &RootFid, userp, &req);
return;
}
cm_req_t req;
DWORD status;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
*ResultCB = (AFSCommResult *)malloc( sizeof( AFSCommResult) + sizeof(AFSPIOCtlIOResultCB));
if (!(*ResultCB))
pResultCB = (AFSPIOCtlIOResultCB *)(*ResultCB)->ResultData;
- code = RDR_IoctlWrite(userp, pPioctlCB->RequestId, pPioctlCB->BufferLength, pPioctlCB->MappedBuffer, &req);
+ code = RDR_IoctlWrite(userp, pPioctlCB->RequestId, pPioctlCB->BufferLength, pPioctlCB->MappedBuffer);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
DWORD status;
afs_uint32 pflags = (bIsLocalSystem ? AFSCALL_FLAG_LOCAL_SYSTEM : 0);
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
*ResultCB = (AFSCommResult *)malloc( sizeof( AFSCommResult) + sizeof(AFSPIOCtlIOResultCB));
if (!(*ResultCB))
pResultCB = (AFSPIOCtlIOResultCB *)(*ResultCB)->ResultData;
code = RDR_IoctlRead(userp, pPioctlCB->RequestId, pPioctlCB->BufferLength, pPioctlCB->MappedBuffer,
- &pResultCB->BytesProcessed, &req, pflags);
+ &pResultCB->BytesProcessed, pflags);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
ProcessId.QuadPart = pBRLRequestCB->ProcessId;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
osi_Log4(afsd_logp, "RDR_ByteRangeLockSync File FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
FileId.Cell, FileId.Volume,
ProcessId.QuadPart = pBRURequestCB->ProcessId;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
osi_Log4(afsd_logp, "RDR_ByteRangeUnlock File FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
FileId.Cell, FileId.Volume,
ProcessId.QuadPart = pBRURequestCB->ProcessId;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
osi_Log4(afsd_logp, "RDR_ByteRangeUnlockAll File FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
FileId.Cell, FileId.Volume,
DWORD Length;
cm_scache_t *scp = NULL;
cm_volume_t *volp = NULL;
- cm_vol_state_t *volstatep = NULL;
afs_uint32 volType;
cm_cell_t *cellp = NULL;
cm_fid_t Fid;
char *OfflineMsg;
char *MOTD;
struct rx_connection * rxconnp;
+ int sync_done = 0;
+ int scp_locked = 0;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
osi_Log4(afsd_logp, "RDR_GetVolumeInfo File FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
FileId.Cell, FileId.Volume,
return;
}
lock_ObtainWrite(&scp->rw);
-
- code = cm_SyncOp(scp, NULL, userp, &req, PRSFS_READ,
- CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- if (code) {
- lock_ReleaseWrite(&scp->rw);
- smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
- (*ResultCB)->ResultStatus = status;
- (*ResultCB)->ResultBufferLength = 0;
- osi_Log3(afsd_logp, "RDR_GetVolumeInfo cm_SyncOp failure scp=0x%p code=0x%x status=0x%x",
- scp, code, status);
- return;
- }
+ scp_locked = 1;
pResultCB->SectorsPerAllocationUnit = 1;
pResultCB->BytesPerSector = 1024;
code = CM_ERROR_NOSUCHVOLUME;
goto _done;
}
- volstatep = cm_VolumeStateByID(volp, scp->fid.volume);
volType = cm_VolumeType(volp, scp->fid.volume);
pResultCB->Characteristics |= ((volType == ROVOL || volType == BACKVOL) ? FILE_READ_ONLY_DEVICE : 0);
- Name = volName;
- OfflineMsg = offLineMsg;
- MOTD = motd;
- lock_ReleaseWrite(&scp->rw);
- do {
- code = cm_ConnFromFID(&scp->fid, userp, &req, &connp);
- if (code) continue;
-
- rxconnp = cm_GetRxConn(connp);
- code = RXAFS_GetVolumeStatus(rxconnp, scp->fid.volume,
- &volStat, &Name, &OfflineMsg, &MOTD);
- rx_PutConnection(rxconnp);
-
- } while (cm_Analyze(connp, userp, &req, &scp->fid, NULL, 0, NULL, NULL, NULL, code));
- code = cm_MapRPCError(code, &req);
+ code = cm_SyncOp(scp, NULL, userp, &req, PRSFS_READ,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ if (code == 0)
+ {
+ sync_done = 1;
+
+ Name = volName;
+ OfflineMsg = offLineMsg;
+ MOTD = motd;
+ lock_ReleaseWrite(&scp->rw);
+ scp_locked = 0;
+
+ do {
+ code = cm_ConnFromFID(&scp->fid, userp, &req, &connp);
+ if (code) continue;
+
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_GetVolumeStatus(rxconnp, scp->fid.volume,
+ &volStat, &Name, &OfflineMsg, &MOTD);
+ rx_PutConnection(rxconnp);
+
+ } while (cm_Analyze(connp, userp, &req, &scp->fid, NULL, 0, NULL, NULL, NULL, code));
+ code = cm_MapRPCError(code, &req);
+ }
+
if (code == 0) {
if (volStat.MaxQuota)
{
}
}
} else {
+ /*
+ * Lie about the available space. Out of quota errors will need
+ * detected when the file server rejects the store data.
+ */
pResultCB->TotalAllocationUnits.QuadPart = 0x7FFFFFFF;
pResultCB->AvailableAllocationUnits.QuadPart = (volType == ROVOL || volType == BACKVOL) ? 0 : 0x3F000000;
+ code = 0;
}
pResultCB->VolumeLabelLength = cm_Utf8ToUtf16( volp->namep, -1, pResultCB->VolumeLabel,
if ( pResultCB->VolumeLabelLength )
pResultCB->VolumeLabelLength--;
- lock_ObtainWrite(&scp->rw);
+ if (sync_done) {
+ if (!scp_locked) {
+ lock_ObtainWrite(&scp->rw);
+ scp_locked = 1;
+ }
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ }
}
pResultCB->VolumeLabelLength *= sizeof(WCHAR); /* convert to bytes from chars */
- cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
-
_done:
- lock_ReleaseWrite(&scp->rw);
+ if (scp_locked)
+ lock_ReleaseWrite(&scp->rw);
if (volp)
cm_PutVolume(volp);
cm_ReleaseSCache(scp);
char *OfflineMsg;
char *MOTD;
struct rx_connection * rxconnp;
+ int sync_done = 0;
+ int scp_locked = 0;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
osi_Log4(afsd_logp, "RDR_GetVolumeSizeInfo File FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
FileId.Cell, FileId.Volume,
return;
}
lock_ObtainWrite(&scp->rw);
-
- code = cm_SyncOp(scp, NULL, userp, &req, PRSFS_READ,
- CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- if (code) {
- lock_ReleaseWrite(&scp->rw);
- smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
- (*ResultCB)->ResultStatus = status;
- (*ResultCB)->ResultBufferLength = 0;
- osi_Log3(afsd_logp, "RDR_GetVolumeSizeInfo cm_SyncOp failure scp=0x%p code=0x%x status=0x%x",
- scp, code, status);
- return;
- }
+ scp_locked = 1;
pResultCB->SectorsPerAllocationUnit = 1;
pResultCB->BytesPerSector = 1024;
if (scp->fid.cell==AFS_FAKE_ROOT_CELL_ID &&
- scp->fid.volume==AFS_FAKE_ROOT_VOL_ID)
+ scp->fid.volume==AFS_FAKE_ROOT_VOL_ID)
{
pResultCB->TotalAllocationUnits.QuadPart = 100;
pResultCB->AvailableAllocationUnits.QuadPart = 0;
}
volType = cm_VolumeType(volp, scp->fid.volume);
- Name = volName;
- OfflineMsg = offLineMsg;
- MOTD = motd;
- lock_ReleaseWrite(&scp->rw);
- do {
- code = cm_ConnFromFID(&scp->fid, userp, &req, &connp);
- if (code) continue;
-
- rxconnp = cm_GetRxConn(connp);
- code = RXAFS_GetVolumeStatus(rxconnp, scp->fid.volume,
- &volStat, &Name, &OfflineMsg, &MOTD);
- rx_PutConnection(rxconnp);
-
- } while (cm_Analyze(connp, userp, &req, &scp->fid, NULL, 0, NULL, NULL, NULL, code));
- code = cm_MapRPCError(code, &req);
+
+ code = cm_SyncOp(scp, NULL, userp, &req, PRSFS_READ,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ if (code == 0)
+ {
+ sync_done = 1;
+
+ Name = volName;
+ OfflineMsg = offLineMsg;
+ MOTD = motd;
+ lock_ReleaseWrite(&scp->rw);
+ scp_locked = 0;
+
+ do {
+ code = cm_ConnFromFID(&scp->fid, userp, &req, &connp);
+ if (code) continue;
+
+ rxconnp = cm_GetRxConn(connp);
+ code = RXAFS_GetVolumeStatus(rxconnp, scp->fid.volume,
+ &volStat, &Name, &OfflineMsg, &MOTD);
+ rx_PutConnection(rxconnp);
+
+ } while (cm_Analyze(connp, userp, &req, &scp->fid, NULL, 0, NULL, NULL, NULL, code));
+ code = cm_MapRPCError(code, &req);
+ }
+
if (code == 0) {
if (volStat.MaxQuota)
{
}
}
} else {
-
+ /*
+ * Lie about the available space. Out of quota errors will need
+ * detected when the file server rejects the store data.
+ */
pResultCB->TotalAllocationUnits.QuadPart = 0x7FFFFFFF;
pResultCB->AvailableAllocationUnits.QuadPart = (volType == ROVOL || volType == BACKVOL) ? 0 : 0x3F000000;
code = 0;
}
- lock_ObtainWrite(&scp->rw);
- }
- cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ if (sync_done) {
+ if (!scp_locked) {
+ lock_ObtainWrite(&scp->rw);
+ scp_locked = 1;
+ }
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ }
+ }
_done:
- lock_ReleaseWrite(&scp->rw);
+ if (scp_locked)
+ lock_ReleaseWrite(&scp->rw);
if (volp)
cm_PutVolume(volp);
cm_ReleaseSCache(scp);
DWORD Length;
cm_req_t req;
- RDR_InitReq(&req);
+ RDR_InitReq(&req, FALSE);
osi_Log1(afsd_logp, "RDR_HoldFid Count=%u", pHoldFidCB->Count);
DWORD Length;
cm_req_t req;
- RDR_InitReq(&req);
+ RDR_InitReq(&req, FALSE);
osi_Log1(afsd_logp, "RDR_ReleaseFid Count=%u", pReleaseFidCB->Count);
cm_req_t req;
DWORD status;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
*ResultCB = (AFSCommResult *)malloc( sizeof( AFSCommResult) + sizeof(AFSPipeIOResultCB));
if (!(*ResultCB))
cm_req_t req;
DWORD status;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
*ResultCB = (AFSCommResult *)malloc( sizeof( AFSCommResult) + ResultBufferLength);
if (!(*ResultCB))
cm_req_t req;
DWORD status;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
*ResultCB = (AFSCommResult *)malloc( sizeof( AFSCommResult));
if (!(*ResultCB))
cm_req_t req;
DWORD status;
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
*ResultCB = (AFSCommResult *)malloc( sizeof( AFSCommResult) + ResultBufferLength);
if (!(*ResultCB))
DWORD status;
DWORD Length = ResultBufferLength + sizeof( AFSCommResult);
- RDR_InitReq(&req);
- if ( bWow64 )
- req.flags |= CM_REQ_WOW64;
+ RDR_InitReq(&req, bWow64);
*ResultCB = (AFSCommResult *)malloc( Length);
if (!(*ResultCB))