return 0;
}
+static wchar_t cname[MAX_COMPUTERNAME_LENGTH+1] = L"";
+
cm_user_t *
RDR_GetLocalSystemUser( void)
{
smb_username_t *unp;
cm_user_t *userp = NULL;
- wchar_t cname[MAX_COMPUTERNAME_LENGTH+1];
- int cnamelen = MAX_COMPUTERNAME_LENGTH+1;
-
- GetComputerNameW(cname, &cnamelen);
- _wcsupr(cname);
+ if ( cname[0] == '\0') {
+ int len = MAX_COMPUTERNAME_LENGTH+1;
+ GetComputerNameW(cname, &len);
+ _wcsupr(cname);
+ }
unp = smb_FindUserByName(NTSID_LOCAL_SYSTEM, cname, SMB_FLAG_CREATE);
lock_ObtainMutex(&unp->mx);
if (!unp->userp)
smb_username_t *unp;
cm_user_t * userp = NULL;
RPC_WSTR UuidString = NULL;
- wchar_t cname[MAX_COMPUTERNAME_LENGTH+1];
- int cnamelen = MAX_COMPUTERNAME_LENGTH+1;
if (UuidToStringW((UUID *)pGuid, &UuidString) != RPC_S_OK)
goto done;
- GetComputerNameW(cname, &cnamelen);
- _wcsupr(cname);
+ if ( cname[0] == '\0') {
+ int len = MAX_COMPUTERNAME_LENGTH+1;
+ GetComputerNameW(cname, &len);
+ _wcsupr(cname);
+ }
unp = smb_FindUserByName(UuidString, cname, SMB_FLAG_CREATE);
lock_ObtainMutex(&unp->mx);
- if (!unp->userp)
+ if (!unp->userp) {
unp->userp = cm_NewUser();
+ memcpy(&unp->userp->authgroup, pGuid, sizeof(GUID));
+ }
unp->flags |= SMB_USERNAMEFLAG_SID;
lock_ReleaseMutex(&unp->mx);
userp = unp->userp;
}
/*
- * Obtain the status information for the specified object and
- *
+ * Obtain the status information for the specified object using
+ * an inline bulk status rpc. cm_BPlusDirEnumBulkStatOne() will
+ * obtain current status for the directory object, the object
+ * which is the focus of the inquiry and as many other objects
+ * in the directory for which there are not callbacks registered
+ * since we are likely to be asked for other objects in the directory.
*/
static afs_uint32
RDR_BulkStatLookup( cm_scache_t *dscp,
code);
}
-
if (enump)
{
code = cm_BPlusDirEnumBulkStatOne(enump, scp);
#define RDR_POP_WOW64 0x04
#define RDR_POP_NO_GETSTATUS 0x08
-afs_uint32
+static afs_uint32
RDR_PopulateCurrentEntry( IN AFSDirEnumEntry * pCurrentEntry,
IN DWORD dwMaxEntryLength,
IN cm_scache_t * dscp,
IN wchar_t * name,
IN wchar_t * shortName,
IN DWORD dwFlags,
+ IN afs_uint32 cmError,
OUT AFSDirEnumEntry **ppNextEntry,
OUT DWORD * pdwRemainingLength)
{
* status information. If not, perform a bulk status lookup of multiple
* entries in order to reduce the number of RPCs issued to the file server.
*/
- if ((scp->flags & CM_SCACHEFLAG_EACCESS))
+ if (cm_EAccesFindEntry(userp, &scp->fid))
bMustFake = TRUE;
else if (!cm_HaveCallback(scp)) {
lock_ReleaseWrite(&scp->rw);
code = RDR_BulkStatLookup(dscp, scp, userp, reqp);
if (code) {
- osi_Log2(afsd_logp, "RDR_PopulateCurrentEntry RXR_BulkStatLookup failed for scp=0x%p code=0x%x",
+ osi_Log2(afsd_logp, "RDR_PopulateCurrentEntry RDR_BulkStatLookup failed for scp=0x%p code=0x%x",
scp, code);
return code;
}
bMustFake = TRUE;
}
}
-
}
+ /* Populate the error code */
+ smb_MapNTError(cmError, &pCurrentEntry->NTStatus, TRUE);
+
/* Populate the real or fake data */
pCurrentEntry->FileId.Cell = scp->fid.cell;
pCurrentEntry->FileId.Volume = scp->fid.volume;
if (bMustFake) {
switch (scp->fileType) {
case CM_SCACHETYPE_DIRECTORY:
+ pCurrentEntry->FileAttributes = SMB_ATTR_DIRECTORY;
+ break;
case CM_SCACHETYPE_MOUNTPOINT:
case CM_SCACHETYPE_INVALID:
- pCurrentEntry->FileAttributes = SMB_ATTR_DIRECTORY;
+ pCurrentEntry->FileAttributes = SMB_ATTR_DIRECTORY | SMB_ATTR_REPARSE_POINT;
break;
case CM_SCACHETYPE_SYMLINK:
if (cm_TargetPerceivedAsDirectory(scp->mountPointStringp))
- pCurrentEntry->FileAttributes = SMB_ATTR_DIRECTORY;
+ pCurrentEntry->FileAttributes = SMB_ATTR_DIRECTORY | SMB_ATTR_REPARSE_POINT;
else
- pCurrentEntry->FileAttributes = SMB_ATTR_NORMAL;
+ pCurrentEntry->FileAttributes = SMB_ATTR_REPARSE_POINT;
break;
default:
/* if we get here we either have a normal file
wcsncpy(wname, name, len);
pCurrentEntry->FileNameLength = (ULONG)(sizeof(WCHAR) * len);
- osi_Log2(afsd_logp, "RDR_PopulateCurrentEntry scp=0x%p fileType=%d",
- scp, scp->fileType);
+ osi_Log3(afsd_logp, "RDR_PopulateCurrentEntry scp=0x%p fileType=%d dv=%u",
+ scp, scp->fileType, (afs_uint32)scp->dataVersion);
if (!(dwFlags & RDR_POP_NO_GETSTATUS))
cm_SyncOpDone( scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
return code;
}
-afs_uint32
+static afs_uint32
RDR_PopulateCurrentEntryNoScp( IN AFSDirEnumEntry * pCurrentEntry,
IN DWORD dwMaxEntryLength,
IN cm_scache_t * dscp,
IN wchar_t * name,
IN wchar_t * shortName,
IN DWORD dwFlags,
+ IN afs_uint32 cmError,
OUT AFSDirEnumEntry **ppNextEntry,
OUT DWORD * pdwRemainingLength)
{
dwEntryLength = sizeof(AFSDirEnumEntry);
+ /* Populate the error code */
+ smb_MapNTError(cmError, &pCurrentEntry->NTStatus, TRUE);
+
+ /* Populate the fake data */
pCurrentEntry->FileId.Cell = fidp->cell;
pCurrentEntry->FileId.Volume = fidp->volume;
pCurrentEntry->FileId.Vnode = fidp->vnode;
fid.unique = DirID.Unique;
fid.hash = DirID.Hash;
- code = cm_GetSCache(&fid, &dscp, userp, &req);
+ code = cm_GetSCache(&fid, NULL, &dscp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
return;
}
+ osi_Log1(afsd_logp, "RDR_EnumerateDirectory dv=%u", (afs_uint32)dscp->dataVersion);
+
/*
* If there is no enumeration handle, then this is a new query
- * and we must perform an enumeration for the specified object
+ * and we must perform an enumeration for the specified object.
*/
if (QueryCB->EnumHandle == (ULONG_PTR)NULL) {
cm_dirOp_t dirop;
code = cm_BeginDirOp(dscp, userp, &req, CM_DIRLOCK_READ, CM_DIROP_FLAG_NONE, &dirop);
if (code == 0) {
- code = cm_BPlusDirEnumerate(dscp, userp, &req, TRUE, NULL, !bSkipStatus, &enump);
+ code = cm_BPlusDirEnumerate(dscp, userp, &req,
+ TRUE /* dir locked */, NULL /* no mask */,
+ TRUE /* fetch status? */, &enump);
if (code) {
osi_Log1(afsd_logp, "RDR_EnumerateDirectory cm_BPlusDirEnumerate failure code=0x%x",
code);
enump = (cm_direnum_t *)QueryCB->EnumHandle;
}
- if (enump && ResultBufferLength) {
- cm_direnum_entry_t * entryp = NULL;
+ if (enump) {
+ if (ResultBufferLength == 0) {
+ code = cm_BPlusDirEnumBulkStat(enump);
+ if (code) {
+ osi_Log1(afsd_logp, "RDR_EnumerateDirectory cm_BPlusDirEnumBulkStat failure code=0x%x",
+ code);
+ }
+ } else {
+ cm_direnum_entry_t * entryp = NULL;
- getnextentry:
- if (dwMaxEntryLength < sizeof(AFSDirEnumEntry) + (MAX_PATH + MOUNTPOINTLEN) * sizeof(wchar_t)) {
- osi_Log0(afsd_logp, "RDR_EnumerateDirectory out of space, returning");
- goto outofspace;
- }
+ pDirEnumResp->SnapshotDataVersion.QuadPart = enump->dataVersion;
- code = cm_BPlusDirNextEnumEntry(enump, &entryp);
+ getnextentry:
+ if (dwMaxEntryLength < sizeof(AFSDirEnumEntry) + (MAX_PATH + MOUNTPOINTLEN) * sizeof(wchar_t)) {
+ osi_Log0(afsd_logp, "RDR_EnumerateDirectory out of space, returning");
+ goto outofspace;
+ }
- if ((code == 0 || code == CM_ERROR_STOPNOW) && entryp) {
- cm_scache_t *scp;
- int stopnow = (code == CM_ERROR_STOPNOW);
+ code = cm_BPlusDirNextEnumEntry(enump, &entryp);
- if ( !wcscmp(L".", entryp->name) || !wcscmp(L"..", entryp->name) ) {
- osi_Log0(afsd_logp, "RDR_EnumerateDirectory skipping . or ..");
- if (stopnow)
- goto outofspace;
- goto getnextentry;
- }
+ if ((code == 0 || code == CM_ERROR_STOPNOW) && entryp) {
+ cm_scache_t *scp = NULL;
+ int stopnow = (code == CM_ERROR_STOPNOW);
- if ( FALSE /* bSkipStatus */) {
- scp = cm_FindSCache(&entryp->fid);
- code = 0;
- } else {
- code = cm_GetSCache(&entryp->fid, &scp, userp, &req);
- }
+ if ( !wcscmp(L".", entryp->name) || !wcscmp(L"..", entryp->name) ) {
+ osi_Log0(afsd_logp, "RDR_EnumerateDirectory skipping . or ..");
+ if (stopnow)
+ goto outofspace;
+ goto getnextentry;
+ }
+
+ if (bSkipStatus) {
+ code = cm_GetSCache(&entryp->fid, &dscp->fid, &scp, userp, &req);
+ if (code) {
+ osi_Log5(afsd_logp, "RDR_EnumerateDirectory cm_GetSCache failure cell %u vol %u vnode %u uniq %u code=0x%x",
+ entryp->fid.cell, entryp->fid.volume, entryp->fid.vnode, entryp->fid.unique, code);
+ }
+ } else {
+ code = entryp->errorCode;
+ scp = code ? NULL : cm_FindSCache(&entryp->fid);
+ }
- if (!code) {
if (scp) {
- code = RDR_PopulateCurrentEntry(pCurrentEntry, dwMaxEntryLength,
+ code = RDR_PopulateCurrentEntry( pCurrentEntry, dwMaxEntryLength,
dscp, scp, userp, &req,
- entryp->name, entryp->shortName,
+ entryp->name,
+ cm_Is8Dot3(entryp->name) ? NULL : entryp->shortName,
(bWow64 ? RDR_POP_WOW64 : 0) |
(bSkipStatus ? RDR_POP_NO_GETSTATUS : 0),
+ code,
&pCurrentEntry, &dwMaxEntryLength);
cm_ReleaseSCache(scp);
} else {
code = RDR_PopulateCurrentEntryNoScp( pCurrentEntry, dwMaxEntryLength,
dscp, &entryp->fid, userp, &req,
- entryp->name, entryp->shortName,
+ entryp->name,
+ cm_Is8Dot3(entryp->name) ? NULL : entryp->shortName,
(bWow64 ? RDR_POP_WOW64 : 0),
+ code,
&pCurrentEntry, &dwMaxEntryLength);
}
if (stopnow)
goto outofspace;
goto getnextentry;
- } else {
- osi_Log2(afsd_logp, "RDR_EnumerateDirectory cm_GetSCache failure scp=0x%p code=0x%x",
- scp, code);
- if (stopnow)
- goto outofspace;
- goto getnextentry;
}
}
}
- if (enump && ResultBufferLength == 0) {
- code = cm_BPlusDirEnumBulkStat(enump);
- if (code) {
- osi_Log1(afsd_logp, "RDR_EnumerateDirectory cm_BPlusDirEnumBulkStat failure code=0x%x",
- code);
- }
- }
outofspace:
if (code || enump->next == enump->count || ResultBufferLength == 0) {
(*ResultCB)->ResultBufferLength = ResultBufferLength - dwMaxEntryLength;
pDirEnumResp->EnumHandle = (ULONG_PTR) enump;
+ pDirEnumResp->CurrentDataVersion.QuadPart = dscp->dataVersion;
}
if (dscp)
IN DWORD ResultBufferLength,
IN OUT AFSCommResult **ResultCB)
{
+ AFSFileEvalResultCB *pEvalResultCB = NULL;
AFSDirEnumEntry * pCurrentEntry;
- size_t size = sizeof(AFSCommResult) + ResultBufferLength - 1;
+ size_t size = ResultBufferLength ? sizeof(AFSCommResult) + ResultBufferLength - 1 : sizeof(AFSCommResult);
afs_uint32 code = 0;
cm_scache_t * scp = NULL;
cm_scache_t * dscp = NULL;
}
memset(*ResultCB, 0, size);
- (*ResultCB)->ResultBufferLength = ResultBufferLength;
- if (ResultBufferLength)
- pCurrentEntry = (AFSDirEnumEntry *)&(*ResultCB)->ResultData;
+ (*ResultCB)->ResultBufferLength = 0;
+ dwRemaining = ResultBufferLength;
+ if (ResultBufferLength >= sizeof( AFSFileEvalResultCB)) {
+ pEvalResultCB = (AFSFileEvalResultCB *)&(*ResultCB)->ResultData;
+ pCurrentEntry = &pEvalResultCB->DirEnum;
+ dwRemaining -= (sizeof( AFSFileEvalResultCB) - sizeof( AFSDirEnumEntry));
+ }
if (ParentID.Cell != 0) {
parentFid.cell = ParentID.Cell;
parentFid.unique = ParentID.Unique;
parentFid.hash = ParentID.Hash;
- code = cm_GetSCache(&parentFid, &dscp, userp, &req);
+ code = cm_GetSCache(&parentFid, NULL, &dscp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
+ if ( status == STATUS_INVALID_HANDLE)
+ status = STATUS_OBJECT_PATH_INVALID;
osi_Log2(afsd_logp, "RDR_EvaluateNodeByName cm_GetSCache parentFID failure code=0x%x status=0x%x",
code, status);
free(wszName);
*/
StringCchCopyNW(wszName, cbName, _C(CM_PREFIX_VOL), CM_PREFIX_VOL_CCH);
StringCbCatNW(wszName, cbName, FileName, FileNameLength);
- cm_strlwr_utf16(wszName);
bVol = TRUE;
code = cm_EvaluateVolumeReference(wszName, CM_FLAG_CHECKPATH, userp, &req, &scp);
shortName[0] = '\0';
}
- code = RDR_PopulateCurrentEntry(pCurrentEntry, ResultBufferLength,
+ code = RDR_PopulateCurrentEntry(pCurrentEntry, dwRemaining,
dscp, scp, userp, &req,
FileName, shortName,
(bWow64 ? RDR_POP_WOW64 : 0) |
(bNoFollow ? 0 : (RDR_POP_FOLLOW_MOUNTPOINTS | RDR_POP_EVALUATE_SYMLINKS)),
- NULL, &dwRemaining);
+ 0, NULL, &dwRemaining);
if (bHoldFid)
RDR_FlagScpInUse( scp, FALSE );
cm_ReleaseSCache(scp);
osi_Log2(afsd_logp, "RDR_EvaluateNodeByName FAILURE code=0x%x status=0x%x",
code, status);
} else {
+ pEvalResultCB->ParentDataVersion.QuadPart = dscp->dataVersion;
(*ResultCB)->ResultStatus = STATUS_SUCCESS;
(*ResultCB)->ResultBufferLength = ResultBufferLength - dwRemaining;
osi_Log0(afsd_logp, "RDR_EvaluateNodeByName SUCCESS");
IN DWORD ResultBufferLength,
IN OUT AFSCommResult **ResultCB)
{
- AFSDirEnumEntry * pCurrentEntry;
- size_t size = sizeof(AFSCommResult) + ResultBufferLength - 1;
+ AFSFileEvalResultCB *pEvalResultCB = NULL;
+ AFSDirEnumEntry * pCurrentEntry = NULL;
+ size_t size = ResultBufferLength ? sizeof(AFSCommResult) + ResultBufferLength - 1 : sizeof(AFSCommResult);
afs_uint32 code = 0;
cm_scache_t * scp = NULL;
cm_scache_t * dscp = NULL;
}
memset(*ResultCB, 0, size);
- (*ResultCB)->ResultBufferLength = ResultBufferLength;
+ (*ResultCB)->ResultBufferLength = 0;
dwRemaining = ResultBufferLength;
- if (ResultBufferLength)
- pCurrentEntry = (AFSDirEnumEntry *)&(*ResultCB)->ResultData;
+ if (ResultBufferLength >= sizeof( AFSFileEvalResultCB)) {
+ pEvalResultCB = (AFSFileEvalResultCB *)&(*ResultCB)->ResultData;
+ pCurrentEntry = &pEvalResultCB->DirEnum;
+ dwRemaining -= (sizeof( AFSFileEvalResultCB) - sizeof( AFSDirEnumEntry));
+ }
RDR_InitReq(&req);
if ( bWow64 )
req.flags |= CM_REQ_WOW64;
if (SourceID.Cell != 0) {
- Fid.cell = SourceID.Cell;
- Fid.volume = SourceID.Volume;
- Fid.vnode = SourceID.Vnode;
- Fid.unique = SourceID.Unique;
- Fid.hash = SourceID.Hash;
-
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ cm_SetFid(&Fid, SourceID.Cell, SourceID.Volume, SourceID.Vnode, SourceID.Unique);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
if (ParentID.Cell != 0) {
cm_SetFid(&parentFid, ParentID.Cell, ParentID.Volume, ParentID.Vnode, ParentID.Unique);
- code = cm_GetSCache(&parentFid, &dscp, userp, &req);
+ code = cm_GetSCache(&parentFid, NULL, &dscp, userp, &req);
if (code) {
cm_ReleaseSCache(scp);
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
+ if ( status == STATUS_INVALID_HANDLE)
+ status = STATUS_OBJECT_PATH_INVALID;
(*ResultCB)->ResultStatus = status;
osi_Log2(afsd_logp, "RDR_EvaluateNodeByID cm_GetSCache parentFID failure code=0x%x status=0x%x",
code, status);
cm_HoldSCache(dscp);
} else if (scp->parentVnode) {
cm_SetFid(&parentFid, SourceID.Cell, SourceID.Volume, scp->parentVnode, scp->parentUnique);
- code = cm_GetSCache(&parentFid, &dscp, userp, &req);
+ code = cm_GetSCache(&parentFid, NULL, &dscp, userp, &req);
if (code) {
cm_ReleaseSCache(scp);
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
+ if ( status == STATUS_INVALID_HANDLE)
+ status = STATUS_OBJECT_PATH_INVALID;
(*ResultCB)->ResultStatus = status;
osi_Log2(afsd_logp, "RDR_EvaluateNodeByID cm_GetSCache parentFID failure code=0x%x status=0x%x",
code, status);
return;
}
- code = RDR_PopulateCurrentEntry(pCurrentEntry, ResultBufferLength,
+ code = RDR_PopulateCurrentEntry(pCurrentEntry, dwRemaining,
dscp, scp, userp, &req, NULL, NULL,
(bWow64 ? RDR_POP_WOW64 : 0) |
(bNoFollow ? 0 : (RDR_POP_FOLLOW_MOUNTPOINTS | RDR_POP_EVALUATE_SYMLINKS)),
- NULL, &dwRemaining);
+ 0, NULL, &dwRemaining);
if (bHoldFid)
RDR_FlagScpInUse( scp, FALSE );
osi_Log2(afsd_logp, "RDR_EvaluateNodeByID FAILURE code=0x%x status=0x%x",
code, status);
} else {
+ pEvalResultCB->ParentDataVersion.QuadPart = dscp->dataVersion;
+
(*ResultCB)->ResultStatus = STATUS_SUCCESS;
(*ResultCB)->ResultBufferLength = ResultBufferLength - dwRemaining;
osi_Log0(afsd_logp, "RDR_EvaluateNodeByID SUCCESS");
parentFid.unique = CreateCB->ParentId.Unique;
parentFid.hash = CreateCB->ParentId.Hash;
- code = cm_GetSCache(&parentFid, &dscp, userp, &req);
+ code = cm_GetSCache(&parentFid, NULL, &dscp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
+ if ( status == STATUS_INVALID_HANDLE)
+ status = STATUS_OBJECT_PATH_INVALID;
osi_Log2(afsd_logp, "RDR_CreateFileEntry cm_GetSCache ParentFID failure code=0x%x status=0x%x",
code, status);
return;
cm_Gen8Dot3NameIntW(FileName, &dfid, shortName, NULL);
else
shortName[0] = '\0';
+
code = RDR_PopulateCurrentEntry(&pResultCB->DirEnum, dwRemaining,
dscp, scp, userp, &req, FileName, shortName,
RDR_POP_FOLLOW_MOUNTPOINTS | RDR_POP_EVALUATE_SYMLINKS,
- NULL, &dwRemaining);
+ 0, NULL, &dwRemaining);
if (bHoldFid)
RDR_FlagScpInUse( scp, FALSE );
parentFid.unique = UpdateCB->ParentId.Unique;
parentFid.hash = UpdateCB->ParentId.Hash;
- code = cm_GetSCache(&parentFid, &dscp, userp, &req);
+ code = cm_GetSCache(&parentFid, NULL, &dscp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
+ if ( status == STATUS_INVALID_HANDLE)
+ status = STATUS_OBJECT_PATH_INVALID;
osi_Log2(afsd_logp, "RDR_UpdateFileEntry cm_GetSCache ParentFID failure code=0x%x status=0x%x",
code, status);
return;
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, &dscp->fid, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
pResultCB = (AFSFileUpdateResultCB *)(*ResultCB)->ResultData;
+ pResultCB->ParentDataVersion.QuadPart = dscp->dataVersion;
+
code = RDR_PopulateCurrentEntry(&pResultCB->DirEnum, dwRemaining,
dscp, scp, userp, &req, NULL, NULL,
RDR_POP_FOLLOW_MOUNTPOINTS | RDR_POP_EVALUATE_SYMLINKS,
- NULL, &dwRemaining);
+ 0, NULL, &dwRemaining);
(*ResultCB)->ResultBufferLength = ResultBufferLength - dwRemaining;
osi_Log0(afsd_logp, "RDR_UpdateFileEntry SUCCESS");
} else {
IN DWORD ResultBufferLength,
IN OUT AFSCommResult **ResultCB)
{
- size_t size = sizeof(AFSCommResult);
+ AFSFileCleanupResultCB *pResultCB = NULL;
+ size_t size = sizeof(AFSCommResult) + ResultBufferLength - 1;
cm_fid_t Fid;
cm_fid_t parentFid;
afs_uint32 code = 0;
BOOL bScpLocked = FALSE;
BOOL bDscpLocked = FALSE;
BOOL bFlushFile = FALSE;
+ cm_key_t key;
RDR_InitReq(&req);
if ( bWow64 )
parentFid.hash = CleanupCB->ParentId.Hash;
if (parentFid.cell) {
- code = cm_GetSCache(&parentFid, &dscp, userp, &req);
+ code = cm_GetSCache(&parentFid, NULL, &dscp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
+ if ( status == STATUS_INVALID_HANDLE)
+ status = STATUS_OBJECT_PATH_INVALID;
(*ResultCB)->ResultStatus = status;
osi_Log2(afsd_logp, "RDR_CleanupFileEntry cm_GetSCache ParentFID failure code=0x%x status=0x%x",
code, status);
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, dscp ? &dscp->fid : NULL, &scp, userp, &req);
if (code) {
osi_Log1(afsd_logp, "RDR_CleanupFileEntry cm_GetSCache object FID failure code=0x%x",
code);
}
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- if (scp->redirBufCount > 0) {
+ if ((bLastHandle || bFlushFile) &&
+ scp->redirBufCount > 0)
+ {
LARGE_INTEGER heldExtents;
AFSFileExtentCB extentList[1024];
DWORD extentCount = 0;
scp->flags &= ~CM_SCACHEFLAG_RDR_IN_USE;
}
- if (bLastHandle || bFlushFile) {
- if (bScpLocked) {
+ /* If not a readonly object, flush dirty data and update metadata */
+ if (!(scp->flags & CM_SCACHEFLAG_RO)) {
+ if ((bLastHandle || bFlushFile) &&
+ buf_DirtyBuffersExist(&scp->fid)) {
+ if (!bScpLocked) {
+ lock_ObtainWrite(&scp->rw);
+ bScpLocked = TRUE;
+ }
+ code = cm_SyncOp(scp, NULL, userp, &req, PRSFS_WRITE,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ if (code == 0) {
+ if (bScpLocked) {
+ lock_ReleaseWrite(&scp->rw);
+ bScpLocked = FALSE;
+ }
+
+ code = cm_FSync(scp, userp, &req, bScpLocked);
+ }
+ if (bLastHandle && code)
+ goto unlock;
+ }
+
+ if (CleanupCB->ChangeTime.QuadPart) {
+
+ if (scp->fileType == CM_SCACHETYPE_FILE) {
+ /* Do not set length and other attributes at the same time */
+ if (scp->length.QuadPart != CleanupCB->AllocationSize.QuadPart) {
+ osi_Log2(afsd_logp, "RDR_CleanupFileEntry Length Change 0x%x -> 0x%x",
+ (afs_uint32)scp->length.QuadPart, (afs_uint32)CleanupCB->AllocationSize.QuadPart);
+ setAttr.mask |= CM_ATTRMASK_LENGTH;
+ setAttr.length.LowPart = CleanupCB->AllocationSize.LowPart;
+ setAttr.length.HighPart = CleanupCB->AllocationSize.HighPart;
+
+ if (bScpLocked) {
+ lock_ReleaseWrite(&scp->rw);
+ bScpLocked = FALSE;
+ }
+ code = cm_SetAttr(scp, &setAttr, userp, &req);
+ if (code)
+ goto unlock;
+ setAttr.mask = 0;
+ }
+ }
+
+ if (!bScpLocked) {
+ lock_ObtainWrite(&scp->rw);
+ bScpLocked = TRUE;
+ }
+
+ if ((scp->unixModeBits & 0200) && (CleanupCB->FileAttributes & FILE_ATTRIBUTE_READONLY)) {
+ setAttr.mask |= CM_ATTRMASK_UNIXMODEBITS;
+ setAttr.unixModeBits = scp->unixModeBits & ~0222;
+ } else if (!(scp->unixModeBits & 0200) && !(CleanupCB->FileAttributes & FILE_ATTRIBUTE_READONLY)) {
+ setAttr.mask |= CM_ATTRMASK_UNIXMODEBITS;
+ setAttr.unixModeBits = scp->unixModeBits | 0222;
+ }
+ }
+
+ if (CleanupCB->LastWriteTime.QuadPart) {
+ ft.dwLowDateTime = CleanupCB->LastWriteTime.LowPart;
+ ft.dwHighDateTime = CleanupCB->LastWriteTime.HighPart;
+
+ cm_UnixTimeFromLargeSearchTime(&clientModTime, &ft);
+ if (scp->clientModTime != clientModTime) {
+ setAttr.mask |= CM_ATTRMASK_CLIENTMODTIME;
+ setAttr.clientModTime = clientModTime;
+ }
+ }
+
+ /* call setattr */
+ if (setAttr.mask) {
lock_ReleaseWrite(&scp->rw);
bScpLocked = FALSE;
+ code = cm_SetAttr(scp, &setAttr, userp, &req);
+ } else
+ code = 0;
+ }
+
+ unlock:
+ /* Now drop the lock enforcing the share access */
+ if ( CleanupCB->FileAccess != AFS_FILE_ACCESS_NOLOCK) {
+ unsigned int sLockType;
+ LARGE_INTEGER LOffset, LLength;
+
+ if (CleanupCB->FileAccess == AFS_FILE_ACCESS_SHARED)
+ sLockType = LOCKING_ANDX_SHARED_LOCK;
+ else
+ sLockType = 0;
+
+ key = cm_GenerateKey(CM_SESSION_IFS, SMB_FID_QLOCK_PID, CleanupCB->Identifier);
+
+ LOffset.HighPart = SMB_FID_QLOCK_HIGH;
+ LOffset.LowPart = SMB_FID_QLOCK_LOW;
+ LLength.HighPart = 0;
+ LLength.LowPart = SMB_FID_QLOCK_LENGTH;
+
+ if (!bScpLocked) {
+ lock_ObtainWrite(&scp->rw);
+ bScpLocked = TRUE;
+ }
+
+ code = cm_SyncOp(scp, NULL, userp, &req, 0, CM_SCACHESYNC_LOCK);
+ if (code == 0)
+ {
+ code = cm_Unlock(scp, sLockType, LOffset, LLength, key, 0, userp, &req);
+
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_LOCK);
+
+ if (code == CM_ERROR_RANGE_NOT_LOCKED)
+ {
+ osi_Log3(afsd_logp, "RDR_CleanupFileEntry Range Not Locked -- FileAccess 0x%x ProcessId 0x%x HandleId 0x%x",
+ CleanupCB->FileAccess, CleanupCB->ProcessId, CleanupCB->Identifier);
+
+ }
}
- code = buf_CleanVnode(scp, userp, &req);
- if (bLastHandle && code)
- goto on_error;
}
if (bUnlockFile || bDeleteFile) {
- cm_key_t key;
-
if (!bScpLocked) {
lock_ObtainWrite(&scp->rw);
bScpLocked = TRUE;
goto on_error;
}
- /* the scp is now locked and current */
key = cm_GenerateKey(CM_SESSION_IFS, CleanupCB->ProcessId, 0);
+ /* the scp is now locked and current */
code = cm_UnlockByKey(scp, key,
bDeleteFile ? CM_UNLOCK_FLAG_BY_FID : 0,
userp, &req);
goto on_error;
}
- if (CleanupCB->ChangeTime.QuadPart) {
-
- if (scp->fileType == CM_SCACHETYPE_FILE) {
- /* Do not set length and other attributes at the same time */
- if (scp->length.QuadPart != CleanupCB->AllocationSize.QuadPart) {
- osi_Log2(afsd_logp, "RDR_CleanupFileEntry Length Change 0x%x -> 0x%x",
- (afs_uint32)scp->length.QuadPart, (afs_uint32)CleanupCB->AllocationSize.QuadPart);
- setAttr.mask |= CM_ATTRMASK_LENGTH;
- setAttr.length.LowPart = CleanupCB->AllocationSize.LowPart;
- setAttr.length.HighPart = CleanupCB->AllocationSize.HighPart;
-
- if (bScpLocked) {
- lock_ReleaseWrite(&scp->rw);
- bScpLocked = FALSE;
- }
- code = cm_SetAttr(scp, &setAttr, userp, &req);
- if (code)
- goto on_error;
- setAttr.mask = 0;
- }
- }
-
- if (!bScpLocked) {
- lock_ObtainWrite(&scp->rw);
- bScpLocked = TRUE;
- }
-
- if ((scp->unixModeBits & 0200) && (CleanupCB->FileAttributes & FILE_ATTRIBUTE_READONLY)) {
- setAttr.mask |= CM_ATTRMASK_UNIXMODEBITS;
- setAttr.unixModeBits = scp->unixModeBits & ~0222;
- } else if (!(scp->unixModeBits & 0200) && !(CleanupCB->FileAttributes & FILE_ATTRIBUTE_READONLY)) {
- setAttr.mask |= CM_ATTRMASK_UNIXMODEBITS;
- setAttr.unixModeBits = scp->unixModeBits | 0222;
- }
- }
-
- if (CleanupCB->LastWriteTime.QuadPart) {
- ft.dwLowDateTime = CleanupCB->LastWriteTime.LowPart;
- ft.dwHighDateTime = CleanupCB->LastWriteTime.HighPart;
-
- cm_UnixTimeFromLargeSearchTime(&clientModTime, &ft);
- if (scp->clientModTime != clientModTime) {
- setAttr.mask |= CM_ATTRMASK_CLIENTMODTIME;
- setAttr.clientModTime = clientModTime;
- }
- }
-
- /* call setattr */
- if (setAttr.mask) {
- lock_ReleaseWrite(&scp->rw);
- bScpLocked = FALSE;
- code = cm_SetAttr(scp, &setAttr, userp, &req);
- } else
- code = 0;
-
on_error:
if (bDscpLocked)
lock_ReleaseWrite(&dscp->rw);
if (bScpLocked)
lock_ReleaseWrite(&scp->rw);
- if (dscp && bDeleteFile) {
+ if (code == 0 && dscp && bDeleteFile) {
WCHAR FileName[260];
StringCchCopyNW(FileName, 260, FileNameCounted, FileNameLength / sizeof(WCHAR));
}
if (code == 0) {
+ if ( ResultBufferLength >= sizeof( AFSFileCleanupResultCB))
+ {
+ (*ResultCB)->ResultBufferLength = sizeof( AFSFileCleanupResultCB);
+ pResultCB = (AFSFileCleanupResultCB *)&(*ResultCB)->ResultData;
+ pResultCB->ParentDataVersion.QuadPart = dscp ? dscp->dataVersion : 0;
+ } else {
+ (*ResultCB)->ResultBufferLength = 0;
+ }
+
(*ResultCB)->ResultStatus = 0;
- (*ResultCB)->ResultBufferLength = 0;
osi_Log0(afsd_logp, "RDR_CleanupFileEntry SUCCESS");
} else {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
- (*ResultCB)->ResultBufferLength = 0;
osi_Log2(afsd_logp, "RDR_CleanupFileEntry FAILURE code=0x%x status=0x%x",
code, status);
}
+
if (scp)
cm_ReleaseSCache(scp);
if (dscp)
parentFid.unique = ParentId.Unique;
parentFid.hash = ParentId.Hash;
- code = cm_GetSCache(&parentFid, &dscp, userp, &req);
+ code = cm_GetSCache(&parentFid, NULL, &dscp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
+ if ( status == STATUS_INVALID_HANDLE)
+ status = STATUS_OBJECT_PATH_INVALID;
(*ResultCB)->ResultStatus = status;
osi_Log2(afsd_logp, "RDR_DeleteFileEntry cm_GetSCache ParentFID failure code=0x%x status=0x%x",
code, status);
DWORD TargetFileNameLength = pRenameCB->TargetNameLength;
cm_fid_t SourceParentFid;
cm_fid_t TargetParentFid;
+ cm_fid_t SourceFid;
+ cm_fid_t OrigTargetFid = {0,0,0,0,0};
+ cm_fid_t TargetFid;
cm_scache_t * oldDscp;
cm_scache_t * newDscp;
+ cm_dirOp_t dirop;
wchar_t shortName[13];
wchar_t SourceFileName[260];
wchar_t TargetFileName[260];
TargetParentFid.unique = TargetParentId.Unique;
TargetParentFid.hash = TargetParentId.Hash;
- code = cm_GetSCache(&SourceParentFid, &oldDscp, userp, &req);
+ code = cm_GetSCache(&SourceParentFid, NULL, &oldDscp, userp, &req);
if (code) {
osi_Log1(afsd_logp, "RDR_RenameFileEntry cm_GetSCache source parent failed code 0x%x", code);
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
+ if ( status == STATUS_INVALID_HANDLE)
+ status = STATUS_OBJECT_PATH_INVALID;
(*ResultCB)->ResultStatus = status;
return;
}
if (code) {
osi_Log2(afsd_logp, "RDR_RenameFileEntry cm_SyncOp oldDscp 0x%p failed code 0x%x", oldDscp, code);
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
+ if ( status == STATUS_INVALID_HANDLE)
+ status = STATUS_OBJECT_PATH_INVALID;
(*ResultCB)->ResultStatus = status;
lock_ReleaseWrite(&oldDscp->rw);
cm_ReleaseSCache(oldDscp);
return;
}
- code = cm_GetSCache(&TargetParentFid, &newDscp, userp, &req);
+ code = cm_GetSCache(&TargetParentFid, NULL, &newDscp, userp, &req);
if (code) {
osi_Log1(afsd_logp, "RDR_RenameFileEntry cm_GetSCache target parent failed code 0x%x", code);
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
return;
}
+ /* Obtain the original FID just for debugging purposes */
+ code = cm_BeginDirOp( oldDscp, userp, &req, CM_DIRLOCK_READ, CM_DIROP_FLAG_NONE, &dirop);
+ if (code == 0) {
+ code = cm_BPlusDirLookup(&dirop, SourceFileName, &SourceFid);
+ code = cm_BPlusDirLookup(&dirop, TargetFileName, &OrigTargetFid);
+ cm_EndDirOp(&dirop);
+ }
+
code = cm_Rename( oldDscp, NULL, SourceFileName,
newDscp, TargetFileName, userp, &req);
if (code == 0) {
- cm_dirOp_t dirop;
- cm_fid_t targetFid;
cm_scache_t *scp = 0;
DWORD dwRemaining;
code = cm_BeginDirOp( newDscp, userp, &req, CM_DIRLOCK_READ, CM_DIROP_FLAG_NONE, &dirop);
if (code == 0) {
- code = cm_BPlusDirLookup(&dirop, TargetFileName, &targetFid);
+ code = cm_BPlusDirLookup(&dirop, TargetFileName, &TargetFid);
cm_EndDirOp(&dirop);
}
}
osi_Log4(afsd_logp, "RDR_RenameFileEntry Target FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
- targetFid.cell, targetFid.volume,
- targetFid.vnode, targetFid.unique);
+ TargetFid.cell, TargetFid.volume,
+ TargetFid.vnode, TargetFid.unique);
- code = cm_GetSCache(&targetFid, &scp, userp, &req);
+ code = cm_GetSCache(&TargetFid, &newDscp->fid, &scp, userp, &req);
if (code) {
osi_Log1(afsd_logp, "RDR_RenameFileEntry cm_GetSCache target failed code 0x%x", code);
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
cm_Gen8Dot3NameIntW(TargetFileName, &dfid, shortName, NULL);
else
shortName[0] = '\0';
+
RDR_PopulateCurrentEntry(&pResultCB->DirEnum, dwRemaining,
newDscp, scp, userp, &req, TargetFileName, shortName,
RDR_POP_FOLLOW_MOUNTPOINTS | RDR_POP_EVALUATE_SYMLINKS,
- NULL, &dwRemaining);
+ 0, NULL, &dwRemaining);
(*ResultCB)->ResultBufferLength = ResultBufferLength - dwRemaining;
cm_ReleaseSCache(scp);
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
osi_Log1(afsd_logp, "RDR_OpenFileEntry LOCAL_SYSTEM access check skipped scp=0x%p",
scp);
pResultCB->GrantedAccess = OpenCB->DesiredAccess;
+ pResultCB->FileAccess = AFS_FILE_ACCESS_NOLOCK;
code = 0;
- } else {
+ }
+ else
+ {
int count = 0;
+
do {
if (count++ > 0) {
Sleep(350);
"RDR_OpenFileEntry repeating open check scp=0x%p userp=0x%p code=0x%x",
scp, userp, code);
}
- code = cm_CheckNTOpen(scp, OpenCB->DesiredAccess, OPEN_ALWAYS, userp, &req, &ldp);
+ code = cm_CheckNTOpen(scp, OpenCB->DesiredAccess, OpenCB->ShareAccess,
+ OPEN_ALWAYS,
+ OpenCB->ProcessId, OpenCB->Identifier,
+ userp, &req, &ldp);
if (code == 0)
code = RDR_CheckAccess(scp, userp, &req, OpenCB->DesiredAccess, &pResultCB->GrantedAccess);
cm_CheckNTOpenDone(scp, userp, &req, &ldp);
} while (count < 100 && (code == CM_ERROR_RETRY || code == CM_ERROR_WOULDBLOCK));
}
+ /*
+ * If we are restricting sharing, we should do so with a suitable
+ * share lock.
+ */
+ if (code == 0 && scp->fileType == CM_SCACHETYPE_FILE && !(OpenCB->ShareAccess & FILE_SHARE_WRITE)) {
+ cm_key_t key;
+ LARGE_INTEGER LOffset, LLength;
+ int sLockType;
+
+ LOffset.HighPart = SMB_FID_QLOCK_HIGH;
+ LOffset.LowPart = SMB_FID_QLOCK_LOW;
+ LLength.HighPart = 0;
+ LLength.LowPart = SMB_FID_QLOCK_LENGTH;
+
+ /*
+ * If we are not opening the file for writing, then we don't
+ * try to get an exclusive lock. No one else should be able to
+ * get an exclusive lock on the file anyway, although someone
+ * else can get a shared lock.
+ */
+ if ((OpenCB->ShareAccess & FILE_SHARE_READ) || !(OpenCB->DesiredAccess & AFS_ACCESS_WRITE))
+ {
+ sLockType = LOCKING_ANDX_SHARED_LOCK;
+ } else {
+ sLockType = 0;
+ }
+
+ key = cm_GenerateKey(CM_SESSION_IFS, SMB_FID_QLOCK_PID, OpenCB->Identifier);
+
+ lock_ObtainWrite(&scp->rw);
+ code = cm_Lock(scp, sLockType, LOffset, LLength, key, 0, userp, &req, NULL);
+ lock_ReleaseWrite(&scp->rw);
+
+ if (code) {
+ code = CM_ERROR_SHARING_VIOLATION;
+ pResultCB->FileAccess = AFS_FILE_ACCESS_NOLOCK;
+ } else {
+ if (sLockType == LOCKING_ANDX_SHARED_LOCK)
+ pResultCB->FileAccess = AFS_FILE_ACCESS_SHARED;
+ else
+ pResultCB->FileAccess = AFS_FILE_ACCESS_EXCLUSIVE;
+ }
+ } else {
+ pResultCB->FileAccess = AFS_FILE_ACCESS_NOLOCK;
+ }
+
cm_ReleaseUser(sysUserp);
- if (bHoldFid)
+ if (code == 0 && bHoldFid)
RDR_FlagScpInUse( scp, FALSE );
cm_ReleaseSCache(scp);
return;
}
+void
+RDR_ReleaseFileAccess( IN cm_user_t *userp,
+ IN AFSFileID FileId,
+ IN AFSFileAccessReleaseCB *ReleaseFileCB,
+ IN BOOL bWow64,
+ IN DWORD ResultBufferLength,
+ IN OUT AFSCommResult **ResultCB)
+{
+ cm_key_t key;
+ unsigned int sLockType;
+ LARGE_INTEGER LOffset, LLength;
+ cm_scache_t *scp = NULL;
+ cm_fid_t Fid;
+ afs_uint32 code;
+ cm_req_t req;
+ DWORD status;
+
+ RDR_InitReq(&req);
+ if ( bWow64 )
+ req.flags |= CM_REQ_WOW64;
+
+ osi_Log4(afsd_logp, "RDR_ReleaseFileAccess File FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
+ FileId.Cell, FileId.Volume,
+ FileId.Vnode, FileId.Unique);
+
+ *ResultCB = (AFSCommResult *)malloc( sizeof( AFSCommResult));
+ if (!(*ResultCB)) {
+ osi_Log0(afsd_logp, "RDR_ReleaseFileAccess out of memory");
+ return;
+ }
+
+ memset( *ResultCB, '\0', sizeof( AFSCommResult));
+
+ if (ReleaseFileCB->FileAccess == AFS_FILE_ACCESS_NOLOCK)
+ return;
+
+ /* Process the release */
+ Fid.cell = FileId.Cell;
+ Fid.volume = FileId.Volume;
+ Fid.vnode = FileId.Vnode;
+ Fid.unique = FileId.Unique;
+ Fid.hash = FileId.Hash;
+
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
+ if (code) {
+ smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
+ (*ResultCB)->ResultStatus = status;
+ osi_Log2(afsd_logp, "RDR_ReleaseFileAccess cm_GetSCache FID failure code=0x%x status=0x%x",
+ code, status);
+ return;
+ }
+
+ if (ReleaseFileCB->FileAccess == AFS_FILE_ACCESS_SHARED)
+ sLockType = LOCKING_ANDX_SHARED_LOCK;
+ else
+ sLockType = 0;
+
+ key = cm_GenerateKey(CM_SESSION_IFS, SMB_FID_QLOCK_PID, ReleaseFileCB->Identifier);
+
+ LOffset.HighPart = SMB_FID_QLOCK_HIGH;
+ LOffset.LowPart = SMB_FID_QLOCK_LOW;
+ LLength.HighPart = 0;
+ LLength.LowPart = SMB_FID_QLOCK_LENGTH;
+
+ lock_ObtainWrite(&scp->rw);
+
+ code = cm_SyncOp(scp, NULL, userp, &req, 0, CM_SCACHESYNC_LOCK);
+ if (code == 0)
+ {
+ code = cm_Unlock(scp, sLockType, LOffset, LLength, key, 0, userp, &req);
+
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_LOCK);
+
+ if (code == CM_ERROR_RANGE_NOT_LOCKED)
+ {
+ osi_Log3(afsd_logp, "RDR_ReleaseFileAccess Range Not Locked -- FileAccess 0x%x ProcessId 0x%x HandleId 0x%x",
+ ReleaseFileCB->FileAccess, ReleaseFileCB->ProcessId, ReleaseFileCB->Identifier);
+ }
+ }
+
+ lock_ReleaseWrite(&scp->rw);
+
+ osi_Log0(afsd_logp, "RDR_ReleaseFileAccessEntry SUCCESS");
+}
+
static const char *
HexCheckSum(unsigned char * buf, int buflen, unsigned char * md5cksum)
{
FileId.Hash = scp->fid.hash;
if ((GetTickCount() - reqp->startTime) / 1000 > HardDeadtimeout * 5) {
- RDR_SetFileStatus( &scp->fid, STATUS_IO_TIMEOUT);
+ RDR_SetFileStatus( &scp->fid, &userp->authgroup, STATUS_IO_TIMEOUT);
return 0;
}
osi_Log2(afsd_logp, "RDR_BkgFetch cm_SyncOp failure scp=0x%p code=0x%x",
scp, code);
smb_MapNTError(cm_MapRPCError(code, reqp), &status, TRUE);
- RDR_SetFileStatus( &scp->fid, status);
+ RDR_SetFileStatus( &scp->fid, &userp->authgroup, status);
return code;
}
lock_ReleaseWrite(&scp->rw);
* we need to re-queue this extent fetch.
*/
force_retry = 1;
- continue;
+ break;
}
if (!rwheld) {
code = cm_GetBuffer(scp, bufp, NULL, userp, reqp);
if (code == 0) {
- if (bufp->flags & CM_BUF_DIRTY) {
- if (rwheld) {
- lock_ReleaseWrite(&scp->rw);
- rwheld = 0;
- }
- cm_BufWrite(scp, &bufp->offset, cm_chunkSize, 0, userp, reqp);
- }
-
if (!(bufp->qFlags & CM_BUF_QREDIR)) {
#ifdef VALIDATE_CHECK_SUM
#ifdef ODS_DEBUG
char dbgstr[1024];
#endif
#endif
- if (!rwheld) {
- lock_ObtainWrite(&scp->rw);
- rwheld = 1;
- }
+ if (bufp->flags & CM_BUF_DIRTY)
+ cm_BufWrite(scp, &bufp->offset, cm_data.buf_blockSize, CM_BUF_WRITE_SCP_LOCKED, userp, reqp);
+
lock_ObtainWrite(&buf_globalLock);
if (!(bufp->flags & CM_BUF_DIRTY) &&
bufp->cmFlags == 0 &&
!(bufp->qFlags & CM_BUF_QREDIR)) {
buf_InsertToRedirQueue(scp, bufp);
lock_ReleaseWrite(&buf_globalLock);
- lock_ReleaseWrite(&scp->rw);
- rwheld = 0;
#ifdef VALIDATE_CHECK_SUM
buf_ComputeCheckSum(bufp);
osi_Log4(afsd_logp, "RDR_BkgFetch Extent2FS Already held by Redirector bufp 0x%p foffset 0x%p coffset 0x%p len 0x%x",
bufp, bufp->offset.QuadPart, bufp->datap - RDR_extentBaseAddress, cm_data.blockSize);
}
-
- if (rwheld) {
- lock_ReleaseWrite(&scp->rw);
- rwheld = 0;
- }
-
} else {
/*
* depending on what the error from cm_GetBuffer is
* non-fatal errors. re-queue the exent
*/
code = CM_ERROR_RETRY;
+ force_retry = 1;
}
}
if (reportErrorToRedir) {
smb_MapNTError(cm_MapRPCError(code, reqp), &status, TRUE);
- RDR_SetFileStatus( &scp->fid, status);
+ RDR_SetFileStatus( &scp->fid, &userp->authgroup, status);
}
osi_Log4(afsd_logp, "Ending BKG Fetch scp 0x%p code 0x%x fetched 0x%x:%x",
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
osi_Log1(afsd_logp, "RDR_RequestFileExtentsAsync cm_GetSCache FID failure code=0x%x",
code);
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
- RDR_SetFileStatus( &scp->fid, status);
return FALSE;
}
osi_Log2(afsd_logp, "RDR_RequestFileExtentsAsync cm_SyncOp failure scp=0x%p code=0x%x",
scp, code);
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
- RDR_SetFileStatus( &scp->fid, status);
+ RDR_SetFileStatus( &scp->fid, &userp->authgroup, status);
return FALSE;
}
break;
default:
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
- RDR_SetFileStatus(&FileId, status);
+ RDR_SetFileStatus(&FileId, &userp->authgroup, status);
bHaveBuffer = FALSE;
code = 0;
}
minLength = scp->length;
if (LargeIntegerGreaterThanOrEqualTo(bufp->offset, minLength)) {
- memset(bufp->datap, 0, cm_data.buf_blockSize);
- bufp->dataVersion = scp->dataVersion;
- bHaveBuffer = TRUE;
+ if (!bHaveBuffer) {
+ memset(bufp->datap, 0, cm_data.buf_blockSize);
+ bufp->dataVersion = scp->dataVersion;
+ bHaveBuffer = TRUE;
+ }
+ else if (bufp->dataVersion == CM_BUF_VERSION_BAD) {
+ bufp->dataVersion = scp->dataVersion;
+ }
}
- lock_ReleaseRead(&scp->rw);
-
- if ((RequestExtentsCB->Flags & AFS_EXTENT_FLAG_CLEAN) &&
- ByteOffset.QuadPart <= bufp->offset.QuadPart &&
- EndOffset.QuadPart >= bufp->offset.QuadPart + cm_data.blockSize) {
+ else if ((RequestExtentsCB->Flags & AFS_EXTENT_FLAG_CLEAN) &&
+ ByteOffset.QuadPart <= bufp->offset.QuadPart &&
+ EndOffset.QuadPart >= bufp->offset.QuadPart + cm_data.blockSize)
+ {
memset(bufp->datap, 0, cm_data.blockSize);
bufp->dataVersion = scp->dataVersion;
buf_SetDirty(bufp, &req, 0, cm_data.blockSize, userp);
bHaveBuffer = TRUE;
}
+ lock_ReleaseRead(&scp->rw);
}
/*
char dbgstr[1024];
#endif
#endif
- lock_ObtainWrite(&scp->rw);
lock_ObtainWrite(&buf_globalLock);
if (!(bufp->qFlags & CM_BUF_QREDIR)) {
buf_InsertToRedirQueue(scp, bufp);
lock_ReleaseWrite(&buf_globalLock);
- lock_ReleaseWrite(&scp->rw);
#ifdef VALIDATE_CHECK_SUM
buf_ComputeCheckSum(bufp);
bufp, ByteOffset.QuadPart, bufp->datap - RDR_extentBaseAddress, cm_data.blockSize);
} else {
lock_ReleaseWrite(&buf_globalLock);
- lock_ReleaseWrite(&scp->rw);
}
} else {
if (bBufRelease) {
* However, we know the buffer is in recent use so move the buffer to the
* front of the queue
*/
- lock_ObtainWrite(&scp->rw);
lock_ObtainWrite(&buf_globalLock);
buf_MoveToHeadOfRedirQueue(scp, bufp);
lock_ReleaseWrite(&buf_globalLock);
- lock_ReleaseWrite(&scp->rw);
osi_Log4(afsd_logp, "RDR_RequestFileExtentsAsync Extent2FS Already held by Redirector bufp 0x%p foffset 0x%p coffset 0x%p len 0x%x",
bufp, ByteOffset.QuadPart, bufp->datap - RDR_extentBaseAddress, cm_data.blockSize);
cm_req_t req;
int dirty = 0;
int released = 0;
+ int deleted = 0;
DWORD status;
#ifdef ODS_DEBUG
#ifdef VALIDATE_CHECK_SUM
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
code, status);
}
+ deleted = scp && (scp->flags & CM_SCACHEFLAG_DELETED);
+
/*
* We do not stop processing as a result of being unable to find the cm_scache object.
* If this occurs something really bad has happened since the cm_scache object must have
* been recycled while extents were held by the redirector. However, we will be resilient
* and carry on without it.
+ *
+ * If the file is known to be deleted, there is no point attempting to ask the
+ * file server about it or update the attributes.
*/
- if (scp && ReleaseExtentsCB->AllocationSize.QuadPart != scp->length.QuadPart) {
+ if (scp && ReleaseExtentsCB->AllocationSize.QuadPart != scp->length.QuadPart &&
+ !deleted)
+ {
cm_attr_t setAttr;
memset(&setAttr, 0, sizeof(cm_attr_t));
pExtent->CacheOffset.LowPart);
/* Move the buffer to the front of the queue */
- if (scp)
- lock_ObtainWrite(&scp->rw);
lock_ObtainWrite(&buf_globalLock);
buf_MoveToHeadOfRedirQueue(scp, bufp);
lock_ReleaseWrite(&buf_globalLock);
- if (scp)
- lock_ReleaseWrite(&scp->rw);
buf_Release(bufp);
continue;
}
(pExtent->Flags & AFS_EXTENT_FLAG_RELEASE) )
{
if (bufp->qFlags & CM_BUF_QREDIR) {
- if (scp)
- lock_ObtainWrite(&scp->rw);
lock_ObtainWrite(&buf_globalLock);
if (bufp->qFlags & CM_BUF_QREDIR) {
buf_RemoveFromRedirQueue(scp, bufp);
- lock_ReleaseWrite(&scp->rw);
buf_ReleaseLocked(bufp, TRUE);
- } else {
- if (scp)
- lock_ReleaseWrite(&scp->rw);
}
- if (scp)
- lock_ReleaseWrite(&buf_globalLock);
+ lock_ReleaseWrite(&buf_globalLock);
}
#ifdef ODS_DEBUG
snprintf( dbgstr, 1024,
if (scp) {
if (ReleaseExtentsCB->Flags & AFS_EXTENT_FLAG_FLUSH) {
- code = buf_CleanVnode(scp, userp, &req);
+ lock_ObtainWrite(&scp->rw);
+ code = cm_SyncOp(scp, NULL, userp, &req, PRSFS_WRITE,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ lock_ReleaseWrite(&scp->rw);
+ if (code == 0)
+ code = cm_FSync(scp, userp, &req, FALSE);
}
else if (dirty) {
osi_hyper_t offset = {0,0};
cm_scache_t * scp = NULL;
int dirty = 0;
int released = 0;
+ int deleted = 0;
char * p;
userp = RDR_UserFromAuthGroup( &pFileCB->AuthGroup);
goto cleanup_file;
}
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
osi_Log1(afsd_logp, "RDR_ProcessReleaseFileExtentsResult cm_GetSCache FID failure code=0x%x",
code);
*/
}
+ deleted = scp && (scp->flags & CM_SCACHEFLAG_DELETED);
+
/* if the scp was not found, do not perform the length check */
if (scp && (pFileCB->AllocationSize.QuadPart != scp->length.QuadPart)) {
cm_attr_t setAttr;
pExtent->CacheOffset.LowPart);
/* Move the buffer to the front of the queue */
- if (scp)
- lock_ObtainWrite(&scp->rw);
lock_ObtainWrite(&buf_globalLock);
buf_MoveToHeadOfRedirQueue(scp, bufp);
lock_ReleaseWrite(&buf_globalLock);
- if (scp)
- lock_ReleaseWrite(&scp->rw);
buf_Release(bufp);
continue;
}
(pExtent->Flags & AFS_EXTENT_FLAG_RELEASE) )
{
if (bufp->qFlags & CM_BUF_QREDIR) {
- if (scp)
- lock_ObtainWrite(&scp->rw);
lock_ObtainWrite(&buf_globalLock);
if (bufp->qFlags & CM_BUF_QREDIR) {
buf_RemoveFromRedirQueue(scp, bufp);
- if (scp)
- lock_ReleaseWrite(&scp->rw);
buf_ReleaseLocked(bufp, TRUE);
- } else {
- if (scp)
- lock_ReleaseWrite(&scp->rw);
}
lock_ReleaseWrite(&buf_globalLock);
}
#endif
}
- if ( (ReleaseFileExtentsResultCB->Flags & AFS_EXTENT_FLAG_DIRTY) ||
- (pExtent->Flags & AFS_EXTENT_FLAG_DIRTY) )
+ if ((ReleaseFileExtentsResultCB->Flags & AFS_EXTENT_FLAG_DIRTY) ||
+ (pExtent->Flags & AFS_EXTENT_FLAG_DIRTY))
{
#ifdef VALIDATE_CHECK_SUM
if ( buf_ValidateCheckSum(bufp) ) {
pExtent->CacheOffset.HighPart,
pExtent->CacheOffset.LowPart);
- buf_SetDirty(bufp, &req, pExtent->DirtyOffset, pExtent->DirtyLength, userp);
- dirty++;
+ if (!deleted) {
+ buf_SetDirty(bufp, &req, pExtent->DirtyOffset, pExtent->DirtyLength, userp);
+ dirty++;
+ }
} else {
#ifdef ODS_DEBUG
snprintf(dbgstr, 1024,
}
}
#else /* !VALIDATE_CHECK_SUM */
- buf_SetDirty(bufp, &req, pExtent->DirtyOffset, pExtent->DirtyLength, userp);
- dirty++;
+ if (!deleted) {
+ buf_SetDirty(bufp, &req, pExtent->DirtyOffset, pExtent->DirtyLength, userp);
+ dirty++;
+ }
#ifdef ODS_DEBUG
snprintf(dbgstr, 1024,
"RDR_ProcessReleaseFileExtentsResult dirty! vol 0x%x vno 0x%x uniq 0x%x foffset 0x%x:%x coffset 0x%x:%x\n",
#ifdef ODS_DEBUG
HexCheckSum(md5dbg, sizeof(md5dbg), bufp->md5cksum);
#endif
- if ( !buf_ValidateCheckSum(bufp) ) {
+ if (!buf_ValidateCheckSum(bufp) ) {
buf_ComputeCheckSum(bufp);
#ifdef ODS_DEBUG
HexCheckSum(md5dbg3, sizeof(md5dbg2), bufp->md5cksum);
#ifdef DEBUG
DebugBreak();
#endif
- buf_SetDirty(bufp, &req, pExtent->DirtyOffset, pExtent->DirtyLength, userp);
- dirty++;
+ if (!deleted) {
+ buf_SetDirty(bufp, &req, pExtent->DirtyOffset, pExtent->DirtyLength, userp);
+ dirty++;
+ }
} else {
buf_ComputeCheckSum(bufp);
#ifdef ODS_DEBUG
goto cleanup_file;
}
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
osi_Log1(afsd_logp, "RDR_ReleaseFailedSetFileExtents cm_GetSCache FID failure code=0x%x",
code);
lock_ObtainMutex(&bufp->mx);
if (bufp->qFlags & CM_BUF_QREDIR) {
- if (scp)
- lock_ObtainWrite(&scp->rw);
lock_ObtainWrite(&buf_globalLock);
if (bufp->qFlags & CM_BUF_QREDIR) {
buf_RemoveFromRedirQueue(scp, bufp);
- if (scp)
- lock_ReleaseWrite(&scp->rw);
buf_ReleaseLocked(bufp, TRUE);
- } else {
- if (scp)
- lock_ReleaseWrite(&scp->rw);
}
lock_ReleaseWrite(&buf_globalLock);
}
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
Fid.unique = FileId.Unique;
Fid.hash = FileId.Hash;
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
(*ResultCB)->ResultBufferLength = sizeof(AFSVolumeInfoCB);
pResultCB = (AFSVolumeInfoCB *)(*ResultCB)->ResultData;
- /* Allocate the extents from the buffer package */
if (FileId.Cell != 0) {
- Fid.cell = FileId.Cell;
- Fid.volume = FileId.Volume;
- Fid.vnode = FileId.Vnode;
- Fid.unique = FileId.Unique;
- Fid.hash = FileId.Hash;
-
- code = cm_GetSCache(&Fid, &scp, userp, &req);
+ cm_SetFid(&Fid, FileId.Cell, FileId.Volume, 1, 1);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
if (code) {
smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
(*ResultCB)->ResultStatus = status;
}
lock_ObtainWrite(&scp->rw);
- /* start by looking up the file's end */
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code) {
return;
}
- /* Fake for now */
pResultCB->SectorsPerAllocationUnit = 1;
pResultCB->BytesPerSector = 1024;
&volStat, &Name, &OfflineMsg, &MOTD);
rx_PutConnection(rxconnp);
- } while (cm_Analyze(connp, userp, &req, &scp->fid, NULL, NULL, NULL, code));
+ } while (cm_Analyze(connp, userp, &req, &scp->fid, 0, NULL, NULL, NULL, code));
code = cm_MapRPCError(code, &req);
if (code == 0) {
- pResultCB->TotalAllocationUnits.QuadPart = volStat.PartMaxBlocks;
- pResultCB->AvailableAllocationUnits.QuadPart = volStat.PartBlocksAvail;
-
- pResultCB->VolumeLabelLength = cm_Utf8ToUtf16( Name, -1, pResultCB->VolumeLabel,
- (sizeof(pResultCB->VolumeLabel) / sizeof(WCHAR)) + 1);
+ if (volStat.MaxQuota)
+ {
+ pResultCB->TotalAllocationUnits.QuadPart = volStat.MaxQuota;
+ if (volType == ROVOL || volType == BACKVOL) {
+ pResultCB->AvailableAllocationUnits.QuadPart = 0;
+ }
+ else
+ {
+ pResultCB->AvailableAllocationUnits.QuadPart =
+ min(volStat.MaxQuota - volStat.BlocksInUse, volStat.PartBlocksAvail);
+ }
+ }
+ else
+ {
+ pResultCB->TotalAllocationUnits.QuadPart = volStat.PartMaxBlocks;
+ if (volType == ROVOL || volType == BACKVOL) {
+ pResultCB->AvailableAllocationUnits.QuadPart = 0;
+ }
+ else
+ {
+ pResultCB->AvailableAllocationUnits.QuadPart = volStat.PartBlocksAvail;
+ }
+ }
} else {
pResultCB->TotalAllocationUnits.QuadPart = 0x7FFFFFFF;
pResultCB->AvailableAllocationUnits.QuadPart = (volType == ROVOL || volType == BACKVOL) ? 0 : 0x3F000000;
}
void
+RDR_GetVolumeSizeInfo( IN cm_user_t *userp,
+ IN AFSFileID FileId,
+ IN BOOL bWow64,
+ IN DWORD ResultBufferLength,
+ IN OUT AFSCommResult **ResultCB)
+{
+ AFSVolumeSizeInfoCB *pResultCB = NULL;
+ DWORD Length;
+ cm_scache_t *scp = NULL;
+ cm_volume_t *volp = NULL;
+ afs_uint32 volType;
+ cm_cell_t *cellp = NULL;
+ cm_fid_t Fid;
+ afs_uint32 code;
+ cm_req_t req;
+ DWORD status;
+
+ char volName[32]="(unknown)";
+ char offLineMsg[256]="server temporarily inaccessible";
+ char motd[256]="server temporarily inaccessible";
+ cm_conn_t *connp;
+ AFSFetchVolumeStatus volStat;
+ char *Name;
+ char *OfflineMsg;
+ char *MOTD;
+ struct rx_connection * rxconnp;
+
+ RDR_InitReq(&req);
+ if ( bWow64 )
+ req.flags |= CM_REQ_WOW64;
+
+ osi_Log4(afsd_logp, "RDR_GetVolumeSizeInfo File FID cell=0x%x vol=0x%x vn=0x%x uniq=0x%x",
+ FileId.Cell, FileId.Volume,
+ FileId.Vnode, FileId.Unique);
+
+ Length = sizeof( AFSCommResult) + sizeof(AFSVolumeSizeInfoCB);
+ if (sizeof(AFSVolumeSizeInfoCB) > ResultBufferLength) {
+ *ResultCB = (AFSCommResult *)malloc(sizeof(AFSCommResult) );
+ if (!(*ResultCB))
+ return;
+ memset( *ResultCB, 0, sizeof(AFSCommResult));
+ (*ResultCB)->ResultStatus = STATUS_BUFFER_OVERFLOW;
+ return;
+ }
+
+ *ResultCB = (AFSCommResult *)malloc( Length );
+ if (!(*ResultCB))
+ return;
+ memset( *ResultCB, '\0', Length );
+ (*ResultCB)->ResultBufferLength = sizeof(AFSVolumeSizeInfoCB);
+ pResultCB = (AFSVolumeSizeInfoCB *)(*ResultCB)->ResultData;
+
+ if (FileId.Cell != 0) {
+ cm_SetFid(&Fid, FileId.Cell, FileId.Volume, 1, 1);
+ code = cm_GetSCache(&Fid, NULL, &scp, userp, &req);
+ if (code) {
+ smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
+ (*ResultCB)->ResultStatus = status;
+ (*ResultCB)->ResultBufferLength = 0;
+ osi_Log2(afsd_logp, "RDR_GetVolumeSizeInfo cm_GetSCache FID failure code=0x%x status=0x%x",
+ code, status);
+ return;
+ }
+ } else {
+ (*ResultCB)->ResultStatus = STATUS_OBJECT_NAME_INVALID;
+ osi_Log0(afsd_logp, "RDR_GetVolumeSizeInfo Object Name Invalid - Cell = 0");
+ return;
+ }
+ lock_ObtainWrite(&scp->rw);
+
+ code = cm_SyncOp(scp, NULL, userp, &req, 0,
+ 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;
+ }
+
+ pResultCB->SectorsPerAllocationUnit = 1;
+ pResultCB->BytesPerSector = 1024;
+
+ if (scp->fid.cell==AFS_FAKE_ROOT_CELL_ID &&
+ scp->fid.volume==AFS_FAKE_ROOT_VOL_ID)
+ {
+ pResultCB->TotalAllocationUnits.QuadPart = 100;
+ pResultCB->AvailableAllocationUnits.QuadPart = 0;
+ } else {
+ volp = cm_GetVolumeByFID(&scp->fid);
+ if (!volp) {
+ code = CM_ERROR_NOSUCHVOLUME;
+ goto _done;
+ }
+
+ 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, 0, NULL, NULL, NULL, code));
+ code = cm_MapRPCError(code, &req);
+ if (code == 0) {
+ if (volStat.MaxQuota)
+ {
+ pResultCB->TotalAllocationUnits.QuadPart = volStat.MaxQuota;
+ if (volType == ROVOL || volType == BACKVOL) {
+ pResultCB->AvailableAllocationUnits.QuadPart = 0;
+ }
+ else
+ {
+ pResultCB->AvailableAllocationUnits.QuadPart =
+ min(volStat.MaxQuota - volStat.BlocksInUse, volStat.PartBlocksAvail);
+ }
+ }
+ else
+ {
+ pResultCB->TotalAllocationUnits.QuadPart = volStat.PartMaxBlocks;
+ if (volType == ROVOL || volType == BACKVOL) {
+ pResultCB->AvailableAllocationUnits.QuadPart = 0;
+ }
+ else
+ {
+ pResultCB->AvailableAllocationUnits.QuadPart = volStat.PartBlocksAvail;
+ }
+ }
+ } else {
+
+ 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);
+
+ _done:
+ lock_ReleaseWrite(&scp->rw);
+ if (volp)
+ cm_PutVolume(volp);
+ cm_ReleaseSCache(scp);
+
+ smb_MapNTError(cm_MapRPCError(code, &req), &status, TRUE);
+ (*ResultCB)->ResultStatus = status;
+ osi_Log0(afsd_logp, "RDR_GetVolumeSizeInfo SUCCESS");
+ return;
+}
+
+void
RDR_HoldFid( IN cm_user_t *userp,
IN AFSHoldFidRequestCB * pHoldFidCB,
IN BOOL bFast,
git://git.openafs.org / openafs.git / blobdiff