#define AFS_MAX_FCBS_TO_DROP 10
-static AFSExtent *ExtentFor( PLIST_ENTRY le, ULONG SkipList );
-static AFSExtent *NextExtent( AFSExtent *Extent, ULONG SkipList );
static ULONG ExtentsMasks[AFS_NUM_EXTENT_LISTS] = AFS_EXTENTS_MASKS;
static VOID VerifyExtentsLists(AFSFcb *Fcb);
static AFSExtent *DirtyExtentFor(PLIST_ENTRY le);
VOID
AFSLockForExtentsTrim( IN AFSFcb *Fcb)
{
- NTSTATUS ntStatus;
- AFSNonPagedFcb *pNPFcb = Fcb->NPFcb;
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLockForExtentsTrim Acuiring Fcb extents lock %08lX EXCL %08lX\n",
- &pNPFcb->Specific.File.ExtentsResource,
+ "AFSLockForExtentsTrim Acquiring Fcb extents lock %08lX EXCL %08lX\n",
+ &Fcb->NPFcb->Specific.File.ExtentsResource,
PsGetCurrentThread());
- AFSAcquireExcl( &pNPFcb->Specific.File.ExtentsResource, TRUE );
+ AFSAcquireExcl( &Fcb->NPFcb->Specific.File.ExtentsResource, TRUE );
return;
}
BOOLEAN
AFSLockForExtentsTrimNoWait( IN AFSFcb *Fcb)
{
- AFSNonPagedFcb *pNPFcb = Fcb->NPFcb;
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSLockForExtentsTrimNoWait Attempting to acquiring Fcb extent lock %08lX EXCL %08lX\n",
- &pNPFcb->Specific.File.ExtentsResource,
+ "AFSLockForExtentsTrimNoWait Attempting to acquire Fcb extent lock %08lX EXCL %08lX\n",
+ &Fcb->NPFcb->Specific.File.ExtentsResource,
PsGetCurrentThread());
- if (!AFSAcquireExcl( &pNPFcb->Specific.File.ExtentsResource, FALSE ))
+ if (!AFSAcquireExcl( &Fcb->NPFcb->Specific.File.ExtentsResource, FALSE ))
{
//
// Couldn't lock immediately
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSLockForExtentsTrimNoWait Refused to wait for Fcb extent lock %08lX EXCL %08lX\n",
- &pNPFcb->Specific.File.ExtentsResource,
+ &Fcb->NPFcb->Specific.File.ExtentsResource,
PsGetCurrentThread());
return FALSE;
return TRUE;
}
+
+static VOID
+AFSFreeExtent( IN AFSFcb *Fcb,
+ IN AFSExtent *pExtent)
+{
+ AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
+ LONG lCount;
+
+ for (ULONG i = 0; i < AFS_NUM_EXTENT_LISTS; i ++)
+ {
+ if (NULL != pExtent->Lists[i].Flink && !IsListEmpty(&pExtent->Lists[i]))
+ {
+ RemoveEntryList( &pExtent->Lists[i] );
+ }
+ }
+
+ InterlockedExchangeAdd( &pControlDevExt->Specific.Control.ExtentsHeldLength, -((LONG)(pExtent->Size/1024)));
+
+ InterlockedExchangeAdd( &Fcb->Specific.File.ExtentLength, -((LONG)(pExtent->Size/1024)));
+
+ lCount = InterlockedDecrement( &Fcb->Specific.File.ExtentCount);
+
+ lCount = InterlockedDecrement( &pControlDevExt->Specific.Control.ExtentCount);
+
+ if( lCount == 0)
+ {
+
+ KeSetEvent( &pControlDevExt->Specific.Control.ExtentsHeldEvent,
+ 0,
+ FALSE);
+ }
+
+ AFSExFreePoolWithTag( pExtent, AFS_EXTENT_TAG);
+}
+
//
-// Pull all the extents away from the FCB.
+// AFSTearDownFcbExtents was originally written to
+// remove all of the extents from an FCB. For that to happen
+// it must be an invariant that the extent list cannot change
+// from the moment the caller decides to execute AFSTearDownFcbExtents
+// until it returns. This invariant does not hold because the
+// the decision to call AFSTearDownFcbExtents is made without
+// holding the ExtentsResource and it is possible that extents
+// are in active use. Therefore, AFSTearDownFcbExtents now releases
+// as many non-active extents as it can.
//
-BOOLEAN
-AFSTearDownFcbExtents( IN AFSFcb *Fcb )
+VOID
+AFSTearDownFcbExtents( IN AFSFcb *Fcb,
+ IN GUID *AuthGroup)
{
- BOOLEAN bFoundExtents = FALSE;
AFSNonPagedFcb *pNPFcb = Fcb->NPFcb;
- LIST_ENTRY *le;
+ LIST_ENTRY *le, *leNext;
AFSExtent *pEntry;
- ULONG ulCount = 0, ulReleaseCount = 0, ulProcessCount = 0;
+ LONG lExtentCount = 0, lProcessCount = 0;
+ ULONG ulReleaseCount = 0;
size_t sz;
AFSReleaseExtentsCB *pRelease = NULL;
BOOLEAN locked = FALSE;
NTSTATUS ntStatus;
AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
+ GUID *pAuthGroup = AuthGroup;
+ GUID stAuthGroup;
+ LONG lCount;
__Enter
{
+ if( pAuthGroup == NULL ||
+ RtlCompareMemory( pAuthGroup,
+ &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
+ sizeof( GUID)) == sizeof( GUID))
+ {
+
+ RtlZeroMemory( &stAuthGroup,
+ sizeof( GUID));
+
+ ntStatus = AFSRetrieveValidAuthGroup( Fcb,
+ NULL,
+ TRUE,
+ &stAuthGroup);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+ try_return( ntStatus);
+ }
+
+ pAuthGroup = &stAuthGroup;
+ }
+
//
// Ensure that no one is working with the extents and grab the
// lock
try_return ( ntStatus = STATUS_SUCCESS);
}
- //
- // Release a max of 100 extents at a time
- //
-
sz = sizeof( AFSReleaseExtentsCB ) + (AFS_MAXIMUM_EXTENT_RELEASE_COUNT * sizeof ( AFSFileExtentCB ));
pRelease = (AFSReleaseExtentsCB*) AFSExAllocatePoolWithTag( NonPagedPool,
try_return ( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
}
- le = Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST].Flink;
-
- ulCount = Fcb->Specific.File.ExtentCount;
+ AFSAcquireExcl( &pNPFcb->Specific.File.DirtyExtentsListLock,
+ TRUE);
- while( ulReleaseCount < ulCount)
+ for( le = Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST].Flink,
+ lExtentCount = 0;
+ lExtentCount < Fcb->Specific.File.ExtentCount;
+ lExtentCount += lProcessCount)
{
- bFoundExtents = TRUE;
-
RtlZeroMemory( pRelease,
sizeof( AFSReleaseExtentsCB ) +
(AFS_MAXIMUM_EXTENT_RELEASE_COUNT * sizeof ( AFSFileExtentCB )));
- if( ulCount - ulReleaseCount <= AFS_MAXIMUM_EXTENT_RELEASE_COUNT)
- {
- ulProcessCount = ulCount - ulReleaseCount;
- }
- else
+ for( lProcessCount = 0, ulReleaseCount = 0;
+ !IsListEmpty( le) &&
+ ulReleaseCount < AFS_MAXIMUM_EXTENT_RELEASE_COUNT &&
+ lExtentCount + lProcessCount < Fcb->Specific.File.ExtentCount;
+ lProcessCount++, le = leNext)
{
- ulProcessCount = AFS_MAXIMUM_EXTENT_RELEASE_COUNT;
- }
- pRelease->Flags = AFS_EXTENT_FLAG_RELEASE;
- pRelease->ExtentCount = ulProcessCount;
+ leNext = le->Flink;
- //
- // Update the metadata for this call
- //
-
- pRelease->AllocationSize = Fcb->ObjectInformation->EndOfFile;
- pRelease->CreateTime = Fcb->ObjectInformation->CreationTime;
- pRelease->ChangeTime = Fcb->ObjectInformation->ChangeTime;
- pRelease->LastAccessTime = Fcb->ObjectInformation->LastAccessTime;
- pRelease->LastWriteTime = Fcb->ObjectInformation->LastWriteTime;
-
- ulProcessCount = 0;
-
- while (ulProcessCount < pRelease->ExtentCount)
- {
pEntry = ExtentFor( le, AFS_EXTENTS_LIST );
- pRelease->FileExtents[ulProcessCount].Flags = AFS_EXTENT_FLAG_RELEASE;
+ if( pEntry->ActiveCount == 0)
+ {
+
+ pRelease->FileExtents[ulReleaseCount].Flags = AFS_EXTENT_FLAG_RELEASE;
#if GEN_MD5
- RtlCopyMemory( pRelease->FileExtents[ulProcessCount].MD5,
- pEntry->MD5,
- sizeof(pEntry->MD5));
+ RtlCopyMemory( pRelease->FileExtents[ulReleaseCount].MD5,
+ pEntry->MD5,
+ sizeof(pEntry->MD5));
- pRelease->FileExtents[ulProcessCount].Flags |= AFS_EXTENT_FLAG_MD5_SET;
+ pRelease->FileExtents[ulReleaseCount].Flags |= AFS_EXTENT_FLAG_MD5_SET;
#endif
- if( BooleanFlagOn( pEntry->Flags, AFS_EXTENT_DIRTY))
- {
-
- AFSAcquireExcl( &pNPFcb->Specific.File.DirtyExtentsListLock,
- TRUE);
-
if( BooleanFlagOn( pEntry->Flags, AFS_EXTENT_DIRTY))
{
AFSRemoveEntryDirtyList( Fcb,
pEntry);
- pRelease->FileExtents[ulProcessCount].Flags |= AFS_EXTENT_FLAG_DIRTY;
+ pRelease->FileExtents[ulReleaseCount].Flags |= AFS_EXTENT_FLAG_DIRTY;
dirtyCount = InterlockedDecrement( &Fcb->Specific.File.ExtentsDirtyCount);
ASSERT( dirtyCount >= 0);
}
- AFSReleaseResource( &pNPFcb->Specific.File.DirtyExtentsListLock);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSTearDownFcbExtents Releasing extent %p fid %08lX-%08lX-%08lX-%08lX Offset %08lX-%08lX Len %08lX\n",
+ pEntry,
+ Fcb->ObjectInformation->FileId.Cell,
+ Fcb->ObjectInformation->FileId.Volume,
+ Fcb->ObjectInformation->FileId.Vnode,
+ Fcb->ObjectInformation->FileId.Unique,
+ pEntry->FileOffset.HighPart,
+ pEntry->FileOffset.LowPart,
+ pEntry->Size);
+
+ pRelease->FileExtents[ulReleaseCount].Length = pEntry->Size;
+ pRelease->FileExtents[ulReleaseCount].DirtyLength = pEntry->Size;
+ pRelease->FileExtents[ulReleaseCount].DirtyOffset = 0;
+ pRelease->FileExtents[ulReleaseCount].CacheOffset = pEntry->CacheOffset;
+ pRelease->FileExtents[ulReleaseCount].FileOffset = pEntry->FileOffset;
+
+ ulReleaseCount++;
+
+ AFSFreeExtent( Fcb,
+ pEntry);
}
+ }
- AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSTearDownFcbExtents Releasing extent %p fid %08lX-%08lX-%08lX-%08lX Offset %08lX-%08lX Len %08lX\n",
- pEntry,
- Fcb->ObjectInformation->FileId.Cell,
- Fcb->ObjectInformation->FileId.Volume,
- Fcb->ObjectInformation->FileId.Vnode,
- Fcb->ObjectInformation->FileId.Unique,
- pEntry->FileOffset.HighPart,
- pEntry->FileOffset.LowPart,
- pEntry->Size);
-
- pRelease->FileExtents[ulProcessCount].Length = pEntry->Size;
- pRelease->FileExtents[ulProcessCount].DirtyLength = pEntry->Size;
- pRelease->FileExtents[ulProcessCount].DirtyOffset = 0;
- pRelease->FileExtents[ulProcessCount].CacheOffset = pEntry->CacheOffset;
- pRelease->FileExtents[ulProcessCount].FileOffset = pEntry->FileOffset;
-
- InterlockedExchangeAdd( &pControlDevExt->Specific.Control.ExtentsHeldLength, -((LONG)(pEntry->Size/1024)));
-
- InterlockedExchangeAdd( &Fcb->Specific.File.ExtentLength, -((LONG)(pEntry->Size/1024)));
-
- ASSERT( pEntry->ActiveCount == 0);
+ if ( ulReleaseCount > 0)
+ {
- ulProcessCount ++;
- le = le->Flink;
- AFSExFreePool( pEntry);
+ pRelease->ExtentCount = ulReleaseCount;
- InterlockedDecrement( &Fcb->Specific.File.ExtentCount);
+ pRelease->Flags = AFS_EXTENT_FLAG_RELEASE;
- if( InterlockedDecrement( &pControlDevExt->Specific.Control.ExtentCount) == 0)
- {
+ //
+ // Update the metadata for this call
+ //
- KeSetEvent( &pControlDevExt->Specific.Control.ExtentsHeldEvent,
- 0,
- FALSE);
- }
- }
+ pRelease->AllocationSize = Fcb->ObjectInformation->EndOfFile;
+ pRelease->CreateTime = Fcb->ObjectInformation->CreationTime;
+ pRelease->ChangeTime = Fcb->ObjectInformation->ChangeTime;
+ pRelease->LastAccessTime = Fcb->ObjectInformation->LastAccessTime;
+ pRelease->LastWriteTime = Fcb->ObjectInformation->LastWriteTime;
- //
- // Send the request down. We cannot send this down
- // asynchronously - if we did that we could request them
- // back before the service got this request and then this
- // request would be a corruption.
- //
+ //
+ // Send the request down. We cannot send this down
+ // asynchronously - if we did that we could request them
+ // back before the service got this request and then this
+ // request would be a corruption.
+ //
- sz = sizeof( AFSReleaseExtentsCB ) + (ulProcessCount * sizeof ( AFSFileExtentCB ));
+ sz = sizeof( AFSReleaseExtentsCB ) + (lProcessCount * sizeof ( AFSFileExtentCB ));
- ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS,
- AFS_REQUEST_FLAG_SYNCHRONOUS,
- &Fcb->AuthGroup,
- NULL,
- &Fcb->ObjectInformation->FileId,
- pRelease,
- sz,
- NULL,
- NULL);
+ ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS,
+ AFS_REQUEST_FLAG_SYNCHRONOUS,
+ pAuthGroup,
+ NULL,
+ &Fcb->ObjectInformation->FileId,
+ pRelease,
+ sz,
+ NULL,
+ NULL);
- if( !NT_SUCCESS(ntStatus))
- {
+ if( !NT_SUCCESS(ntStatus))
+ {
- //
- // Regardless of whether or not the AFSProcessRequest() succeeded, the extents
- // were released (if AFS_EXTENT_FLAG_RELEASE was set). Log the error so it is known.
- //
+ //
+ // Regardless of whether or not the AFSProcessRequest() succeeded, the extents
+ // were released (if AFS_EXTENT_FLAG_RELEASE was set). Log the error so it is known.
+ //
- AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
- AFS_TRACE_LEVEL_ERROR,
- "AFSTearDownFcbExtents AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS failed fid %08lX-%08lX-%08lX-%08lX Status %08lX\n",
- Fcb->ObjectInformation->FileId.Cell,
- Fcb->ObjectInformation->FileId.Volume,
- Fcb->ObjectInformation->FileId.Vnode,
- Fcb->ObjectInformation->FileId.Unique,
- ntStatus);
+ AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSTearDownFcbExtents AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS failed fid %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ Fcb->ObjectInformation->FileId.Cell,
+ Fcb->ObjectInformation->FileId.Volume,
+ Fcb->ObjectInformation->FileId.Vnode,
+ Fcb->ObjectInformation->FileId.Unique,
+ ntStatus);
+ }
}
-
- ulReleaseCount += ulProcessCount;
}
+ AFSReleaseResource( &pNPFcb->Specific.File.DirtyExtentsListLock);
+
//
- // Reinitialize the skip lists
+ // if all extents have been released, reinitialize the skip lists
//
- ASSERT( Fcb->Specific.File.ExtentCount == 0);
-
- for (ULONG i = 0; i < AFS_NUM_EXTENT_LISTS; i++)
+ if( Fcb->Specific.File.ExtentCount == 0)
{
- InitializeListHead(&Fcb->Specific.File.ExtentsLists[i]);
- }
- //
- // Reinitialize the dirty list as well
- //
+ for (ULONG i = 0; i < AFS_NUM_EXTENT_LISTS; i++)
+ {
+ InitializeListHead(&Fcb->Specific.File.ExtentsLists[i]);
+ }
- AFSAcquireExcl( &pNPFcb->Specific.File.DirtyExtentsListLock,
- TRUE);
+ //
+ // Reinitialize the dirty list as well
+ //
- ASSERT( Fcb->Specific.File.ExtentsDirtyCount == 0);
+ AFSAcquireExcl( &pNPFcb->Specific.File.DirtyExtentsListLock,
+ TRUE);
- Fcb->NPFcb->Specific.File.DirtyListHead = NULL;
- Fcb->NPFcb->Specific.File.DirtyListTail = NULL;
+ ASSERT( Fcb->Specific.File.ExtentsDirtyCount == 0);
- AFSReleaseResource( &pNPFcb->Specific.File.DirtyExtentsListLock);
+ Fcb->NPFcb->Specific.File.DirtyListHead = NULL;
+ Fcb->NPFcb->Specific.File.DirtyListTail = NULL;
+
+ AFSReleaseResource( &pNPFcb->Specific.File.DirtyExtentsListLock);
+ }
Fcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
if (pRelease)
{
- AFSExFreePool( pRelease);
+ AFSExFreePoolWithTag( pRelease, AFS_EXTENT_RELEASE_TAG);
}
}
-
- return bFoundExtents;
}
static PAFSExtent
__Enter
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSDoExtentsMapRegion Acquiring Fcb extent lock %08lX SHARED %08lX\n",
- &Fcb->NPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
+ ASSERT( ExIsResourceAcquiredLite( &Fcb->NPFcb->Specific.File.ExtentsResource ));
- AFSAcquireShared( &Fcb->NPFcb->Specific.File.ExtentsResource, TRUE );
-
- entry = AFSExtentForOffsetHint(Fcb, Offset, TRUE, *FirstExtent);
- *FirstExtent = entry;
-
- if (NULL == entry || !AFSExtentContains(entry, Offset))
+ __try
{
- try_return (retVal = FALSE);
- }
-
- ASSERT(Offset->QuadPart >= entry->FileOffset.QuadPart);
+ entry = AFSExtentForOffsetHint(Fcb, Offset, TRUE, *FirstExtent);
+ *FirstExtent = entry;
- while (TRUE)
- {
- if ((entry->FileOffset.QuadPart + entry->Size) >=
- (Offset->QuadPart + Size))
+ if (NULL == entry || !AFSExtentContains(entry, Offset))
{
- //
- // The end is inside the extent
- //
- try_return (retVal = TRUE);
- }
-
- if (entry->Lists[AFS_EXTENTS_LIST].Flink == &Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST])
- {
- //
- // Run out of extents
- //
- try_return (retVal = FALSE);
- }
-
- newEntry = NextExtent( entry, AFS_EXTENTS_LIST );
-
- if (newEntry->FileOffset.QuadPart !=
- (entry->FileOffset.QuadPart + entry->Size))
- {
- //
- // Gap
- //
try_return (retVal = FALSE);
}
- entry = newEntry;
- }
-
-try_exit:
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSDoExtentsMapRegion Releasing Fcb extent lock %08lX SHARED %08lX\n",
- &Fcb->NPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
-
- AFSReleaseResource( &Fcb->NPFcb->Specific.File.ExtentsResource );
-
- *LastExtent = entry;
- }
-
- return retVal;
-}
-
-//
-// Given an FCB and an Offset we look to see whether there extents to
-// Map them all. If there are then we return TRUE to fullymapped
-// and *FirstExtent points to the first extent to map the extent.
-// If not then we return FALSE, but we request the extents to be mapped.
-// Further *FirstExtent (if non null) is the last extent which doesn't
-// map the extent.
-//
-// Finally on the way *in* if *FirstExtent is non null it is where we start looking
-//
-
-NTSTATUS
-AFSRequestExtents( IN AFSFcb *Fcb,
- IN PLARGE_INTEGER Offset,
- IN ULONG Size,
- OUT BOOLEAN *FullyMapped)
-{
-
- AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
- NTSTATUS ntStatus = STATUS_SUCCESS;
- AFSExtent *pExtent;
- AFSRequestExtentsCB request;
- AFSNonPagedFcb *pNPFcb = Fcb->NPFcb;
- AFSExtent *pFirstExtent;
- LARGE_INTEGER liAlignedOffset;
- ULONG ulAlignedLength = 0;
- LARGE_INTEGER liTimeOut;
-
- //
- // Check our extents, then fire off a request if we need to.
- // We start off knowing nothing about where we will go.
- //
- pFirstExtent = NULL;
- pExtent = NULL;
-
- *FullyMapped = AFSDoExtentsMapRegion( Fcb, Offset, Size, &pFirstExtent, &pExtent );
-
- if (*FullyMapped)
- {
-
- ASSERT(AFSExtentContains(pFirstExtent, Offset));
- LARGE_INTEGER end = *Offset;
- end.QuadPart += (Size-1);
- ASSERT(AFSExtentContains(pExtent, &end));
-
- return STATUS_SUCCESS;
- }
-
- //
- // So we need to queue a request. Since we will be clearing the
- // ExtentsRequestComplete event we need to do with with the lock
- // EX
- //
-
- liTimeOut.QuadPart = -(50000000);
-
- while (TRUE)
- {
- if (!NT_SUCCESS( pNPFcb->Specific.File.ExtentsRequestStatus))
- {
-
- //
- // If this isn't the same process which caused the failure then try to request them again
- //
-
- if( Fcb->Specific.File.ExtentRequestProcessId == (ULONGLONG)PsGetCurrentProcessId())
- {
- ntStatus = pNPFcb->Specific.File.ExtentsRequestStatus;
-
- break;
- }
-
- pNPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
- }
-
- ntStatus = KeWaitForSingleObject( &pNPFcb->Specific.File.ExtentsRequestComplete,
- Executive,
- KernelMode,
- FALSE,
- &liTimeOut);
- if (!NT_SUCCESS(ntStatus))
- {
-
- //
- // try again
- //
-
- continue;
- }
-
- //
- // Lock resource EX and look again
- //
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSRequestExtents Acquiring Fcb extent lock %08lX EXCL %08lX\n",
- &pNPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
-
- AFSAcquireExcl( &pNPFcb->Specific.File.ExtentsResource, TRUE );
-
- if (!NT_SUCCESS( pNPFcb->Specific.File.ExtentsRequestStatus))
- {
-
- //
- // If this isn't the same process which caused the failure then try to request them again
- //
-
- if( Fcb->Specific.File.ExtentRequestProcessId == (ULONGLONG)PsGetCurrentProcessId())
- {
- ntStatus = pNPFcb->Specific.File.ExtentsRequestStatus;
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSRequestExtents Releasing Fcb extent lock %08lX EXCL %08lX\n",
- &pNPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
-
- AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource );
-
- break;
- }
-
- pNPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
- }
-
- if( KeReadStateEvent( &pNPFcb->Specific.File.ExtentsRequestComplete) ||
- ntStatus == STATUS_TIMEOUT)
- {
+ ASSERT(Offset->QuadPart >= entry->FileOffset.QuadPart);
- ntStatus = pNPFcb->Specific.File.ExtentsRequestStatus;
-
- if( !NT_SUCCESS( ntStatus))
+ while (TRUE)
{
-
- //
- // If this isn't the same process which caused the failure then try to request them again
- //
-
- if( Fcb->Specific.File.ExtentRequestProcessId == (ULONGLONG)PsGetCurrentProcessId())
+ if ((entry->FileOffset.QuadPart + entry->Size) >=
+ (Offset->QuadPart + Size))
{
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSRequestExtents Releasing Fcb extent lock %08lX EXCL %08lX\n",
- &pNPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
-
- AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource );
+ //
+ // The end is inside the extent
+ //
+ try_return (retVal = TRUE);
}
- else
- {
- pNPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
-
- ntStatus = STATUS_SUCCESS;
+ if (entry->Lists[AFS_EXTENTS_LIST].Flink == &Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST])
+ {
+ //
+ // Run out of extents
+ //
+ try_return (retVal = FALSE);
}
- }
- break;
- }
+ newEntry = NextExtent( entry, AFS_EXTENTS_LIST );
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSRequestExtents Releasing Fcb extent lock %08lX EXCL %08lX\n",
- &pNPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
-
- AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource );
- }
-
- if (!NT_SUCCESS(ntStatus))
- {
-
- return ntStatus;
- }
-
- __Enter
- {
- //
- // We have the lock Ex and there is no filling going on.
- // Check again to see whether things have moved since we last
- // checked. Since we haven't locked against pinning, we will
- // reset here.
- //
-
- pFirstExtent = NULL;
-
- *FullyMapped = AFSDoExtentsMapRegion(Fcb, Offset, Size, &pFirstExtent, &pExtent);
-
- if (*FullyMapped)
- {
-
- ASSERT(AFSExtentContains(pFirstExtent, Offset));
- LARGE_INTEGER end = *Offset;
- end.QuadPart += (Size-1);
- ASSERT(AFSExtentContains(pExtent, &end));
-
- try_return (ntStatus = STATUS_SUCCESS);
- }
-
- RtlZeroMemory( &request,
- sizeof( AFSRequestExtentsCB));
-
- //
- // Align the request
- //
-
- ulAlignedLength = Size;
-
- liAlignedOffset = *Offset;
-
- if( liAlignedOffset.QuadPart % pDevExt->Specific.RDR.CacheBlockSize != 0)
- {
-
- liAlignedOffset.QuadPart = (ULONGLONG)( (ULONGLONG)(liAlignedOffset.QuadPart / pDevExt->Specific.RDR.CacheBlockSize) * (ULONGLONG)pDevExt->Specific.RDR.CacheBlockSize);
-
- ulAlignedLength += (ULONG)(Offset->QuadPart - liAlignedOffset.QuadPart);
- }
-
- if( ulAlignedLength % pDevExt->Specific.RDR.CacheBlockSize != 0)
- {
-
- ulAlignedLength = (ULONG)(((ulAlignedLength / pDevExt->Specific.RDR.CacheBlockSize) + 1) * pDevExt->Specific.RDR.CacheBlockSize);
- }
-
- request.ByteOffset = liAlignedOffset;
- request.Length = ulAlignedLength;
-
- if( !AFSIsExtentRequestQueued( &Fcb->ObjectInformation->FileId,
- &request.ByteOffset,
- request.Length))
- {
-
- AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSRequestExtents Request extents for fid %08lX-%08lX-%08lX-%08lX Offset %08lX Len %08lX Thread %08lX\n",
- Fcb->ObjectInformation->FileId.Cell,
- Fcb->ObjectInformation->FileId.Volume,
- Fcb->ObjectInformation->FileId.Vnode,
- Fcb->ObjectInformation->FileId.Unique,
- request.ByteOffset.LowPart,
- request.Length,
- PsGetCurrentThread());
-
- ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_REQUEST_FILE_EXTENTS,
- 0,
- &Fcb->AuthGroup,
- NULL,
- &Fcb->ObjectInformation->FileId,
- &request,
- sizeof( AFSRequestExtentsCB ),
- NULL,
- NULL);
+ if (newEntry->FileOffset.QuadPart !=
+ (entry->FileOffset.QuadPart + entry->Size))
+ {
+ //
+ // Gap
+ //
+ try_return (retVal = FALSE);
+ }
- if( NT_SUCCESS( ntStatus))
- {
- KeClearEvent( &pNPFcb->Specific.File.ExtentsRequestComplete );
+ entry = newEntry;
}
}
- else
+ __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
{
- KeClearEvent( &pNPFcb->Specific.File.ExtentsRequestComplete );
- }
-
-try_exit:
+ AFSDbgLogMsg( 0,
+ 0,
+ "EXCEPTION - AFSDoExtentsMapRegion\n");
- if (NT_SUCCESS( ntStatus ))
- {
- KeQueryTickCount( &Fcb->Specific.File.LastExtentAccess );
+ AFSDumpTraceFilesFnc();
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSRequestExtents Releasing Fcb extent lock %08lX EXCL %08lX\n",
- &pNPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
+try_exit:
- AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource );
+ *LastExtent = entry;
}
- return ntStatus;
+ return retVal;
}
NTSTATUS
AFSRequestExtentsAsync( IN AFSFcb *Fcb,
+ IN AFSCcb *Ccb,
IN PLARGE_INTEGER Offset,
IN ULONG Size)
{
LARGE_INTEGER liAlignedOffset;
ULONG ulAlignedLength = 0;
BOOLEAN bRegionMapped = FALSE;
+ ULONGLONG ullProcessId = (ULONGLONG)PsGetCurrentProcessId();
__Enter
{
{
//
- // If this isn't the same process which caused the failure then try to request them again
+ // If this isn't the same authgroup which caused the failure
+ // then try to request them again
//
- if( Fcb->Specific.File.ExtentRequestProcessId == (ULONGLONG)PsGetCurrentProcessId())
+ if( RtlCompareMemory( &pNPFcb->Specific.File.ExtentsRequestAuthGroup,
+ &Ccb->AuthGroup,
+ sizeof( GUID)) == sizeof( GUID))
{
- try_return( ntStatus = pNPFcb->Specific.File.ExtentsRequestStatus);
- }
- pNPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
+ ntStatus = pNPFcb->Specific.File.ExtentsRequestStatus;
+
+ pNPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
+
+ RtlZeroMemory( &pNPFcb->Specific.File.ExtentsRequestAuthGroup,
+ sizeof( GUID));
+
+ try_return( ntStatus);
+ }
}
//
// Check if we are already mapped
//
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSRequestExtentsAsync Acquiring Fcb extents lock %08lX SHARED %08lX\n",
+ &pNPFcb->Specific.File.ExtentsResource,
+ PsGetCurrentThread());
+
+ AFSAcquireShared( &pNPFcb->Specific.File.ExtentsResource, TRUE );
+
bRegionMapped = AFSDoExtentsMapRegion( Fcb, Offset, Size, &pFirstExtent, &pExtent);
if( bRegionMapped)
{
+ KeClearEvent( &pNPFcb->Specific.File.ExtentsRequestComplete );
+ }
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSRequestExtentsAsync Releasing Fcb extents lock %08lX SHARED %08lX\n",
+ &pNPFcb->Specific.File.ExtentsResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource );
+
+ if ( bRegionMapped)
+ {
+
try_return( ntStatus = STATUS_SUCCESS);
}
request.Length))
{
+ KeClearEvent( &pNPFcb->Specific.File.ExtentsRequestComplete );
+
AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSRequestExtentsAsync Request extents for fid %08lX-%08lX-%08lX-%08lX Offset %08lX Len %08lX Thread %08lX\n",
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_REQUEST_FILE_EXTENTS,
0,
- &Fcb->AuthGroup,
+ &Ccb->AuthGroup,
NULL,
&Fcb->ObjectInformation->FileId,
&request,
NULL,
NULL);
- if( NT_SUCCESS( ntStatus))
+ if ( ntStatus == STATUS_ACCESS_DENIED)
{
+ GUID stAuthGroup;
+ DWORD ntStatus2;
+
+ ntStatus2 = AFSRetrieveValidAuthGroup( Fcb,
+ NULL,
+ TRUE,
+ &stAuthGroup);
+
+ if ( NT_SUCCESS( ntStatus2) &&
+ RtlCompareMemory( &stAuthGroup,
+ &Ccb->AuthGroup,
+ sizeof( GUID)) != sizeof( GUID))
+ {
- KeClearEvent( &pNPFcb->Specific.File.ExtentsRequestComplete );
+ ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_REQUEST_FILE_EXTENTS,
+ 0,
+ &stAuthGroup,
+ NULL,
+ &Fcb->ObjectInformation->FileId,
+ &request,
+ sizeof( AFSRequestExtentsCB ),
+ NULL,
+ NULL);
+ }
}
- }
- else
- {
- KeClearEvent( &pNPFcb->Specific.File.ExtentsRequestComplete );
+ if( !NT_SUCCESS( ntStatus))
+ {
+
+ KeSetEvent( &pNPFcb->Specific.File.ExtentsRequestComplete,
+ 0,
+ FALSE);
+ }
}
try_exit:
BOOLEAN bFoundExtent = FALSE;
LIST_ENTRY *pSkipEntries[AFS_NUM_EXTENT_LISTS] = { 0 };
AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
+ LONG lCount;
//
// Grab the extents exclusive for the duration
if (NULL == pExtent)
{
- ASSERT( FALSE);
-
try_return (ntStatus = STATUS_INSUFFICIENT_RESOURCES );
}
InterlockedExchangeAdd( &Fcb->Specific.File.ExtentLength, (LONG)(pExtent->Size/1024));
- InterlockedIncrement( &Fcb->Specific.File.ExtentCount);
+ lCount = InterlockedIncrement( &Fcb->Specific.File.ExtentCount);
- if( InterlockedIncrement( &pControlDevExt->Specific.Control.ExtentCount) == 1)
+ lCount = InterlockedIncrement( &pControlDevExt->Specific.Control.ExtentCount);
+
+ if( lCount == 1)
{
KeClearEvent( &pControlDevExt->Specific.Control.ExtentsHeldEvent);
AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
ULONGLONG ullIndex = 0;
AFSObjectInfoCB *pObjectInfo = NULL;
+ LONG lCount;
__Enter
{
pVolumeCB->ObjectInfoTree.TreeLock,
PsGetCurrentThread());
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
+ lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
}
AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
TRUE);
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
+ lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
//
// Now locate the Object in this volume
// Reference the node so it won't be torn down
//
- InterlockedIncrement( &pObjectInfo->ObjectReferenceCount);
+ lCount = AFSObjectInfoIncrement( pObjectInfo);
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSProcessSetFileExtents Increment count on object %08lX Cnt %d\n",
pObjectInfo,
- pObjectInfo->ObjectReferenceCount);
+ lCount);
}
AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
if( pObjectInfo != NULL)
{
- InterlockedDecrement( &pObjectInfo->ObjectReferenceCount);
+ lCount = AFSObjectInfoDecrement( pObjectInfo);
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSProcessSetFileExtents Decrement count on object %08lX Cnt %d\n",
pObjectInfo,
- pObjectInfo->ObjectReferenceCount);
+ lCount);
}
}
NTSTATUS ntStatus = STATUS_SUCCESS;
BOOLEAN bReleaseAll = FALSE;
AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
+ LONG lCount;
__Enter
{
FileExtents[*ExtentCount].Flags |= AFS_EXTENT_FLAG_DIRTY;
- InterlockedDecrement( &Fcb->Specific.File.ExtentsDirtyCount);
+ lCount = InterlockedDecrement( &Fcb->Specific.File.ExtentsDirtyCount);
*DirtyExtents = TRUE;
}
ulExtentCount ++;
*ExtentCount = (*ExtentCount) + 1;
- //
- // And unpick
- //
- for (ULONG i = 0; i < AFS_NUM_EXTENT_LISTS; i ++)
- {
- if (NULL != pExtent->Lists[i].Flink && !IsListEmpty(&pExtent->Lists[i]))
- {
- RemoveEntryList( &pExtent->Lists[i] );
- }
- }
-
- InterlockedExchangeAdd( &pControlDevExt->Specific.Control.ExtentsHeldLength, -((LONG)(pExtent->Size/1024)));
-
- InterlockedExchangeAdd( &Fcb->Specific.File.ExtentLength, -((LONG)(pExtent->Size/1024)));
-
- //
- // and free
- //
- AFSExFreePool( pExtent);
-
- InterlockedDecrement( &Fcb->Specific.File.ExtentCount);
-
- if( InterlockedDecrement( &pControlDevExt->Specific.Control.ExtentCount) == 0)
- {
-
- KeSetEvent( &pControlDevExt->Specific.Control.ExtentsHeldEvent,
- 0,
- FALSE);
- }
+ AFSFreeExtent( Fcb,
+ pExtent);
}
try_exit:
BOOLEAN bLocatedEntry = FALSE;
AFSObjectInfoCB *pCurrentObject = NULL;
BOOLEAN bReleaseVolumeListLock = FALSE;
+ LONG lCount;
pRDRDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
pControlDeviceExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
pVolumeCB->ObjectInfoTree.TreeLock,
PsGetCurrentThread());
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
+ lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
AFSReleaseResource( &pRDRDeviceExt->Specific.RDR.VolumeListLock);
AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
TRUE);
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
+ lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
if( NULL == LastFcb)
{
// A hit a very palpable hit. Pin it
//
- InterlockedIncrement( &pCurrentObject->ObjectReferenceCount);
+ lCount = AFSObjectInfoIncrement( pCurrentObject);
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSFindFcbToClean Increment count on Fcb %08lX Cnt %d\n",
pCurrentObject,
- pCurrentObject->ObjectReferenceCount);
+ lCount);
bLocatedEntry = TRUE;
AFSVolumeCB *pVolumeCB = NULL;
ULONGLONG ullIndex = 0;
AFSObjectInfoCB *pObjectInfo = NULL;
+ LONG lCount;
__Enter
{
pVolumeCB->ObjectInfoTree.TreeLock,
PsGetCurrentThread());
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
+ lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
}
AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
TRUE);
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
+ lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
//
// Now locate the Object in this volume
// Reference the node so it won't be torn down
//
- InterlockedIncrement( &pObjectInfo->ObjectReferenceCount);
+ lCount = AFSObjectInfoIncrement( pObjectInfo);
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSProcessExtentFailure Increment count on object %08lX Cnt %d\n",
pObjectInfo,
- pObjectInfo->ObjectReferenceCount);
+ lCount);
}
AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestStatus = pFailureCB->FailureStatus;
+ RtlCopyMemory( &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
+ &pFailureCB->AuthGroup,
+ sizeof( GUID));
+
KeSetEvent( &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsRequestComplete,
0,
FALSE);
AFSReleaseResource( &pObjectInfo->Fcb->NPFcb->Specific.File.ExtentsResource);
- InterlockedDecrement( &pObjectInfo->ObjectReferenceCount);
+ lCount = AFSObjectInfoDecrement( pObjectInfo);
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSProcessExtentFailure Decrement count on object %08lX Cnt %d\n",
pObjectInfo,
- pObjectInfo->ObjectReferenceCount);
+ lCount);
try_exit:
AFSObjectInfoCB *pObjectInfo = NULL;
BOOLEAN bLocked = FALSE;
BOOLEAN bDirtyExtents = FALSE;
+ GUID stAuthGroup;
+ LONG lCount;
__Enter
{
pVolumeCB->ObjectInfoTree.TreeLock,
PsGetCurrentThread());
- InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
+ lCount = InterlockedIncrement( &pVolumeCB->VolumeReferenceCount);
}
AFSReleaseResource( &pDevExt->Specific.RDR.VolumeTreeLock);
AFSAcquireShared( pVolumeCB->ObjectInfoTree.TreeLock,
TRUE);
- InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
+ lCount = InterlockedDecrement( &pVolumeCB->VolumeReferenceCount);
//
// Now locate the Object in this volume
// Reference the node so it won't be torn down
//
- InterlockedIncrement( &pObjectInfo->ObjectReferenceCount);
+ lCount = AFSObjectInfoIncrement( pObjectInfo);
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSProcessReleaseFileExtents Increment count on object %08lX Cnt %d\n",
pObjectInfo,
- pObjectInfo->ObjectReferenceCount);
+ lCount);
}
AFSReleaseResource( pVolumeCB->ObjectInfoTree.TreeLock);
// Stash away the auth group
//
+ RtlZeroMemory( &stAuthGroup,
+ sizeof( GUID));
+
+ ntStatus = AFSRetrieveValidAuthGroup( pFcb,
+ NULL,
+ TRUE,
+ &stAuthGroup);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+ try_return( ntStatus);
+ }
+
RtlCopyMemory( &pFile->AuthGroup,
- &pFcb->AuthGroup,
+ &stAuthGroup,
sizeof( GUID));
//
Irp->AssociatedIrp.SystemBuffer != pResult)
{
- AFSExFreePool(pResult);
+ AFSExFreePoolWithTag(pResult, AFS_EXTENTS_RESULT_TAG);
}
if (NT_SUCCESS(ntStatus))
if( pObjectInfo != NULL)
{
- InterlockedDecrement( &pObjectInfo->ObjectReferenceCount);
+ lCount = AFSObjectInfoDecrement( pObjectInfo);
AFSDbgLogMsg( AFS_SUBSYSTEM_OBJECT_REF_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSProcessReleaseFileExtents Decrement count on object %08lX Cnt %d\n",
pObjectInfo,
- pObjectInfo->ObjectReferenceCount);
+ lCount);
}
}
}
NTSTATUS
-AFSWaitForExtentMapping( AFSFcb *Fcb )
+AFSWaitForExtentMapping( AFSFcb *Fcb,
+ AFSCcb *Ccb)
{
NTSTATUS ntStatus = STATUS_SUCCESS;
LARGE_INTEGER liTimeOut;
+ ULONGLONG ullProcessId = (ULONGLONG)PsGetCurrentProcessId();
__Enter
{
{
//
- // If this isn't the same process which caused the failure then try to request them again
+ // If this isn't the same authgroup which caused the failure
+ // then try to request them again
//
- if( Fcb->Specific.File.ExtentRequestProcessId == (ULONGLONG)PsGetCurrentProcessId())
+ if( RtlCompareMemory( &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
+ &Ccb->AuthGroup,
+ sizeof( GUID)) == sizeof( GUID))
{
- try_return( ntStatus = Fcb->NPFcb->Specific.File.ExtentsRequestStatus);
- }
- Fcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
+ ntStatus = Fcb->NPFcb->Specific.File.ExtentsRequestStatus;
+
+ Fcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
+
+ RtlZeroMemory( &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
+ sizeof( GUID));
+
+ try_return( ntStatus);
+ }
}
- liTimeOut.QuadPart = -(50000000);
+ liTimeOut.QuadPart = -(1 * AFS_ONE_SECOND);
ntStatus = KeWaitForSingleObject( &Fcb->NPFcb->Specific.File.ExtentsRequestComplete,
Executive,
{
//
- // If this isn't the same process which caused the failure then try to request them again
+ // If this isn't the same authgroup which caused the failure
+ // or the System Process,
+ // then try to request the extents again
//
- if( Fcb->Specific.File.ExtentRequestProcessId == (ULONGLONG)PsGetCurrentProcessId())
+ if( RtlCompareMemory( &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
+ &Ccb->AuthGroup,
+ sizeof( GUID)) == sizeof( GUID) ||
+ ullProcessId == (ULONGLONG)AFSSysProcess)
{
- try_return( ntStatus = Fcb->NPFcb->Specific.File.ExtentsRequestStatus);
- }
- Fcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
+ ntStatus = Fcb->NPFcb->Specific.File.ExtentsRequestStatus;
+
+ Fcb->NPFcb->Specific.File.ExtentsRequestStatus = STATUS_SUCCESS;
+
+ RtlZeroMemory( &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
+ sizeof( GUID));
+
+ try_return( ntStatus);
+ }
}
if( ntStatus == STATUS_TIMEOUT)
}
NTSTATUS
-AFSFlushExtents( IN AFSFcb *Fcb)
+AFSFlushExtents( IN AFSFcb *Fcb,
+ IN GUID *AuthGroup)
{
AFSNonPagedFcb *pNPFcb = Fcb->NPFcb;
AFSExtent *pExtent, *pNextExtent;
LARGE_INTEGER liLastFlush;
AFSExtent *pDirtyListHead = NULL, *pDirtyListTail = NULL;
AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
+ GUID *pAuthGroup = AuthGroup;
+ GUID stAuthGroup;
+ LONG lCount;
ASSERT( Fcb->Header.NodeTypeCode == AFS_FILE_FCB);
__Enter
{
+ lCount = InterlockedIncrement( &Fcb->Specific.File.QueuedFlushCount);
+
+ if( pAuthGroup == NULL ||
+ RtlCompareMemory( pAuthGroup,
+ &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
+ sizeof( GUID)) == sizeof( GUID))
+ {
+
+ RtlZeroMemory( &stAuthGroup,
+ sizeof( GUID));
+
+ ntStatus = AFSRetrieveValidAuthGroup( Fcb,
+ NULL,
+ TRUE,
+ &stAuthGroup);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+ try_return( ntStatus);
+ }
+
+ pAuthGroup = &stAuthGroup;
+ }
+
//
// Lock extents while we count and set up the array to send to
// the service
bExtentsLocked = TRUE;
- InterlockedIncrement( &Fcb->Specific.File.QueuedFlushCount);
-
//
// Clear our queued flush event
//
pExtent->DirtyList.fLink = NULL;
pExtent->DirtyList.bLink = NULL;
- InterlockedDecrement( &Fcb->Specific.File.ExtentsDirtyCount);
+ lCount = InterlockedDecrement( &Fcb->Specific.File.ExtentsDirtyCount);
//
// Clear the flag in advance of the write. If we do
pRelease->FileExtents[count].Flags |= AFS_EXTENT_FLAG_RELEASE;
- //
- // Need to pull this extent from the main list as well
- //
-
- for (ULONG i = 0; i < AFS_NUM_EXTENT_LISTS; i ++)
- {
- if (NULL != pExtent->Lists[i].Flink && !IsListEmpty(&pExtent->Lists[i]))
- {
- RemoveEntryList( &pExtent->Lists[i] );
- }
- }
-
- InterlockedExchangeAdd( &pControlDevExt->Specific.Control.ExtentsHeldLength, -((LONG)(pExtent->Size/1024)));
-
- InterlockedExchangeAdd( &Fcb->Specific.File.ExtentLength, -((LONG)(pExtent->Size/1024)));
-
- AFSExFreePool( pExtent);
-
- InterlockedDecrement( &Fcb->Specific.File.ExtentCount);
-
- if( InterlockedDecrement( &pControlDevExt->Specific.Control.ExtentCount) == 0)
- {
-
- KeSetEvent( &pControlDevExt->Specific.Control.ExtentsHeldEvent,
- 0,
- FALSE);
- }
+ AFSFreeExtent( Fcb,
+ pExtent);
count ++;
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- &Fcb->AuthGroup,
+ pAuthGroup,
NULL,
&Fcb->ObjectInformation->FileId,
pRelease,
try_exit:
- if( InterlockedDecrement( &Fcb->Specific.File.QueuedFlushCount) == 0)
+ lCount = InterlockedDecrement( &Fcb->Specific.File.QueuedFlushCount);
+
+ ASSERT( lCount >= 0);
+
+ if( lCount == 0)
{
KeSetEvent( &pNPFcb->Specific.File.QueuedFlushEvent,
if (pRelease)
{
- AFSExFreePool( pRelease);
+ AFSExFreePoolWithTag( pRelease, AFS_EXTENT_RELEASE_TAG);
}
}
}
NTSTATUS
-AFSReleaseExtentsWithFlush( IN AFSFcb *Fcb)
+AFSReleaseExtentsWithFlush( IN AFSFcb *Fcb,
+ IN GUID *AuthGroup,
+ IN BOOLEAN bReleaseAll)
{
AFSNonPagedFcb *pNPFcb = Fcb->NPFcb;
AFSExtent *pExtent;
LARGE_INTEGER liLastFlush;
ULONG ulRemainingExtentLength = 0;
AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
+ GUID *pAuthGroup = AuthGroup;
+ GUID stAuthGroup;
+ LONG lCount;
ASSERT( Fcb->Header.NodeTypeCode == AFS_FILE_FCB);
__Enter
{
+ if( pAuthGroup == NULL ||
+ RtlCompareMemory( pAuthGroup,
+ &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
+ sizeof( GUID)) == sizeof( GUID))
+ {
+
+ RtlZeroMemory( &stAuthGroup,
+ sizeof( GUID));
+
+ ntStatus = AFSRetrieveValidAuthGroup( Fcb,
+ NULL,
+ TRUE,
+ &stAuthGroup);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+ try_return( ntStatus);
+ }
+
+ pAuthGroup = &stAuthGroup;
+ }
+
//
// Look for a start in the list to flush entries
//
try_return ( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
}
- if( Fcb->OpenHandleCount > 0)
+ if( Fcb->OpenHandleCount > 0 &&
+ !bReleaseAll)
{
//
// Don't release everything ...
//
- //
- // For now release everything
- //
-
- //ulRemainingExtentLength = 1500;
+ ulRemainingExtentLength = 1024;
}
while( Fcb->Specific.File.ExtentLength > (LONG)ulRemainingExtentLength)
pRelease->FileExtents[count].Flags |= AFS_EXTENT_FLAG_DIRTY;
- InterlockedDecrement( &Fcb->Specific.File.ExtentsDirtyCount);
+ lCount = InterlockedDecrement( &Fcb->Specific.File.ExtentsDirtyCount);
}
AFSReleaseResource( &pNPFcb->Specific.File.DirtyExtentsListLock);
}
+ AFSFreeExtent( Fcb,
+ pExtent);
+
+ count ++;
+ }
+
+ //
+ // If we are done then get out
+ //
+
+ if( count == 0)
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSReleaseExtentsWithFlush No more dirty extents found\n");
+
+ break;
+ }
+
+ //
+ // Fire off the request synchronously
+ //
+
+ sz = sizeof( AFSReleaseExtentsCB ) + (count * sizeof ( AFSFileExtentCB ));
+
+ pRelease->ExtentCount = count;
+
+ //
+ // Drop the extents lock for the duration of the call to
+ // the network. We have pinned the extents so, even
+ // though we might get extents added during this period,
+ // but none will be removed. Hence we can carry on from
+ // le.
+ //
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSReleaseExtentsWithFlush Releasing Fcb extents lock %08lX thread %08lX\n",
+ &pNPFcb->Specific.File.ExtentsResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource);
+ bExtentsLocked = FALSE;
+
+ ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS,
+ AFS_REQUEST_FLAG_SYNCHRONOUS,
+ pAuthGroup,
+ NULL,
+ &Fcb->ObjectInformation->FileId,
+ pRelease,
+ sz,
+ NULL,
+ NULL);
+
+ if( !NT_SUCCESS(ntStatus))
+ {
+
//
- // Need to pull this extent from the main list as well
+ // Regardless of whether or not the AFSProcessRequest() succeeded, the extents
+ // were released (if AFS_EXTENT_FLAG_RELEASE was set). Log the error so it is known.
//
- for (ULONG i = 0; i < AFS_NUM_EXTENT_LISTS; i ++)
+ AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
+ AFS_TRACE_LEVEL_ERROR,
+ "AFSReleaseExtentsWithFlush AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS failed fid %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ Fcb->ObjectInformation->FileId.Cell,
+ Fcb->ObjectInformation->FileId.Volume,
+ Fcb->ObjectInformation->FileId.Vnode,
+ Fcb->ObjectInformation->FileId.Unique,
+ ntStatus);
+ }
+ }
+
+try_exit:
+
+ if (bExtentsLocked)
+ {
+
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSReleaseExtentsWithFlush Releasing Fcb extents lock %08lX thread %08lX\n",
+ &pNPFcb->Specific.File.ExtentsResource,
+ PsGetCurrentThread());
+
+ AFSReleaseResource( &pNPFcb->Specific.File.ExtentsResource );
+ }
+
+ if (pRelease)
+ {
+ AFSExFreePoolWithTag( pRelease, AFS_EXTENT_RELEASE_TAG);
+ }
+ }
+
+ return ntStatus;
+}
+
+NTSTATUS
+AFSReleaseCleanExtents( IN AFSFcb *Fcb,
+ IN GUID *AuthGroup)
+{
+ AFSNonPagedFcb *pNPFcb = Fcb->NPFcb;
+ AFSExtent *pExtent;
+ LIST_ENTRY *le;
+ AFSReleaseExtentsCB *pRelease = NULL;
+ ULONG count = 0;
+ ULONG initialDirtyCount = 0;
+ BOOLEAN bExtentsLocked = FALSE;
+ ULONG total = 0;
+ ULONG sz = 0;
+ NTSTATUS ntStatus = STATUS_SUCCESS;
+ LARGE_INTEGER liLastFlush;
+ ULONG ulRemainingExtentLength = 0;
+ AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
+ GUID *pAuthGroup = AuthGroup;
+ GUID stAuthGroup;
+
+ ASSERT( Fcb->Header.NodeTypeCode == AFS_FILE_FCB);
+
+ //
+ // Save, then reset the flush time
+ //
+
+ liLastFlush = Fcb->Specific.File.LastServerFlush;
+
+ KeQueryTickCount( &Fcb->Specific.File.LastServerFlush);
+
+ __Enter
+ {
+
+ if( pAuthGroup == NULL ||
+ RtlCompareMemory( pAuthGroup,
+ &Fcb->NPFcb->Specific.File.ExtentsRequestAuthGroup,
+ sizeof( GUID)) == sizeof( GUID))
+ {
+
+ RtlZeroMemory( &stAuthGroup,
+ sizeof( GUID));
+
+ ntStatus = AFSRetrieveValidAuthGroup( Fcb,
+ NULL,
+ TRUE,
+ &stAuthGroup);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+ try_return( ntStatus);
+ }
+
+ pAuthGroup = &stAuthGroup;
+ }
+
+ //
+ // Look for a start in the list to flush entries
+ //
+
+ total = count;
+
+ sz = sizeof( AFSReleaseExtentsCB ) + (AFS_MAXIMUM_EXTENT_RELEASE_COUNT * sizeof ( AFSFileExtentCB ));
+
+ pRelease = (AFSReleaseExtentsCB*) AFSExAllocatePoolWithTag( NonPagedPool,
+ sz,
+ AFS_EXTENT_RELEASE_TAG);
+ if( NULL == pRelease)
+ {
+
+ try_return ( ntStatus = STATUS_INSUFFICIENT_RESOURCES );
+ }
+
+ while( Fcb->Specific.File.ExtentLength > (LONG)ulRemainingExtentLength)
+ {
+
+ AFSLockForExtentsTrim( Fcb);
+
+ bExtentsLocked = TRUE;
+
+ pRelease->Flags = AFS_EXTENT_FLAG_RELEASE;
+
+ //
+ // Update the metadata for this call
+ //
+
+ pRelease->AllocationSize = Fcb->ObjectInformation->EndOfFile;
+ pRelease->CreateTime = Fcb->ObjectInformation->CreationTime;
+ pRelease->ChangeTime = Fcb->ObjectInformation->ChangeTime;
+ pRelease->LastAccessTime = Fcb->ObjectInformation->LastAccessTime;
+ pRelease->LastWriteTime = Fcb->ObjectInformation->LastWriteTime;
+
+ count = 0;
+
+ le = Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST].Flink;
+
+ while( count < AFS_MAXIMUM_EXTENT_RELEASE_COUNT &&
+ le != &Fcb->Specific.File.ExtentsLists[AFS_EXTENTS_LIST])
+ {
+
+ pExtent = ExtentFor( le, AFS_EXTENTS_LIST);
+
+ le = le->Flink;
+
+ if( pExtent->ActiveCount > 0 ||
+ BooleanFlagOn( pExtent->Flags, AFS_EXTENT_DIRTY))
{
- if (NULL != pExtent->Lists[i].Flink && !IsListEmpty(&pExtent->Lists[i]))
- {
- RemoveEntryList( &pExtent->Lists[i] );
- }
+ continue;
}
- InterlockedExchangeAdd( &pControlDevExt->Specific.Control.ExtentsHeldLength, -((LONG)(pExtent->Size/1024)));
+ pRelease->FileExtents[count].Flags = AFS_EXTENT_FLAG_RELEASE;
- InterlockedExchangeAdd( &Fcb->Specific.File.ExtentLength, -((LONG)(pExtent->Size/1024)));
+ AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSReleaseCleanExtents Releasing extent %p fid %08lX-%08lX-%08lX-%08lX Offset %I64X Len %08lX\n",
+ pExtent,
+ Fcb->ObjectInformation->FileId.Cell,
+ Fcb->ObjectInformation->FileId.Volume,
+ Fcb->ObjectInformation->FileId.Vnode,
+ Fcb->ObjectInformation->FileId.Unique,
+ pExtent->FileOffset.QuadPart,
+ pExtent->Size);
- AFSExFreePool( pExtent);
+ pRelease->FileExtents[count].Length = pExtent->Size;
+ pRelease->FileExtents[count].DirtyLength = pExtent->Size;
+ pRelease->FileExtents[count].DirtyOffset = 0;
+ pRelease->FileExtents[count].CacheOffset = pExtent->CacheOffset;
+ pRelease->FileExtents[count].FileOffset = pExtent->FileOffset;
- InterlockedDecrement( &Fcb->Specific.File.ExtentCount);
+#if GEN_MD5
+ RtlCopyMemory( pRelease->FileExtents[count].MD5,
+ pExtent->MD5,
+ sizeof(pExtent->MD5));
- if( InterlockedDecrement( &pControlDevExt->Specific.Control.ExtentCount) == 0)
- {
+ pRelease->FileExtents[count].Flags |= AFS_EXTENT_FLAG_MD5_SET;
+#endif
- KeSetEvent( &pControlDevExt->Specific.Control.ExtentsHeldEvent,
- 0,
- FALSE);
- }
+ AFSFreeExtent( Fcb,
+ pExtent);
count ++;
}
AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSReleaseExtentsWithFlush No more dirty extents found\n");
+ "AFSReleaseCleanExtents No more dirty extents found\n");
break;
}
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSReleaseExtentsWithFlush Releasing Fcb extents lock %08lX thread %08lX\n",
+ "AFSReleaseCleanExtents Releasing Fcb extents lock %08lX thread %08lX\n",
&pNPFcb->Specific.File.ExtentsResource,
PsGetCurrentThread());
ntStatus = AFSProcessRequest( AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS,
AFS_REQUEST_FLAG_SYNCHRONOUS,
- &Fcb->AuthGroup,
+ pAuthGroup,
NULL,
&Fcb->ObjectInformation->FileId,
pRelease,
AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
- "AFSReleaseExtentsWithFlush AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS failed fid %08lX-%08lX-%08lX-%08lX Status %08lX\n",
+ "AFSReleaseCleanExtents AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS failed fid %08lX-%08lX-%08lX-%08lX Status %08lX\n",
Fcb->ObjectInformation->FileId.Cell,
Fcb->ObjectInformation->FileId.Volume,
Fcb->ObjectInformation->FileId.Vnode,
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
- "AFSReleaseExtentsWithFlush Releasing Fcb extents lock %08lX thread %08lX\n",
+ "AFSReleaseCleanExtents Releasing Fcb extents lock %08lX thread %08lX\n",
&pNPFcb->Specific.File.ExtentsResource,
PsGetCurrentThread());
if (pRelease)
{
- AFSExFreePool( pRelease);
+ AFSExFreePoolWithTag( pRelease, AFS_EXTENT_RELEASE_TAG);
}
}
AFSMarkDirty( IN AFSFcb *Fcb,
IN AFSExtent *StartExtent,
IN ULONG ExtentsCount,
- IN LARGE_INTEGER *StartingByte)
+ IN LARGE_INTEGER *StartingByte,
+ IN BOOLEAN DerefExtents)
{
AFSNonPagedFcb *pNPFcb = Fcb->NPFcb;
AFSExtent *pNextExtent, *pCurrentExtent = NULL;
ULONG ulCount = 0;
BOOLEAN bInsertTail = FALSE, bInsertHead = FALSE;
+ LONG lCount;
AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
&Fcb->NPFcb->Specific.File.ExtentsResource,
PsGetCurrentThread());
- AFSAcquireShared( &Fcb->NPFcb->Specific.File.ExtentsResource, TRUE);
-
- AFSAcquireExcl( &pNPFcb->Specific.File.DirtyExtentsListLock,
- TRUE);
-
- //
- // Find the insertion point
- //
-
- if( pNPFcb->Specific.File.DirtyListHead == NULL)
- {
+ ASSERT( ExIsResourceAcquiredLite( &pNPFcb->Specific.File.ExtentsResource));
- bInsertTail = TRUE;
- }
- else if( StartingByte->QuadPart == 0)
- {
+ AFSAcquireExcl( &pNPFcb->Specific.File.DirtyExtentsListLock,
+ TRUE);
- bInsertHead = TRUE;
- }
- else
+ __try
{
+ //
+ // Find the insertion point
+ //
- pCurrentExtent = pNPFcb->Specific.File.DirtyListHead;
+ if( pNPFcb->Specific.File.DirtyListHead == NULL)
+ {
- while( pCurrentExtent != NULL)
+ bInsertTail = TRUE;
+ }
+ else if( StartingByte->QuadPart == 0)
{
- if( pCurrentExtent->FileOffset.QuadPart + pCurrentExtent->Size >= StartingByte->QuadPart ||
- pCurrentExtent->DirtyList.fLink == NULL)
- {
+ bInsertHead = TRUE;
+ }
+ else
+ {
- break;
- }
+ pCurrentExtent = pNPFcb->Specific.File.DirtyListHead;
- pCurrentExtent = (AFSExtent *)pCurrentExtent->DirtyList.fLink;
- }
- }
+ while( pCurrentExtent != NULL)
+ {
- while( ulCount < ExtentsCount)
- {
+ if( pCurrentExtent->FileOffset.QuadPart + pCurrentExtent->Size >= StartingByte->QuadPart ||
+ pCurrentExtent->DirtyList.fLink == NULL)
+ {
- pNextExtent = NextExtent( pExtent, AFS_EXTENTS_LIST);
+ break;
+ }
- if( !BooleanFlagOn( pExtent->Flags, AFS_EXTENT_DIRTY))
- {
+ pCurrentExtent = (AFSExtent *)pCurrentExtent->DirtyList.fLink;
+ }
+ }
- AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSMarkDirty Marking extent offset %I64X Length %08lX DIRTY\n",
- pExtent->FileOffset.QuadPart,
- pExtent->Size);
+ while( ulCount < ExtentsCount)
+ {
- pExtent->DirtyList.fLink = NULL;
- pExtent->DirtyList.bLink = NULL;
+ pNextExtent = NextExtent( pExtent, AFS_EXTENTS_LIST);
- if( bInsertHead)
+ if( !BooleanFlagOn( pExtent->Flags, AFS_EXTENT_DIRTY))
{
- pExtent->DirtyList.fLink = (void *)pNPFcb->Specific.File.DirtyListHead;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSMarkDirty Marking extent offset %I64X Length %08lX DIRTY\n",
+ pExtent->FileOffset.QuadPart,
+ pExtent->Size);
+ pExtent->DirtyList.fLink = NULL;
pExtent->DirtyList.bLink = NULL;
- pNPFcb->Specific.File.DirtyListHead->DirtyList.bLink = (void *)pExtent;
-
- pNPFcb->Specific.File.DirtyListHead = pExtent;
+ if( bInsertHead)
+ {
- pCurrentExtent = pExtent;
+ pExtent->DirtyList.fLink = (void *)pNPFcb->Specific.File.DirtyListHead;
- bInsertHead = FALSE;
- }
- else if( bInsertTail)
- {
+ pExtent->DirtyList.bLink = NULL;
- if( pNPFcb->Specific.File.DirtyListHead == NULL)
- {
+ pNPFcb->Specific.File.DirtyListHead->DirtyList.bLink = (void *)pExtent;
pNPFcb->Specific.File.DirtyListHead = pExtent;
- }
- else
- {
- pNPFcb->Specific.File.DirtyListTail->DirtyList.fLink = (void *)pExtent;
+ pCurrentExtent = pExtent;
- pExtent->DirtyList.bLink = (void *)pNPFcb->Specific.File.DirtyListTail;
+ bInsertHead = FALSE;
}
+ else if( bInsertTail)
+ {
- pNPFcb->Specific.File.DirtyListTail = pExtent;
- }
- else
- {
+ if( pNPFcb->Specific.File.DirtyListHead == NULL)
+ {
+
+ pNPFcb->Specific.File.DirtyListHead = pExtent;
+ }
+ else
+ {
- pExtent->DirtyList.fLink = pCurrentExtent->DirtyList.fLink;
- pExtent->DirtyList.bLink = (void *)pCurrentExtent;
+ pNPFcb->Specific.File.DirtyListTail->DirtyList.fLink = (void *)pExtent;
- if( pExtent->DirtyList.fLink == NULL)
- {
+ pExtent->DirtyList.bLink = (void *)pNPFcb->Specific.File.DirtyListTail;
+ }
pNPFcb->Specific.File.DirtyListTail = pExtent;
}
else
{
- ((AFSExtent *)pExtent->DirtyList.fLink)->DirtyList.bLink = (void *)pExtent;
+ pExtent->DirtyList.fLink = pCurrentExtent->DirtyList.fLink;
+
+ pExtent->DirtyList.bLink = (void *)pCurrentExtent;
+
+ if( pExtent->DirtyList.fLink == NULL)
+ {
+
+ pNPFcb->Specific.File.DirtyListTail = pExtent;
+ }
+ else
+ {
+
+ ((AFSExtent *)pExtent->DirtyList.fLink)->DirtyList.bLink = (void *)pExtent;
+ }
+
+ pCurrentExtent->DirtyList.fLink = (void *)pExtent;
+
+ pCurrentExtent = pExtent;
}
- pCurrentExtent->DirtyList.fLink = (void *)pExtent;
+ pExtent->Flags |= AFS_EXTENT_DIRTY;
+
+ //
+ // Up the dirty count
+ //
+
+ lCount = InterlockedIncrement( &Fcb->Specific.File.ExtentsDirtyCount);
+ }
+ else
+ {
pCurrentExtent = pExtent;
}
- pExtent->Flags |= AFS_EXTENT_DIRTY;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_ACTIVE_COUNTING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSMarkDirty Decrement count on extent %08lX Cnt %d\n",
+ pExtent,
+ pExtent->ActiveCount);
- //
- // Up the dirty count
- //
+ if( DerefExtents)
+ {
+ ASSERT( pExtent->ActiveCount > 0);
+ lCount = InterlockedDecrement( &pExtent->ActiveCount);
+ }
- InterlockedIncrement( &Fcb->Specific.File.ExtentsDirtyCount);
- }
- else
- {
+ pExtent = pNextExtent;
- pCurrentExtent = pExtent;
+ ulCount++;
}
+ }
+ __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
+ {
- AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_ACTIVE_COUNTING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSMarkDirty Decrement count on extent %08lX Cnt %d\n",
- pExtent,
- pExtent->ActiveCount);
-
- ASSERT( pExtent->ActiveCount > 0);
-
- InterlockedDecrement( &pExtent->ActiveCount);
-
- pExtent = pNextExtent;
+ AFSDbgLogMsg( 0,
+ 0,
+ "EXCEPTION - AFSMarkDirty\n");
- ulCount++;
+ AFSDumpTraceFilesFnc();
}
AFSReleaseResource( &pNPFcb->Specific.File.DirtyExtentsListLock);
&Fcb->NPFcb->Specific.File.ExtentsResource,
PsGetCurrentThread());
- AFSReleaseResource( &Fcb->NPFcb->Specific.File.ExtentsResource );
-
return;
}
// Helper functions
//
-static AFSExtent *ExtentFor(PLIST_ENTRY le, ULONG SkipList)
+AFSExtent *
+ExtentFor(PLIST_ENTRY le, ULONG SkipList)
{
+
return CONTAINING_RECORD( le, AFSExtent, Lists[SkipList] );
}
-static AFSExtent *NextExtent(AFSExtent *Extent, ULONG SkipList)
+AFSExtent *
+NextExtent(AFSExtent *Extent, ULONG SkipList)
{
+
return ExtentFor(Extent->Lists[SkipList].Flink, SkipList);
}
static AFSExtent *DirtyExtentFor(PLIST_ENTRY le)
{
+
return CONTAINING_RECORD( le, AFSExtent, DirtyList );
}
LARGE_INTEGER liAlignedOffset = {0,0};
AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
+ LONG lCount;
__Enter
{
AFSReleaseResource( &pNPFcb->Specific.File.DirtyExtentsListLock);
}
- for (ULONG i = 0; i < AFS_NUM_EXTENT_LISTS; i ++)
- {
- if (NULL != pExtent->Lists[i].Flink && !IsListEmpty(&pExtent->Lists[i]))
- {
- RemoveEntryList( &pExtent->Lists[i] );
- }
- }
-
AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSTrimExtents Releasing extent %p fid %08lX-%08lX-%08lX-%08lX Offset %I64X Len %08lX\n",
pExtent->FileOffset.QuadPart,
pExtent->Size);
- InterlockedExchangeAdd( &pControlDevExt->Specific.Control.ExtentsHeldLength, -((LONG)(pExtent->Size/1024)));
-
- InterlockedExchangeAdd( &Fcb->Specific.File.ExtentLength, -((LONG)(pExtent->Size/1024)));
-
ASSERT( pExtent->ActiveCount == 0);
- //
- // and free
- //
- AFSExFreePool( pExtent);
-
- InterlockedDecrement( &Fcb->Specific.File.ExtentCount);
-
- if( InterlockedDecrement( &pControlDevExt->Specific.Control.ExtentCount) == 0)
- {
-
- KeSetEvent( &pControlDevExt->Specific.Control.ExtentsHeldEvent,
- 0,
- FALSE);
- }
+ AFSFreeExtent( Fcb,
+ pExtent);
}
}
NTSTATUS ntStatus = STATUS_SUCCESS;
AFSDeviceExt *pDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSControlDeviceObject->DeviceExtension;
+ LONG lCount;
__Enter
{
}
- for (ULONG i = 0; i < AFS_NUM_EXTENT_LISTS; i ++)
- {
- if (NULL != pExtent->Lists[i].Flink && !IsListEmpty(&pExtent->Lists[i]))
- {
- RemoveEntryList( &pExtent->Lists[i] );
- }
- }
-
AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSTrimSpecifiedExtents Releasing extent %p fid %08lX-%08lX-%08lX-%08lX Offset %I64X Len %08lX\n",
pExtent->FileOffset.QuadPart,
pExtent->Size);
- InterlockedExchangeAdd( &pControlDevExt->Specific.Control.ExtentsHeldLength, -((LONG)(pExtent->Size/1024)));
-
- InterlockedExchangeAdd( &Fcb->Specific.File.ExtentLength, -((LONG)(pExtent->Size/1024)));
-
ASSERT( pExtent->ActiveCount == 0);
- //
- // and free
- //
- AFSExFreePool( pExtent);
-
- InterlockedDecrement( &Fcb->Specific.File.ExtentCount);
-
- if( InterlockedDecrement( &pControlDevExt->Specific.Control.ExtentCount) == 0)
- {
-
- KeSetEvent( &pControlDevExt->Specific.Control.ExtentsHeldEvent,
- 0,
- FALSE);
- }
+ AFSFreeExtent( Fcb,
+ pExtent);
//
// Next extent we are looking for
AFSExtent *pExtent = StartExtent;
AFSExtent *pNextExtent;
ULONG ulCount = 0;
+ LONG lCount;
while( ulCount < ExtentsCount)
{
pNextExtent = NextExtent( pExtent, AFS_EXTENTS_LIST);
- InterlockedIncrement( &pExtent->ActiveCount);
+ lCount = InterlockedIncrement( &pExtent->ActiveCount);
AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_ACTIVE_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSReferenceActiveExtents Increment count on extent %08lX Cnt %d\n",
pExtent,
- pExtent->ActiveCount);
+ lCount);
pExtent = pNextExtent;
AFSExtent *pExtent = StartExtent;
AFSExtent *pNextExtent;
ULONG ulCount = 0;
+ LONG lCount;
while( ulCount < ExtentsCount)
{
pNextExtent = NextExtent( pExtent, AFS_EXTENTS_LIST);
+ ASSERT( pExtent->ActiveCount > 0);
+
+ lCount = InterlockedDecrement( &pExtent->ActiveCount);
+
AFSDbgLogMsg( AFS_SUBSYSTEM_EXTENT_ACTIVE_COUNTING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSDereferenceActiveExtents Decrement count on extent %08lX Cnt %d\n",
pExtent,
- pExtent->ActiveCount);
-
- ASSERT( pExtent->ActiveCount > 0);
-
- InterlockedDecrement( &pExtent->ActiveCount);
+ lCount);
pExtent = pNextExtent;
return;
}
+ULONG
+AFSConstructCleanByteRangeList( AFSFcb * pFcb,
+ AFSByteRange ** pByteRangeList)
+{
+
+ ULONG ulByteRangeMax;
+ ULONG ulByteRangeCount = 0;
+ AFSByteRange *ByteRangeList;
+ AFSExtent *pExtent, *pNextExtent;
+
+ AFSAcquireShared( &pFcb->NPFcb->Specific.File.DirtyExtentsListLock, TRUE);
+
+ ulByteRangeMax = pFcb->Specific.File.ExtentsDirtyCount + 1;
+
+ ByteRangeList = (AFSByteRange *) AFSExAllocatePoolWithTag( PagedPool,
+ ulByteRangeMax * sizeof( AFSByteRange),
+ AFS_BYTERANGE_TAG);
+
+ if ( ByteRangeList == NULL)
+ {
+
+ (*pByteRangeList) = NULL;
+
+ try_return( ulByteRangeCount = DWORD_MAX);
+ }
+
+ RtlZeroMemory( ByteRangeList,
+ ulByteRangeMax * sizeof( AFSByteRange));
+
+ //
+ // The for loop populates the ByteRangeList entries with values that are
+ // the gaps in the DirtyList. In other words, if a range is not present
+ // in the DirtyList it will be represented in the ByteRangeList array.
+ //
+
+ for ( ulByteRangeCount = 0,
+ pExtent = (AFSExtent *)pFcb->NPFcb->Specific.File.DirtyListHead;
+ ulByteRangeCount < ulByteRangeMax && pExtent != NULL;
+ pExtent = pNextExtent)
+ {
+
+ pNextExtent = (AFSExtent *)pExtent->DirtyList.fLink;
+
+ //
+ // The first time the for() is entered the ulByteRangeCount will be zero and
+ // ByteRangeList[0] FileOffset and Length will both be zero. If the first
+ // extent is not for offset zero, the ByteRangeList[0] Length is set to the
+ // FileOffset of the Extent.
+ //
+ // Future passes through the loop behave in a similar fashion but
+ // ByteRangeList[ulByteRangeCount] FileOffset will have been set below.
+ //
+
+ if ( pExtent->FileOffset.QuadPart != ByteRangeList[ulByteRangeCount].FileOffset.QuadPart + ByteRangeList[ulByteRangeCount].Length.QuadPart)
+ {
+
+ ByteRangeList[ulByteRangeCount].Length.QuadPart =
+ pExtent->FileOffset.QuadPart - ByteRangeList[ulByteRangeCount].FileOffset.QuadPart;
+
+ ulByteRangeCount++;
+ }
+
+ //
+ // Having processed the current dirty extent, the following while loop
+ // searches for the next clean gap between dirty extents.
+ //
+
+ while ( pNextExtent && pNextExtent->FileOffset.QuadPart == pExtent->FileOffset.QuadPart + pExtent->Size)
+ {
+
+ pExtent = pNextExtent;
+
+ pNextExtent = (AFSExtent *)pExtent->DirtyList.fLink;
+ }
+
+ //
+ // Having found the next gap, the ByteRangeList[] FileOffset is set to the start of the gap.
+ // The Length is left at zero and will be assigned either when the for loop continues or
+ // when the for loop exits.
+ //
+
+ ByteRangeList[ulByteRangeCount].FileOffset.QuadPart = pExtent->FileOffset.QuadPart + pExtent->Size;
+ }
+
+ //
+ // Assign the Length of the final clean range to match the file length.
+ //
+
+ ByteRangeList[ulByteRangeCount].Length.QuadPart =
+ pFcb->ObjectInformation->EndOfFile.QuadPart - ByteRangeList[ulByteRangeCount].FileOffset.QuadPart;
+
+ (*pByteRangeList) = ByteRangeList;
+
+ try_exit:
+
+ AFSReleaseResource( &pFcb->NPFcb->Specific.File.DirtyExtentsListLock);
+
+ return ulByteRangeCount;
+}
+
#if GEN_MD5
void
AFSSetupMD5Hash( IN AFSFcb *Fcb,
AFSAcquireShared( &Fcb->NPFcb->Specific.File.ExtentsResource, TRUE);
- liByteOffset.QuadPart = ByteOffset->QuadPart;
-
- while( ulCount < ExtentsCount)
+ __try
{
+ liByteOffset.QuadPart = ByteOffset->QuadPart;
- RtlZeroMemory( pExtent->MD5,
- sizeof( pExtent->MD5));
+ while( ulCount < ExtentsCount)
+ {
- pNextExtent = NextExtent( pExtent, AFS_EXTENTS_LIST);
+ RtlZeroMemory( pExtent->MD5,
+ sizeof( pExtent->MD5));
- if( liByteOffset.QuadPart == pExtent->FileOffset.QuadPart &&
- ByteCount < pExtent->Size)
- {
+ pNextExtent = NextExtent( pExtent, AFS_EXTENTS_LIST);
- if( pExtentBuffer == NULL)
+ if( liByteOffset.QuadPart == pExtent->FileOffset.QuadPart &&
+ ByteCount < pExtent->Size)
{
- pExtentBuffer = AFSExAllocatePoolWithTag( PagedPool,
- pExtent->Size,
- AFS_GENERIC_MEMORY_9_TAG);
-
if( pExtentBuffer == NULL)
{
- break;
- }
- }
+ pExtentBuffer = AFSExAllocatePoolWithTag( PagedPool,
+ pExtent->Size,
+ AFS_GENERIC_MEMORY_9_TAG);
- RtlZeroMemory( pExtentBuffer,
- pExtent->Size);
+ if( pExtentBuffer == NULL)
+ {
- RtlCopyMemory( pExtentBuffer,
- pCurrentBuffer,
- ByteCount);
+ break;
+ }
+ }
- pMD5Buffer = (char *)pExtentBuffer;
+ RtlZeroMemory( pExtentBuffer,
+ pExtent->Size);
- ulCurrentLen = ByteCount;
- }
- else if( liByteOffset.QuadPart != pExtent->FileOffset.QuadPart)
- {
+ RtlCopyMemory( pExtentBuffer,
+ pCurrentBuffer,
+ ByteCount);
- pExtentBuffer = AFSExAllocatePoolWithTag( PagedPool,
- pExtent->Size,
- AFS_GENERIC_MEMORY_10_TAG);
+ pMD5Buffer = (char *)pExtentBuffer;
- if( pExtentBuffer == NULL)
+ ulCurrentLen = ByteCount;
+ }
+ else if( liByteOffset.QuadPart != pExtent->FileOffset.QuadPart)
{
- break;
- }
+ pExtentBuffer = AFSExAllocatePoolWithTag( PagedPool,
+ pExtent->Size,
+ AFS_GENERIC_MEMORY_10_TAG);
- RtlZeroMemory( pExtentBuffer,
- pExtent->Size);
+ if( pExtentBuffer == NULL)
+ {
- if( BooleanFlagOn( AFSLibControlFlags, AFS_REDIR_LIB_FLAGS_NONPERSISTENT_CACHE))
- {
+ break;
+ }
-#ifdef AMD64
- RtlCopyMemory( pExtentBuffer,
- ((char *)AFSLibCacheBaseAddress + pExtent->CacheOffset.QuadPart),
+ RtlZeroMemory( pExtentBuffer,
pExtent->Size);
+
+ if( BooleanFlagOn( AFSLibControlFlags, AFS_REDIR_LIB_FLAGS_NONPERSISTENT_CACHE))
+ {
+
+#ifdef AMD64
+ RtlCopyMemory( pExtentBuffer,
+ ((char *)AFSLibCacheBaseAddress + pExtent->CacheOffset.QuadPart),
+ pExtent->Size);
#else
- ASSERT( pExtent->CacheOffset.HighPart == 0);
- RtlCopyMemory( pExtentBuffer,
- ((char *)AFSLibCacheBaseAddress + pExtent->CacheOffset.LowPart),
- pExtent->Size);
+ ASSERT( pExtent->CacheOffset.HighPart == 0);
+ RtlCopyMemory( pExtentBuffer,
+ ((char *)AFSLibCacheBaseAddress + pExtent->CacheOffset.LowPart),
+ pExtent->Size);
#endif
- ulBytesRead = pExtent->Size;
+ ulBytesRead = pExtent->Size;
+ }
+ else
+ {
+
+ ntStatus = AFSReadCacheFile( pExtentBuffer,
+ &pExtent->CacheOffset,
+ pExtent->Size,
+ &ulBytesRead);
+
+ if( !NT_SUCCESS( ntStatus))
+ {
+
+ break;
+ }
+ }
+
+ pMD5Buffer = (char *)pExtentBuffer;
+
+ ulCurrentLen = min( ByteCount, pExtent->Size - (ULONG)(liByteOffset.QuadPart - pExtent->FileOffset.QuadPart));
+
+ RtlCopyMemory( (void *)((char *)pExtentBuffer + (ULONG)(liByteOffset.QuadPart - pExtent->FileOffset.QuadPart)),
+ pCurrentBuffer,
+ ulCurrentLen);
}
else
{
- ntStatus = AFSReadCacheFile( pExtentBuffer,
- &pExtent->CacheOffset,
- pExtent->Size,
- &ulBytesRead);
+ ulCurrentLen = pExtent->Size;
- if( !NT_SUCCESS( ntStatus))
- {
- break;
- }
+ pMD5Buffer = pCurrentBuffer;
}
- pMD5Buffer = (char *)pExtentBuffer;
+ AFSGenerateMD5( pMD5Buffer,
+ pExtent->Size,
+ pExtent->MD5);
- ulCurrentLen = min( ByteCount, pExtent->Size - (ULONG)(liByteOffset.QuadPart - pExtent->FileOffset.QuadPart));
-
- RtlCopyMemory( (void *)((char *)pExtentBuffer + (ULONG)(liByteOffset.QuadPart - pExtent->FileOffset.QuadPart)),
- pCurrentBuffer,
- ulCurrentLen);
- }
- else
- {
+ pExtent = pNextExtent;
- ulCurrentLen = pExtent->Size;
+ ulCount++;
- pMD5Buffer = pCurrentBuffer;
- }
+ ByteCount -= ulCurrentLen;
- AFSGenerateMD5( pMD5Buffer,
- pExtent->Size,
- pExtent->MD5);
+ pCurrentBuffer += ulCurrentLen;
- pExtent = pNextExtent;
+ liByteOffset.QuadPart += ulCurrentLen;
+ }
- ulCount++;
+ AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
+ AFS_TRACE_LEVEL_VERBOSE,
+ "AFSSetupMD5Hash Releasing Fcb extents lock %08lX SHARED %08lX\n",
+ &Fcb->NPFcb->Specific.File.ExtentsResource,
+ PsGetCurrentThread());
- ByteCount -= ulCurrentLen;
+ }
+ __except( AFSExceptionFilter( __FUNCTION__, GetExceptionCode(), GetExceptionInformation()) )
+ {
- pCurrentBuffer += ulCurrentLen;
+ AFSDbgLogMsg( 0,
+ 0,
+ "EXCEPTION - AFSSetupMD5Hash\n");
- liByteOffset.QuadPart += ulCurrentLen;
+ AFSDumpTraceFilesFnc();
}
- AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
- AFS_TRACE_LEVEL_VERBOSE,
- "AFSSetupMD5Hash Releasing Fcb extents lock %08lX SHARED %08lX\n",
- &Fcb->NPFcb->Specific.File.ExtentsResource,
- PsGetCurrentThread());
-
AFSReleaseResource( &Fcb->NPFcb->Specific.File.ExtentsResource );
if( pExtentBuffer != NULL)
{
- AFSExFreePool( pExtentBuffer);
+ AFSExFreePoolWithTag( pExtentBuffer, AFS_GENERIC_MEMORY_9_TAG);
}
}
git://git.openafs.org / openafs.git / blobdiff