Ros-diffs

ros-diffs@reactos.org

81390 discussions

[reactos] 01/06: [CDFS_NEW] Replace old driver with a Ms-PL licensed version straight out of the driver samples github repository.
by David Quintana 25 Nov '17

25 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=fd345482634d8ef4c64e5… commit fd345482634d8ef4c64e5910ce4752ac0c7438cc Author: David Quintana <gigaherz(a)gmail.com> AuthorDate: Thu Nov 23 21:02:16 2017 +0100 [CDFS_NEW] Replace old driver with a Ms-PL licensed version straight out of the driver samples github repository. --- drivers/filesystems/cdfs_new/CMakeLists.txt | 5 +- drivers/filesystems/cdfs_new/README.md | 20 + drivers/filesystems/cdfs_new/allocsup.c | 134 ++- drivers/filesystems/cdfs_new/cachesup.c | 73 +- drivers/filesystems/cdfs_new/cd.h | 8 +- drivers/filesystems/cdfs_new/cddata.c | 256 +++-- drivers/filesystems/cdfs_new/cddata.h | 113 +- drivers/filesystems/cdfs_new/cdfs.rc | 19 +- drivers/filesystems/cdfs_new/cdinit.c | 199 ++-- drivers/filesystems/cdfs_new/cdprocs.h | 1434 +++++++++++++++---------- drivers/filesystems/cdfs_new/cdprocssrc.c | 1 + drivers/filesystems/cdfs_new/cdstruc.h | 198 +++- drivers/filesystems/cdfs_new/cleanup.c | 64 +- drivers/filesystems/cdfs_new/close.c | 143 ++- drivers/filesystems/cdfs_new/create.c | 306 +++--- drivers/filesystems/cdfs_new/devctrl.c | 25 +- drivers/filesystems/cdfs_new/deviosup.c | 1507 ++++++++++++++++++--------- drivers/filesystems/cdfs_new/dirctrl.c | 183 ++-- drivers/filesystems/cdfs_new/dirsup.c | 161 +-- drivers/filesystems/cdfs_new/fieldoff.c | 4 +- drivers/filesystems/cdfs_new/fileinfo.c | 274 ++--- drivers/filesystems/cdfs_new/filobsup.c | 49 +- drivers/filesystems/cdfs_new/fsctrl.c | 668 ++++++++---- drivers/filesystems/cdfs_new/fspdisp.c | 40 +- drivers/filesystems/cdfs_new/lockctrl.c | 127 +-- drivers/filesystems/cdfs_new/namesup.c | 189 +++- drivers/filesystems/cdfs_new/nodetype.h | 17 +- drivers/filesystems/cdfs_new/pathsup.c | 100 +- drivers/filesystems/cdfs_new/pnp.c | 140 ++- drivers/filesystems/cdfs_new/prefxsup.c | 56 +- drivers/filesystems/cdfs_new/read.c | 68 +- drivers/filesystems/cdfs_new/resrcsup.c | 119 ++- drivers/filesystems/cdfs_new/shutdown.c | 175 ++++ drivers/filesystems/cdfs_new/strucsup.c | 464 +++++---- drivers/filesystems/cdfs_new/verfysup.c | 145 +-- drivers/filesystems/cdfs_new/volinfo.c | 187 +++- drivers/filesystems/cdfs_new/workque.c | 54 +- drivers/filesystems/cdfs_new/write.c | 381 +++++++ 38 files changed, 5301 insertions(+), 2805 deletions(-) diff --git a/drivers/filesystems/cdfs_new/CMakeLists.txt b/drivers/filesystems/cdfs_new/CMakeLists.txt index c0b56e99db..8bf4fa2639 100644 --- a/drivers/filesystems/cdfs_new/CMakeLists.txt +++ b/drivers/filesystems/cdfs_new/CMakeLists.txt @@ -6,6 +6,7 @@ list(APPEND SOURCE cachesup.c cddata.c cdinit.c + cdprocssrc.c cleanup.c close.c create.c @@ -24,10 +25,12 @@ list(APPEND SOURCE prefxsup.c read.c resrcsup.c + shutdown.c strucsup.c verfysup.c volinfo.c - workque.c) + workque.c + write.c) add_library(cdfs SHARED ${SOURCE} cdfs.rc) set_module_type(cdfs kernelmodedriver) diff --git a/drivers/filesystems/cdfs_new/README.md b/drivers/filesystems/cdfs_new/README.md new file mode 100644 index 0000000000..cbe8e4c468 --- /dev/null +++ b/drivers/filesystems/cdfs_new/README.md @@ -0,0 +1,20 @@ + + + +CDFS File System Driver +======================= + +The CD-ROM file system driver (cdfs) sample is a sample file system driver that you can use to write new file systems. + +Cdfs is a read-only file system that addresses various issues such as accessing data on disk, interacting with the cache manager, and handling various I/O operations such as opening files, performing reads on a file, retrieving information on a file, and performing various control operations on the file system. The Cdfs file system is included with the Microsoft Windows operating system. + +## Universal Windows Driver Compliant +This sample builds a Universal Windows Driver. It uses only APIs and DDIs that are included in OneCoreUAP. + diff --git a/drivers/filesystems/cdfs_new/allocsup.c b/drivers/filesystems/cdfs_new/allocsup.c index 93b35bcfda..6a92817cb5 100755 --- a/drivers/filesystems/cdfs_new/allocsup.c +++ b/drivers/filesystems/cdfs_new/allocsup.c @@ -44,7 +44,7 @@ Abstract: --*/ -#include "cdprocs.h" +#include "CdProcs.h" // // The Bug check file id for this module @@ -58,18 +58,18 @@ Abstract: ULONG CdFindMcbEntry ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN LONGLONG FileOffset + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ LONGLONG FileOffset ); VOID CdDiskOffsetFromMcbEntry ( - IN PIRP_CONTEXT IrpContext, - IN PCD_MCB_ENTRY McbEntry, - IN LONGLONG FileOffset, - IN PLONGLONG DiskOffset, - IN PULONG ByteCount + _In_ PIRP_CONTEXT IrpContext, + _In_ PCD_MCB_ENTRY McbEntry, + _In_ LONGLONG FileOffset, + _Out_ PLONGLONG DiskOffset, + _Out_ PULONG ByteCount ); #ifdef ALLOC_PRAGMA @@ -84,13 +84,16 @@ CdDiskOffsetFromMcbEntry ( #endif +_Requires_lock_held_(_Global_critical_region_) VOID +// PREFast currently has no way to express the Fcb==Fcb->Vcb->VolumeDasdFcb early return +#pragma warning(suppress: 6001 6101) CdLookupAllocation ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN LONGLONG FileOffset, - OUT PLONGLONG DiskOffset, - OUT PULONG ByteCount + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ LONGLONG FileOffset, + _Out_ PLONGLONG DiskOffset, + _Out_ PULONG ByteCount ) /*++ @@ -128,7 +131,7 @@ Return Value: { BOOLEAN FirstPass = TRUE; ULONG McbEntryOffset; - PFCB ParentFcb = NULL; /* ReactOS Change: GCC uninitialized variable bug */ + PFCB ParentFcb = NULL; BOOLEAN CleanupParent = FALSE; BOOLEAN UnlockFcb = FALSE; @@ -137,19 +140,31 @@ Return Value: ULONG CurrentMcbOffset; PCD_MCB_ENTRY CurrentMcbEntry; - DIRENT_ENUM_CONTEXT DirContext; - DIRENT Dirent; + DIRENT_ENUM_CONTEXT DirContext = {0}; + DIRENT Dirent = {0}; PAGED_CODE(); ASSERT_IRP_CONTEXT( IrpContext ); ASSERT_FCB( Fcb ); + // + // For DASD IO we already have clamped the read to the volume limits. + // We'll allow reading beyond those limits for extended DASD IO, so + // no MCB lookup here. + // + + if (Fcb == Fcb->Vcb->VolumeDasdFcb) { + + *DiskOffset = FileOffset; + return; + } + // // Use a try finally to facilitate cleanup. // - _SEH2_TRY { + try { // // We use a loop to perform the lookup. If we don't find the mapping in the @@ -215,10 +230,7 @@ Return Value: // Do an unsafe test to see if we need to create a file object. // - if (ParentFcb->FileObject == NULL) { - - CdCreateInternalStream( IrpContext, ParentFcb->Vcb, ParentFcb ); - } + CdVerifyOrCreateDirStreamFile( IrpContext, ParentFcb); // // Initialize the local variables to indicate the first dirent @@ -296,7 +308,7 @@ Return Value: FirstPass = FALSE; } - } _SEH2_FINALLY { + } finally { if (CleanupParent) { @@ -311,7 +323,7 @@ Return Value: } if (UnlockFcb) { CdUnlockFcb( IrpContext, Fcb ); } - } _SEH2_END; + } return; } @@ -319,11 +331,11 @@ Return Value: VOID CdAddAllocationFromDirent ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN ULONG McbEntryOffset, - IN LONGLONG StartingFileOffset, - IN PDIRENT Dirent + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB Fcb, + _In_ ULONG McbEntryOffset, + _In_ LONGLONG StartingFileOffset, + _In_ PDIRENT Dirent ) /*++ @@ -358,6 +370,8 @@ Return Value: PAGED_CODE(); + UNREFERENCED_PARAMETER( IrpContext ); + ASSERT_IRP_CONTEXT( IrpContext ); ASSERT_FCB( Fcb ); ASSERT_LOCKED_FCB( Fcb ); @@ -466,10 +480,10 @@ Return Value: VOID CdAddInitialAllocation ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN ULONG StartingBlock, - IN LONGLONG DataLength + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB Fcb, + _In_ ULONG StartingBlock, + _In_ LONGLONG DataLength ) /*++ @@ -505,11 +519,13 @@ Return Value: PAGED_CODE(); + UNREFERENCED_PARAMETER( IrpContext ); + ASSERT_IRP_CONTEXT( IrpContext ); ASSERT_FCB( Fcb ); ASSERT_LOCKED_FCB( Fcb ); - ASSERT( 0 == Fcb->Mcb.CurrentEntryCount); - ASSERT( CDFS_NTC_FCB_DATA != Fcb->NodeTypeCode); + NT_ASSERT( 0 == Fcb->Mcb.CurrentEntryCount); + NT_ASSERT( CDFS_NTC_FCB_DATA != Fcb->NodeTypeCode); // // Update the new entry with the input data. @@ -555,9 +571,9 @@ Return Value: VOID CdTruncateAllocation ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN LONGLONG StartingFileOffset + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB Fcb, + _In_ LONGLONG StartingFileOffset ) /*++ @@ -591,7 +607,7 @@ Return Value: ASSERT_LOCKED_FCB( Fcb ); // - // Find the entry containing this starting offset. + // Find the entry containg this starting offset. // McbEntryOffset = CdFindMcbEntry( IrpContext, Fcb, StartingFileOffset ); @@ -606,10 +622,11 @@ Return Value: } +_At_(Fcb->NodeByteSize, _In_range_(>=, FIELD_OFFSET( FCB, FcbType ))) VOID CdInitializeMcb ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb + _In_ PIRP_CONTEXT IrpContext, + _Inout_updates_bytes_(Fcb->NodeByteSize) PFCB Fcb ) /*++ @@ -635,6 +652,8 @@ Return Value: { PAGED_CODE(); + UNREFERENCED_PARAMETER( IrpContext ); + ASSERT_IRP_CONTEXT( IrpContext ); ASSERT_FCB( Fcb ); @@ -652,10 +671,14 @@ Return Value: } +_At_(Fcb->NodeByteSize, _In_range_(>=, FIELD_OFFSET( FCB, FcbType ))) +_When_(Fcb->NodeTypeCode == CDFS_NTC_FCB_PATH_TABLE, _At_(Fcb->NodeByteSize, _In_range_(==, SIZEOF_FCB_INDEX))) +_When_(Fcb->NodeTypeCode == CDFS_NTC_FCB_INDEX, _At_(Fcb->NodeByteSize, _In_range_(==, SIZEOF_FCB_INDEX))) +_When_(Fcb->NodeTypeCode == CDFS_NTC_FCB_DATA, _At_(Fcb->NodeByteSize, _In_range_(==, SIZEOF_FCB_DATA))) VOID CdUninitializeMcb ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb + _In_ PIRP_CONTEXT IrpContext, + _Inout_updates_bytes_(Fcb->NodeByteSize) PFCB Fcb ) /*++ @@ -681,6 +704,8 @@ Return Value: { PAGED_CODE(); + UNREFERENCED_PARAMETER( IrpContext ); + ASSERT_IRP_CONTEXT( IrpContext ); ASSERT_FCB( Fcb ); @@ -698,14 +723,14 @@ Return Value: // -// Local support routine +// Local suupport routine // ULONG CdFindMcbEntry ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN LONGLONG FileOffset + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ LONGLONG FileOffset ) /*++ @@ -736,6 +761,8 @@ Return Value: PAGED_CODE(); + UNREFERENCED_PARAMETER( IrpContext ); + ASSERT_IRP_CONTEXT( IrpContext ); ASSERT_FCB( Fcb ); ASSERT_LOCKED_FCB( Fcb ); @@ -781,11 +808,11 @@ Return Value: VOID CdDiskOffsetFromMcbEntry ( - IN PIRP_CONTEXT IrpContext, - IN PCD_MCB_ENTRY McbEntry, - IN LONGLONG FileOffset, - IN PLONGLONG DiskOffset, - IN PULONG ByteCount + _In_ PIRP_CONTEXT IrpContext, + _In_ PCD_MCB_ENTRY McbEntry, + _In_ LONGLONG FileOffset, + _Out_ PLONGLONG DiskOffset, + _Out_ PULONG ByteCount ) /*++ @@ -827,6 +854,9 @@ Return Value: LONGLONG LocalByteCount; PAGED_CODE(); + + UNREFERENCED_PARAMETER( IrpContext ); + ASSERT_IRP_CONTEXT( IrpContext ); // diff --git a/drivers/filesystems/cdfs_new/cachesup.c b/drivers/filesystems/cdfs_new/cachesup.c index 600262f84a..eea1fd28da 100755 --- a/drivers/filesystems/cdfs_new/cachesup.c +++ b/drivers/filesystems/cdfs_new/cachesup.c @@ -14,7 +14,7 @@ Abstract: --*/ -#include "cdprocs.h" +#include "CdProcs.h" // // The Bug check file id for this module @@ -36,9 +36,10 @@ Abstract: VOID CdCreateInternalStream ( - IN PIRP_CONTEXT IrpContext, - IN PVCB Vcb, - IN PFCB Fcb + _In_ PIRP_CONTEXT IrpContext, + _In_ PVCB Vcb, + _Inout_ PFCB Fcb, + _In_ PUNICODE_STRING Name ) /*++ @@ -69,8 +70,8 @@ Return Value: BOOLEAN CleanupDirContext = FALSE; BOOLEAN UpdateFcbSizes = FALSE; - DIRENT Dirent; - DIRENT_ENUM_CONTEXT DirContext; + DIRENT Dirent = {0}; + DIRENT_ENUM_CONTEXT DirContext = {0}; PAGED_CODE(); @@ -94,14 +95,14 @@ Return Value: // Use a try-finally to facilitate cleanup. // - _SEH2_TRY { + try { // // Create the internal stream. The Vpb should be pointing at our volume // device object at this point. // - StreamFile = IoCreateStreamFileObject( NULL, Vcb->Vpb->RealDevice ); + StreamFile = IoCreateStreamFileObjectLite( NULL, Vcb->Vpb->RealDevice ); if (StreamFile == NULL) { @@ -127,6 +128,14 @@ Return Value: StreamFileOpen, Fcb, NULL ); + + // + // We'll give stream file objects a name to aid IO profiling etc. We + // NULL this in CdDeleteInternalStream before OB deletes the file object, + // and before CdRemovePrefix is called (which frees Fcb names). + // + + StreamFile->FileName = *Name; // // We will reference the current Fcb twice to keep it from going @@ -272,7 +281,7 @@ Return Value: } } - } _SEH2_FINALLY { + } finally { // // Cleanup any dirent structures we may have used. @@ -290,6 +299,14 @@ Return Value: if (StreamFile != NULL) { + // + // Null the name pointer, since the stream file object never actually + // 'owns' the names, we just point it to existing ones. + // + + StreamFile->FileName.Buffer = NULL; + StreamFile->FileName.MaximumLength = StreamFile->FileName.Length = 0; + ObDereferenceObject( StreamFile ); Fcb->FileObject = NULL; } @@ -306,7 +323,7 @@ Return Value: } CdUnlockFcb( IrpContext, Fcb ); - } _SEH2_END; + } return; } @@ -314,8 +331,8 @@ Return Value: VOID CdDeleteInternalStream ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB Fcb ) /*++ @@ -342,6 +359,8 @@ Return Value: PAGED_CODE(); + UNREFERENCED_PARAMETER( IrpContext ); + ASSERT_IRP_CONTEXT( IrpContext ); ASSERT_FCB( Fcb ); @@ -375,17 +394,23 @@ Return Value: CcUninitializeCacheMap( FileObject, NULL, NULL ); } + // + // Null the name pointer, since the stream file object never actually + // 'owns' the names, we just point it to existing ones. + // + + FileObject->FileName.Buffer = NULL; + FileObject->FileName.MaximumLength = FileObject->FileName.Length = 0; + ObDereferenceObject( FileObject ); } - - return; } NTSTATUS CdCompleteMdl ( - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ) /*++ @@ -434,11 +459,13 @@ Return Value: } + +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdPurgeVolume ( - IN PIRP_CONTEXT IrpContext, - IN PVCB Vcb, - IN BOOLEAN DismountUnderway + _In_ PIRP_CONTEXT IrpContext, + _In_ PVCB Vcb, + _In_ BOOLEAN DismountUnderway ) /*++ @@ -592,7 +619,7 @@ Return Value: if (Vcb->PathTableFcb != NULL) { ThisFcb = Vcb->PathTableFcb; - InterlockedIncrement( &Vcb->PathTableFcb->FcbReference ); + InterlockedIncrement( (LONG*)&Vcb->PathTableFcb->FcbReference ); if ((ThisFcb->FcbNonpaged->SegmentObject.DataSectionObject != NULL) && !CcPurgeCacheSection( &ThisFcb->FcbNonpaged->SegmentObject, @@ -606,7 +633,7 @@ Return Value: CdDeleteInternalStream( IrpContext, ThisFcb ); - InterlockedDecrement( &ThisFcb->FcbReference ); + InterlockedDecrement( (LONG*)&ThisFcb->FcbReference ); CdTeardownStructures( IrpContext, ThisFcb, &RemovedFcb ); } @@ -614,7 +641,7 @@ Return Value: if (Vcb->VolumeDasdFcb != NULL) { ThisFcb = Vcb->VolumeDasdFcb; - InterlockedIncrement( &ThisFcb->FcbReference ); + InterlockedIncrement( (LONG*)&ThisFcb->FcbReference ); if ((ThisFcb->FcbNonpaged->SegmentObject.DataSectionObject != NULL) && !CcPurgeCacheSection( &ThisFcb->FcbNonpaged->SegmentObject, @@ -626,7 +653,7 @@ Return Value: Status = STATUS_UNABLE_TO_DELETE_SECTION; } - InterlockedDecrement( &ThisFcb->FcbReference ); + InterlockedDecrement( (LONG*)&ThisFcb->FcbReference ); CdTeardownStructures( IrpContext, ThisFcb, &RemovedFcb ); } diff --git a/drivers/filesystems/cdfs_new/cd.h b/drivers/filesystems/cdfs_new/cd.h index ef41b58968..f830210a7b 100755 --- a/drivers/filesystems/cdfs_new/cd.h +++ b/drivers/filesystems/cdfs_new/cd.h @@ -221,7 +221,7 @@ typedef struct _RAW_JOLIET_VD { UCHAR Reserved[8]; // reserved 8 = 0 ULONG VolSpaceI; // size of the volume in LBN's Intel ULONG VolSpaceM; // size of the volume in LBN's Motorola - UCHAR CharSet[32]; // character set bytes 0 = ASCII, Joliet Seq here + UCHAR CharSet[32]; // character set bytes 0 = ASCII, Joliett Seq here USHORT VolSetSizeI; // volume set size Intel USHORT VolSetSizeM; // volume set size Motorola USHORT VolSeqNumI; // volume set sequence number Intel @@ -383,9 +383,9 @@ typedef RAW_DIRENT *PRAW_DIRENT; // // VOID // CdConvertCdTimeToNtTime ( -// IN PIRP_CONTEXT IrpContext, -// IN PCHAR CdTime, -// OUT PLARGE_INTEGER NtTime +// _In_ PIRP_CONTEXT IrpContext, +// _In_ PCHAR CdTime, +// _Out_ PLARGE_INTEGER NtTime // ); // diff --git a/drivers/filesystems/cdfs_new/cddata.c b/drivers/filesystems/cdfs_new/cddata.c index c8367233ab..15cfe2d5db 100755 --- a/drivers/filesystems/cdfs_new/cddata.c +++ b/drivers/filesystems/cdfs_new/cddata.c @@ -17,7 +17,7 @@ Abstract: --*/ -#include "cdprocs.h" +#include "CdProcs.h" #ifdef CD_SANITY BOOLEAN CdTestTopLevel = TRUE; @@ -178,16 +178,42 @@ LONG CdXAFileHeader[] = { -44 // <CD-XA Raw Sectors> ADJUST }; +#ifdef CDFS_TELEMETRY_DATA + +// +// Telemetry Data for reporting +// + +CDFS_TELEMETRY_DATA_CONTEXT CdTelemetryData; + +#endif // CDFS_TELEMETRY_DATA + #ifdef ALLOC_PRAGMA #pragma alloc_text(PAGE, CdFastIoCheckIfPossible) #pragma alloc_text(PAGE, CdSerial32) +#pragma alloc_text(PAGE, CdSetThreadContext) #endif - +_IRQL_requires_max_(APC_LEVEL) +__drv_dispatchType(DRIVER_DISPATCH) +__drv_dispatchType(IRP_MJ_CREATE) +__drv_dispatchType(IRP_MJ_CLOSE) +__drv_dispatchType(IRP_MJ_READ) +__drv_dispatchType(IRP_MJ_WRITE) +__drv_dispatchType(IRP_MJ_QUERY_INFORMATION) +__drv_dispatchType(IRP_MJ_SET_INFORMATION) +__drv_dispatchType(IRP_MJ_QUERY_VOLUME_INFORMATION) +__drv_dispatchType(IRP_MJ_DIRECTORY_CONTROL) +__drv_dispatchType(IRP_MJ_FILE_SYSTEM_CONTROL) +__drv_dispatchType(IRP_MJ_DEVICE_CONTROL) +__drv_dispatchType(IRP_MJ_LOCK_CONTROL) +__drv_dispatchType(IRP_MJ_CLEANUP) +__drv_dispatchType(IRP_MJ_PNP) +__drv_dispatchType(IRP_MJ_SHUTDOWN) NTSTATUS CdFsdDispatch ( - IN PVOLUME_DEVICE_OBJECT VolumeDeviceObject, - IN PIRP Irp + _In_ PDEVICE_OBJECT DeviceObject, + _Inout_ PIRP Irp ) /*++ @@ -214,7 +240,7 @@ Routine Description: Arguments: - VolumeDeviceObject - Supplies the volume device object for this request + DeviceObject - Supplies the volume device object for this request Irp - Supplies the Irp being processed @@ -225,7 +251,7 @@ Return Value: --*/ { - THREAD_CONTEXT ThreadContext; + THREAD_CONTEXT ThreadContext = {0}; PIRP_CONTEXT IrpContext = NULL; BOOLEAN Wait; @@ -243,6 +269,8 @@ Return Value: ASSERT_OPTIONAL_IRP( Irp ); + UNREFERENCED_PARAMETER( DeviceObject ); + FsRtlEnterFileSystem(); #ifdef CD_SANITY @@ -259,7 +287,7 @@ Return Value: // Use a try-except to handle the exception cases. // - _SEH2_TRY { + try { // // If the IrpContext is NULL then this is the first pass through @@ -293,7 +321,7 @@ Return Value: CdSetThreadContext( IrpContext, &ThreadContext ); #ifdef CD_SANITY - ASSERT( !CdTestTopLevel || + NT_ASSERT( !CdTestTopLevel || SafeNodeType( IrpContext->TopLevel ) == CDFS_NTC_IRP_CONTEXT ); #endif @@ -347,6 +375,11 @@ Return Value: break; + case IRP_MJ_WRITE : + + Status = CdCommonWrite( IrpContext, Irp ); + break; + case IRP_MJ_QUERY_INFORMATION : Status = CdCommonQueryInfo( IrpContext, Irp ); @@ -392,40 +425,46 @@ Return Value: Status = CdCommonPnp( IrpContext, Irp ); break; + case IRP_MJ_SHUTDOWN : + + Status = CdCommonShutdown( IrpContext, Irp ); + break; + default : Status = STATUS_INVALID_DEVICE_REQUEST; CdCompleteRequest( IrpContext, Irp, Status ); } - } _SEH2_EXCEPT( CdExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) { + } except( CdExceptionFilter( IrpContext, GetExceptionInformation() )) { - Status = CdProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() ); - } _SEH2_END; + Status = CdProcessException( IrpContext, Irp, GetExceptionCode() ); + } } while (Status == STATUS_CANT_WAIT); #ifdef CD_SANITY - ASSERT( !CdTestTopLevel || + NT_ASSERT( !CdTestTopLevel || (PreviousTopLevel == IoGetTopLevelIrp()) ); #endif FsRtlExitFileSystem(); - ASSERT( SaveIrql == KeGetCurrentIrql( )); + NT_ASSERT( SaveIrql == KeGetCurrentIrql( )); return Status; } + #ifdef CD_SANITY VOID -CdRaiseStatusEx( - IN PIRP_CONTEXT IrpContext, - IN NTSTATUS Status, - IN BOOLEAN NormalizeStatus, - IN OPTIONAL ULONG FileId, - IN OPTIONAL ULONG Line +CdRaiseStatusEx ( + _In_ PIRP_CONTEXT IrpContext, + _In_ NTSTATUS Status, + _In_ BOOLEAN NormalizeStatus, + _In_opt_ ULONG FileId, + _In_opt_ ULONG Line ) { BOOLEAN BreakIn = FALSE; @@ -461,7 +500,7 @@ CdRaiseStatusEx( DbgPrint( "CDFS: Contact CDFS.SYS component owner for triage.\n"); DbgPrint( "CDFS: 'eb %p 0;eb %p 0' to disable this alert.\n", &CdTestRaisedStatus, &CdBreakOnAnyRaise); - DbgBreakPoint(); + NT_ASSERT(FALSE); } if (NormalizeStatus) { @@ -480,10 +519,11 @@ CdRaiseStatusEx( #endif + LONG CdExceptionFilter ( - IN PIRP_CONTEXT IrpContext, - IN PEXCEPTION_POINTERS ExceptionPointer + _Inout_ PIRP_CONTEXT IrpContext, + _In_ PEXCEPTION_POINTERS ExceptionPointer ) /*++ @@ -557,6 +597,7 @@ Return Value: if (TestStatus && !FsRtlIsNtstatusExpected( ExceptionCode )) { +#pragma prefast( suppress: __WARNING_USE_OTHER_FUNCTION, "We're corrupted." ) CdBugCheck( (ULONG_PTR) ExceptionPointer->ExceptionRecord, (ULONG_PTR) ExceptionPointer->ContextRecord, (ULONG_PTR) ExceptionPointer->ExceptionRecord->ExceptionAddress ); @@ -567,11 +608,13 @@ Return Value: } + +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdProcessException ( - IN PIRP_CONTEXT IrpContext OPTIONAL, - IN PIRP Irp, - IN NTSTATUS ExceptionCode + _In_opt_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp, + _In_ NTSTATUS ExceptionCode ) /*++ @@ -601,7 +644,7 @@ Return Value: --*/ { - PDEVICE_OBJECT Device; + PDEVICE_OBJECT Device = NULL; PVPB Vpb; PETHREAD Thread; @@ -625,17 +668,6 @@ Return Value: ExceptionCode = IrpContext->ExceptionStatus; - // - // If we are not a top level request then we just complete the request - // with the current status code. - // - - if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL )) { - - CdCompleteRequest( IrpContext, Irp, ExceptionCode ); - return ExceptionCode; - } - // // Check if we are posting this request. One of the following must be true // if we are to post a request. @@ -644,7 +676,8 @@ Return Value: // or we are forcing this to be posted. // // - Status code is STATUS_VERIFY_REQUIRED and we are at APC level - // or higher. Can't wait for IO in the verify path in this case. + // or higher, or within a guarded region. Can't wait for IO in + // the verify path in this case. // // Set the MORE_PROCESSING flag in the IrpContext to keep if from being // deleted if this is a retryable condition. @@ -653,27 +686,26 @@ Return Value: // Note that (children of) CdFsdPostRequest can raise (Mdl allocation). // - _SEH2_TRY { - + try { + if (ExceptionCode == STATUS_CANT_WAIT) { if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_FORCE_POST )) { ExceptionCode = CdFsdPostRequest( IrpContext, Irp ); } - - } else if (ExceptionCode == STATUS_VERIFY_REQUIRED) { - - if (KeGetCurrentIrql() >= APC_LEVEL) { - - ExceptionCode = CdFsdPostRequest( IrpContext, Irp ); - } + } + else if ((ExceptionCode == STATUS_VERIFY_REQUIRED) && + FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL ) && + KeAreAllApcsDisabled()) { + + ExceptionCode = CdFsdPostRequest( IrpContext, Irp ); } } - _SEH2_EXCEPT( CdExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) { + except( CdExceptionFilter( IrpContext, GetExceptionInformation() )) { - ExceptionCode = _SEH2_GetExceptionCode(); - } _SEH2_END; + ExceptionCode = GetExceptionCode(); + } // // If we posted the request or our caller will retry then just return here. @@ -687,6 +719,17 @@ Return Value: ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING ); + // + // If we are not a top level request then we just complete the request + // with the current status code. + // + + if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL )) { + + CdCompleteRequest( IrpContext, Irp, ExceptionCode ); + return ExceptionCode; + } + // // Store this error into the Irp for posting back to the Io system. // @@ -722,20 +765,34 @@ Return Value: Device = IoGetDeviceToVerify( PsGetCurrentThread() ); IoSetDeviceToVerify( PsGetCurrentThread(), NULL ); - ASSERT( Device != NULL ); + NT_ASSERT( Device != NULL ); - // - // Let's not BugCheck just because the driver messes up. - // + } - if (Device == NULL) { + // + // It turns out some storage drivers really do set invalid non-NULL device + // objects to verify. + // + // To work around this, completely ignore the device to verify in the thread, + // and just use our real device object instead. + // - ExceptionCode = STATUS_DRIVER_INTERNAL_ERROR; + if (IrpContext->Vcb) { - CdCompleteRequest( IrpContext, Irp, ExceptionCode ); + Device = IrpContext->Vcb->Vpb->RealDevice; + } - return ExceptionCode; - } + // + // Let's not BugCheck just because the device to verify is somehow still NULL. + // + + if (Device == NULL) { + + ExceptionCode = STATUS_DRIVER_INTERNAL_ERROR; + + CdCompleteRequest( IrpContext, Irp, ExceptionCode ); + + return ExceptionCode; } // @@ -773,6 +830,7 @@ Return Value: Vpb = NULL; } + // // The device to verify is either in my thread local storage // or that of the thread that owns the Irp. @@ -786,18 +844,31 @@ Return Value: Thread = PsGetCurrentThread(); Device = IoGetDeviceToVerify( Thread ); - ASSERT( Device != NULL ); + NT_ASSERT( Device != NULL ); + } - // - // Let's not BugCheck just because the driver messes up. - // + // + // It turns out some storage drivers really do set invalid non-NULL device + // objects to verify. + // + // To work around this, completely ignore the device to verify in the thread, + // and just use our real device object instead. + // - if (Device == NULL) { + if (IrpContext->Vcb) { - CdCompleteRequest( IrpContext, Irp, ExceptionCode ); + Device = IrpContext->Vcb->Vpb->RealDevice; + } - return ExceptionCode; - } + // + // Let's not BugCheck just because the device to verify is somehow still NULL. + // + + if (Device == NULL) { + + CdCompleteRequest( IrpContext, Irp, ExceptionCode ); + + return ExceptionCode; } // @@ -839,9 +910,9 @@ Return Value: VOID CdCompleteRequest ( - IN PIRP_CONTEXT IrpContext OPTIONAL, - IN PIRP Irp OPTIONAL, - IN NTSTATUS Status + _Inout_opt_ PIRP_CONTEXT IrpContext, + _Inout_opt_ PIRP Irp, + _In_ NTSTATUS Status ) /*++ @@ -906,8 +977,8 @@ Return Value: VOID CdSetThreadContext ( - IN PIRP_CONTEXT IrpContext, - IN PTHREAD_CONTEXT ThreadContext + _Inout_ PIRP_CONTEXT IrpContext, + _In_ PTHREAD_CONTEXT ThreadContext ) /*++ @@ -938,8 +1009,6 @@ Return Value: { PTHREAD_CONTEXT CurrentThreadContext; - ULONG_PTR StackTop; - ULONG_PTR StackBottom; PAGED_CODE(); @@ -971,12 +1040,9 @@ Return Value: // If this is not a valid Cdfs context then use the input thread // context and store it in the top level context. // - - IoGetStackLimits( &StackTop, &StackBottom); - +#pragma warning(suppress: 6011) // Bug in PREFast around bitflag operations if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL ) || - (((ULONG_PTR) CurrentThreadContext > StackBottom - sizeof( THREAD_CONTEXT )) || - ((ULONG_PTR) CurrentThreadContext <= StackTop) || + (!IoWithinStackLimits( (ULONG_PTR)CurrentThreadContext, sizeof( THREAD_CONTEXT ) ) || FlagOn( (ULONG_PTR) CurrentThreadContext, 0x3 ) || (CurrentThreadContext->Cdfs != 0x53464443))) { @@ -1002,18 +1068,23 @@ Return Value: return; } - + +_Function_class_(FAST_IO_CHECK_IF_POSSIBLE) +_IRQL_requires_same_ +_Success_(return != FALSE) BOOLEAN -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ CdFastIoCheckIfPossible ( - IN PFILE_OBJECT FileObject, - IN PLARGE_INTEGER FileOffset, - IN ULONG Length, - IN BOOLEAN Wait, - IN ULONG LockKey, - IN BOOLEAN CheckForReadOperation, - OUT PIO_STATUS_BLOCK IoStatus, - IN PDEVICE_OBJECT DeviceObject + _In_ PFILE_OBJECT FileObject, + _In_ PLARGE_INTEGER FileOffset, + _In_ ULONG Length, + _In_ BOOLEAN Wait, + _In_ ULONG LockKey, + _In_ BOOLEAN CheckForReadOperation, + _Pre_notnull_ + _When_(return != FALSE, _Post_equal_to_(_Old_(IoStatus))) + _When_(return == FALSE, _Post_valid_) + PIO_STATUS_BLOCK IoStatus, + _In_ PDEVICE_OBJECT DeviceObject ) /*++ @@ -1054,6 +1125,9 @@ Return Value: PAGED_CODE(); + UNREFERENCED_PARAMETER( Wait ); + UNREFERENCED_PARAMETER( DeviceObject ); + // // Decode the type of file object we're being asked to process and // make sure that is is only a user file open. @@ -1090,8 +1164,8 @@ Return Value: ULONG CdSerial32 ( - IN PCHAR Buffer, - IN ULONG ByteCount + _In_reads_bytes_(ByteCount) PCHAR Buffer, + _In_ ULONG ByteCount ) /*++ diff --git a/drivers/filesystems/cdfs_new/cddata.h b/drivers/filesystems/cdfs_new/cddata.h index a03fc36f34..395b1862ca 100755 --- a/drivers/filesystems/cdfs_new/cddata.h +++ b/drivers/filesystems/cdfs_new/cddata.h @@ -94,82 +94,77 @@ extern LONG CdXAFileHeader[]; extern LONG CdAudioPlayHeader[]; extern LONG CdXAAudioPhileHeader[]; - +#ifdef CDFS_TELEMETRY_DATA + // -// Turn on pseudo-asserts if CD_FREE_ASSERTS is defined. +// Globals for Telemetry data. // -#if !DBG -#ifdef CD_FREE_ASSERTS -#undef ASSERT -#undef ASSERTMSG -#define ASSERT(exp) if (!(exp)) { extern BOOLEAN KdDebuggerEnabled; DbgPrint("%s:%d %s\n",__FILE__,__LINE__,#exp); if (KdDebuggerEnabled) { DbgBreakPoint(); } } -#define ASSERTMSG(msg,exp) if (!(exp)) { extern BOOLEAN KdDebuggerEnabled; DbgPrint("%s:%d %s %s\n",__FILE__,__LINE__,msg,#exp); if (KdDebuggerEnabled) { DbgBreakPoint(); } } -#endif -#endif +extern CDFS_TELEMETRY_DATA_CONTEXT CdTelemetryData; + +#endif // CDFS_TELEMETRY_DATA - // // The following assertion macros ensure that the indicated structure // is valid // -// ASSERT_STRUCT( IN PVOID Struct, IN CSHORT NodeType ); -// ASSERT_OPTIONAL_STRUCT( IN PVOID Struct OPTIONAL, IN CSHORT NodeType ); +// ASSERT_STRUCT( _In_ PVOID Struct, _In_ CSHORT NodeType ); +// ASSERT_OPTIONAL_STRUCT( _In_opt_ PVOID Struct, _In_ CSHORT NodeType ); // -// ASSERT_VCB( IN PVCB Vcb ); -// ASSERT_OPTIONAL_VCB( IN PVCB Vcb OPTIONAL ); +// ASSERT_VCB( _In_ PVCB Vcb ); +// ASSERT_OPTIONAL_VCB( _In_opt_ PVCB Vcb ); // -// ASSERT_FCB( IN PFCB Fcb ); -// ASSERT_OPTIONAL_FCB( IN PFCB Fcb OPTIONAL ); +// ASSERT_FCB( _In_ PFCB Fcb ); +// ASSERT_OPTIONAL_FCB( _In_opt_ PFCB Fcb ); // -// ASSERT_FCB_NONPAGED( IN PFCB_NONPAGED FcbNonpaged ); -// ASSERT_OPTIONAL_FCB( IN PFCB_NONPAGED FcbNonpaged OPTIONAL ); +// ASSERT_FCB_NONPAGED( _In_ PFCB_NONPAGED FcbNonpaged ); +// ASSERT_OPTIONAL_FCB( _In_opt_ PFCB_NONPAGED FcbNonpaged ); // -// ASSERT_CCB( IN PSCB Ccb ); -// ASSERT_OPTIONAL_CCB( IN PSCB Ccb OPTIONAL ); +// ASSERT_CCB( _In_ PSCB Ccb ); +// ASSERT_OPTIONAL_CCB( _In_opt_ PSCB Ccb ); // -// ASSERT_IRP_CONTEXT( IN PIRP_CONTEXT IrpContext ); -// ASSERT_OPTIONAL_IRP_CONTEXT( IN PIRP_CONTEXT IrpContext OPTIONAL ); +// ASSERT_IRP_CONTEXT( _In_ PIRP_CONTEXT IrpContext ); +// ASSERT_OPTIONAL_IRP_CONTEXT( _In_opt_ PIRP_CONTEXT IrpContext ); // -// ASSERT_IRP( IN PIRP Irp ); -// ASSERT_OPTIONAL_IRP( IN PIRP Irp OPTIONAL ); +// ASSERT_IRP( _In_ PIRP Irp ); +// ASSERT_OPTIONAL_IRP( _In_opt_ PIRP Irp ); // -// ASSERT_FILE_OBJECT( IN PFILE_OBJECT FileObject ); -// ASSERT_OPTIONAL_FILE_OBJECT( IN PFILE_OBJECT FileObject OPTIONAL ); +// ASSERT_FILE_OBJECT( _In_ PFILE_OBJECT FileObject ); +// ASSERT_OPTIONAL_FILE_OBJECT( _In_opt_ PFILE_OBJECT FileObject ); // // The following macros are used to check the current thread owns // the indicated resource // -// ASSERT_EXCLUSIVE_RESOURCE( IN PERESOURCE Resource ); +// ASSERT_EXCLUSIVE_RESOURCE( _In_ PERESOURCE Resource ); // -// ASSERT_SHARED_RESOURCE( IN PERESOURCE Resource ); +// ASSERT_SHARED_RESOURCE( _In_ PERESOURCE Resource ); // -// ASSERT_RESOURCE_NOT_MINE( IN PERESOURCE Resource ); +// ASSERT_RESOURCE_NOT_MINE( _In_ PERESOURCE Resource ); // // The following macros are used to check whether the current thread -// owns the resource in the given structures. +// owns the resoures in the given structures. // // ASSERT_EXCLUSIVE_CDDATA // -// ASSERT_EXCLUSIVE_VCB( IN PVCB Vcb ); +// ASSERT_EXCLUSIVE_VCB( _In_ PVCB Vcb ); // -// ASSERT_SHARED_VCB( IN PVCB Vcb ); +// ASSERT_SHARED_VCB( _In_ PVCB Vcb ); // -// ASSERT_EXCLUSIVE_FCB( IN PFCB Fcb ); +// ASSERT_EXCLUSIVE_FCB( _In_ PFCB Fcb ); // -// ASSERT_SHARED_FCB( IN PFCB Fcb ); +// ASSERT_SHARED_FCB( _In_ PFCB Fcb ); // -// ASSERT_EXCLUSIVE_FILE( IN PFCB Fcb ); +// ASSERT_EXCLUSIVE_FILE( _In_ PFCB Fcb ); // -// ASSERT_SHARED_FILE( IN PFCB Fcb ); +// ASSERT_SHARED_FILE( _In_ PFCB Fcb ); // -// ASSERT_LOCKED_VCB( IN PVCB Vcb ); +// ASSERT_LOCKED_VCB( _In_ PVCB Vcb ); // -// ASSERT_NOT_LOCKED_VCB( IN PVCB Vcb ); +// ASSERT_NOT_LOCKED_VCB( _In_ PVCB Vcb ); // -// ASSERT_LOCKED_FCB( IN PFCB Fcb ); +// ASSERT_LOCKED_FCB( _In_ PFCB Fcb ); // -// ASSERT_NOT_LOCKED_FCB( IN PFCB Fcb ); +// ASSERT_NOT_LOCKED_FCB( _In_ PFCB Fcb ); // // @@ -183,19 +178,19 @@ extern LONG CdXAAudioPhileHeader[]; #ifdef CD_SANITY -#define ASSERT_STRUCT(S,T) ASSERT( SafeNodeType( S ) == (T) ) -#define ASSERT_OPTIONAL_STRUCT(S,T) ASSERT( ((S) == NULL) || (SafeNodeType( S ) == (T)) ) +#define ASSERT_STRUCT(S,T) NT_ASSERT( SafeNodeType( S ) == (T) ) +#define ASSERT_OPTIONAL_STRUCT(S,T) NT_ASSERT( ((S) == NULL) || (SafeNodeType( S ) == (T)) ) #define ASSERT_VCB(V) ASSERT_STRUCT( (V), CDFS_NTC_VCB ) #define ASSERT_OPTIONAL_VCB(V) ASSERT_OPTIONAL_STRUCT( (V), CDFS_NTC_VCB ) #define ASSERT_FCB(F) \ - ASSERT( (SafeNodeType( F ) == CDFS_NTC_FCB_DATA ) || \ + NT_ASSERT( (SafeNodeType( F ) == CDFS_NTC_FCB_DATA ) || \ (SafeNodeType( F ) == CDFS_NTC_FCB_INDEX ) || \ (SafeNodeType( F ) == CDFS_NTC_FCB_PATH_TABLE ) ) #define ASSERT_OPTIONAL_FCB(F) \ - ASSERT( ((F) == NULL) || \ + NT_ASSERT( ((F) == NULL) || \ (SafeNodeType( F ) == CDFS_NTC_FCB_DATA ) || \ (SafeNodeType( F ) == CDFS_NTC_FCB_INDEX ) || \ (SafeNodeType( F ) == CDFS_NTC_FCB_PATH_TABLE ) ) @@ -215,27 +210,27 @@ extern LONG CdXAAudioPhileHeader[]; #define ASSERT_FILE_OBJECT(FO) ASSERT_STRUCT( (FO), IO_TYPE_FILE ) #define ASSERT_OPTIONAL_FILE_OBJECT(FO) ASSERT_OPTIONAL_STRUCT( (FO), IO_TYPE_FILE ) -#define ASSERT_EXCLUSIVE_RESOURCE(R) ASSERT( ExIsResourceAcquiredExclusiveLite( R )) +#define ASSERT_EXCLUSIVE_RESOURCE(R) NT_ASSERT( ExIsResourceAcquiredExclusiveLite( R )) -#define ASSERT_SHARED_RESOURCE(R) ASSERT( ExIsResourceAcquiredSharedLite( R )) +#define ASSERT_SHARED_RESOURCE(R) NT_ASSERT( ExIsResourceAcquiredSharedLite( R )) -#define ASSERT_RESOURCE_NOT_MINE(R) ASSERT( !ExIsResourceAcquiredSharedLite( R )) +#define ASSERT_RESOURCE_NOT_MINE(R) NT_ASSERT( !ExIsResourceAcquiredSharedLite( R )) -#define ASSERT_EXCLUSIVE_CDDATA ASSERT( ExIsResourceAcquiredExclusiveLite( &CdData.DataResource )) -#define ASSERT_EXCLUSIVE_VCB(V) ASSERT( ExIsResourceAcquiredExclusiveLite( &(V)->VcbResource )) -#define ASSERT_SHARED_VCB(V) ASSERT( ExIsResourceAcquiredSharedLite( &(V)->VcbResource )) +#define ASSERT_EXCLUSIVE_CDDATA NT_ASSERT( ExIsResourceAcquiredExclusiveLite( &CdData.DataResource )) +#define ASSERT_EXCLUSIVE_VCB(V) NT_ASSERT( ExIsResourceAcquiredExclusiveLite( &(V)->VcbResource )) +#define ASSERT_SHARED_VCB(V) NT_ASSERT( ExIsResourceAcquiredSharedLite( &(V)->VcbResource )) -#define ASSERT_EXCLUSIVE_FCB(F) ASSERT( ExIsResourceAcquiredExclusiveLite( &(F)->FcbNonpaged->FcbResource )) -#define ASSERT_SHARED_FCB(F) ASSERT( ExIsResourceAcquiredSharedLite( &(F)->FcbNonpaged->FcbResource )) +#define ASSERT_EXCLUSIVE_FCB(F) NT_ASSERT( ExIsResourceAcquiredExclusiveLite( &(F)->FcbNonpaged->FcbResource )) +#define ASSERT_SHARED_FCB(F) NT_ASSERT( ExIsResourceAcquiredSharedLite( &(F)->FcbNonpaged->FcbResource )) -#define ASSERT_EXCLUSIVE_FILE(F) ASSERT( ExIsResourceAcquiredExclusiveLite( (F)->Resource )) -#define ASSERT_SHARED_FILE(F) ASSERT( ExIsResourceAcquiredSharedLite( (F)->Resource )) +#define ASSERT_EXCLUSIVE_FILE(F) NT_ASSERT( ExIsResourceAcquiredExclusiveLite( (F)->Resource )) +#define ASSERT_SHARED_FILE(F) NT_ASSERT( ExIsResourceAcquiredSharedLite( (F)->Resource )) -#define ASSERT_LOCKED_VCB(V) ASSERT( (V)->VcbLockThread == PsGetCurrentThread() ) -#define ASSERT_NOT_LOCKED_VCB(V) ASSERT( (V)->VcbLockThread != PsGetCurrentThread() ) +#define ASSERT_LOCKED_VCB(V) NT_ASSERT( (V)->VcbLockThread == PsGetCurrentThread() ) +#define ASSERT_NOT_LOCKED_VCB(V) NT_ASSERT( (V)->VcbLockThread != PsGetCurrentThread() ) -#define ASSERT_LOCKED_FCB(F) ASSERT( !FlagOn( (F)->FcbState, FCB_STATE_IN_FCB_TABLE) || ((F)->FcbLockThread == PsGetCurrentThread())) -#define ASSERT_NOT_LOCKED_FCB(F) ASSERT( (F)->FcbLockThread != PsGetCurrentThread() ) +#define ASSERT_LOCKED_FCB(F) NT_ASSERT( !FlagOn( (F)->FcbState, FCB_STATE_IN_FCB_TABLE) || ((F)->FcbLockThread == PsGetCurrentThread())) +#define ASSERT_NOT_LOCKED_FCB(F) NT_ASSERT( (F)->FcbLockThread != PsGetCurrentThread() ) #else diff --git a/drivers/filesystems/cdfs_new/cdfs.rc b/drivers/filesystems/cdfs_new/cdfs.rc index 1cf70c6084..5d4dcafce0 100644 --- a/drivers/filesystems/cdfs_new/cdfs.rc +++ b/drivers/filesystems/cdfs_new/cdfs.rc @@ -1,7 +1,14 @@ -/* $Id: cdfs.rc 21710 2006-04-22 16:36:21Z tretiakov $ */ +// +// Copyright (C) Microsoft. All rights reserved. +// +#include <verrsrc.h> + +#include <ntverp.h> + +#define VER_FILETYPE VFT_DRV +#define VER_FILESUBTYPE VFT2_DRV_SYSTEM +#define VER_FILEDESCRIPTION_STR "CD-ROM File System Driver" +#define VER_INTERNALNAME_STR "cdfs.sys" + +#include "common.ver" -#define REACTOS_VERSION_DLL -#define REACTOS_STR_FILE_DESCRIPTION "ISO9660 Driver\0" -#define REACTOS_STR_INTERNAL_NAME "cdfs\0" -#define REACTOS_STR_ORIGINAL_FILENAME "cdfs.sys\0" -#include <reactos/version.rc> diff --git a/drivers/filesystems/cdfs_new/cdinit.c b/drivers/filesystems/cdfs_new/cdinit.c index b6bec14c45..5ec9d50324 100755 --- a/drivers/filesystems/cdfs_new/cdinit.c +++ b/drivers/filesystems/cdfs_new/cdinit.c @@ -13,7 +13,7 @@ Abstract: --*/ -#include "cdprocs.h" +#include "CdProcs.h" // // The Bug check file id for this module @@ -21,40 +21,33 @@ Abstract: #define BugCheckFileId (CDFS_BUG_CHECK_CDINIT) +// Tell prefast the function type. +DRIVER_INITIALIZE DriverEntry; + NTSTATUS -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ DriverEntry( - IN PDRIVER_OBJECT DriverObject, - IN PUNICODE_STRING RegistryPath + _In_ PDRIVER_OBJECT DriverObject, + _In_ PUNICODE_STRING RegistryPath ); + +// tell prefast this is a driver unload function +DRIVER_UNLOAD CdUnload; + VOID -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ CdUnload( - IN PDRIVER_OBJECT DriverObject + _In_ PDRIVER_OBJECT DriverObject ); NTSTATUS CdInitializeGlobalData ( - IN PDRIVER_OBJECT DriverObject, - IN PDEVICE_OBJECT FileSystemDeviceObject -#ifdef __REACTOS__ - , - IN PDEVICE_OBJECT HddFileSystemDeviceObject -#endif - ); - -NTSTATUS -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ -CdShutdown ( - IN PDEVICE_OBJECT DeviceObject, - IN PIRP Irp + _In_ PDRIVER_OBJECT DriverObject, + _In_ PDEVICE_OBJECT FileSystemDeviceObject ); #ifdef ALLOC_PRAGMA #pragma alloc_text(INIT, DriverEntry) #pragma alloc_text(PAGE, CdUnload) -#pragma alloc_text(PAGE, CdShutdown) #pragma alloc_text(INIT, CdInitializeGlobalData) #endif @@ -64,10 +57,9 @@ CdShutdown ( // NTSTATUS -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ DriverEntry( - IN PDRIVER_OBJECT DriverObject, - IN PUNICODE_STRING RegistryPath + _In_ PDRIVER_OBJECT DriverObject, + _In_ PUNICODE_STRING RegistryPath ) /*++ @@ -93,9 +85,9 @@ Return Value: NTSTATUS Status; UNICODE_STRING UnicodeString; PDEVICE_OBJECT CdfsFileSystemDeviceObject; -#ifdef __REACTOS__ - PDEVICE_OBJECT HddFileSystemDeviceObject; -#endif + FS_FILTER_CALLBACKS FilterCallbacks; + + UNREFERENCED_PARAMETER( RegistryPath ); // // Create the device object. @@ -115,27 +107,14 @@ Return Value: return Status; } -#ifdef __REACTOS__ - // - // Create the HDD device object. - // - - RtlInitUnicodeString( &UnicodeString, L"\\CdfsHdd" ); - - Status = IoCreateDevice( DriverObject, - 0, - &UnicodeString, - FILE_DEVICE_DISK_FILE_SYSTEM, - 0, - FALSE, - &HddFileSystemDeviceObject ); +#pragma prefast(push) +#pragma prefast(disable: 28155, "the dispatch routine has the correct type, prefast is just being paranoid.") +#pragma prefast(disable: 28168, "the dispatch routine has the correct type, prefast is just being paranoid.") +#pragma prefast(disable: 28169, "the dispatch routine has the correct type, prefast is just being paranoid.") +#pragma prefast(disable: 28175, "we're allowed to change these.") - if (!NT_SUCCESS( Status )) { - IoDeleteDevice (CdfsFileSystemDeviceObject); - return Status; - } -#endif DriverObject->DriverUnload = CdUnload; + // // Note that because of the way data caching is done, we set neither // the Direct I/O or Buffered I/O bit in DeviceObject->Flags. If @@ -153,6 +132,7 @@ Return Value: DriverObject->MajorFunction[IRP_MJ_CREATE] = DriverObject->MajorFunction[IRP_MJ_CLOSE] = DriverObject->MajorFunction[IRP_MJ_READ] = + DriverObject->MajorFunction[IRP_MJ_WRITE] = DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION]= @@ -161,17 +141,29 @@ Return Value: DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = DriverObject->MajorFunction[IRP_MJ_CLEANUP] = - DriverObject->MajorFunction[IRP_MJ_PNP] = (PDRIVER_DISPATCH) CdFsdDispatch; - DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = CdShutdown; + DriverObject->MajorFunction[IRP_MJ_PNP] = + DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = (PDRIVER_DISPATCH) CdFsdDispatch; +#pragma prefast(pop) +#pragma prefast(suppress: 28175, "this is a file system driver, we're allowed to touch FastIoDispatch.") DriverObject->FastIoDispatch = &CdFastIoDispatch; - Status = IoRegisterShutdownNotification (CdfsFileSystemDeviceObject); - if (!NT_SUCCESS (Status)) { - IoDeleteDevice (CdfsFileSystemDeviceObject); -#ifdef __REACTOS__ - IoDeleteDevice (HddFileSystemDeviceObject); -#endif + // + // Initialize the filter callbacks we use. + // + + RtlZeroMemory( &FilterCallbacks, + sizeof(FS_FILTER_CALLBACKS) ); + + FilterCallbacks.SizeOfFsFilterCallbacks = sizeof(FS_FILTER_CALLBACKS); + FilterCallbacks.PreAcquireForSectionSynchronization = CdFilterCallbackAcquireForCreateSection; + + Status = FsRtlRegisterFileSystemFilterCallbacks( DriverObject, + &FilterCallbacks ); + + if (!NT_SUCCESS( Status )) { + + IoDeleteDevice( CdfsFileSystemDeviceObject ); return Status; } @@ -179,16 +171,9 @@ Return Value: // Initialize the global data structures // -#ifndef __REACTOS__ Status = CdInitializeGlobalData( DriverObject, CdfsFileSystemDeviceObject ); -#else - Status = CdInitializeGlobalData( DriverObject, CdfsFileSystemDeviceObject, HddFileSystemDeviceObject ); -#endif if (!NT_SUCCESS (Status)) { IoDeleteDevice (CdfsFileSystemDeviceObject); -#ifdef __REACTOS__ - IoDeleteDevice (HddFileSystemDeviceObject); -#endif return Status; } @@ -199,69 +184,30 @@ Return Value: // CdfsFileSystemDeviceObject->Flags |= DO_LOW_PRIORITY_FILESYSTEM; -#ifdef __REACTOS__ - HddFileSystemDeviceObject->Flags |= DO_LOW_PRIORITY_FILESYSTEM; -#endif IoRegisterFileSystem( CdfsFileSystemDeviceObject ); ObReferenceObject (CdfsFileSystemDeviceObject); -#ifdef __REACTOS__ - IoRegisterFileSystem( HddFileSystemDeviceObject ); - ObReferenceObject (HddFileSystemDeviceObject); -#endif +#ifdef CDFS_TELEMETRY_DATA // - // And return to our caller + // Initialize Telemetry // - return( STATUS_SUCCESS ); -} - -NTSTATUS -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ -CdShutdown ( - IN PDEVICE_OBJECT DeviceObject, - IN PIRP Irp - ) -/*++ - -Routine Description: - - This routine is the shutdown handler for CDFS. + CdInitializeTelemetry(); -Arguments: - - DeviceObject - Supplies the registered device object for CDFS. - Irp - Shutdown IRP - - -Return Value: - - None. - ---*/ -{ -#ifdef __REACTOS__ - ASSERT(DeviceObject == CdData.FileSystemDeviceObject || - DeviceObject == CdData.HddFileSystemDeviceObject); #endif - IoUnregisterFileSystem (DeviceObject); -#ifndef __REACTOS__ - IoDeleteDevice (CdData.FileSystemDeviceObject); -#else - IoDeleteDevice (DeviceObject); -#endif + // + // And return to our caller + // - CdCompleteRequest( NULL, Irp, STATUS_SUCCESS ); - return STATUS_SUCCESS; + return( STATUS_SUCCESS ); } VOID -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ CdUnload( - IN PDRIVER_OBJECT DriverObject + _In_ PDRIVER_OBJECT DriverObject ) /*++ @@ -281,6 +227,10 @@ Return Value: { PIRP_CONTEXT IrpContext; + PAGED_CODE(); + + UNREFERENCED_PARAMETER( DriverObject ); + // // Free any IRP contexts // @@ -295,9 +245,6 @@ Return Value: IoFreeWorkItem (CdData.CloseItem); ExDeleteResourceLite( &CdData.DataResource ); ObDereferenceObject (CdData.FileSystemDeviceObject); -#ifdef __REACTOS__ - ObDereferenceObject (CdData.HddFileSystemDeviceObject); -#endif } // @@ -306,12 +253,8 @@ Return Value: NTSTATUS CdInitializeGlobalData ( - IN PDRIVER_OBJECT DriverObject, - IN PDEVICE_OBJECT FileSystemDeviceObject -#ifdef __REACTOS__ - , - IN PDEVICE_OBJECT HddFileSystemDeviceObject -#endif + _In_ PDRIVER_OBJECT DriverObject, + _In_ PDEVICE_OBJECT FileSystemDeviceObject ) /*++ @@ -340,6 +283,10 @@ Return Value: RtlZeroMemory( &CdFastIoDispatch, sizeof( FAST_IO_DISPATCH )); CdFastIoDispatch.SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH); + +#pragma prefast(push) +#pragma prefast(disable:28155, "these are all correct") + CdFastIoDispatch.FastIoCheckIfPossible = CdFastIoCheckIfPossible; // CheckForFastIo CdFastIoDispatch.FastIoRead = FsRtlCopyRead; // Read CdFastIoDispatch.FastIoQueryBasicInfo = CdFastQueryBasicInfo; // QueryBasicInfo @@ -348,7 +295,12 @@ Return Value: CdFastIoDispatch.FastIoUnlockSingle = CdFastUnlockSingle; // UnlockSingle CdFastIoDispatch.FastIoUnlockAll = CdFastUnlockAll; // UnlockAll CdFastIoDispatch.FastIoUnlockAllByKey = CdFastUnlockAllByKey; // UnlockAllByKey - CdFastIoDispatch.AcquireFileForNtCreateSection = CdAcquireForCreateSection; + + // + // This callback has been replaced by CdFilterCallbackAcquireForCreateSection. + // + + CdFastIoDispatch.AcquireFileForNtCreateSection = NULL; CdFastIoDispatch.ReleaseFileForNtCreateSection = CdReleaseForCreateSection; CdFastIoDispatch.FastIoQueryNetworkOpenInfo = CdFastQueryNetworkInfo; // QueryNetworkInfo @@ -357,6 +309,8 @@ Return Value: CdFastIoDispatch.PrepareMdlWrite = FsRtlPrepareMdlWriteDev; CdFastIoDispatch.MdlWriteComplete = FsRtlMdlWriteCompleteDev; +#pragma prefast(pop) + // // Initialize the CdData structure. // @@ -368,9 +322,6 @@ Return Value: CdData.DriverObject = DriverObject; CdData.FileSystemDeviceObject = FileSystemDeviceObject; -#ifdef __REACTOS__ - CdData.HddFileSystemDeviceObject = HddFileSystemDeviceObject; -#endif InitializeListHead( &CdData.VcbQueue ); @@ -380,10 +331,10 @@ Return Value: // Initialize the cache manager callback routines // - CdData.CacheManagerCallbacks.AcquireForLazyWrite = (PVOID)&CdAcquireForCache;/* ReactOS Change: GCC "assignment from incompatible pointer type" */ - CdData.CacheManagerCallbacks.ReleaseFromLazyWrite = (PVOID)&CdReleaseFromCache;/* ReactOS Change: GCC "assignment from incompatible pointer type" */ - CdData.CacheManagerCallbacks.AcquireForReadAhead = (PVOID)&CdAcquireForCache;/* ReactOS Change: GCC "assignment from incompatible pointer type" */ - CdData.CacheManagerCallbacks.ReleaseFromReadAhead = (PVOID)&CdReleaseFromCache;/* ReactOS Change: GCC "assignment from incompatible pointer type" */ + CdData.CacheManagerCallbacks.AcquireForLazyWrite = &CdAcquireForCache; + CdData.CacheManagerCallbacks.ReleaseFromLazyWrite = &CdReleaseFromCache; + CdData.CacheManagerCallbacks.AcquireForReadAhead = &CdAcquireForCache; + CdData.CacheManagerCallbacks.ReleaseFromReadAhead = &CdReleaseFromCache; CdData.CacheManagerVolumeCallbacks.AcquireForLazyWrite = &CdNoopAcquire; CdData.CacheManagerVolumeCallbacks.ReleaseFromLazyWrite = &CdNoopRelease; diff --git a/drivers/filesystems/cdfs_new/cdprocs.h b/drivers/filesystems/cdfs_new/cdprocs.h index 2b066e7192..d2f7db0b4b 100755 --- a/drivers/filesystems/cdfs_new/cdprocs.h +++ b/drivers/filesystems/cdfs_new/cdprocs.h @@ -17,24 +17,36 @@ Abstract: #ifndef _CDPROCS_ #define _CDPROCS_ +#pragma warning( disable: 4127 ) // conditional expression is constant + +#pragma warning( push ) +#pragma warning( disable: 4201 ) // nonstandard extension used : nameless struct/union +#pragma warning( disable: 4214 ) // nonstandard extension used : bit field types + #include <ntifs.h> #include <ntddcdrm.h> #include <ntdddisk.h> #include <ntddscsi.h> -#ifdef __REACTOS__ -#include <pseh/pseh2.h> -#endif #ifndef INLINE #define INLINE __inline #endif #include "nodetype.h" -#include "cd.h" -#include "cdstruc.h" -#include "cddata.h" +#include "Cd.h" +#include "CdStruc.h" +#include "CdData.h" + +#ifdef CDFS_TELEMETRY_DATA + +#include <winmeta.h> +#include <TraceLoggingProvider.h> +#include <telemetry\MicrosoftTelemetry.h> + +#endif // CDFS_TELEMETRY_DATA +#pragma warning( pop ) //**** x86 compiler bug **** @@ -43,6 +55,14 @@ Abstract: #define Int64ShraMod32(a, b) ((LONGLONG)(a) >> (b)) #endif +#ifndef Min +#define Min(a, b) ((a) < (b) ? (a) : (b)) +#endif + +#ifndef Max +#define Max(a, b) ((a) > (b) ? (a) : (b)) +#endif + // // Here are the different pool tags. // @@ -91,9 +111,9 @@ Abstract: // // BOOLEAN // CdIllegalFcbAccess ( -// IN PIRP_CONTEXT IrpContext, -// IN TYPE_OF_OPEN TypeOfOpen, -// IN ACCESS_MASK DesiredAccess +// _In_ PIRP_CONTEXT IrpContext, +// _In_ TYPE_OF_OPEN TypeOfOpen, +// _In_ ACCESS_MASK DesiredAccess // ); // @@ -117,49 +137,55 @@ Abstract: // These routines are for querying allocation on individual streams. // +_Requires_lock_held_(_Global_critical_region_) VOID CdLookupAllocation ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN LONGLONG FileOffset, - OUT PLONGLONG DiskOffset, - OUT PULONG ByteCount + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ LONGLONG FileOffset, + _Out_ PLONGLONG DiskOffset, + _Out_ PULONG ByteCount ); VOID CdAddAllocationFromDirent ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN ULONG McbEntryOffset, - IN LONGLONG StartingFileOffset, - IN PDIRENT Dirent + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB Fcb, + _In_ ULONG McbEntryOffset, + _In_ LONGLONG StartingFileOffset, + _In_ PDIRENT Dirent ); VOID CdAddInitialAllocation ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN ULONG StartingBlock, - IN LONGLONG DataLength + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB Fcb, + _In_ ULONG StartingBlock, + _In_ LONGLONG DataLength ); VOID CdTruncateAllocation ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN LONGLONG StartingFileOffset + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB Fcb, + _In_ LONGLONG StartingFileOffset ); +_At_(Fcb->NodeByteSize, _In_range_(>=, FIELD_OFFSET( FCB, FcbType ))) VOID CdInitializeMcb ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb + _In_ PIRP_CONTEXT IrpContext, + _Inout_updates_bytes_(Fcb->NodeByteSize) PFCB Fcb ); +_At_(Fcb->NodeByteSize, _In_range_(>=, FIELD_OFFSET( FCB, FcbType ))) +_When_(Fcb->NodeTypeCode == CDFS_NTC_FCB_PATH_TABLE, _At_(Fcb->NodeByteSize, _In_range_(==, SIZEOF_FCB_INDEX))) +_When_(Fcb->NodeTypeCode == CDFS_NTC_FCB_INDEX, _At_(Fcb->NodeByteSize, _In_range_(==, SIZEOF_FCB_INDEX))) +_When_(Fcb->NodeTypeCode == CDFS_NTC_FCB_DATA, _At_(Fcb->NodeByteSize, _In_range_(==, SIZEOF_FCB_DATA))) VOID CdUninitializeMcb ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb + _In_ PIRP_CONTEXT IrpContext, + _Inout_updates_bytes_(Fcb->NodeByteSize) PFCB Fcb ); @@ -169,35 +195,58 @@ CdUninitializeMcb ( VOID CdCreateInternalStream ( - IN PIRP_CONTEXT IrpContext, - IN PVCB Vcb, - IN PFCB Fcb + _In_ PIRP_CONTEXT IrpContext, + _In_ PVCB Vcb, + _Inout_ PFCB Fcb, + _In_ PUNICODE_STRING Name ); VOID CdDeleteInternalStream ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB Fcb ); NTSTATUS CdCompleteMdl ( - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdPurgeVolume ( - IN PIRP_CONTEXT IrpContext, - IN PVCB Vcb, - IN BOOLEAN DismountUnderway + _In_ PIRP_CONTEXT IrpContext, + _In_ PVCB Vcb, + _In_ BOOLEAN DismountUnderway ); +VOID +INLINE +CdVerifyOrCreateDirStreamFile ( + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb + ) +{ + // + // Unsafe test to see if call / lock neccessary. + // + + if (NULL == Fcb->FileObject) { + + CdCreateInternalStream( IrpContext, + Fcb->Vcb, + Fcb, + &Fcb->FileNamePrefix.ExactCaseName.FileName); + } +} + + // // VOID // CdUnpinData ( -// IN PIRP_CONTEXT IrpContext, -// IN OUT PBCB *Bcb +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PBCB *Bcb // ); // @@ -212,56 +261,97 @@ CdPurgeVolume ( // the on disk structure and do not alter any other data structures. // +_Requires_lock_held_(_Global_critical_region_) +VOID +CdFreeDirCache ( + _In_ PIRP_CONTEXT IrpContext + ); + +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdNonCachedRead ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN LONGLONG StartingOffset, - IN ULONG ByteCount + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ LONGLONG StartingOffset, + _In_ ULONG ByteCount ); +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdNonCachedXARead ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN LONGLONG StartingOffset, - IN ULONG ByteCount + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ LONGLONG StartingOffset, + _In_ ULONG ByteCount + ); + +_Requires_lock_held_(_Global_critical_region_) +NTSTATUS +CdVolumeDasdWrite ( + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ LONGLONG StartingOffset, + _In_ ULONG ByteCount ); BOOLEAN CdReadSectors ( - IN PIRP_CONTEXT IrpContext, - IN LONGLONG StartingOffset, - IN ULONG ByteCount, - IN BOOLEAN RaiseOnError, - IN OUT PVOID Buffer, - IN PDEVICE_OBJECT TargetDeviceObject + _In_ PIRP_CONTEXT IrpContext, + _In_ LONGLONG StartingOffset, + _In_ ULONG ByteCount, + _In_ BOOLEAN ReturnError, + _Out_writes_bytes_(ByteCount) PVOID Buffer, + _In_ PDEVICE_OBJECT TargetDeviceObject ); NTSTATUS CdCreateUserMdl ( - IN PIRP_CONTEXT IrpContext, - IN ULONG BufferLength, - IN BOOLEAN RaiseOnError + _In_ PIRP_CONTEXT IrpContext, + _In_ ULONG BufferLength, + _In_ BOOLEAN RaiseOnError, + _In_ LOCK_OPERATION Operation ); NTSTATUS +FASTCALL CdPerformDevIoCtrl ( - IN PIRP_CONTEXT IrpContext, - IN ULONG IoControlCode, - IN PDEVICE_OBJECT Device, - OUT PVOID OutputBuffer OPTIONAL, - IN ULONG OutputBufferLength, - IN BOOLEAN InternalDeviceIoControl, - IN BOOLEAN OverrideVerify, - OUT PIO_STATUS_BLOCK Iosb OPTIONAL + _In_ PIRP_CONTEXT IrpContext, + _In_ ULONG IoControlCode, + _In_ PDEVICE_OBJECT Device, + _Out_writes_bytes_opt_(OutputBufferLength) PVOID OutputBuffer, + _In_ ULONG OutputBufferLength, + _In_ BOOLEAN InternalDeviceIoControl, + _In_ BOOLEAN OverrideVerify, + _Out_opt_ PIO_STATUS_BLOCK Iosb + ); + +NTSTATUS +CdPerformDevIoCtrlEx ( + _In_ PIRP_CONTEXT IrpContext, + _In_ ULONG IoControlCode, + _In_ PDEVICE_OBJECT Device, + _In_reads_bytes_opt_(InputBufferLength) PVOID InputBuffer, + _In_ ULONG InputBufferLength, + _Out_writes_bytes_opt_(OutputBufferLength) PVOID OutputBuffer, + _In_ ULONG OutputBufferLength, + _In_ BOOLEAN InternalDeviceIoControl, + _In_ BOOLEAN OverrideVerify, + _Out_opt_ PIO_STATUS_BLOCK Iosb + ); + +NTSTATUS +CdHijackIrpAndFlushDevice ( + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp, + _In_ PDEVICE_OBJECT TargetDeviceObject ); + // // VOID // CdMapUserBuffer ( -// IN PIRP_CONTEXT IrpContext -// OUT PVOID UserBuffer +// _In_ PIRP_CONTEXT IrpContext +// _Out_ PVOID UserBuffer // ); // // Returns pointer to sys address. Will raise on failure. @@ -269,25 +359,25 @@ CdPerformDevIoCtrl ( // // VOID // CdLockUserBuffer ( -// IN PIRP_CONTEXT IrpContext, -// IN ULONG BufferLength +// _Inout_ PIRP_CONTEXT IrpContext, +// _In_ ULONG BufferLength // ); // #define CdMapUserBuffer(IC, UB) { \ *(UB) = (PVOID) ( ((IC)->Irp->MdlAddress == NULL) ? \ (IC)->Irp->UserBuffer : \ - (MmGetSystemAddressForMdlSafe( (IC)->Irp->MdlAddress, NormalPagePriority))); \ + (MmGetSystemAddressForMdlSafe( (IC)->Irp->MdlAddress, NormalPagePriority | MdlMappingNoExecute))); \ if (NULL == *(UB)) { \ CdRaiseStatus( (IC), STATUS_INSUFFICIENT_RESOURCES); \ } \ } -#define CdLockUserBuffer(IC,BL) { \ - if ((IC)->Irp->MdlAddress == NULL) { \ - (VOID) CdCreateUserMdl( (IC), (BL), TRUE ); \ - } \ +#define CdLockUserBuffer(IC,BL,OP) { \ + if ((IC)->Irp->MdlAddress == NULL) { \ + (VOID) CdCreateUserMdl( (IC), (BL), TRUE, (OP) ); \ + } \ } @@ -297,122 +387,124 @@ CdPerformDevIoCtrl ( VOID CdLookupDirent ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN ULONG DirentOffset, - OUT PDIRENT_ENUM_CONTEXT DirContext + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ ULONG DirentOffset, + _Out_ PDIRENT_ENUM_CONTEXT DirContext ); BOOLEAN CdLookupNextDirent ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN PDIRENT_ENUM_CONTEXT CurrentDirContext, - OUT PDIRENT_ENUM_CONTEXT NextDirContext + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ PDIRENT_ENUM_CONTEXT CurrentDirContext, + _Inout_ PDIRENT_ENUM_CONTEXT NextDirContext ); +_At_(Dirent->CdTime, _Post_notnull_) VOID CdUpdateDirentFromRawDirent ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN PDIRENT_ENUM_CONTEXT DirContext, - IN OUT PDIRENT Dirent + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ PDIRENT_ENUM_CONTEXT DirContext, + _Inout_ PDIRENT Dirent ); VOID CdUpdateDirentName ( - IN PIRP_CONTEXT IrpContext, - IN OUT PDIRENT Dirent, - IN ULONG IgnoreCase + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PDIRENT Dirent, + _In_ ULONG IgnoreCase ); -BOOLEAN +_Success_(return != FALSE) BOOLEAN CdFindFile ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN PCD_NAME Name, - IN BOOLEAN IgnoreCase, - IN OUT PFILE_ENUM_CONTEXT FileContext, - OUT PCD_NAME *MatchingName + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ PCD_NAME Name, + _In_ BOOLEAN IgnoreCase, + _Inout_ PFILE_ENUM_CONTEXT FileContext, + _Out_ PCD_NAME *MatchingName ); BOOLEAN CdFindDirectory ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN PCD_NAME Name, - IN BOOLEAN IgnoreCase, - IN OUT PFILE_ENUM_CONTEXT FileContext + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ PCD_NAME Name, + _In_ BOOLEAN IgnoreCase, + _Inout_ PFILE_ENUM_CONTEXT FileContext ); +_At_(FileContext->ShortName.FileName.MaximumLength, _In_range_(>=, BYTE_COUNT_8_DOT_3)) BOOLEAN CdFindFileByShortName ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN PCD_NAME Name, - IN BOOLEAN IgnoreCase, - IN ULONG ShortNameDirentOffset, - IN OUT PFILE_ENUM_CONTEXT FileContext + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ PCD_NAME Name, + _In_ BOOLEAN IgnoreCase, + _In_ ULONG ShortNameDirentOffset, + _Inout_ PFILE_ENUM_CONTEXT FileContext ); BOOLEAN CdLookupNextInitialFileDirent ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN OUT PFILE_ENUM_CONTEXT FileContext + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _Inout_ PFILE_ENUM_CONTEXT FileContext ); VOID CdLookupLastFileDirent ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN PFILE_ENUM_CONTEXT FileContext + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ PFILE_ENUM_CONTEXT FileContext ); VOID CdCleanupFileContext ( - IN PIRP_CONTEXT IrpContext, - IN PFILE_ENUM_CONTEXT FileContext + _In_ PIRP_CONTEXT IrpContext, + _In_ PFILE_ENUM_CONTEXT FileContext ); // // VOID // CdInitializeFileContext ( -// IN PIRP_CONTEXT IrpContext, -// IN PFILE_ENUM_CONTEXT FileContext +// _In_ PIRP_CONTEXT IrpContext, +// _Out_ PFILE_ENUM_CONTEXT FileContext // ); // // // VOID // CdInitializeDirent ( -// IN PIRP_CONTEXT IrpContext, -// IN PDIRENT Dirent +// _In_ PIRP_CONTEXT IrpContext, +// _Out_ PDIRENT Dirent // ); // // VOID // CdInitializeDirContext ( -// IN PIRP_CONTEXT IrpContext, -// IN PDIRENT_ENUM_CONTEXT DirContext +// _In_ PIRP_CONTEXT IrpContext, +// _Out_ PDIRENT_ENUM_CONTEXT DirContext // ); // // VOID // CdCleanupDirent ( -// IN PIRP_CONTEXT IrpContext, -// IN PDIRENT Dirent +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PDIRENT Dirent // ); // // VOID // CdCleanupDirContext ( -// IN PIRP_CONTEXT IrpContext, -// IN PDIRENT_ENUM_CONTEXT DirContext +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PDIRENT_ENUM_CONTEXT DirContext // ); // // VOID // CdLookupInitialFileDirent ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb, -// IN PFILE_ENUM_CONTEXT FileContext, -// IN ULONG DirentOffset +// _In_ PIRP_CONTEXT IrpContext, +// _In_ PFCB Fcb, +// _Out_ PFILE_ENUM_CONTEXT FileContext, +// _In_ ULONG DirentOffset // ); // @@ -472,27 +564,33 @@ typedef enum _TYPE_OF_OPEN { } TYPE_OF_OPEN; typedef TYPE_OF_OPEN *PTYPE_OF_OPEN; +_When_(TypeOfOpen == UnopenedFileObject, _At_(Fcb, _In_opt_)) +_When_(TypeOfOpen != UnopenedFileObject, _At_(Fcb, _In_)) VOID CdSetFileObject ( - IN PIRP_CONTEXT IrpContext, - IN PFILE_OBJECT FileObject, - IN TYPE_OF_OPEN TypeOfOpen, - IN PFCB Fcb OPTIONAL, - IN PCCB Ccb OPTIONAL + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFILE_OBJECT FileObject, + _In_ TYPE_OF_OPEN TypeOfOpen, + PFCB Fcb, + _In_opt_ PCCB Ccb ); +_When_(return == UnopenedFileObject, _At_(*Fcb, _Post_null_)) +_When_(return != UnopenedFileObject, _At_(Fcb, _Outptr_)) +_When_(return == UnopenedFileObject, _At_(*Ccb, _Post_null_)) +_When_(return != UnopenedFileObject, _At_(Ccb, _Outptr_)) TYPE_OF_OPEN CdDecodeFileObject ( - IN PIRP_CONTEXT IrpContext, - IN PFILE_OBJECT FileObject, - OUT PFCB *Fcb, - OUT PCCB *Ccb + _In_ PIRP_CONTEXT IrpContext, + _In_ PFILE_OBJECT FileObject, + PFCB *Fcb, + PCCB *Ccb ); TYPE_OF_OPEN CdFastDecodeFileObject ( - IN PFILE_OBJECT FileObject, - OUT PFCB *Fcb + _In_ PFILE_OBJECT FileObject, + _Out_ PFCB *Fcb ); @@ -500,69 +598,77 @@ CdFastDecodeFileObject ( // Name support routines, implemented in NameSup.c // +_Post_satisfies_(_Old_(CdName->FileName.Length) >= + CdName->FileName.Length + CdName->VersionString.Length) VOID CdConvertNameToCdName ( - IN PIRP_CONTEXT IrpContext, - IN OUT PCD_NAME CdName + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PCD_NAME CdName ); VOID CdConvertBigToLittleEndian ( - IN PIRP_CONTEXT IrpContext, - IN PCHAR BigEndian, - IN ULONG ByteCount, - OUT PCHAR LittleEndian + _In_ PIRP_CONTEXT IrpContext, + _In_reads_bytes_(ByteCount) PCHAR BigEndian, + _In_ ULONG ByteCount, + _Out_writes_bytes_(ByteCount) PCHAR LittleEndian ); VOID CdUpcaseName ( - IN PIRP_CONTEXT IrpContext, - IN PCD_NAME Name, - IN OUT PCD_NAME UpcaseName + _In_ PIRP_CONTEXT IrpContext, + _In_ PCD_NAME Name, + _Inout_ PCD_NAME UpcaseName ); VOID CdDissectName ( - IN PIRP_CONTEXT IrpContext, - IN OUT PUNICODE_STRING RemainingName, - OUT PUNICODE_STRING FinalName + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PUNICODE_STRING RemainingName, + _Out_ PUNICODE_STRING FinalName + ); + +BOOLEAN +CdIsLegalName ( + _In_ PIRP_CONTEXT IrpContext, + _In_ PUNICODE_STRING FileName ); BOOLEAN CdIs8dot3Name ( - IN PIRP_CONTEXT IrpContext, - IN UNICODE_STRING FileName + _In_ PIRP_CONTEXT IrpContext, + _In_ UNICODE_STRING FileName ); VOID CdGenerate8dot3Name ( - IN PIRP_CONTEXT IrpContext, - IN PUNICODE_STRING FileName, - IN ULONG DirentOffset, - OUT PWCHAR ShortFileName, - OUT PUSHORT ShortByteCount + _In_ PIRP_CONTEXT IrpContext, + _In_ PUNICODE_STRING FileName, + _In_ ULONG DirentOffset, + _Out_writes_bytes_to_(BYTE_COUNT_8_DOT_3, *ShortByteCount) PWCHAR ShortFileName, + _Out_ PUSHORT ShortByteCount ); BOOLEAN CdIsNameInExpression ( - IN PIRP_CONTEXT IrpContext, - IN PCD_NAME CurrentName, - IN PCD_NAME SearchExpression, - IN ULONG WildcardFlags, - IN BOOLEAN CheckVersion + _In_ PIRP_CONTEXT IrpContext, + _In_ PCD_NAME CurrentName, + _In_ PCD_NAME SearchExpression, + _In_ ULONG WildcardFlags, + _In_ BOOLEAN CheckVersion ); ULONG CdShortNameDirentOffset ( - IN PIRP_CONTEXT IrpContext, - IN PUNICODE_STRING Name + _In_ PIRP_CONTEXT IrpContext, + _In_ PUNICODE_STRING Name ); FSRTL_COMPARISON_RESULT CdFullCompareNames ( - IN PIRP_CONTEXT IrpContext, - IN PUNICODE_STRING NameA, - IN PUNICODE_STRING NameB + _In_ PIRP_CONTEXT IrpContext, + _In_ PUNICODE_STRING NameA, + _In_ PUNICODE_STRING NameB ); @@ -570,18 +676,20 @@ CdFullCompareNames ( // Filesystem control operations. Implemented in Fsctrl.c // +_Requires_lock_held_(_Global_critical_region_) +_Requires_lock_held_(Vcb->VcbResource) NTSTATUS CdLockVolumeInternal ( - IN PIRP_CONTEXT IrpContext, - IN PVCB Vcb, - IN PFILE_OBJECT FileObject OPTIONAL + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PVCB Vcb, + _In_opt_ PFILE_OBJECT FileObject ); NTSTATUS CdUnlockVolumeInternal ( - IN PIRP_CONTEXT IrpContext, - IN PVCB Vcb, - IN PFILE_OBJECT FileObject OPTIONAL + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PVCB Vcb, + _In_opt_ PFILE_OBJECT FileObject ); @@ -591,47 +699,48 @@ CdUnlockVolumeInternal ( VOID CdLookupPathEntry ( - IN PIRP_CONTEXT IrpContext, - IN ULONG PathEntryOffset, - IN ULONG Ordinal, - IN BOOLEAN VerifyBounds, - IN OUT PCOMPOUND_PATH_ENTRY CompoundPathEntry + _In_ PIRP_CONTEXT IrpContext, + _In_ ULONG PathEntryOffset, + _In_ ULONG Ordinal, + _In_ BOOLEAN VerifyBounds, + _Inout_ PCOMPOUND_PATH_ENTRY CompoundPathEntry ); BOOLEAN CdLookupNextPathEntry ( - IN PIRP_CONTEXT IrpContext, - IN OUT PPATH_ENUM_CONTEXT PathContext, - IN OUT PPATH_ENTRY PathEntry + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PPATH_ENUM_CONTEXT PathContext, + _Inout_ PPATH_ENTRY PathEntry ); +_Success_(return != FALSE) BOOLEAN CdFindPathEntry ( - IN PIRP_CONTEXT IrpContext, - IN PFCB ParentFcb, - IN PCD_NAME DirName, - IN BOOLEAN IgnoreCase, - IN OUT PCOMPOUND_PATH_ENTRY CompoundPathEntry + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB ParentFcb, + _In_ PCD_NAME DirName, + _In_ BOOLEAN IgnoreCase, + _Inout_ PCOMPOUND_PATH_ENTRY CompoundPathEntry ); VOID CdUpdatePathEntryName ( - IN PIRP_CONTEXT IrpContext, - IN OUT PPATH_ENTRY PathEntry, - IN BOOLEAN IgnoreCase + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PPATH_ENTRY PathEntry, + _In_ BOOLEAN IgnoreCase ); // // VOID // CdInitializeCompoundPathEntry ( -// IN PIRP_CONTEXT IrpContext, -// IN PCOMPOUND_PATH_ENTRY CompoundPathEntry +// _In_ PIRP_CONTEXT IrpContext, +// _Out_ PCOMPOUND_PATH_ENTRY CompoundPathEntry // ); // // VOID // CdCleanupCompoundPathEntry ( -// IN PIRP_CONTEXT IrpContext, -// IN PCOMPOUND_PATH_ENTRY CompoundPathEntry +// _In_ PIRP_CONTEXT IrpContext, +// _Out_ PCOMPOUND_PATH_ENTRY CompoundPathEntry // ); // @@ -655,26 +764,27 @@ CdUpdatePathEntryName ( VOID CdInsertPrefix ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN PCD_NAME Name, - IN BOOLEAN IgnoreCase, - IN BOOLEAN ShortNameMatch, - IN PFCB ParentFcb + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB Fcb, + _In_ PCD_NAME Name, + _In_ BOOLEAN IgnoreCase, + _In_ BOOLEAN ShortNameMatch, + _Inout_ PFCB ParentFcb ); VOID CdRemovePrefix ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB Fcb ); +_Requires_lock_held_(_Global_critical_region_) VOID CdFindPrefix ( - IN PIRP_CONTEXT IrpContext, - IN OUT PFCB *CurrentFcb, - IN OUT PUNICODE_STRING RemainingName, - IN BOOLEAN IgnoreCase + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB *CurrentFcb, + _Inout_ PUNICODE_STRING RemainingName, + _In_ BOOLEAN IgnoreCase ); @@ -706,93 +816,98 @@ typedef enum _TYPE_OF_ACQUIRE { } TYPE_OF_ACQUIRE, *PTYPE_OF_ACQUIRE; +_Requires_lock_held_(_Global_critical_region_) +_When_(Type == AcquireExclusive && return != FALSE, _Acquires_exclusive_lock_(*Resource)) +_When_(Type == AcquireShared && return != FALSE, _Acquires_shared_lock_(*Resource)) +_When_(Type == AcquireSharedStarveExclusive && return != FALSE, _Acquires_shared_lock_(*Resource)) +_When_(IgnoreWait == FALSE, _Post_satisfies_(return == TRUE)) BOOLEAN CdAcquireResource ( - IN PIRP_CONTEXT IrpContext, - IN PERESOURCE Resource, - IN BOOLEAN IgnoreWait, - IN TYPE_OF_ACQUIRE Type + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PERESOURCE Resource, + _In_ BOOLEAN IgnoreWait, + _In_ TYPE_OF_ACQUIRE Type ); // // BOOLEAN // CdAcquireCdData ( -// IN PIRP_CONTEXT IrpContext +// _In_ PIRP_CONTEXT IrpContext // ); // // VOID // CdReleaseCdData ( -// IN PIRP_CONTEXT IrpContext +// _In_ PIRP_CONTEXT IrpContext // ); // // BOOLEAN // CdAcquireVcbExclusive ( -// IN PIRP_CONTEXT IrpContext, -// IN PVCB Vcb, -// IN BOOLEAN IgnoreWait +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PVCB Vcb, +// _In_ BOOLEAN IgnoreWait // ); // // BOOLEAN // CdAcquireVcbShared ( -// IN PIRP_CONTEXT IrpContext, -// IN PVCB Vcb, -// IN BOOLEAN IgnoreWait +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PVCB Vcb, +// _In_ BOOLEAN IgnoreWait // ); // // VOID // CdReleaseVcb ( -// IN PIRP_CONTEXT IrpContext, -// IN PVCB Vcb +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PVCB Vcb // ); // // VOID // CdAcquireAllFiles ( -// IN PIRP_CONTEXT, -// IN PVCB Vcb +// _In_ PIRP_CONTEXT, +// _In_ PVCB Vcb // ); // // VOID // CdReleaseAllFiles ( -// IN PIRP_CONTEXT, -// IN PVCB Vcb +// _In_ PIRP_CONTEXT, +// _In_ PVCB Vcb // ); // // VOID // CdAcquireFileExclusive ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb, +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PFCB Fcb, // ); // // VOID // CdAcquireFileShared ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PFCB Fcb // ); // // VOID // CdReleaseFile ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PFCB Fcb // ); // // BOOLEAN // CdAcquireFcbExclusive ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb, -// IN BOOLEAN IgnoreWait +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PFCB Fcb, +// _In_ BOOLEAN IgnoreWait // ); // // BOOLEAN // CdAcquireFcbShared ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb, -// IN BOOLEAN IgnoreWait +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PFCB Fcb, +// _In_ BOOLEAN IgnoreWait // ); // // BOOLEAN // CdReleaseFcb ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PFCB Fcb // ); // // VOID @@ -805,27 +920,40 @@ CdAcquireResource ( // // VOID // CdLockVcb ( -// IN PIRP_CONTEXT IrpContext +// _In_ PIRP_CONTEXT IrpContext // ); // // VOID // CdUnlockVcb ( -// IN PIRP_CONTEXT IrpContext +// _In_ PIRP_CONTEXT IrpContext // ); // // VOID // CdLockFcb ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PFCB Fcb // ); // // VOID // CdUnlockFcb ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PFCB Fcb // ); // + +#define CdAcquireCacheForRead( IC) \ + ExAcquireResourceSharedLite( &(IC)->Vcb->SectorCacheResource, TRUE) + +#define CdAcquireCacheForUpdate( IC) \ + ExAcquireResourceExclusiveLite( &(IC)->Vcb->SectorCacheResource, TRUE) + +#define CdReleaseCache( IC) \ + ExReleaseResourceLite( &(IC)->Vcb->SectorCacheResource); + +#define CdConvertCacheToShared( IC) \ + ExConvertExclusiveToSharedLite( &(IC)->Vcb->SectorCacheResource); + #define CdAcquireCdData(IC) \ ExAcquireResourceExclusiveLite( &CdData.DataResource, TRUE ) @@ -878,21 +1006,38 @@ CdAcquireResource ( #define CdLockVcb(IC,V) \ ExAcquireFastMutex( &(V)->VcbMutex ); \ - ASSERT( NULL == (V)->VcbLockThread); \ + NT_ASSERT( NULL == (V)->VcbLockThread); \ (V)->VcbLockThread = PsGetCurrentThread() #define CdUnlockVcb(IC,V) \ - ASSERT( NULL != (V)->VcbLockThread); \ + NT_ASSERT( NULL != (V)->VcbLockThread); \ (V)->VcbLockThread = NULL; \ ExReleaseFastMutex( &(V)->VcbMutex ) +#if defined(_PREFAST_) + +_Success_(return) +_IRQL_saves_global_(OldIrql, FastMutex) +BOOLEAN DummySaveIrql(_Inout_ PFAST_MUTEX FastMutex); + +_Success_(return) +_IRQL_restores_global_(OldIrql, FastMutex) +BOOLEAN DummyRestoreIrql(_Inout_ PFAST_MUTEX FastMutex); +#endif // _PREFAST_ + #define CdLockFcb(IC,F) { \ PVOID _CurrentThread = PsGetCurrentThread(); \ if (_CurrentThread != (F)->FcbLockThread) { \ ExAcquireFastMutex( &(F)->FcbNonpaged->FcbMutex ); \ - ASSERT( (F)->FcbLockCount == 0 ); \ + NT_ASSERT( (F)->FcbLockCount == 0 ); \ + _Analysis_assume_( (F)->FcbLockCount == 0 ); \ (F)->FcbLockThread = _CurrentThread; \ } \ + else \ + { \ + _Analysis_assume_lock_held_( (F)->FcbNonpaged->FcbMutex ); \ + _Analysis_assume_(FALSE != DummySaveIrql(&(F)->FcbNonpaged->FcbMutex)); \ + } \ (F)->FcbLockCount += 1; \ } @@ -902,44 +1047,67 @@ CdAcquireResource ( (F)->FcbLockThread = NULL; \ ExReleaseFastMutex( &(F)->FcbNonpaged->FcbMutex ); \ } \ + else \ + { \ + _Analysis_assume_lock_not_held_( (F)->FcbNonpaged->FcbMutex ); \ + _Analysis_assume_(FALSE != DummyRestoreIrql(&(F)->FcbNonpaged->FcbMutex)); \ + } \ } +// +// The following macro is used to retrieve the oplock structure within +// the Fcb. This structure was moved to the advanced Fcb header +// in Win8. +// + +#if (NTDDI_VERSION >= NTDDI_WIN8) + +#define CdGetFcbOplock(F) &(F)->Header.Oplock + +#else + +#define CdGetFcbOplock(F) &(F)->Oplock + +#endif + BOOLEAN -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ CdNoopAcquire ( - IN PVOID Fcb, - IN BOOLEAN Wait + _In_ PVOID Fcb, + _In_ BOOLEAN Wait ); VOID -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ CdNoopRelease ( - IN PVOID Fcb + _In_ PVOID Fcb ); +_Requires_lock_held_(_Global_critical_region_) +_When_(return!=0, _Acquires_shared_lock_(*Fcb->Resource)) BOOLEAN -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ CdAcquireForCache ( - IN PFCB Fcb, - IN BOOLEAN Wait + _Inout_ PFCB Fcb, + _In_ BOOLEAN Wait ); +_Requires_lock_held_(_Global_critical_region_) +_Releases_lock_(*Fcb->Resource) VOID -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ CdReleaseFromCache ( - IN PFCB Fcb + _Inout_ PFCB Fcb ); -VOID -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ -CdAcquireForCreateSection ( - IN PFILE_OBJECT FileObject +_Requires_lock_held_(_Global_critical_region_) +NTSTATUS +CdFilterCallbackAcquireForCreateSection ( + _In_ PFS_FILTER_CALLBACK_DATA CallbackData, + _Unreferenced_parameter_ PVOID *CompletionContext ); +_Function_class_(FAST_IO_RELEASE_FILE) +_Requires_lock_held_(_Global_critical_region_) VOID -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ CdReleaseForCreateSection ( - IN PFILE_OBJECT FileObject + _In_ PFILE_OBJECT FileObject ); @@ -949,108 +1117,110 @@ CdReleaseForCreateSection ( VOID CdInitializeVcb ( - IN PIRP_CONTEXT IrpContext, - IN OUT PVCB Vcb, - IN PDEVICE_OBJECT TargetDeviceObject, - IN PVPB Vpb, - IN PCDROM_TOC CdromToc, - IN ULONG TocLength, - IN ULONG TocTrackCount, - IN ULONG TocDiskFlags, - IN ULONG BlockFactor, - IN ULONG MediaChangeCount + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PVCB Vcb, + _In_ __drv_aliasesMem PDEVICE_OBJECT TargetDeviceObject, + _In_ __drv_aliasesMem PVPB Vpb, + _In_ __drv_aliasesMem PCDROM_TOC_LARGE CdromToc, + _In_ ULONG TocLength, + _In_ ULONG TocTrackCount, + _In_ ULONG TocDiskFlags, + _In_ ULONG BlockFactor, + _In_ ULONG MediaChangeCount ); VOID CdUpdateVcbFromVolDescriptor ( - IN PIRP_CONTEXT IrpContext, - IN OUT PVCB Vcb, - IN PCHAR RawIsoVd OPTIONAL + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PVCB Vcb, + _In_reads_bytes_opt_(SECTOR_SIZE) PCHAR RawIsoVd ); VOID CdDeleteVcb ( - IN PIRP_CONTEXT IrpContext, - IN OUT PVCB Vcb + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PVCB Vcb ); PFCB CdCreateFcb ( - IN PIRP_CONTEXT IrpContext, - IN FILE_ID FileId, - IN NODE_TYPE_CODE NodeTypeCode, - OUT PBOOLEAN FcbExisted OPTIONAL + _In_ PIRP_CONTEXT IrpContext, + _In_ FILE_ID FileId, + _In_ NODE_TYPE_CODE NodeTypeCode, + _Out_opt_ PBOOLEAN FcbExisted ); VOID CdInitializeFcbFromPathEntry ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN PFCB ParentFcb OPTIONAL, - IN PPATH_ENTRY PathEntry + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB Fcb, + _In_opt_ PFCB ParentFcb, + _In_ PPATH_ENTRY PathEntry ); VOID CdInitializeFcbFromFileContext ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN PFCB ParentFcb OPTIONAL, - IN PFILE_ENUM_CONTEXT FileContext + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB Fcb, + _In_ PFCB ParentFcb, + _In_ PFILE_ENUM_CONTEXT FileContext ); PCCB CdCreateCcb ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN ULONG Flags + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ ULONG Flags ); VOID CdDeleteCcb ( - IN PIRP_CONTEXT IrpContext, - IN PCCB Ccb + _In_ PIRP_CONTEXT IrpContext, + _In_ __drv_freesMem( Pool ) PCCB Ccb ); +_When_(RaiseOnError || return, _At_(Fcb->FileLock, _Post_notnull_)) +_When_(RaiseOnError, _At_(IrpContext, _Pre_notnull_)) BOOLEAN CdCreateFileLock ( - IN PIRP_CONTEXT IrpContext OPTIONAL, - IN PFCB Fcb, - IN BOOLEAN RaiseOnError + _In_opt_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB Fcb, + _In_ BOOLEAN RaiseOnError ); VOID CdDeleteFileLock ( - IN PIRP_CONTEXT IrpContext, - IN PFILE_LOCK FileLock + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFILE_LOCK FileLock ); -PIRP_CONTEXT +_Ret_valid_ PIRP_CONTEXT CdCreateIrpContext ( - IN PIRP Irp, - IN BOOLEAN Wait + _In_ PIRP Irp, + _In_ BOOLEAN Wait ); VOID CdCleanupIrpContext ( - IN PIRP_CONTEXT IrpContext, - IN BOOLEAN Post + _In_ PIRP_CONTEXT IrpContext, + _In_ BOOLEAN Post ); VOID CdInitializeStackIrpContext ( - OUT PIRP_CONTEXT IrpContext, - IN PIRP_CONTEXT_LITE IrpContextLite + _Out_ PIRP_CONTEXT IrpContext, + _In_ PIRP_CONTEXT_LITE IrpContextLite ); // // PIRP_CONTEXT_LITE // CdCreateIrpContextLite ( -// IN PIRP_CONTEXT IrpContext +// _In_ PIRP_CONTEXT IrpContext // ); // // VOID // CdFreeIrpContextLite ( -// IN PIRP_CONTEXT_LITE IrpContextLite +// _Inout_ PIRP_CONTEXT_LITE IrpContextLite // ); // @@ -1060,52 +1230,53 @@ CdInitializeStackIrpContext ( #define CdFreeIrpContextLite(ICL) \ CdFreePool( &(ICL) ) +_Requires_lock_held_(_Global_critical_region_) VOID CdTeardownStructures ( - IN PIRP_CONTEXT IrpContext, - IN PFCB StartingFcb, - OUT PBOOLEAN RemovedStartingFcb + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PFCB StartingFcb, + _Out_ PBOOLEAN RemovedStartingFcb ); // // VOID // CdIncrementCleanupCounts ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PFCB Fcb // ); // // VOID // CdDecrementCleanupCounts ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PFCB Fcb // ); // // VOID // CdIncrementReferenceCounts ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb, -// IN ULONG ReferenceCount -// IN ULONG UserReferenceCount +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PFCB Fcb, +// _In_ ULONG ReferenceCount +// _In_ ULONG UserReferenceCount // ); // // VOID // CdDecrementReferenceCounts ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb, -// IN ULONG ReferenceCount -// IN ULONG UserReferenceCount +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PFCB Fcb, +// _In_ ULONG ReferenceCount +// _In_ ULONG UserReferenceCount // ); // // VOID // CdIncrementFcbReference ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PFCB Fcb // ); // // VOID // CdDecrementFcbReference ( -// IN PIRP_CONTEXT IrpContext, -// IN PFCB Fcb +// _In_ PIRP_CONTEXT IrpContext, +// _Inout_ PFCB Fcb // ); // @@ -1157,26 +1328,26 @@ CdTeardownStructures ( PFCB CdLookupFcbTable ( - IN PIRP_CONTEXT IrpContext, - IN PVCB Vcb, - IN FILE_ID FileId + _In_ PIRP_CONTEXT IrpContext, + _In_ PVCB Vcb, + _In_ FILE_ID FileId ); PFCB CdGetNextFcb ( - IN PIRP_CONTEXT IrpContext, - IN PVCB Vcb, - IN PVOID *RestartKey + _In_ PIRP_CONTEXT IrpContext, + _In_ PVCB Vcb, + _In_ PVOID *RestartKey ); NTSTATUS CdProcessToc ( - IN PIRP_CONTEXT IrpContext, - IN PDEVICE_OBJECT TargetDeviceObject, - IN PCDROM_TOC CdromToc, - IN OUT PULONG Length, - OUT PULONG TrackCount, - OUT PULONG DiskFlags + _In_ PIRP_CONTEXT IrpContext, + _In_ PDEVICE_OBJECT TargetDeviceObject, + _In_ PCDROM_TOC_LARGE CdromToc, + _Inout_ PULONG Length, + _Out_ PULONG TrackCount, + _Inout_ PULONG DiskFlags ); // @@ -1185,19 +1356,19 @@ CdProcessToc ( // #define CdPagedPool PagedPool -#define CdNonPagedPool NonPagedPool -#define CdNonPagedPoolCacheAligned NonPagedPoolCacheAligned +#define CdNonPagedPool NonPagedPoolNx +#define CdNonPagedPoolCacheAligned NonPagedPoolNxCacheAligned // // Verification support routines. Contained in verfysup.c // -/* ReactOS Change: "LD multiple definition of `_CdOperationIsDasdOpen'" */ -static inline + +INLINE BOOLEAN -CdOperationIsDasdOpen( - IN PIRP_CONTEXT IrpContext +CdOperationIsDasdOpen ( + _In_ PIRP_CONTEXT IrpContext ) { PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation( IrpContext->Irp); @@ -1207,37 +1378,44 @@ CdOperationIsDasdOpen( (IrpSp->FileObject->RelatedFileObject == NULL)); } - +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdPerformVerify ( - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp, - IN PDEVICE_OBJECT DeviceToVerify + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp, + _In_ PDEVICE_OBJECT DeviceToVerify ); +_Requires_lock_held_(_Global_critical_region_) BOOLEAN CdCheckForDismount ( - IN PIRP_CONTEXT IrpContext, - IN PVCB, - IN BOOLEAN Force + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PVCB Vcb, + _In_ BOOLEAN Force + ); + +BOOLEAN +CdMarkDevForVerifyIfVcbMounted ( + _Inout_ PVCB Vcb ); VOID CdVerifyVcb ( - IN PIRP_CONTEXT IrpContext, - IN PVCB Vcb + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PVCB Vcb ); BOOLEAN CdVerifyFcbOperation ( - IN PIRP_CONTEXT IrpContext OPTIONAL, - IN PFCB Fcb + _In_opt_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb ); +_Requires_lock_held_(_Global_critical_region_) BOOLEAN CdDismountVcb ( - IN PIRP_CONTEXT IrpContext, - IN PVCB Vcb + _In_ PIRP_CONTEXT IrpContext, + _Inout_ PVCB Vcb ); @@ -1258,8 +1436,8 @@ CdDismountVcb ( // // BOOLEAN // CdIsRawDevice ( -// IN PIRP_CONTEXT IrpContext, -// IN NTSTATUS Status +// _In_ PIRP_CONTEXT IrpContext, +// _In_ NTSTATUS Status // ); // @@ -1274,24 +1452,25 @@ CdDismountVcb ( // workque.c // +_Requires_lock_held_(_Global_critical_region_) NTSTATUS -CdFsdPostRequest( - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp +CdFsdPostRequest ( + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); +_Requires_lock_held_(_Global_critical_region_) VOID -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ CdPrePostIrp ( - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); +_Requires_lock_held_(_Global_critical_region_) VOID -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ CdOplockComplete ( - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); @@ -1304,9 +1483,7 @@ CdOplockComplete ( // otherwise // -/* ReactOS Change: GCC doesn't understand the comment style */ -/* - //#ifndef BooleanFlagOn +//#ifndef BooleanFlagOn //#define BooleanFlagOn(F,SF) ( \ // (BOOLEAN)(((F) & (SF)) != 0) \ //) @@ -1323,20 +1500,19 @@ CdOplockComplete ( // (Flags) &= ~(SingleFlag); \ //} //#endif -*/ // // CAST // Add2Ptr ( -// IN PVOID Pointer, -// IN ULONG Increment -// IN (CAST) +// _In_ PVOID Pointer, +// _In_ ULONG Increment +// _In_ (CAST) // ); // // ULONG // PtrOffset ( -// IN PVOID BasePtr, -// IN PVOID OffsetPtr +// _In_ PVOID BasePtr, +// _In_ PVOID OffsetPtr // ); // @@ -1399,6 +1575,15 @@ CdOplockComplete ( ((ULONG) (L)) >> SECTOR_SHIFT \ ) +INLINE +ULONG +SectorsFromLlBytes( + ULONGLONG Bytes +) { + + return (ULONG)(Bytes >> SECTOR_SHIFT); +} + #define LlBytesFromSectors(L) ( \ Int64ShllMod32( (LONGLONG)(L), SECTOR_SHIFT ) \ ) @@ -1499,61 +1684,97 @@ typedef union _USHORT2 { *((USHORT2 *)(Dst)) = *((UNALIGNED USHORT2 *)(Src));\ } - +// +// This macro copies an unaligned src longword to a dst longword, +// performing an little/big endian swap. +// + +#define SwapCopyUchar4(Dst,Src) { \ + *((UNALIGNED UCHAR1 *)(Dst)) = *((UNALIGNED UCHAR1 *)(Src) + 3); \ + *((UNALIGNED UCHAR1 *)(Dst) + 1) = *((UNALIGNED UCHAR1 *)(Src) + 2); \ + *((UNALIGNED UCHAR1 *)(Dst) + 2) = *((UNALIGNED UCHAR1 *)(Src) + 1); \ + *((UNALIGNED UCHAR1 *)(Dst) + 3) = *((UNALIGNED UCHAR1 *)(Src)); \ +} + +VOID +CdLbnToMmSsFf ( + _In_ ULONG Blocks, + _Out_writes_(3) PUCHAR Msf + ); + // // Following routines handle entry in and out of the filesystem. They are // contained in CdData.c // +_IRQL_requires_max_(APC_LEVEL) +__drv_dispatchType(DRIVER_DISPATCH) +__drv_dispatchType(IRP_MJ_CREATE) +__drv_dispatchType(IRP_MJ_CLOSE) +__drv_dispatchType(IRP_MJ_READ) +__drv_dispatchType(IRP_MJ_WRITE) +__drv_dispatchType(IRP_MJ_QUERY_INFORMATION) +__drv_dispatchType(IRP_MJ_SET_INFORMATION) +__drv_dispatchType(IRP_MJ_QUERY_VOLUME_INFORMATION) +__drv_dispatchType(IRP_MJ_DIRECTORY_CONTROL) +__drv_dispatchType(IRP_MJ_FILE_SYSTEM_CONTROL) +__drv_dispatchType(IRP_MJ_DEVICE_CONTROL) +__drv_dispatchType(IRP_MJ_LOCK_CONTROL) +__drv_dispatchType(IRP_MJ_CLEANUP) +__drv_dispatchType(IRP_MJ_PNP) +__drv_dispatchType(IRP_MJ_SHUTDOWN) NTSTATUS CdFsdDispatch ( - IN PVOLUME_DEVICE_OBJECT VolumeDeviceObject, - IN PIRP Irp + _In_ PDEVICE_OBJECT DeviceObject, + _Inout_ PIRP Irp ); +// DRIVER_DISPATCH CdFsdDispatch; + LONG CdExceptionFilter ( - IN PIRP_CONTEXT IrpContext, - IN PEXCEPTION_POINTERS ExceptionPointer + _Inout_ PIRP_CONTEXT IrpContext, + _In_ PEXCEPTION_POINTERS ExceptionPointer ); +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdProcessException ( - IN PIRP_CONTEXT IrpContext OPTIONAL, - IN PIRP Irp, - IN NTSTATUS ExceptionCode + _In_opt_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp, + _In_ NTSTATUS ExceptionCode ); VOID CdCompleteRequest ( - IN PIRP_CONTEXT IrpContext OPTIONAL, - IN PIRP Irp OPTIONAL, - IN NTSTATUS Status + _Inout_opt_ PIRP_CONTEXT IrpContext, + _Inout_opt_ PIRP Irp, + _In_ NTSTATUS Status ); // // VOID // CdRaiseStatus ( -// IN PRIP_CONTEXT IrpContext, -// IN NT_STATUS Status +// _In_ PRIP_CONTEXT IrpContext, +// _In_ NT_STATUS Status // ); // // VOID // CdNormalizeAndRaiseStatus ( -// IN PRIP_CONTEXT IrpContext, -// IN NT_STATUS Status +// _In_ PRIP_CONTEXT IrpContext, +// _In_ NT_STATUS Status // ); // #if 0 #define AssertVerifyDevice(C, S) \ - ASSERT( (C) == NULL || \ + NT_ASSERT( (C) == NULL || \ FlagOn( (C)->Flags, IRP_CONTEXT_FLAG_IN_FSP ) || \ !((S) == STATUS_VERIFY_REQUIRED && \ IoGetDeviceToVerify( PsGetCurrentThread() ) == NULL )); #define AssertVerifyDeviceIrp(I) \ - ASSERT( (I) == NULL || \ + NT_ASSERT( (I) == NULL || \ !(((I)->IoStatus.Status) == STATUS_VERIFY_REQUIRED && \ ((I)->Tail.Overlay.Thread == NULL || \ IoGetDeviceToVerify( (I)->Tail.Overlay.Thread ) == NULL ))); @@ -1567,12 +1788,12 @@ CdCompleteRequest ( DECLSPEC_NORETURN VOID -CdRaiseStatusEx( - IN PIRP_CONTEXT IrpContext, - IN NTSTATUS Status, - IN BOOLEAN NormalizeStatus, - IN OPTIONAL ULONG FileId, - IN OPTIONAL ULONG Line +CdRaiseStatusEx ( + _In_ PIRP_CONTEXT IrpContext, + _In_ NTSTATUS Status, + _In_ BOOLEAN NormalizeStatus, + _In_opt_ ULONG FileId, + _In_opt_ ULONG Line ); #else @@ -1581,11 +1802,11 @@ INLINE DECLSPEC_NORETURN VOID CdRaiseStatusEx( - IN PIRP_CONTEXT IrpContext, - IN NTSTATUS Status, - IN BOOLEAN NormalizeStatus, - IN ULONG Fileid, - IN ULONG Line + _In_ PIRP_CONTEXT IrpContext, + _In_ NTSTATUS Status, + _In_ BOOLEAN NormalizeStatus, + _In_ ULONG Fileid, + _In_ ULONG Line ) { if (NormalizeStatus) { @@ -1611,93 +1832,104 @@ CdRaiseStatusEx( // Following are the fast entry points. // -BOOLEAN -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ -CdFastQueryBasicInfo ( - IN PFILE_OBJECT FileObject, - IN BOOLEAN Wait, - IN OUT PFILE_BASIC_INFORMATION Buffer, - OUT PIO_STATUS_BLOCK IoStatus, - IN PDEVICE_OBJECT DeviceObject - ); +// _Success_(return != FALSE) +// BOOLEAN +// CdFastQueryBasicInfo ( +// _In_ PFILE_OBJECT FileObject, +// _In_ BOOLEAN Wait, +// _Out_ PFILE_BASIC_INFORMATION Buffer, +// _Out_ PIO_STATUS_BLOCK IoStatus, +// _In_ PDEVICE_OBJECT DeviceObject +// ); -BOOLEAN -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ -CdFastQueryStdInfo ( - IN PFILE_OBJECT FileObject, - IN BOOLEAN Wait, - IN OUT PFILE_STANDARD_INFORMATION Buffer, - OUT PIO_STATUS_BLOCK IoStatus, - IN PDEVICE_OBJECT DeviceObject - ); +FAST_IO_QUERY_BASIC_INFO CdFastQueryBasicInfo; -BOOLEAN -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ -CdFastLock ( - IN PFILE_OBJECT FileObject, - IN PLARGE_INTEGER FileOffset, - IN PLARGE_INTEGER Length, - PEPROCESS ProcessId, - ULONG Key, - BOOLEAN FailImmediately, - BOOLEAN ExclusiveLock, - OUT PIO_STATUS_BLOCK IoStatus, - IN PDEVICE_OBJECT DeviceObject - ); +// _Success_(return != FALSE) +// BOOLEAN +// CdFastQueryStdInfo ( +// _In_ PFILE_OBJECT FileObject, +// _In_ BOOLEAN Wait, +// _Out_ PFILE_STANDARD_INFORMATION Buffer, +// _Out_ PIO_STATUS_BLOCK IoStatus, +// _In_ PDEVICE_OBJECT DeviceObject +// ); -BOOLEAN -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ -CdFastUnlockSingle ( - IN PFILE_OBJECT FileObject, - IN PLARGE_INTEGER FileOffset, - IN PLARGE_INTEGER Length, - PEPROCESS ProcessId, - ULONG Key, - OUT PIO_STATUS_BLOCK IoStatus, - IN PDEVICE_OBJECT DeviceObject - ); +FAST_IO_QUERY_STANDARD_INFO CdFastQueryStdInfo; -BOOLEAN -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ -CdFastUnlockAll ( - IN PFILE_OBJECT FileObject, - PEPROCESS ProcessId, - OUT PIO_STATUS_BLOCK IoStatus, - IN PDEVICE_OBJECT DeviceObject - ); +// BOOLEAN +// CdFastLock ( +// _In_ PFILE_OBJECT FileObject, +// _In_ PLARGE_INTEGER FileOffset, +// _In_ PLARGE_INTEGER Length, +// _In_ PEPROCESS ProcessId, +// _In_ ULONG Key, +// _In_ BOOLEAN FailImmediately, +// _In_ BOOLEAN ExclusiveLock, +// _Out_ PIO_STATUS_BLOCK IoStatus, +// _In_ PDEVICE_OBJECT DeviceObject +// ); -BOOLEAN -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ -CdFastUnlockAllByKey ( - IN PFILE_OBJECT FileObject, - PVOID ProcessId, - ULONG Key, - OUT PIO_STATUS_BLOCK IoStatus, - IN PDEVICE_OBJECT DeviceObject - ); +FAST_IO_LOCK CdFastLock; -BOOLEAN -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ -CdFastIoCheckIfPossible ( - IN PFILE_OBJECT FileObject, - IN PLARGE_INTEGER FileOffset, - IN ULONG Length, - IN BOOLEAN Wait, - IN ULONG LockKey, - IN BOOLEAN CheckForReadOperation, - OUT PIO_STATUS_BLOCK IoStatus, - IN PDEVICE_OBJECT DeviceObject - ); +// BOOLEAN +// CdFastUnlockSingle ( +// _In_ PFILE_OBJECT FileObject, +// _In_ PLARGE_INTEGER FileOffset, +// _In_ PLARGE_INTEGER Length, +// _In_ PEPROCESS ProcessId, +// _In_ ULONG Key, +// _Out_ PIO_STATUS_BLOCK IoStatus, +// _In_ PDEVICE_OBJECT DeviceObject +// ); -BOOLEAN -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ -CdFastQueryNetworkInfo ( - IN PFILE_OBJECT FileObject, - IN BOOLEAN Wait, - OUT PFILE_NETWORK_OPEN_INFORMATION Buffer, - OUT PIO_STATUS_BLOCK IoStatus, - IN PDEVICE_OBJECT DeviceObject - ); +FAST_IO_UNLOCK_SINGLE CdFastUnlockSingle; + +// BOOLEAN +// CdFastUnlockAll ( +// _In_ PFILE_OBJECT FileObject, +// _In_ PEPROCESS ProcessId, +// _Out_ PIO_STATUS_BLOCK IoStatus, +// _In_ PDEVICE_OBJECT DeviceObject +// ); + +FAST_IO_UNLOCK_ALL CdFastUnlockAll; + +// BOOLEAN +// CdFastUnlockAllByKey ( +// _In_ PFILE_OBJECT FileObject, +// _In_ PVOID ProcessId, +// _In_ ULONG Key, +// _Out_ PIO_STATUS_BLOCK IoStatus, +// _In_ PDEVICE_OBJECT DeviceObject +// ); + +FAST_IO_UNLOCK_ALL_BY_KEY CdFastUnlockAllByKey; + +// BOOLEAN +// CdFastIoCheckIfPossible ( +// _In_ PFILE_OBJECT FileObject, +// _In_ PLARGE_INTEGER FileOffset, +// _In_ ULONG Length, +// _In_ BOOLEAN Wait, +// _In_ ULONG LockKey, +// _In_ BOOLEAN CheckForReadOperation, +// _Out_ PIO_STATUS_BLOCK IoStatus, +// _In_ PDEVICE_OBJECT DeviceObject +// ); + +FAST_IO_CHECK_IF_POSSIBLE CdFastIoCheckIfPossible; + +// _Success_(return != FALSE) +// BOOLEAN +// CdFastQueryNetworkInfo ( +// _In_ PFILE_OBJECT FileObject, +// _In_ BOOLEAN Wait, +// _Out_ PFILE_NETWORK_OPEN_INFORMATION Buffer, +// _Out_ PIO_STATUS_BLOCK IoStatus, +// _In_ PDEVICE_OBJECT DeviceObject +// ); + +FAST_IO_QUERY_NETWORK_OPEN_INFO CdFastQueryNetworkInfo; // // Following are the routines to handle the top level thread logic. @@ -1705,15 +1937,15 @@ CdFastQueryNetworkInfo ( VOID CdSetThreadContext ( - IN PIRP_CONTEXT IrpContext, - IN PTHREAD_CONTEXT ThreadContext + _Inout_ PIRP_CONTEXT IrpContext, + _In_ PTHREAD_CONTEXT ThreadContext ); // // VOID // CdRestoreThreadContext ( -// IN PIRP_CONTEXT IrpContext +// _Inout_ PIRP_CONTEXT IrpContext // ); // @@ -1724,8 +1956,8 @@ CdSetThreadContext ( ULONG CdSerial32 ( - IN PCHAR Buffer, - IN ULONG ByteCount + _In_reads_bytes_(ByteCount) PCHAR Buffer, + _In_ ULONG ByteCount ); // @@ -1751,7 +1983,7 @@ CdSerial32 ( #define CdIsFastIoPossible(F) ((BOOLEAN) \ ((((F)->Vcb->VcbCondition != VcbMounted ) || \ - !FsRtlOplockIsFastIoPossible( &(F)->Oplock )) ? \ + !FsRtlOplockIsFastIoPossible( CdGetFcbOplock(F) )) ? \ \ FastIoIsNotPossible : \ \ @@ -1769,14 +2001,16 @@ CdSerial32 ( // work routine. // -VOID -CdFspDispatch ( // implemented in FspDisp.c - IN PIRP_CONTEXT IrpContext - ); +// VOID +// CdFspDispatch ( // implemented in FspDisp.c +// _Inout_ PIRP_CONTEXT IrpContext +// ); + +WORKER_THREAD_ROUTINE CdFspDispatch; VOID CdFspClose ( // implemented in Close.c - IN PVCB Vcb OPTIONAL + _In_opt_ PVCB Vcb ); // @@ -1784,78 +2018,103 @@ CdFspClose ( // implemented in Close.c // based on the IrpSp major functions. // +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdCommonCreate ( // Implemented in Create.c - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdCommonClose ( // Implemented in Close.c - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdCommonRead ( // Implemented in Read.c - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); +_Requires_lock_held_(_Global_critical_region_) +NTSTATUS +CdCommonWrite ( // Implemented in Write.c + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp + ); + +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdCommonQueryInfo ( // Implemented in FileInfo.c - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdCommonSetInfo ( // Implemented in FileInfo.c - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdCommonQueryVolInfo ( // Implemented in VolInfo.c - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdCommonDirControl ( // Implemented in DirCtrl.c - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdCommonFsControl ( // Implemented in FsCtrl.c - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); NTSTATUS CdCommonDevControl ( // Implemented in DevCtrl.c - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); NTSTATUS CdCommonLockControl ( // Implemented in LockCtrl.c - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdCommonCleanup ( // Implemented in Cleanup.c - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdCommonPnp ( // Implemented in Pnp.c - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp + ); + +_Requires_lock_held_(_Global_critical_region_) +NTSTATUS +CdCommonShutdown ( // Implemented in Shutdown.c + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ); + // // The following macros are used to establish the semantics needed @@ -1885,24 +2144,17 @@ CdCommonPnp ( // Implemented in Pnp.c // #define try_return(S) { S; goto try_exit; } // -#ifndef __REACTOS__ #define try_return(S) { S; goto try_exit; } #define try_leave(S) { S; leave; } -#else -#define try_return(S) { S; goto try_exit; } -#define try_leave(S) { S; _SEH2_LEAVE; } -#endif - // // Encapsulate safe pool freeing // -/* ReactOS Change: GCC "passing argument 1 of CdFreePool from incompatible pointer type" */ -#define CdFreePool(x) _CdFreePool((PVOID*)(x)) -/* ReactOS Change: "LD multiple definition of `_CdOperationIsDasdOpen'" */ -static inline void _CdFreePool( - IN PVOID *Pool +INLINE +VOID +CdFreePool( + _Inout_ _At_(*Pool, __drv_freesMem(Mem) _Post_null_) PVOID *Pool ) { if (*Pool != NULL) { @@ -1912,6 +2164,116 @@ static inline void _CdFreePool( } } +#ifdef CDFS_TELEMETRY_DATA + +// +// CDFS Telemetry. Current implementation uses the Telemetry TraceLogging APIs. +// +// The Telemetry TraceLoggingWrite() routines use a lot of stack space. We must +// therefor wrap all our telemetry points with our own routines, and add a guard to +// make sure there's enough stack space to call these routines. +// +// These telemetry routines should not be called on high-performance code paths. +// + +TRACELOGGING_DECLARE_PROVIDER( CdTelemetryProvider ); + +VOID +CdInitializeTelemetry ( + VOID + ); + +DECLSPEC_NOINLINE +VOID +CdTelemetryMount ( + __in PGUID VolumeGuid, + __in NTSTATUS Status, + __in PVCB Vcb + ); + +// +// Every additional argument passed to TraceLoggingWrite() consumes an additional +// 16 to 32 bytes extra stack space. Having 512 bytes reserved space should be +// sufficient for up to 20 arguments or so. This will be less of course if our +// wrapper routines also declare their own local variables. +// + +#define CDFS_TELEMETRY_STACK_THRESHOLD_DEFAULT 512 // for "small" telemetry points +#define CDFS_TELEMETRY_STACK_THRESHOLD_LARGE 2048 // for "large" telemetry points + +INLINE +BOOLEAN +CdTelemetryGuard ( + __in ULONG StackSpaceNeeded ) +/*++ + +Routine Description: + + This routine returns TRUE only when: + + 1) There is an ETW listener, AND + 2) There is enough free stack space to safely call the Telemetry TraceLogging APIs + + We'll also count how many times there wasn't enough stack space, and include this + value as part of the periodic cdfs Telemetry. + +Arguments: + + StackSpaceNeeded - Stack space needed in bytes + +--*/ +{ + ASSERT( IoGetRemainingStackSize() >= StackSpaceNeeded ); + + if (CdTelemetryProvider->LevelPlus1 <= 5) { + + // + // Bail out early if there are no ETW listeners + // + + return FALSE; + } + + if (IoGetRemainingStackSize() < StackSpaceNeeded) { + + // + // Count how many times it was unsafe to generate telemetry because of + // not enough stack space. + // + + InterlockedIncrement( &CdTelemetryData.MissedTelemetryPoints ); + + return FALSE; + } + + return TRUE; +} + +#define CdTelemetryMountSafe( VolumeGuid, Status, Vcb ) \ + if (CdTelemetryGuard( CDFS_TELEMETRY_STACK_THRESHOLD_LARGE )) { \ + CdTelemetryMount( VolumeGuid, Status, Vcb ); \ + } + +#if DBG +#define CDFS_TELEMETRY_PERIODIC_INTERVAL CdTelemetryData.PeriodicInterval +#else +#define CDFS_TELEMETRY_PERIODIC_INTERVAL INTERVAL_ONE_DAY +#endif + +#else // CDFS_TELEMETRY_DATA + +// +// When CDFS_TELEMETRY_DATA is not defined then the CdTelemetry___Safe() routines +// expand to nothing. This minimizes the cdfs.sys binary footprint. This also +// means that the places where these Safe() routines are called do not +// have to have to be surrounded by #ifdef CDFS_TELEMETRY_DATA .. #endif +// + + +#define CdTelemetryMountSafe( ... ) NOTHING + +#endif // CDFS_TELEMETRY_DATA + #endif // _CDPROCS_ diff --git a/drivers/filesystems/cdfs_new/cdprocssrc.c b/drivers/filesystems/cdfs_new/cdprocssrc.c new file mode 100644 index 0000000000..a370cab122 --- /dev/null +++ b/drivers/filesystems/cdfs_new/cdprocssrc.c @@ -0,0 +1 @@ +#include "cdprocs.h" \ No newline at end of file diff --git a/drivers/filesystems/cdfs_new/cdstruc.h b/drivers/filesystems/cdfs_new/cdstruc.h index 1259349db2..72abe0a1c3 100755 --- a/drivers/filesystems/cdfs_new/cdstruc.h +++ b/drivers/filesystems/cdfs_new/cdstruc.h @@ -133,7 +133,7 @@ Abstract: 5. A fast mutex in the Vcb will protect access to the Fcb table and the open counts in the Vcb. It is also used to modify the reference counts in all Fcbs. This mutex cannot be acquired - exclusively and is an end resource. + exclusely and is an end resource. 6. A fast mutex in the Fcb will synchronize access to all Fcb fields which aren't synchronized in some other way. A thread may acquire @@ -244,7 +244,7 @@ typedef struct _CD_NAME { UNICODE_STRING FileName; // - // String containing the version number. + // String containging the version number. // UNICODE_STRING VersionString; @@ -318,7 +318,7 @@ typedef struct _CD_DATA { // The type and size of this record (must be CDFS_NTC_DATA_HEADER) // - NODE_TYPE_CODE NodeTypeCode; + _Field_range_(==, CDFS_NTC_DATA_HEADER) NODE_TYPE_CODE NodeTypeCode; NODE_BYTE_SIZE NodeByteSize; // @@ -349,10 +349,6 @@ typedef struct _CD_DATA { PDEVICE_OBJECT FileSystemDeviceObject; -#ifdef __REACTOS__ - PDEVICE_OBJECT HddFileSystemDeviceObject; -#endif - // // Following are used to manage the async and delayed close queue. // @@ -360,7 +356,7 @@ typedef struct _CD_DATA { // two close queues. // ReduceDelayedClose - Indicates that we have hit the upper threshold // for the delayed close queue and need to reduce it to lower threshold. - // + // Flags - CD flags. // AsyncCloseQueue - Queue of IrpContext waiting for async close operation. // AsyncCloseCount - Number of entries on the async close queue. // @@ -368,7 +364,7 @@ typedef struct _CD_DATA { // operation. // MaxDelayedCloseCount - Trigger delay close work at this threshold. // MinDelayedCloseCount - Turn off delay close work at this threshold. - // DelayedCloseCount - Number of entries on the delayed close queue. + // DelayedCloseCount - Number of entries on the delayted close queue. // // CloseItem - Workqueue item used to start FspClose thread. // @@ -377,7 +373,7 @@ typedef struct _CD_DATA { ULONG AsyncCloseCount; BOOLEAN FspCloseActive; BOOLEAN ReduceDelayedClose; - USHORT PadUshort; + USHORT Flags; // // The following fields describe the deferred close file objects. @@ -418,7 +414,48 @@ typedef struct _CD_DATA { } CD_DATA; typedef CD_DATA *PCD_DATA; - + +#define CD_FLAGS_SHUTDOWN (0x0001) + + +// +// Since DVD drives allow > 100 "sessions", we need to use a larger TOC +// than the legacy CD definition. The maximum is theoretically 0xaa-16 (max +// number of open tracks in a session), but it's quite possible that some +// drive does not enforce this, so we'll go with 169 (track 0xaa is always the +// leadout). +// + +#define MAXIMUM_NUMBER_TRACKS_LARGE 0xAA + +typedef struct _CDROM_TOC_LARGE { + + // + // Header + // + + UCHAR Length[2]; // add two bytes for this field + UCHAR FirstTrack; + UCHAR LastTrack; + + // + // Track data + // + + TRACK_DATA TrackData[ MAXIMUM_NUMBER_TRACKS_LARGE]; + +} CDROM_TOC_LARGE, *PCDROM_TOC_LARGE; + +typedef struct _CD_SECTOR_CACHE_CHUNK { + + ULONG BaseLbn; + PUCHAR Buffer; + +} CD_SECTOR_CACHE_CHUNK, *PCD_SECTOR_CACHE_CHUNK; + +#define CD_SEC_CACHE_CHUNKS 4 +#define CD_SEC_CHUNK_BLOCKS 0x18 + // // The Vcb (Volume control block) record corresponds to every // volume mounted by the file system. They are ordered in a queue off @@ -460,7 +497,7 @@ typedef struct _VCB { // The type and size of this record (must be CDFS_NTC_VCB) // - NODE_TYPE_CODE NodeTypeCode; + _Field_range_(==, CDFS_NTC_VCB) NODE_TYPE_CODE NodeTypeCode; NODE_BYTE_SIZE NodeByteSize; // @@ -508,8 +545,8 @@ typedef struct _VCB { // ULONG VcbCleanup; - LONG VcbReference; /* ReactOS Change: GCC 'pointer targets in passing argument 1 of 'InterlockedXxx' differ in signedness */ - LONG VcbUserReference; /* ReactOS Change: GCC 'pointer targets in passing argument 1 of 'InterlockedXxx' differ in signedness */ + __volatile ULONG VcbReference; + __volatile ULONG VcbUserReference; // // Fcb for the Volume Dasd file, root directory and the Path Table. @@ -593,7 +630,7 @@ typedef struct _VCB { // Volume TOC. Cache this information for quick lookup. // - PCDROM_TOC CdromToc; + PCDROM_TOC_LARGE CdromToc; ULONG TocLength; ULONG TrackCount; ULONG DiskFlags; @@ -625,8 +662,42 @@ typedef struct _VCB { PVPB SwapVpb; -} VCB; -typedef VCB *PVCB; + // + // Directory block cache. Read large numbers of blocks on directory + // reads, hoping to benefit from the fact that most mastered/pressed + // discs clump metadata in one place thus allowing us to crudely + // pre-cache and reduce seeks back to directory data during app install, + // file copy etc. + // + // Note that the purpose of this is to PRE cache unread data, + // not cache already read data (since Cc already provides that), thus + // speeding initial access to the volume. + // + + PUCHAR SectorCacheBuffer; + CD_SECTOR_CACHE_CHUNK SecCacheChunks[ CD_SEC_CACHE_CHUNKS]; + ULONG SecCacheLRUChunkIndex; + + PIRP SectorCacheIrp; + KEVENT SectorCacheEvent; + ERESOURCE SectorCacheResource; + +#ifdef CDFS_TELEMETRY_DATA + + // + // An ID that is common across the volume stack used to correlate volume events and for telemetry purposes. + // It may have a different value than the VolumeGuid. + // + + GUID VolumeCorrelationId; + +#endif // CDFS_TELEMETRY_DATA + +#if DBG + ULONG SecCacheHits; + ULONG SecCacheMisses; +#endif +} VCB, *PVCB; #define VCB_STATE_HSG (0x00000001) #define VCB_STATE_ISO (0x00000002) @@ -637,6 +708,8 @@ typedef VCB *PVCB; #define VCB_STATE_AUDIO_DISK (0x00000080) #define VCB_STATE_NOTIFY_REMOUNT (0x00000100) #define VCB_STATE_VPB_NOT_ON_DEVICE (0x00000200) +#define VCB_STATE_SHUTDOWN (0x00000400) +#define VCB_STATE_DISMOUNTED (0x00000800) // @@ -659,7 +732,7 @@ typedef struct _VOLUME_DEVICE_OBJECT { // executed later. // - LONG PostedRequestCount; /* ReactOS Change: GCC "pointer targets in passing argument 1 of 'InterlockedDecrement' differ in signedness" */ + __volatile ULONG PostedRequestCount; // // The following field indicates the number of IRP's waiting @@ -706,12 +779,14 @@ typedef enum _FCB_CONDITION { typedef struct _FCB_DATA { +#if (NTDDI_VERSION < NTDDI_WIN8) // // The following field is used by the oplock module // to maintain current oplock information. // OPLOCK Oplock; +#endif // // The following field is used by the filelock module @@ -780,12 +855,12 @@ typedef struct _FCB_NONPAGED { // Type and size of this record must be CDFS_NTC_FCB_NONPAGED // - NODE_TYPE_CODE NodeTypeCode; + _Field_range_(==, CDFS_NTC_FCB_NONPAGED) NODE_TYPE_CODE NodeTypeCode; NODE_BYTE_SIZE NodeByteSize; // // The following field contains a record of special pointers used by - // MM and Cache to manipulate section objects. Note that the values + // MM and Cache to manipluate section objects. Note that the values // are set outside of the file system. However the file system on an // open/create will set the file object's SectionObject field to // point to this field @@ -882,7 +957,7 @@ typedef struct _FCB { // ULONG FcbCleanup; - LONG FcbReference; /* ReactOS Change: GCC 'pointer targets in passing argument 1 of 'InterlockedXxx' differ in signedness */ + __volatile ULONG FcbReference; ULONG FcbUserReference; // @@ -991,7 +1066,7 @@ typedef struct _CCB { // Type and size of this record (must be CDFS_NTC_CCB) // - NODE_TYPE_CODE NodeTypeCode; + _Field_range_(==, CDFS_NTC_CCB) NODE_TYPE_CODE NodeTypeCode; NODE_BYTE_SIZE NodeByteSize; // @@ -1026,6 +1101,7 @@ typedef CCB *PCCB; #define CCB_FLAG_IGNORE_CASE (0x00000004) #define CCB_FLAG_OPEN_WITH_VERSION (0x00000008) #define CCB_FLAG_DISMOUNT_ON_CLOSE (0x00000010) +#define CCB_FLAG_ALLOW_EXTENDED_DASD_IO (0x00000020) // // Following flags refer to index enumeration. @@ -1041,7 +1117,7 @@ typedef CCB *PCCB; // -// The Irp Context record is allocated for every originating Irp. It is +// The Irp Context record is allocated for every orginating Irp. It is // created by the Fsd dispatch routines, and deallocated by the CdComplete // request routine // @@ -1052,7 +1128,7 @@ typedef struct _IRP_CONTEXT { // Type and size of this record (must be CDFS_NTC_IRP_CONTEXT) // - NODE_TYPE_CODE NodeTypeCode; + _Field_range_(==, CDFS_NTC_IRP_CONTEXT) NODE_TYPE_CODE NodeTypeCode; NODE_BYTE_SIZE NodeByteSize; // @@ -1197,7 +1273,7 @@ typedef struct _IRP_CONTEXT_LITE { // Type and size of this record (must be CDFS_NTC_IRP_CONTEXT_LITE) // - NODE_TYPE_CODE NodeTypeCode; + _Field_range_(==, CDFS_NTC_IRP_CONTEXT_LITE) NODE_TYPE_CODE NodeTypeCode; NODE_BYTE_SIZE NodeByteSize; // @@ -1242,9 +1318,9 @@ typedef struct _CD_IO_CONTEXT { // These two fields are used for multiple run Io // - LONG IrpCount; + __volatile LONG IrpCount; PIRP MasterIrp; - NTSTATUS Status; + __volatile NTSTATUS Status; BOOLEAN AllocatedContext; union { @@ -1491,7 +1567,7 @@ typedef DIRENT_ENUM_CONTEXT *PDIRENT_ENUM_CONTEXT; // // Following structure is used to smooth out the differences in the HSG, ISO -// and Joliet directory entries. +// and Joliett directory entries. // typedef struct _DIRENT { @@ -1763,5 +1839,71 @@ typedef AUDIO_PLAY_HEADER *PAUDIO_PLAY_HEADER; } \ } +#ifdef CDFS_TELEMETRY_DATA +// ============================================================================ +// ============================================================================ +// +// Telemetry +// +// ============================================================================ +// ============================================================================ + +typedef struct _CDFS_TELEMETRY_DATA_CONTEXT { + + // + // Number of times there was not enough stack space to generate telemetry + // + + volatile LONG MissedTelemetryPoints; + + // + // System Time of the last periodic telemtry event. System Time + // is according to KeQuerySystemTime() + // + + LARGE_INTEGER LastPeriodicTelemetrySystemTime; + + // + // TickCount of the last periodic telemtry event. TickCount is + // according to KeQueryTickCount() + // + + LARGE_INTEGER LastPeriodicTelemetryTickCount; + + // + // Hint for Worker thread whether to generate + // periodic telemetry or not + // + + BOOLEAN GeneratePeriodicTelemetry; + + // + // Guid for ID parity with other file systems telemetry. + // + + GUID VolumeGuid; + + +#if DBG + + // + // For DBG builds we want a machanism to change the frequency of + // periodic events + // + + LONGLONG PeriodicInterval; + +#endif + + // + // File system statistics at time of last period telemetry event + // + + FILESYSTEM_STATISTICS CommonStats; + +} CDFS_TELEMETRY_DATA_CONTEXT, *PCDFS_TELEMETRY_DATA_CONTEXT; + +#endif // CDFS_TELEMETRY_DATA + #endif // _CDSTRUC_ diff --git a/drivers/filesystems/cdfs_new/cleanup.c b/drivers/filesystems/cdfs_new/cleanup.c index a89be2ffef..a0d8ce43fc 100755 --- a/drivers/filesystems/cdfs_new/cleanup.c +++ b/drivers/filesystems/cdfs_new/cleanup.c @@ -14,7 +14,7 @@ Abstract: --*/ -#include "cdprocs.h" +#include "CdProcs.h" // // The Bug check file id for this module @@ -22,11 +22,11 @@ Abstract: #define BugCheckFileId (CDFS_BUG_CHECK_CLEANUP) - +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdCommonCleanup ( - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ) /*++ @@ -82,7 +82,7 @@ Return Value: TYPE_OF_OPEN TypeOfOpen; BOOLEAN SendUnlockNotification = FALSE; - BOOLEAN AttemptTeardown; + BOOLEAN AttemptTeardown = FALSE; BOOLEAN VcbAcquired = FALSE; PVCB Vcb; @@ -148,7 +148,38 @@ Return Value: SetFlag( FileObject->Flags, FO_CLEANUP_COMPLETE ); CdReleaseFile( IrpContext, Fcb); - + + if (TypeOfOpen == UserVolumeOpen) { + + // + // For a force dismount, physically disconnect this Vcb from the device so + // a new mount can occur. Vcb deletion cannot happen at this time since + // there is a reference on it associated with this very request, but we'll + // call check for dismount again later after we process this close. + // + + if (FlagOn( Ccb->Flags, CCB_FLAG_DISMOUNT_ON_CLOSE )) { + + CdAcquireCdData( IrpContext ); + + CdCheckForDismount( IrpContext, Vcb, TRUE ); + + CdReleaseCdData( IrpContext ); + + // + // If this handle actually wrote something, flush the device buffers, + // and then set the verify bit now just to be safe (in case there is no + // dismount). + // + + } else if (FlagOn( FileObject->Flags, FO_FILE_MODIFIED )) { + + CdHijackIrpAndFlushDevice( IrpContext, Irp, Vcb->TargetDeviceObject ); + + CdMarkDevForVerifyIfVcbMounted( Vcb ); + } + } + // // Acquire the current file. // @@ -159,7 +190,7 @@ Return Value: // Use a try-finally to facilitate cleanup. // - _SEH2_TRY { + try { // // Case on the type of open that we are trying to cleanup. @@ -187,7 +218,7 @@ Return Value: // need to check for STATUS_PENDING. // - FsRtlCheckOplock( &Fcb->Oplock, + FsRtlCheckOplock( CdGetFcbOplock(Fcb), Irp, IrpContext, NULL, @@ -221,12 +252,13 @@ Return Value: break; - case UserVolumeOpen : + case UserVolumeOpen: break; default : +#pragma prefast( suppress:__WARNING_USE_OTHER_FUNCTION, "argument bogus" ) CdBugCheck( TypeOfOpen, 0, 0 ); } @@ -257,7 +289,7 @@ Return Value: if (FileObject == Vcb->VolumeLockFileObject) { - ASSERT( FlagOn( Vcb->VcbState, VCB_STATE_LOCKED)); + NT_ASSERT( FlagOn( Vcb->VcbState, VCB_STATE_LOCKED)); IoAcquireVpbSpinLock( &SavedIrql ); @@ -279,15 +311,15 @@ Return Value: IoRemoveShareAccess( FileObject, &Fcb->ShareAccess ); - } _SEH2_FINALLY { + } finally { - CdReleaseFcb( IrpContext, Fcb ); + CdReleaseFcb( IrpContext, Fcb ); if (SendUnlockNotification) { FsRtlNotifyVolumeEvent( FileObject, FSRTL_VOLUME_UNLOCK ); } - } _SEH2_END; + } // // If appropriate, try to spark teardown by purging the volume. Should @@ -305,19 +337,19 @@ Return Value: CdAcquireCdData( IrpContext); - _SEH2_TRY { + try { CdAcquireVcbExclusive( IrpContext, Vcb, FALSE ); VcbAcquired = TRUE; CdPurgeVolume( IrpContext, Vcb, FALSE ); - } _SEH2_FINALLY { + } finally { if (VcbAcquired) { CdReleaseVcb( IrpContext, Vcb ); } CdReleaseCdData( IrpContext); - } _SEH2_END; + } } // diff --git a/drivers/filesystems/cdfs_new/close.c b/drivers/filesystems/cdfs_new/close.c index d2827793c6..5e45587544 100755 --- a/drivers/filesystems/cdfs_new/close.c +++ b/drivers/filesystems/cdfs_new/close.c @@ -42,7 +42,7 @@ Abstract: --*/ -#include "cdprocs.h" +#include "CdProcs.h" // // The Bug check file id for this module @@ -54,36 +54,40 @@ Abstract: // Local support routines // +_Requires_lock_held_(_Global_critical_region_) BOOLEAN CdCommonClosePrivate ( - IN PIRP_CONTEXT IrpContext, - IN PVCB Vcb, - IN PFCB Fcb, - IN ULONG UserReference, - IN BOOLEAN FromFsd + _In_ PIRP_CONTEXT IrpContext, + _In_ PVCB Vcb, + _In_ PFCB Fcb, + _In_ ULONG UserReference, + _In_ BOOLEAN FromFsd ); VOID CdQueueClose ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN ULONG UserReference, - IN BOOLEAN DelayedClose + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ ULONG UserReference, + _In_ BOOLEAN DelayedClose ); PIRP_CONTEXT CdRemoveClose ( - IN PVCB Vcb OPTIONAL + _In_opt_ PVCB Vcb ); +// Tell prefast this is a workitem routine +IO_WORKITEM_ROUTINE CdCloseWorker; + VOID -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ CdCloseWorker ( - IN PDEVICE_OBJECT DeviceObject, - IN PVOID Context + _In_ PDEVICE_OBJECT DeviceObject, + _In_opt_ PVOID Context ); #ifdef ALLOC_PRAGMA +#pragma alloc_text(PAGE, CdFspClose) #pragma alloc_text(PAGE, CdCommonClose) #pragma alloc_text(PAGE, CdCommonClosePrivate) #pragma alloc_text(PAGE, CdQueueClose) @@ -94,7 +98,7 @@ CdCloseWorker ( VOID CdFspClose ( - IN PVCB Vcb OPTIONAL + _In_opt_ PVCB Vcb ) /*++ @@ -120,7 +124,7 @@ Return Value: PIRP_CONTEXT IrpContext; IRP_CONTEXT StackIrpContext; - THREAD_CONTEXT ThreadContext; + THREAD_CONTEXT ThreadContext = {0}; PFCB Fcb; ULONG UserReference; @@ -137,8 +141,8 @@ Return Value: // // Continue processing until there are no more closes to process. // - /* ReactOS Change: "GCC suggest parentheses around assignment used as truth value" */ - while ((IrpContext = CdRemoveClose( Vcb ))) { + + while ((IrpContext = CdRemoveClose( Vcb )) != NULL) { // // If we don't have an IrpContext then use the one on the stack. @@ -166,7 +170,7 @@ Return Value: // Free the IrpContextLite. // - CdFreeIrpContextLite( IrpContext ); /* ReactOS Change: GCC "error: invalid lvalue in unary '&'" */ + CdFreeIrpContextLite( (PIRP_CONTEXT_LITE) IrpContext ); // // Remember we have the IrpContext from the stack. @@ -191,6 +195,8 @@ Return Value: IrpContext->ExceptionStatus = STATUS_SUCCESS; } + _Analysis_assume_(Fcb != NULL && Fcb->Vcb != NULL); + // // We have an IrpContext. Now we need to set the top level thread // context. @@ -261,6 +267,9 @@ Return Value: } CurrentVcb = Fcb->Vcb; + + _Analysis_assume_( CurrentVcb != NULL ); + CdAcquireVcbShared( IrpContext, CurrentVcb, FALSE ); VcbHoldCount = 0; @@ -309,14 +318,15 @@ Return Value: } +#pragma prefast(suppress:26165, "Esp:1153") FsRtlExitFileSystem(); } - +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdCommonClose ( - IN PIRP_CONTEXT IrpContext, - IN PIRP Irp + _Inout_ PIRP_CONTEXT IrpContext, + _Inout_ PIRP Irp ) /*++ @@ -349,7 +359,6 @@ Return Value: ULONG UserReference = 0; BOOLEAN PotentialVcbTeardown = FALSE; - BOOLEAN ForceDismount = FALSE; PAGED_CODE(); @@ -397,13 +406,6 @@ Return Value: UserReference = 1; - // - // Was a FSCTL_DISMOUNT issued on this handle? If so, we need to - // force a dismount of the volume now. - // - - ForceDismount = BooleanFlagOn( Ccb->Flags, CCB_FLAG_DISMOUNT_ON_CLOSE); - // // We can always deallocate the Ccb if present. // @@ -431,7 +433,8 @@ Return Value: // if we can't acquire all of the resources. // - } else { + } + else { // // If we may be dismounting this volume then acquire the CdData @@ -439,7 +442,7 @@ Return Value: // // Since we now must make volumes go away as soon as reasonable after // the last user handles closes, key off of the cleanup count. It is - // OK to do this more than necessary. Since this Fcb could be holding + // OK to do this more than neccesary. Since this Fcb could be holding // a number of other Fcbs (and thus their references), a simple check // on reference count is not appropriate. // @@ -447,33 +450,17 @@ Return Value: // common case. // - if (((Vcb->VcbCleanup == 0) || ForceDismount) && + if ((Vcb->VcbCleanup == 0) && (Vcb->VcbCondition != VcbMounted)) { // - // Possible. Acquire CdData to synchronise with the remount path, and - // then repeat the tests. - // - // Note that we must send the notification outside of any locks, since - // the worker that processes the notify could also be calling into our - // pnp path which wants both CdData and VcbResource. For a force dismount - // the volume will be marked invalid (no going back), so we will definitely - // go ahead and dismount below. + // Possible dismount. Acquire CdData to synchronise with the remount path + // before looking at the vcb condition again. // - if (ForceDismount) { - - // - // Send notification. - // - - FsRtlNotifyVolumeEvent( IoGetCurrentIrpStackLocation( Irp )->FileObject, - FSRTL_VOLUME_DISMOUNT ); - } - CdAcquireCdData( IrpContext ); - if (((Vcb->VcbCleanup == 0) || ForceDismount) && + if ((Vcb->VcbCleanup == 0) && (Vcb->VcbCondition != VcbMounted) && (Vcb->VcbCondition != VcbMountInProgress) && FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL_CDFS )) { @@ -486,21 +473,16 @@ Return Value: // We can't dismount this volume now, there are other references or // it's just been remounted. // - - CdReleaseCdData( IrpContext); } - } - if (ForceDismount) { - // - // Physically disconnect this Vcb from the device so a new mount can - // occur. Vcb deletion cannot happen at this time since there is - // a handle on it associated with this very request, but we'll call - // check for dismount again later anyway. + // Drop the global lock if we don't need it anymore. // - CdCheckForDismount( IrpContext, Vcb, TRUE ); + if (!PotentialVcbTeardown) { + + CdReleaseCdData( IrpContext ); + } } // @@ -522,7 +504,8 @@ Return Value: // the request. // - } else if (PotentialVcbTeardown) { + } + else if (PotentialVcbTeardown) { CdCheckForDismount( IrpContext, Vcb, FALSE ); } @@ -551,13 +534,14 @@ Return Value: // Local support routine // +_Requires_lock_held_(_Global_critical_region_) BOOLEAN CdCommonClosePrivate ( - IN PIRP_CONTEXT IrpContext, - IN PVCB Vcb, - IN PFCB Fcb, - IN ULONG UserReference, - IN BOOLEAN FromFsd + _In_ PIRP_CONTEXT IrpContext, + _In_ PVCB Vcb, + _In_ PFCB Fcb, + _In_ ULONG UserReference, + _In_ BOOLEAN FromFsd ) /*++ @@ -651,6 +635,9 @@ Return Value: CdReleaseFcb( IrpContext, Fcb ); } + else { + _Analysis_assume_lock_not_held_(Fcb->FcbNonpaged->FcbResource); + } // // Release the Vcb and return to our caller. Let him know we completed @@ -663,10 +650,9 @@ Return Value: } VOID -NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */ CdCloseWorker ( - IN PDEVICE_OBJECT DeviceObject, - IN PVOID Context + _In_ PDEVICE_OBJECT DeviceObject, + _In_opt_ PVOID Context ) /*++ @@ -687,16 +673,21 @@ Return Value: --*/ { + PAGED_CODE(); + + UNREFERENCED_PARAMETER( DeviceObject ); + UNREFERENCED_PARAMETER( Context ); + CdFspClose (NULL); } VOID CdQueueClose ( - IN PIRP_CONTEXT IrpContext, - IN PFCB Fcb, - IN ULONG UserReference, - IN BOOLEAN DelayedClose + _In_ PIRP_CONTEXT IrpContext, + _In_ PFCB Fcb, + _In_ ULONG UserReference, + _In_ BOOLEAN DelayedClose ) /*++ @@ -880,7 +871,7 @@ Return Value: PIRP_CONTEXT CdRemoveClose ( - IN PVCB Vcb OPTIONAL + _In_opt_ PVCB Vcb ) /*++ diff --git a/drivers/filesystems/cdfs_new/create.c b/drivers/filesystems/cdfs_new/create.c index 3cab9b9ff9..695121df0f 100755 --- a/drivers/filesystems/cdfs_new/create.c +++ b/drivers/filesystems/cdfs_new/create.c @@ -14,7 +14,7 @@ Abstract: --*/ -#include "cdprocs.h" +#include "CdProcs.h" // // The Bug check file id for this module @@ -26,73 +26,84 @@ Abstract: // Local support routines // +_When_(RelatedTypeOfOpen != UnopenedFileObject, _At_(RelatedCcb, _In_)) +_When_(RelatedTypeOfOpen == UnopenedFileObject, _At_(RelatedCcb, _In_opt_)) +_When_(RelatedTypeOfOpen != UnopenedFileObject, _At_(RelatedFileName, _In_)) +_When_(RelatedTypeOfOpen == UnopenedFileObject, _At_(RelatedFileName, _In_opt_)) NTSTATUS CdNormalizeFileNames ( - IN PIRP_CONTEXT IrpContext, - IN PVCB Vcb, - IN BOOLEAN OpenByFileId, - IN BOOLEAN IgnoreCase, - IN TYPE_OF_OPEN RelatedTypeOfOpen, - IN PCCB RelatedCcb OPTIONAL, - IN PUNICODE_STRING RelatedFileName OPTIONAL, - IN OUT PUNICODE_STRING FileName, - IN OUT PCD_NAME RemainingName + _Inout_ PIRP_CONTEXT IrpContext, + _In_ PVCB Vcb, + _In_ BOOLEAN OpenByFileId, + _In_ BOOLEAN IgnoreCase, + _In_ TYPE_OF_OPEN RelatedTypeOfOpen, + PCCB RelatedCcb, + PUNICODE_STRING RelatedFileName, + _Inout_ PUNICODE_STRING FileName, + _Inout_ PCD_NAME RemainingName ); +_Requires_lock_held_(_Global_critical_region_) +_Acquires_exclusive_lock_((*CurrentFcb)->FcbNonpaged->FcbResource) NTSTATUS CdOpenByFileId ( - IN PIRP_CONTEXT IrpContext, - IN PIO_STACK_LOCATION IrpSp, - IN PVCB Vcb, - IN OUT PFCB *CurrentFcb + _In_ PIRP_CONTEXT IrpContext, + _In_ PIO_STACK_LOCATION IrpSp, + _In_ PVCB Vcb, + _Inout_ PFCB *CurrentFcb ); +_Requires_lock_held_(_Global_critical_region_) NTSTATUS CdOpenExistingFcb ( - IN PIRP_CONTEXT IrpContext, - IN PIO_STACK_LOCATION IrpSp, - IN OUT PFCB *CurrentFcb, - IN TYPE_OF_OPEN TypeOfOpen, - IN BOOLEAN IgnoreCase, - IN PCCB RelatedCcb OPTIONAL + _In_ PIRP_CONTEXT IrpContext, + _In_ PIO_STACK_LOCATION IrpSp, + _Inout_ PFCB *CurrentFcb, + _In_ TYPE_OF_OPEN TypeOfOpen, + _In_ BOOLEAN IgnoreCase, + _In_opt_ PCCB RelatedCcb ); +_Requires_lock_held_(_Global_critical_region_) +_Acquires_lock_((*CurrentFcb)->FcbNonpaged->FcbResource) NTSTATUS CdOpenDirectoryFromPathEntry ( - IN PIRP_CONTEXT IrpContext, - IN PIO_STACK_LOCATION IrpSp, - IN PVCB Vcb, - IN OUT PFCB *CurrentFcb, - IN PCD_NAME DirName, - IN BOOLEAN IgnoreCase, - IN BOOLEAN ShortNameMatch, - IN PPATH_ENTRY PathEntry, - IN BOOLEAN PerformUserOpen, - IN PCCB RelatedCcb OPTIONAL + _In_ PIRP_CONTEXT IrpContext, + _In_ PIO_STACK_LOCATION IrpSp, + _In_ PVCB Vcb, + _Inout_ PFCB *CurrentFcb, + _In_ PCD_NAME DirName, + _In_ BOOLEAN IgnoreCase, + _In_ BOOLEAN ShortNameMatch, + _In_ PPATH_ENTRY PathEntry, + _In_ BOOLEAN PerformUserOpen, ... 10456 lines suppressed ...

1 0

[reactos] 01/01: [SHELL32] Don't show error when closing disk prop sheet (#144)
by Katayama Hirofumi MZ 25 Nov '17

25 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=87d276f05d673e53a4132… commit 87d276f05d673e53a413269099eeb1e7882ec825 Author: Katayama Hirofumi MZ <katayama.hirofumi.mz(a)gmail.com> AuthorDate: Sat Nov 25 18:27:20 2017 +0900 [SHELL32] Don't show error when closing disk prop sheet (#144) CORE-14035 --- dll/win32/shell32/dialogs/drive.cpp | 16 ++++++++++------ dll/win32/shell32/dialogs/fprop.cpp | 3 ++- dll/win32/shell32/folders/CDrivesFolder.cpp | 4 ++-- dll/win32/shell32/wine/shell32_main.h | 2 +- 4 files changed, 15 insertions(+), 10 deletions(-) diff --git a/dll/win32/shell32/dialogs/drive.cpp b/dll/win32/shell32/dialogs/drive.cpp index a5919f027f..3afbe80d8c 100644 --- a/dll/win32/shell32/dialogs/drive.cpp +++ b/dll/win32/shell32/dialogs/drive.cpp @@ -2,6 +2,7 @@ * Shell Library Functions * * Copyright 2005 Johannes Anderwald + * Copyright 2017 Katayama Hirofumi MZ * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -127,7 +128,7 @@ typedef struct _DRIVE_PROP_PAGE UINT DriveType; } DRIVE_PROP_PAGE; -BOOL +HRESULT SH_ShowDriveProperties(WCHAR *pwszDrive, LPCITEMIDLIST pidlFolder, PCUITEMID_CHILD_ARRAY apidl) { HPSXA hpsx = NULL; @@ -145,7 +146,7 @@ SH_ShowDriveProperties(WCHAR *pwszDrive, LPCITEMIDLIST pidlFolder, PCUITEMID_CHI LPITEMIDLIST completePidl = ILCombine(pidlFolder, apidl[0]); if (!completePidl) - return FALSE; + return E_OUTOFMEMORY; if (ILGetDisplayNameExW(NULL, completePidl, wszName, ILGDN_NORMAL)) { @@ -179,16 +180,19 @@ SH_ShowDriveProperties(WCHAR *pwszDrive, LPCITEMIDLIST pidlFolder, PCUITEMID_CHI SHAddFromPropSheetExtArray(hpsx, (LPFNADDPROPSHEETPAGE)AddPropSheetPageCallback, (LPARAM)&psh); } - HWND hwnd = (HWND)PropertySheetW(&psh); + // NOTE: Currently property sheet is modal. If we make it modeless, then it returns HWND. + INT_PTR ret = PropertySheetW(&psh); if (hpsx) SHDestroyPropSheetExtArray(hpsx); if (pDrvDefExt) pDrvDefExt->Release(); - if (!hwnd) - return FALSE; - return TRUE; + if (ret > 0) + return S_OK; + if (ret == 0) + return S_FALSE; + return E_FAIL; } static VOID diff --git a/dll/win32/shell32/dialogs/fprop.cpp b/dll/win32/shell32/dialogs/fprop.cpp index ede236fa85..989a9ce6c1 100644 --- a/dll/win32/shell32/dialogs/fprop.cpp +++ b/dll/win32/shell32/dialogs/fprop.cpp @@ -3,6 +3,7 @@ * * Copyright 2005 Johannes Anderwald * Copyright 2012 Rafal Harabien + * Copyright 2017 Katayama Hirofumi MZ * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -117,7 +118,7 @@ SH_ShowPropertiesDialog(LPCWSTR pwszPath, LPCITEMIDLIST pidlFolder, PCUITEMID_CH /* Handle drives */ if (PathIsRootW(wszPath)) - return SH_ShowDriveProperties(wszPath, pidlFolder, apidl); + return SUCCEEDED(SH_ShowDriveProperties(wszPath, pidlFolder, apidl)); /* Handle files and folders */ PROPSHEETHEADERW Header; diff --git a/dll/win32/shell32/folders/CDrivesFolder.cpp b/dll/win32/shell32/folders/CDrivesFolder.cpp index 701a10643f..196165597f 100644 --- a/dll/win32/shell32/folders/CDrivesFolder.cpp +++ b/dll/win32/shell32/folders/CDrivesFolder.cpp @@ -215,9 +215,9 @@ HRESULT CALLBACK DrivesContextMenuCallback(IShellFolder *psf, if (wParam == DFM_CMD_PROPERTIES) { - if (!SH_ShowDriveProperties(wszBuf, pidlFolder, apidl)) + hr = SH_ShowDriveProperties(wszBuf, pidlFolder, apidl); + if (FAILED(hr)) { - hr = E_FAIL; dwError = ERROR_CAN_NOT_COMPLETE; nStringID = IDS_CANTSHOWPROPERTIES; } diff --git a/dll/win32/shell32/wine/shell32_main.h b/dll/win32/shell32/wine/shell32_main.h index 8e17caf421..170d844b4b 100644 --- a/dll/win32/shell32/wine/shell32_main.h +++ b/dll/win32/shell32/wine/shell32_main.h @@ -184,7 +184,7 @@ BOOL SHELL_IsShortcut(LPCITEMIDLIST) DECLSPEC_HIDDEN; INT_PTR CALLBACK SH_FileGeneralDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam); INT_PTR CALLBACK SH_FileVersionDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam); HPROPSHEETPAGE SH_CreatePropertySheetPage(WORD wDialogId, DLGPROC pfnDlgProc, LPARAM lParam, LPCWSTR pwszTitle); -BOOL SH_ShowDriveProperties(WCHAR *drive, LPCITEMIDLIST pidlFolder, PCUITEMID_CHILD_ARRAY apidl); +HRESULT SH_ShowDriveProperties(WCHAR *drive, LPCITEMIDLIST pidlFolder, PCUITEMID_CHILD_ARRAY apidl); BOOL SH_ShowRecycleBinProperties(WCHAR sDrive); BOOL SH_ShowPropertiesDialog(LPCWSTR pwszPath, LPCITEMIDLIST pidlFolder, PCUITEMID_CHILD_ARRAY apidl); LPWSTR SH_FormatFileSizeWithBytes(PULARGE_INTEGER lpQwSize, LPWSTR pszBuf, UINT cchBuf);

1 0

[reactos] 01/01: [GDI] - Add type for setting world transform modification modes.
by jimtabor 24 Nov '17

24 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=d85023c9c976ec002dcde… commit d85023c9c976ec002dcde33514252678d2be79f8 Author: jimtabor <james.tabor(a)reactos.org> AuthorDate: Fri Nov 24 17:22:43 2017 -0600 [GDI] - Add type for setting world transform modification modes. References: https://msdn.microsoft.com/en-us/library/cc230538.aspx https://github.com/KDE/krita/blob/master/libs/vectorimage/libemf/EmfEnums.h --- win32ss/gdi/gdi32/objects/coord.c | 3 +-- win32ss/gdi/ntgdi/coord.c | 2 +- win32ss/gdi/ntgdi/path.c | 2 +- win32ss/include/ntgdityp.h | 6 ++++++ 4 files changed, 9 insertions(+), 4 deletions(-) diff --git a/win32ss/gdi/gdi32/objects/coord.c b/win32ss/gdi/gdi32/objects/coord.c index 727d4bd4a7..2caa575352 100644 --- a/win32ss/gdi/gdi32/objects/coord.c +++ b/win32ss/gdi/gdi32/objects/coord.c @@ -302,8 +302,7 @@ SetWorldTransform( _In_ HDC hdc, _Out_ CONST XFORM *pxform) { - /* FIXME shall we add undoc #define MWT_SETXFORM 4 ?? */ - return ModifyWorldTransform(hdc, pxform, MWT_MAX+1); + return ModifyWorldTransform(hdc, pxform, MWT_SET); } diff --git a/win32ss/gdi/ntgdi/coord.c b/win32ss/gdi/ntgdi/coord.c index 8d7be4e26c..58d236581b 100644 --- a/win32ss/gdi/ntgdi/coord.c +++ b/win32ss/gdi/ntgdi/coord.c @@ -480,7 +480,7 @@ GreModifyWorldTransform( XFORMOBJ_iCombine(&xoDC, &xoDC, &xoSrc); break; - case MWT_MAX+1: // Must be MWT_SET???? + case MWT_SET: XFORMOBJ_vInit(&xoDC, &pdc->pdcattr->mxWorldToPage); if (XFORMOBJ_iSetXform(&xoDC, pxform) == DDI_ERROR) return FALSE; diff --git a/win32ss/gdi/ntgdi/path.c b/win32ss/gdi/ntgdi/path.c index 5a014a3e03..f4cc24951a 100644 --- a/win32ss/gdi/ntgdi/path.c +++ b/win32ss/gdi/ntgdi/path.c @@ -1529,7 +1529,7 @@ PATH_FillPath( /* Go to GM_ADVANCED temporarily to restore the world transform */ graphicsMode = pdcattr->iGraphicsMode; pdcattr->iGraphicsMode = GM_ADVANCED; - GreModifyWorldTransform(dc, &xform, MWT_MAX+1); + GreModifyWorldTransform(dc, &xform, MWT_SET); pdcattr->iGraphicsMode = graphicsMode; return TRUE; } diff --git a/win32ss/include/ntgdityp.h b/win32ss/include/ntgdityp.h index 7b54c323e8..4bf8aa92fa 100644 --- a/win32ss/include/ntgdityp.h +++ b/win32ss/include/ntgdityp.h @@ -170,6 +170,12 @@ typedef enum GDILoObjType GDILoObjType_LO_METADC16_TYPE = 0x660000 } GDILOOBJTYPE, *PGDILOOBJTYPE; +/** + World Transform modification modes + See [MS-EMF] Section 2.1.24 +*/ +#define MWT_SET 0x04 + #define GdiWorldSpaceToPageSpace 0x203 #define GdiWorldSpaceToDeviceSpace 0x204 #define GdiPageSpaceToDeviceSpace 0x304

1 0

[reactos] 01/01: [APPVEYOR] Add an appveyor.yml file. Dedicated to Alexander Shaposhnikov (sanchaez). [APPVEYOR/CLANG-CL] Add the clang-cl build as a second job next to our msvc build.
by Amine Khaldi 24 Nov '17

24 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=f310b023375270d7eaf82… commit f310b023375270d7eaf82202ac82e6240ca3ba97 Author: Amine Khaldi <amine.khaldi(a)reactos.org> AuthorDate: Fri Nov 24 12:13:10 2017 +0100 [APPVEYOR] Add an appveyor.yml file. Dedicated to Alexander Shaposhnikov (sanchaez). [APPVEYOR/CLANG-CL] Add the clang-cl build as a second job next to our msvc build. --- appveyor.yml | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/appveyor.yml b/appveyor.yml new file mode 100644 index 0000000000..443508b7f8 --- /dev/null +++ b/appveyor.yml @@ -0,0 +1,34 @@ +environment: + matrix: + - BuildType: "clang-cl" + - BuildType: "msvc" + +version: reactos.appveyor.{build} +skip_branch_with_pr: true +clone_depth: 5 +clone_folder: c:\reactos-cov + +init: + - ps: (New-Object System.Net.WebClient).DownloadFile("https://svn.reactos.org/amine/RosCMakeNinja.zip","C:\RosCMakeNinja.zip") + - 7z x C:\RosCMakeNinja.zip -oC:\RosCMakeNinja + - ps: >- + If ($env:BuildType -Match "clang-cl") { + $env:clang_configure_option="clang" + (New-Object System.Net.WebClient).DownloadFile("https://svn.reactos.org/amine/clang-cl.7z","C:\clang-cl.7z") + 7z x C:\clang-cl.7z -oC:\RosCMakeNinja\bin + } Else { + $env:clang_configure_option="" + } + +build_script: + - set PATH=C:\RosCMakeNinja\bin;%PATH% + - call "C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat" x86 + - cmake --version + - md c:\ros_build + - cd c:\ros_build + - call %APPVEYOR_BUILD_FOLDER%\configure.cmd %clang_configure_option% -DENABLE_ROSTESTS=1 + - ninja -k0 + - ninja bootcd + +test: off +deploy: off

1 0

[reactos] 01/01: [DLLIMPORT_TEST] Skip this module in the clang-cl build until framedyn is back in it. CORE-11799
by Amine Khaldi 24 Nov '17

24 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=ed3bdb44f5bd82c585f24… commit ed3bdb44f5bd82c585f24e781d70889082d3da9c Author: Amine Khaldi <amine.khaldi(a)reactos.org> AuthorDate: Fri Nov 24 12:07:56 2017 +0100 [DLLIMPORT_TEST] Skip this module in the clang-cl build until framedyn is back in it. CORE-11799 --- modules/rostests/tests/dllexport/CMakeLists.txt | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/modules/rostests/tests/dllexport/CMakeLists.txt b/modules/rostests/tests/dllexport/CMakeLists.txt index a204ad395f..76c883af9a 100644 --- a/modules/rostests/tests/dllexport/CMakeLists.txt +++ b/modules/rostests/tests/dllexport/CMakeLists.txt @@ -27,6 +27,9 @@ if(MSVC) add_compile_flags("/Zc:wchar_t-") endif() +# framedyn is skipped in the clang-cl build +if(NOT USE_CLANG_CL) + add_library(dllimport_test SHARED dllimport_framedyn.cpp) set_module_type(dllimport_test module) add_importlibs(dllimport_test framedyn) @@ -34,3 +37,5 @@ add_importlibs(dllimport_test framedyn) if(NOT MSVC) target_link_libraries(dllimport_test framedynex) endif() + +endif()

1 0

[reactos] 01/01: [CMAKE/CLANG-CL] Force clang-cl's identity to be MSVC instead of the default Clang one as the latter results in skipping several MSVC related CMake checks/tasks. CORE-11799
by Amine Khaldi 24 Nov '17

24 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=10f300697837981be3d28… commit 10f300697837981be3d2807c15eced3c3afcdc19 Author: Amine Khaldi <amine.khaldi(a)reactos.org> AuthorDate: Fri Nov 24 12:01:43 2017 +0100 [CMAKE/CLANG-CL] Force clang-cl's identity to be MSVC instead of the default Clang one as the latter results in skipping several MSVC related CMake checks/tasks. CORE-11799 --- toolchain-msvc.cmake | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/toolchain-msvc.cmake b/toolchain-msvc.cmake index 6028e61493..c94493bf7d 100644 --- a/toolchain-msvc.cmake +++ b/toolchain-msvc.cmake @@ -14,8 +14,15 @@ set(CMAKE_SYSTEM_NAME Windows) set(CMAKE_SYSTEM_PROCESSOR i686) # which compilers to use for C and C++ +# clang-cl gets detected as "Clang" instead of "MSVC" so we force it here if(USE_CLANG_CL) - set(CMAKE_C_COMPILER clang-cl) + include(CMakeForceCompiler) + CMAKE_FORCE_C_COMPILER(clang-cl MSVC) + set(CMAKE_C_COMPILER_VERSION "16.00.40219.01") + if(ARCH STREQUAL "i386") + set(MSVC_C_ARCHITECTURE_ID "X86") + endif() + include(${CMAKE_ROOT}/Modules/CMakeClDeps.cmake) else() set(CMAKE_C_COMPILER cl) endif() @@ -25,7 +32,8 @@ if(ARCH STREQUAL "arm") CMAKE_FORCE_CXX_COMPILER(cl MSVC) else() if(USE_CLANG_CL) - set(CMAKE_CXX_COMPILER clang-cl) + include(CMakeForceCompiler) + CMAKE_FORCE_CXX_COMPILER(clang-cl MSVC) else() set(CMAKE_CXX_COMPILER cl) endif()

1 0

[reactos] 01/01: [FASTFAT_NEW] Fix build with FASTFATDBG set
by Pierre Schweitzer 24 Nov '17

24 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=3013e153b0e085de0abd2… commit 3013e153b0e085de0abd2b2eeb83bdfaf6eded13 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Fri Nov 24 12:00:10 2017 +0100 [FASTFAT_NEW] Fix build with FASTFATDBG set --- drivers/filesystems/fastfat_new/fatdata.h | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/drivers/filesystems/fastfat_new/fatdata.h b/drivers/filesystems/fastfat_new/fatdata.h index 18fb891aab..ad4d1fb812 100644 --- a/drivers/filesystems/fastfat_new/fatdata.h +++ b/drivers/filesystems/fastfat_new/fatdata.h @@ -234,6 +234,7 @@ extern LONG FatDebugTraceIndent; } \ } +#ifdef _MSC_VER #define DebugDump(STR,LEVEL,PTR) { \ __pragma(warning(push)) \ __pragma(warning(disable:4210)) \ @@ -248,9 +249,22 @@ extern LONG FatDebugTraceIndent; } \ __pragma(warning(pop)) \ } +#else +#define DebugDump(STR,LEVEL,PTR) { \ + ULONG _i; \ + VOID FatDump(IN PVOID Ptr); \ + if (((LEVEL) == 0) || (FatDebugTraceLevel & (LEVEL))) { \ + _i = (ULONG)PsGetCurrentThread(); \ + DbgPrint("%08lx:",_i); \ + DbgPrint(STR); \ + if (PTR != NULL) {FatDump(PTR);} \ + NT_ASSERT(FALSE); \ + } \ +} +#endif #define DebugUnwind(X) { \ - if (AbnormalTermination()) { \ + if (_SEH2_AbnormalTermination()) { \ DebugTrace(0, DEBUG_TRACE_UNWIND, #X ", Abnormal termination.\n", 0); \ } \ }

1 0

[reactos] 02/02: [FASTFAT_NEW] Import again FastFAT from MS. This time from GitHub for license reasons. This implies that a sample for W10. It has been backported to NT5.2; not sure how it would work on a W2K3 (feel free to test!)
by Pierre Schweitzer 23 Nov '17

23 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=0daa5547d98d8e374e991… commit 0daa5547d98d8e374e991c3a052f30d409775279 Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Thu Nov 23 23:26:10 2017 +0100 [FASTFAT_NEW] Import again FastFAT from MS. This time from GitHub for license reasons. This implies that a sample for W10. It has been backported to NT5.2; not sure how it would work on a W2K3 (feel free to test!) --- drivers/filesystems/fastfat_new/CMakeLists.txt | 43 + drivers/filesystems/fastfat_new/README.md | 54 + drivers/filesystems/fastfat_new/acchksup.c | 423 ++ drivers/filesystems/fastfat_new/allocsup.c | 5295 +++++++++++++++ drivers/filesystems/fastfat_new/cachesup.c | 2017 ++++++ drivers/filesystems/fastfat_new/cleanup.c | 1189 ++++ drivers/filesystems/fastfat_new/close.c | 1289 ++++ drivers/filesystems/fastfat_new/create.c | 7000 ++++++++++++++++++++ drivers/filesystems/fastfat_new/devctrl.c | 415 ++ drivers/filesystems/fastfat_new/deviosup.c | 3858 +++++++++++ drivers/filesystems/fastfat_new/dirctrl.c | 1613 +++++ drivers/filesystems/fastfat_new/dirsup.c | 3804 +++++++++++ drivers/filesystems/fastfat_new/dumpsup.c | 381 ++ drivers/filesystems/fastfat_new/ea.c | 2043 ++++++ drivers/filesystems/fastfat_new/easup.c | 3856 +++++++++++ drivers/filesystems/fastfat_new/fastfat.rc | 14 + drivers/filesystems/fastfat_new/fat.h | 755 +++ drivers/filesystems/fastfat_new/fatdata.c | 1576 +++++ drivers/filesystems/fastfat_new/fatdata.h | 338 + drivers/filesystems/fastfat_new/fatinit.c | 771 +++ drivers/filesystems/fastfat_new/fatprocs.h | 3098 +++++++++ drivers/filesystems/fastfat_new/fatprocssrc.c | 1 + drivers/filesystems/fastfat_new/fatstruc.h | 1786 ++++++ drivers/filesystems/fastfat_new/fileinfo.c | 5202 +++++++++++++++ drivers/filesystems/fastfat_new/filobsup.c | 591 ++ drivers/filesystems/fastfat_new/flush.c | 1371 ++++ drivers/filesystems/fastfat_new/fsctrl.c | 8198 ++++++++++++++++++++++++ drivers/filesystems/fastfat_new/fspdisp.c | 485 ++ drivers/filesystems/fastfat_new/lfn.h | 56 + drivers/filesystems/fastfat_new/lockctrl.c | 770 +++ drivers/filesystems/fastfat_new/namesup.c | 1114 ++++ drivers/filesystems/fastfat_new/nodetype.h | 194 + drivers/filesystems/fastfat_new/pnp.c | 902 +++ drivers/filesystems/fastfat_new/read.c | 1755 +++++ drivers/filesystems/fastfat_new/resrcsup.c | 966 +++ drivers/filesystems/fastfat_new/shutdown.c | 318 + drivers/filesystems/fastfat_new/splaysup.c | 488 ++ drivers/filesystems/fastfat_new/strucsup.c | 3944 ++++++++++++ drivers/filesystems/fastfat_new/timesup.c | 375 ++ drivers/filesystems/fastfat_new/verfysup.c | 2036 ++++++ drivers/filesystems/fastfat_new/volinfo.c | 1372 ++++ drivers/filesystems/fastfat_new/workque.c | 372 ++ drivers/filesystems/fastfat_new/write.c | 3089 +++++++++ media/doc/README.FSD | 3 + 44 files changed, 75220 insertions(+) diff --git a/drivers/filesystems/fastfat_new/CMakeLists.txt b/drivers/filesystems/fastfat_new/CMakeLists.txt new file mode 100644 index 0000000000..1c254a1f4c --- /dev/null +++ b/drivers/filesystems/fastfat_new/CMakeLists.txt @@ -0,0 +1,43 @@ +list(APPEND SOURCE + acchksup.c + allocsup.c + cachesup.c + cleanup.c + close.c + create.c + devctrl.c + deviosup.c + dirctrl.c + dirsup.c + dumpsup.c + ea.c + easup.c + fatdata.c + fatinit.c + fatprocssrc.c + fileinfo.c + filobsup.c + flush.c + fsctrl.c + fspdisp.c + lockctrl.c + namesup.c + pnp.c + read.c + resrcsup.c + shutdown.c + splaysup.c + strucsup.c + timesup.c + verfysup.c + volinfo.c + workque.c + write.c + fatprocs.h) + +add_library(fastfat SHARED ${SOURCE} fastfat.rc) +set_module_type(fastfat kernelmodedriver) +target_link_libraries(fastfat ${PSEH_LIB} memcmp) +add_importlibs(fastfat ntoskrnl hal) +add_pch(fastfat fatprocs.h SOURCE) +add_cd_file(TARGET fastfat DESTINATION reactos/system32/drivers NO_CAB FOR all) diff --git a/drivers/filesystems/fastfat_new/README.md b/drivers/filesystems/fastfat_new/README.md new file mode 100644 index 0000000000..801e3f7365 --- /dev/null +++ b/drivers/filesystems/fastfat_new/README.md @@ -0,0 +1,54 @@ + + + + +fastfat File System Driver +========================== + +The *fastfat* sample is file system driver that you can use as a model to write new file systems. + +*fastfat* is a complete file system that addresses various issues such as storing data on disk, interacting with the cache manager, and handling various I/O operations such as file creation, performing read/writes on a file, setting information on a file, and performing control operations on the file system. + +## Universal Windows Driver Compliant +This sample builds a Universal Windows Driver. It uses only APIs and DDIs that are included in OneCoreUAP. + +Build the sample +---------------- + +You can build the sample in two ways: using Microsoft Visual Studio or the command line (*MSBuild*). + +### Building a Driver Using Visual Studio + +You build a driver the same way you build any project or solution in Visual Studio. When you create a new driver project using a Windows driver template, the template defines a default (active) project configuration and a default (active) solution build configuration. When you create a project from existing driver sources or convert existing driver code that was built with previous versions of the WDK, the conversion process preserves the target version information (operating systems and [...] + +The default Solution build configuration is **Debug** and **Win32**. + +**To select a configuration and build a driver** + +1. Open the driver project or solution in Visual Studio (find fastfat.sln or fastfat.vcxproj). +2. Right-click the solution in the **Solutions Explorer** and select **Configuration Manager**. +3. From the **Configuration Manager**, select the **Active Solution Configuration** (for example, Debug or Release) and the **Active Solution Platform** (for example, Win32) that correspond to the type of build you are interested in. +4. From the Build menu, click **Build Solution** (Ctrl+Shift+B). + +### Building a Driver Using the Command Line (MSBuild) + +You can build a driver from the command line using the Visual Studio Command Prompt window and the Microsoft Build Engine (MSBuild.exe) Previous versions of the WDK used the Windows Build utility (Build.exe) and provided separate build environment windows for each of the supported build configurations. You can now use the Visual Studio Command Prompt window for all build configurations. + +**To select a configuration and build a driver or an application** + +1. Open a Visual Studio Command Prompt window at the **Start** screen. From this window you can use MsBuild.exe to build any Visual Studio project by specifying the project (.VcxProj) or solutions (.Sln) file. +2. Navigate to the project directory and enter the **MSbuild** command for your target. For example, to perform a clean build of a Visual Studio driver project called *filtername*.vcxproj, navigate to the project directory and enter the following MSBuild command: + + **msbuild /t:clean /t:build .\\fastfat.vcxproj**. + +Installation +------------ + +No INF file is provided with this sample because the *fastfat* file system driver (fastfat.sys) is already part of the Windows operating system. You can build a private version of this file system and use it as a replacement for the native driver. diff --git a/drivers/filesystems/fastfat_new/acchksup.c b/drivers/filesystems/fastfat_new/acchksup.c new file mode 100644 index 0000000000..b6924e5e40 --- /dev/null +++ b/drivers/filesystems/fastfat_new/acchksup.c @@ -0,0 +1,423 @@ +/*++ + +Copyright (c) 1989-2000 Microsoft Corporation + +Module Name: + + AcChkSup.c + +Abstract: + + This module implements the FAT access checking routine + + +--*/ + +#include "fatprocs.h" + +// +// Our debug trace level +// + +#define Dbg (DEBUG_TRACE_ACCHKSUP) + +NTSTATUS +FatCreateRestrictEveryoneToken( + IN PACCESS_TOKEN Token, + OUT PACCESS_TOKEN *RestrictedToken + ); + +#ifdef ALLOC_PRAGMA +#pragma alloc_text(PAGE, FatCheckFileAccess) +#pragma alloc_text(PAGE, FatCheckManageVolumeAccess) +#pragma alloc_text(PAGE, FatCreateRestrictEveryoneToken) +#pragma alloc_text(PAGE, FatExplicitDeviceAccessGranted) +#endif + + +BOOLEAN +FatCheckFileAccess ( + PIRP_CONTEXT IrpContext, + IN UCHAR DirentAttributes, + IN PACCESS_MASK DesiredAccess + ) + +/*++ + +Routine Description: + + This routine checks if a desired access is allowed to a file represented + by the specified DirentAttriubutes. + +Arguments: + + DirentAttributes - Supplies the Dirent attributes to check access for + + DesiredAccess - Supplies the desired access mask that we are checking for + +Return Value: + + BOOLEAN - TRUE if access is allowed and FALSE otherwise + +--*/ + +{ + BOOLEAN Result; + + DebugTrace(+1, Dbg, "FatCheckFileAccess\n", 0); + DebugTrace( 0, Dbg, "DirentAttributes = %8lx\n", DirentAttributes); + DebugTrace( 0, Dbg, "DesiredAccess = %8lx\n", *DesiredAccess); + + PAGED_CODE(); + + // + // This procedures is programmed like a string of filters each + // filter checks to see if some access is allowed, if it is not allowed + // the filter return FALSE to the user without further checks otherwise + // it moves on to the next filter. The filter check is to check for + // desired access flags that are not allowed for a particular dirent + // + + Result = TRUE; + + _SEH2_TRY { + + // + // Check for Volume ID or Device Dirents, these are not allowed user + // access at all + // + + if (FlagOn(DirentAttributes, FAT_DIRENT_ATTR_VOLUME_ID) || + FlagOn(DirentAttributes, FAT_DIRENT_ATTR_DEVICE)) { + + DebugTrace(0, Dbg, "Cannot access volume id or device\n", 0); + + try_return( Result = FALSE ); + } + + // + // Check the desired access for the object - we only blackball that + // we do not understand. The model of filesystems using ACLs is that + // they do not type the ACL to the object the ACL is on. Permissions + // are not checked for consistency vs. the object type - dir/file. + // + + if (FlagOn(*DesiredAccess, ~(DELETE | + READ_CONTROL | + WRITE_OWNER | + WRITE_DAC | + SYNCHRONIZE | + ACCESS_SYSTEM_SECURITY | + FILE_WRITE_DATA | + FILE_READ_EA | + FILE_WRITE_EA | + FILE_READ_ATTRIBUTES | + FILE_WRITE_ATTRIBUTES | + FILE_LIST_DIRECTORY | + FILE_TRAVERSE | + FILE_DELETE_CHILD | + FILE_APPEND_DATA | + MAXIMUM_ALLOWED))) { + + DebugTrace(0, Dbg, "Cannot open object\n", 0); + + try_return( Result = FALSE ); + } + + // + // Check for a read-only Dirent + // + + if (FlagOn(DirentAttributes, FAT_DIRENT_ATTR_READ_ONLY)) { + + // + // Check the desired access for a read-only dirent. AccessMask will contain + // the flags we're going to allow. + // + + ACCESS_MASK AccessMask = DELETE | READ_CONTROL | WRITE_OWNER | WRITE_DAC | + SYNCHRONIZE | ACCESS_SYSTEM_SECURITY | FILE_READ_DATA | + FILE_READ_EA | FILE_WRITE_EA | FILE_READ_ATTRIBUTES | + FILE_WRITE_ATTRIBUTES | FILE_EXECUTE | FILE_LIST_DIRECTORY | + FILE_TRAVERSE; + + // + // If this is a subdirectory also allow add file/directory and delete. + // + + if (FlagOn(DirentAttributes, FAT_DIRENT_ATTR_DIRECTORY)) { + + AccessMask |= FILE_ADD_SUBDIRECTORY | FILE_ADD_FILE | FILE_DELETE_CHILD; + } + + if (FlagOn(*DesiredAccess, ~AccessMask)) { + + DebugTrace(0, Dbg, "Cannot open readonly\n", 0); + + try_return( Result = FALSE ); + } + } + + try_exit: NOTHING; + } _SEH2_FINALLY { + + DebugUnwind( FatCheckFileAccess ); + + DebugTrace(-1, Dbg, "FatCheckFileAccess -> %08lx\n", Result); + } _SEH2_END; + + UNREFERENCED_PARAMETER( IrpContext ); + + return Result; +} + + +BOOLEAN +FatCheckManageVolumeAccess ( + _In_ PIRP_CONTEXT IrpContext, + _In_ PACCESS_STATE AccessState, + _In_ KPROCESSOR_MODE ProcessorMode + ) + +/*++ + +Routine Description: + + This function checks whether the SID described in the input access state has + manage volume privilege. + +Arguments: + + AccessState - the access state describing the security context to be checked + + ProcessorMode - the mode this check should occur against + +Return Value: + + BOOLEAN - TRUE if privilege is held and FALSE otherwise + +--*/ + +{ + PRIVILEGE_SET PrivilegeSet; + + PAGED_CODE(); + + PrivilegeSet.PrivilegeCount = 1; + PrivilegeSet.Control = PRIVILEGE_SET_ALL_NECESSARY; + PrivilegeSet.Privilege[0].Luid = RtlConvertLongToLuid( SE_MANAGE_VOLUME_PRIVILEGE ); + PrivilegeSet.Privilege[0].Attributes = 0; + + if (SePrivilegeCheck( &PrivilegeSet, + &AccessState->SubjectSecurityContext, + ProcessorMode )) { + + return TRUE; + } + + UNREFERENCED_PARAMETER( IrpContext ); + + return FALSE; +} + + +NTSTATUS +FatExplicitDeviceAccessGranted ( + IN PIRP_CONTEXT IrpContext, + IN PDEVICE_OBJECT DeviceObject, + IN PACCESS_STATE AccessState, + IN KPROCESSOR_MODE ProcessorMode + ) + +/*++ + +Routine Description: + + This function asks whether the SID described in the input access state has + been granted any explicit access to the given device object. It does this + by acquiring a token stripped of its ability to acquire access via the + Everyone SID and re-doing the access check. + +Arguments: + + DeviceObject - the device whose ACL will be checked + + AccessState - the access state describing the security context to be checked + + ProcessorMode - the mode this check should occur against + +Return Value: + + NTSTATUS - Indicating whether explicit access was granted. + +--*/ + +{ + NTSTATUS Status; + + PACCESS_TOKEN OriginalAccessToken; + PACCESS_TOKEN RestrictedAccessToken; + + PACCESS_TOKEN *EffectiveToken; + + ACCESS_MASK GrantedAccess; + + PAGED_CODE(); + + UNREFERENCED_PARAMETER( IrpContext ); + + // + // If the access state indicates that specific access other + // than traverse was acquired, either Everyone does have such + // access or explicit access was granted. In both cases, we're + // happy to let this proceed. + // + + if (AccessState->PreviouslyGrantedAccess & (SPECIFIC_RIGHTS_ALL ^ + FILE_TRAVERSE)) { + + return STATUS_SUCCESS; + } + + // + // If the manage volume privilege is held, this also permits access. + // + + if (FatCheckManageVolumeAccess( IrpContext, + AccessState, + ProcessorMode )) { + + return STATUS_SUCCESS; + } + + // + // Capture the subject context as a prelude to everything below. + // + + SeLockSubjectContext( &AccessState->SubjectSecurityContext ); + + // + // Convert the token in the subject context into one which does not + // acquire access through the Everyone SID. + // + // The logic for deciding which token is effective comes from + // SeQuerySubjectContextToken; since there is no natural way + // of getting a pointer to it, do it by hand. + // + + if (ARGUMENT_PRESENT( AccessState->SubjectSecurityContext.ClientToken )) { + EffectiveToken = &AccessState->SubjectSecurityContext.ClientToken; + } else { + EffectiveToken = &AccessState->SubjectSecurityContext.PrimaryToken; + } + + OriginalAccessToken = *EffectiveToken; + Status = FatCreateRestrictEveryoneToken( OriginalAccessToken, &RestrictedAccessToken ); + + if (!NT_SUCCESS(Status)) { + + SeReleaseSubjectContext( &AccessState->SubjectSecurityContext ); + return Status; + } + + // + // Now see if the resulting context has access to the device through + // its explicitly granted access. We swap in our restricted token + // for this check as the effective client token. + // + + *EffectiveToken = RestrictedAccessToken; + +#ifdef _MSC_VER +#pragma prefast( suppress: 28175, "we're a file system, this is ok to touch" ) +#endif + SeAccessCheck( DeviceObject->SecurityDescriptor, + &AccessState->SubjectSecurityContext, + FALSE, + AccessState->OriginalDesiredAccess, + 0, + NULL, + IoGetFileObjectGenericMapping(), + ProcessorMode, + &GrantedAccess, + &Status ); + + *EffectiveToken = OriginalAccessToken; + + // + // Cleanup and return. + // + + SeUnlockSubjectContext( &AccessState->SubjectSecurityContext ); + ObDereferenceObject( RestrictedAccessToken ); + + return Status; +} + + +NTSTATUS +FatCreateRestrictEveryoneToken ( + IN PACCESS_TOKEN Token, + OUT PACCESS_TOKEN *RestrictedToken + ) + +/*++ + +Routine Description: + + This function takes a token as the input and returns a new restricted token + from which Everyone sid has been disabled. The resulting token may be used + to find out if access is available to a user-sid by explicit means. + +Arguments: + + Token - Input token from which Everyone sid needs to be deactivated. + + RestrictedToken - Receives the the new restricted token. + This must be released using ObDereferenceObject(*RestrictedToken); + +Return Value: + + NTSTATUS - Returned by SeFilterToken. + +--*/ + +{ + // + // Array of sids to disable. + // + + TOKEN_GROUPS SidsToDisable; + + NTSTATUS Status = STATUS_SUCCESS; + + PAGED_CODE(); + + // + // Restricted token will contain the original sids with one change: + // If Everyone sid is present in the token, it will be marked for DenyOnly. + // + + *RestrictedToken = NULL; + + // + // Put Everyone sid in the array of sids to disable. This will mark it + // for SE_GROUP_USE_FOR_DENY_ONLY and it'll only be applicable for Deny aces. + // + + SidsToDisable.GroupCount = 1; + SidsToDisable.Groups[0].Attributes = 0; + SidsToDisable.Groups[0].Sid = SeExports->SeWorldSid; + + Status = SeFilterToken( + Token, // Token that needs to be restricted. + 0, // No flags + &SidsToDisable, // Disable everyone sid + NULL, // Do not create any restricted sids + NULL, // Do not delete any privileges + RestrictedToken // Restricted token + ); + + return Status; +} + diff --git a/drivers/filesystems/fastfat_new/allocsup.c b/drivers/filesystems/fastfat_new/allocsup.c new file mode 100644 index 0000000000..883f758d68 --- /dev/null +++ b/drivers/filesystems/fastfat_new/allocsup.c @@ -0,0 +1,5295 @@ +/*++ + +Copyright (c) 1990-2000 Microsoft Corporation + +Module Name: + + AllocSup.c + +Abstract: + + This module implements the Allocation support routines for Fat. + + +--*/ + +#include "fatprocs.h" + +// +// The Bug check file id for this module +// + +#define BugCheckFileId (FAT_BUG_CHECK_ALLOCSUP) + +// +// Local debug trace level +// + +#define Dbg (DEBUG_TRACE_ALLOCSUP) + +#define FatMin(a, b) ((a) < (b) ? (a) : (b)) + +// +// Define prefetch page count for the FAT +// + +#define FAT_PREFETCH_PAGE_COUNT 0x100 + +// +// Local support routine prototypes +// + +VOID +FatLookupFatEntry( + IN PIRP_CONTEXT IrpContext, + IN PVCB Vcb, + IN ULONG FatIndex, + IN OUT PULONG FatEntry, + IN OUT PFAT_ENUMERATION_CONTEXT Context + ); + +VOID +FatSetFatRun( + IN PIRP_CONTEXT IrpContext, + IN PVCB Vcb, + IN ULONG StartingFatIndex, + IN ULONG ClusterCount, + IN BOOLEAN ChainTogether + ); + +UCHAR +FatLogOf( + IN ULONG Value + ); + +// +// Note that the KdPrint below will ONLY fire when the assert does. Leave it +// alone. +// + +#if DBG +#define ASSERT_CURRENT_WINDOW_GOOD(VCB) { \ + ULONG FreeClusterBitMapClear; \ + NT_ASSERT( (VCB)->FreeClusterBitMap.Buffer != NULL ); \ + FreeClusterBitMapClear = RtlNumberOfClearBits(&(VCB)->FreeClusterBitMap); \ + if ((VCB)->CurrentWindow->ClustersFree != FreeClusterBitMapClear) { \ + KdPrint(("FAT: ClustersFree %x h != FreeClusterBitMapClear %x h\n", \ + (VCB)->CurrentWindow->ClustersFree, \ + FreeClusterBitMapClear)); \ + } \ + NT_ASSERT( (VCB)->CurrentWindow->ClustersFree == FreeClusterBitMapClear ); \ +} +#else +#define ASSERT_CURRENT_WINDOW_GOOD(VCB) +#endif + +// +// The following macros provide a convenient way of hiding the details +// of bitmap allocation schemes. +// + + +// +// VOID +// FatLockFreeClusterBitMap ( +// IN PVCB Vcb +// ); +// + +#define FatLockFreeClusterBitMap(VCB) { \ + NT_ASSERT(KeAreApcsDisabled()); \ + ExAcquireFastMutexUnsafe( &(VCB)->FreeClusterBitMapMutex ); \ + ASSERT_CURRENT_WINDOW_GOOD(VCB) \ +} + +// +// VOID +// FatUnlockFreeClusterBitMap ( +// IN PVCB Vcb +// ); +// + +#define FatUnlockFreeClusterBitMap(VCB) { \ + ASSERT_CURRENT_WINDOW_GOOD(VCB) \ + NT_ASSERT(KeAreApcsDisabled()); \ + ExReleaseFastMutexUnsafe( &(VCB)->FreeClusterBitMapMutex ); \ +} + +// +// BOOLEAN +// FatIsClusterFree ( +// IN PIRP_CONTEXT IrpContext, +// IN PVCB Vcb, +// IN ULONG FatIndex +// ); +// + +#define FatIsClusterFree(IRPCONTEXT,VCB,FAT_INDEX) \ + (RtlCheckBit(&(VCB)->FreeClusterBitMap,(FAT_INDEX)-2) == 0) + +// +// VOID +// FatFreeClusters ( +// IN PIRP_CONTEXT IrpContext, +// IN PVCB Vcb, +// IN ULONG FatIndex, +// IN ULONG ClusterCount +// ); +// + +#define FatFreeClusters(IRPCONTEXT,VCB,FAT_INDEX,CLUSTER_COUNT) { \ + if ((CLUSTER_COUNT) == 1) { \ + FatSetFatEntry((IRPCONTEXT),(VCB),(FAT_INDEX),FAT_CLUSTER_AVAILABLE); \ + } else { \ + FatSetFatRun((IRPCONTEXT),(VCB),(FAT_INDEX),(CLUSTER_COUNT),FALSE); \ + } \ +} + +// +// VOID +// FatAllocateClusters ( +// IN PIRP_CONTEXT IrpContext, +// IN PVCB Vcb, +// IN ULONG FatIndex, +// IN ULONG ClusterCount +// ); +// + +#define FatAllocateClusters(IRPCONTEXT,VCB,FAT_INDEX,CLUSTER_COUNT) { \ + if ((CLUSTER_COUNT) == 1) { \ + FatSetFatEntry((IRPCONTEXT),(VCB),(FAT_INDEX),FAT_CLUSTER_LAST); \ + } else { \ + FatSetFatRun((IRPCONTEXT),(VCB),(FAT_INDEX),(CLUSTER_COUNT),TRUE); \ + } \ +} + +// +// VOID +// FatUnreserveClusters ( +// IN PIRP_CONTEXT IrpContext, +// IN PVCB Vcb, +// IN ULONG FatIndex, +// IN ULONG ClusterCount +// ); +// + +#define FatUnreserveClusters(IRPCONTEXT,VCB,FAT_INDEX,CLUSTER_COUNT) { \ + NT_ASSERT( (FAT_INDEX) + (CLUSTER_COUNT) - 2 <= (VCB)->FreeClusterBitMap.SizeOfBitMap );\ + NT_ASSERT( (FAT_INDEX) >= 2); \ + RtlClearBits(&(VCB)->FreeClusterBitMap,(FAT_INDEX)-2,(CLUSTER_COUNT)); \ + if ((FAT_INDEX) < (VCB)->ClusterHint) { \ + (VCB)->ClusterHint = (FAT_INDEX); \ + } \ +} + +// +// VOID +// FatReserveClusters ( +// IN PIRP_CONTEXT IrpContext, +// IN PVCB Vcb, +// IN ULONG FatIndex, +// IN ULONG ClusterCount +// ); +// +// Handle wrapping the hint back to the front. +// + +#define FatReserveClusters(IRPCONTEXT,VCB,FAT_INDEX,CLUSTER_COUNT) { \ + ULONG _AfterRun = (FAT_INDEX) + (CLUSTER_COUNT); \ + NT_ASSERT( (FAT_INDEX) + (CLUSTER_COUNT) - 2 <= (VCB)->FreeClusterBitMap.SizeOfBitMap );\ + NT_ASSERT( (FAT_INDEX) >= 2); \ + RtlSetBits(&(VCB)->FreeClusterBitMap,(FAT_INDEX)-2,(CLUSTER_COUNT)); \ + \ + if (_AfterRun - 2 >= (VCB)->FreeClusterBitMap.SizeOfBitMap) { \ + _AfterRun = 2; \ + } \ + if (RtlCheckBit(&(VCB)->FreeClusterBitMap, _AfterRun - 2)) { \ + (VCB)->ClusterHint = RtlFindClearBits( &(VCB)->FreeClusterBitMap, 1, _AfterRun - 2) + 2; \ + if (1 == (VCB)->ClusterHint) { \ + (VCB)->ClusterHint = 2; \ + } \ + } \ + else { \ + (VCB)->ClusterHint = _AfterRun; \ + } \ +} + +// +// ULONG +// FatFindFreeClusterRun ( +// IN PIRP_CONTEXT IrpContext, +// IN PVCB Vcb, +// IN ULONG ClusterCount, +// IN ULONG AlternateClusterHint +// ); +// +// Do a special check if only one cluster is desired. +// + +#define FatFindFreeClusterRun(IRPCONTEXT,VCB,CLUSTER_COUNT,CLUSTER_HINT) ( \ + (CLUSTER_COUNT == 1) && \ + FatIsClusterFree((IRPCONTEXT), (VCB), (CLUSTER_HINT)) ? \ + (CLUSTER_HINT) : \ + RtlFindClearBits( &(VCB)->FreeClusterBitMap, \ + (CLUSTER_COUNT), \ + (CLUSTER_HINT) - 2) + 2 \ +) + +// +// FAT32: Define the maximum size of the FreeClusterBitMap to be the +// maximum size of a FAT16 FAT. If there are more clusters on the +// volume than can be represented by this many bytes of bitmap, the +// FAT will be split into "buckets", each of which does fit. +// +// Note this count is in clusters/bits of bitmap. +// + +#define MAX_CLUSTER_BITMAP_SIZE (1 << 16) + +// +// Calculate the window a given cluster number is in. +// + +#define FatWindowOfCluster(C) (((C) - 2) / MAX_CLUSTER_BITMAP_SIZE) + +#ifdef ALLOC_PRAGMA +#pragma alloc_text(PAGE, FatAddFileAllocation) +#pragma alloc_text(PAGE, FatAllocateDiskSpace) +#pragma alloc_text(PAGE, FatDeallocateDiskSpace) +#pragma alloc_text(PAGE, FatExamineFatEntries) +#pragma alloc_text(PAGE, FatInterpretClusterType) +#pragma alloc_text(PAGE, FatLogOf) +#pragma alloc_text(PAGE, FatLookupFatEntry) +#pragma alloc_text(PAGE, FatLookupFileAllocation) +#pragma alloc_text(PAGE, FatLookupFileAllocationSize) +#pragma alloc_text(PAGE, FatMergeAllocation) +#pragma alloc_text(PAGE, FatSetFatEntry) +#pragma alloc_text(PAGE, FatSetFatRun) +#pragma alloc_text(PAGE, FatSetupAllocationSupport) +#pragma alloc_text(PAGE, FatSplitAllocation) +#pragma alloc_text(PAGE, FatTearDownAllocationSupport) +#pragma alloc_text(PAGE, FatTruncateFileAllocation) +#endif + + +INLINE +ULONG +FatSelectBestWindow( + IN PVCB Vcb + ) +/*++ + +Routine Description: + + Choose a window to allocate clusters from. Order of preference is: + + 1. First window with >50% free clusters + 2. First empty window + 3. Window with greatest number of free clusters. + +Arguments: + + Vcb - Supplies the Vcb for the volume + +Return Value: + + 'Best window' number (index into Vcb->Windows[]) + +--*/ +{ + ULONG i, Fave = 0; + ULONG MaxFree = 0; + ULONG FirstEmpty = (ULONG)-1; + ULONG ClustersPerWindow = MAX_CLUSTER_BITMAP_SIZE; + + NT_ASSERT( 1 != Vcb->NumberOfWindows); + + for (i = 0; i < Vcb->NumberOfWindows; i++) { + + if (Vcb->Windows[i].ClustersFree == ClustersPerWindow) { + + if (-1 == FirstEmpty) { + + // + // Keep note of the first empty window on the disc + // + + FirstEmpty = i; + } + } + else if (Vcb->Windows[i].ClustersFree > MaxFree) { + + // + // This window has the most free clusters, so far + // + + MaxFree = Vcb->Windows[i].ClustersFree; + Fave = i; + + // + // If this window has >50% free clusters, then we will take it, + // so don't bother considering more windows. + // + + if (MaxFree >= (ClustersPerWindow >> 1)) { + + break; + } + } + } + + // + // If there were no windows with 50% or more freespace, then select the + // first empty window on the disc, if any - otherwise we'll just go with + // the one with the most free clusters. + // + + if ((MaxFree < (ClustersPerWindow >> 1)) && (-1 != FirstEmpty)) { + + Fave = FirstEmpty; + } + + return Fave; +} + + +VOID +FatSetupAllocationSupport ( + IN PIRP_CONTEXT IrpContext, + IN PVCB Vcb + ) + +/*++ + +Routine Description: + + This routine fills in the Allocation Support structure in the Vcb. + Most entries are computed using fat.h macros supplied with data from + the Bios Parameter Block. The free cluster count, however, requires + going to the Fat and actually counting free sectors. At the same time + the free cluster bit map is initalized. + +Arguments: + + Vcb - Supplies the Vcb to fill in. + +--*/ + +{ + ULONG BitIndex; + ULONG ClustersDescribableByFat; + + PAGED_CODE(); + + DebugTrace(+1, Dbg, "FatSetupAllocationSupport\n", 0); + DebugTrace( 0, Dbg, " Vcb = %p\n", Vcb); + + // + // Compute a number of fields for Vcb.AllocationSupport + // + + Vcb->AllocationSupport.RootDirectoryLbo = FatRootDirectoryLbo( &Vcb->Bpb ); + Vcb->AllocationSupport.RootDirectorySize = FatRootDirectorySize( &Vcb->Bpb ); + + Vcb->AllocationSupport.FileAreaLbo = FatFileAreaLbo( &Vcb->Bpb ); + + Vcb->AllocationSupport.NumberOfClusters = FatNumberOfClusters( &Vcb->Bpb ); + + Vcb->AllocationSupport.FatIndexBitSize = FatIndexBitSize( &Vcb->Bpb ); + + Vcb->AllocationSupport.LogOfBytesPerSector = FatLogOf(Vcb->Bpb.BytesPerSector); + Vcb->AllocationSupport.LogOfBytesPerCluster = FatLogOf(FatBytesPerCluster( &Vcb->Bpb )); + Vcb->AllocationSupport.NumberOfFreeClusters = 0; + + + // + // Deal with a bug in DOS 5 format, if the Fat is not big enough to + // describe all the clusters on the disk, reduce this number. We expect + // that fat32 volumes will not have this problem. + // + // Turns out this was not a good assumption. We have to do this always now. + // + + ClustersDescribableByFat = ( ((FatIsFat32(Vcb)? Vcb->Bpb.LargeSectorsPerFat : + Vcb->Bpb.SectorsPerFat) * + Vcb->Bpb.BytesPerSector * 8) + / FatIndexBitSize(&Vcb->Bpb) ) - 2; + + if (Vcb->AllocationSupport.NumberOfClusters > ClustersDescribableByFat) { + + Vcb->AllocationSupport.NumberOfClusters = ClustersDescribableByFat; + } + + // + // Extend the virtual volume file to include the Fat + // + + { + CC_FILE_SIZES FileSizes; + + FileSizes.AllocationSize.QuadPart = + FileSizes.FileSize.QuadPart = (FatReservedBytes( &Vcb->Bpb ) + + FatBytesPerFat( &Vcb->Bpb )); + FileSizes.ValidDataLength = FatMaxLarge; + + if ( Vcb->VirtualVolumeFile->PrivateCacheMap == NULL ) { + + FatInitializeCacheMap( Vcb->VirtualVolumeFile, + &FileSizes, + TRUE, + &FatData.CacheManagerNoOpCallbacks, + Vcb ); + + } else { + + CcSetFileSizes( Vcb->VirtualVolumeFile, &FileSizes ); + } + } + + _SEH2_TRY { + + if (FatIsFat32(Vcb) && + Vcb->AllocationSupport.NumberOfClusters > MAX_CLUSTER_BITMAP_SIZE) { + + Vcb->NumberOfWindows = (Vcb->AllocationSupport.NumberOfClusters + + MAX_CLUSTER_BITMAP_SIZE - 1) / + MAX_CLUSTER_BITMAP_SIZE; + + } else { + + Vcb->NumberOfWindows = 1; + } + + Vcb->Windows = FsRtlAllocatePoolWithTag( PagedPool, + Vcb->NumberOfWindows * sizeof(FAT_WINDOW), + TAG_FAT_WINDOW ); + + RtlInitializeBitMap( &Vcb->FreeClusterBitMap, + NULL, + 0 ); + + // + // Chose a FAT window to begin operation in. + // + + if (Vcb->NumberOfWindows > 1) { + + // + // Read the fat and count up free clusters. We bias by the two reserved + // entries in the FAT. + // + + FatExamineFatEntries( IrpContext, Vcb, + 2, + Vcb->AllocationSupport.NumberOfClusters + 2 - 1, + TRUE, + NULL, + NULL); + + + // + // Pick a window to begin allocating from + // + + Vcb->CurrentWindow = &Vcb->Windows[ FatSelectBestWindow( Vcb)]; + + } else { + + Vcb->CurrentWindow = &Vcb->Windows[0]; + + // + // Carefully bias ourselves by the two reserved entries in the FAT. + // + + Vcb->CurrentWindow->FirstCluster = 2; + Vcb->CurrentWindow->LastCluster = Vcb->AllocationSupport.NumberOfClusters + 2 - 1; + } + + // + // Now transition to the FAT window we have chosen. + // + + FatExamineFatEntries( IrpContext, Vcb, + 0, + 0, + FALSE, + Vcb->CurrentWindow, + NULL); + + // + // Now set the ClusterHint to the first free bit in our favorite + // window (except the ClusterHint is off by two). + // + + Vcb->ClusterHint = + (BitIndex = RtlFindClearBits( &Vcb->FreeClusterBitMap, 1, 0 )) != -1 ? + BitIndex + 2 : 2; + + } _SEH2_FINALLY { + + DebugUnwind( FatSetupAllocationSupport ); + + // + // If we hit an exception, back out. + // + + if (_SEH2_AbnormalTermination()) { + + FatTearDownAllocationSupport( IrpContext, Vcb ); + } + } _SEH2_END; + + return; +} + + +VOID +FatTearDownAllocationSupport ( + IN PIRP_CONTEXT IrpContext, + IN PVCB Vcb + ) + +/*++ + +Routine Description: + + This routine prepares the volume for closing. Specifically, we must + release the free fat bit map buffer, and uninitialize the dirty fat + Mcb. + +Arguments: + + Vcb - Supplies the Vcb to fill in. + +Return Value: + + VOID + +--*/ + +{ + DebugTrace(+1, Dbg, "FatTearDownAllocationSupport\n", 0); + DebugTrace( 0, Dbg, " Vcb = %p\n", Vcb); + + PAGED_CODE(); + + // + // If there are FAT buckets, free them. + // + + if ( Vcb->Windows != NULL ) { + + ExFreePool( Vcb->Windows ); + Vcb->Windows = NULL; + } + + // + // Free the memory associated with the free cluster bitmap. + // + + if ( Vcb->FreeClusterBitMap.Buffer != NULL ) { + + ExFreePool( Vcb->FreeClusterBitMap.Buffer ); + + // + // NULL this field as an flag. + // + + Vcb->FreeClusterBitMap.Buffer = NULL; + } + + // + // And remove all the runs in the dirty fat Mcb + // + + FatRemoveMcbEntry( Vcb, &Vcb->DirtyFatMcb, 0, 0xFFFFFFFF ); + + DebugTrace(-1, Dbg, "FatTearDownAllocationSupport -> (VOID)\n", 0); + + UNREFERENCED_PARAMETER( IrpContext ); + + return; +} + + +_Requires_lock_held_(_Global_critical_region_) +VOID +FatLookupFileAllocation ( + IN PIRP_CONTEXT IrpContext, + IN PFCB FcbOrDcb, + IN VBO Vbo, + OUT PLBO Lbo, + OUT PULONG ByteCount, + OUT PBOOLEAN Allocated, + OUT PBOOLEAN EndOnMax, + OUT PULONG Index + ) + +/*++ + +Routine Description: + + This routine looks up the existing mapping of VBO to LBO for a + file/directory. The information it queries is either stored in the + mcb field of the fcb/dcb or it is stored on in the fat table and + needs to be retrieved and decoded, and updated in the mcb. + +Arguments: + + FcbOrDcb - Supplies the Fcb/Dcb of the file/directory being queried + + Vbo - Supplies the VBO whose LBO we want returned + + Lbo - Receives the LBO corresponding to the input Vbo if one exists + + ByteCount - Receives the number of bytes within the run the run + that correpond between the input vbo and output lbo. + + Allocated - Receives TRUE if the Vbo does have a corresponding Lbo + and FALSE otherwise. + + EndOnMax - Receives TRUE if the run ends in the maximal FAT cluster, + which results in a fractional bytecount. + + Index - Receives the Index of the run + +--*/ + +{ + VBO CurrentVbo; + LBO CurrentLbo; + LBO PriorLbo; + + VBO FirstVboOfCurrentRun = 0; + LBO FirstLboOfCurrentRun; + + BOOLEAN LastCluster; + ULONG Runs; + + PVCB Vcb; + FAT_ENTRY FatEntry; + ULONG BytesPerCluster; + ULARGE_INTEGER BytesOnVolume; + + FAT_ENUMERATION_CONTEXT Context; + + PAGED_CODE(); + + Vcb = FcbOrDcb->Vcb; + + + DebugTrace(+1, Dbg, "FatLookupFileAllocation\n", 0); + DebugTrace( 0, Dbg, " FcbOrDcb = %p\n", FcbOrDcb); + DebugTrace( 0, Dbg, " Vbo = %8lx\n", Vbo); + DebugTrace( 0, Dbg, " pLbo = %8lx\n", Lbo); + DebugTrace( 0, Dbg, " pByteCount = %8lx\n", ByteCount); + DebugTrace( 0, Dbg, " pAllocated = %8lx\n", Allocated); + + Context.Bcb = NULL; + + *EndOnMax = FALSE; + + // + // Check the trivial case that the mapping is already in our + // Mcb. + // + + if ( FatLookupMcbEntry(Vcb, &FcbOrDcb->Mcb, Vbo, Lbo, ByteCount, Index) ) { + + *Allocated = TRUE; + + NT_ASSERT( *ByteCount != 0 ); + + // + // Detect the overflow case, trim and claim the condition. + // + + if (Vbo + *ByteCount == 0) { + + *EndOnMax = TRUE; + } + + DebugTrace( 0, Dbg, "Found run in Mcb.\n", 0); + DebugTrace(-1, Dbg, "FatLookupFileAllocation -> (VOID)\n", 0); + return; + } + + // + // Initialize the Vcb, the cluster size, LastCluster, and + // FirstLboOfCurrentRun (to be used as an indication of the first + // iteration through the following while loop). + // + + BytesPerCluster = 1 << Vcb->AllocationSupport.LogOfBytesPerCluster; + + BytesOnVolume.QuadPart = UInt32x32To64( Vcb->AllocationSupport.NumberOfClusters, BytesPerCluster ); + + LastCluster = FALSE; + FirstLboOfCurrentRun = 0; + + // + // Discard the case that the request extends beyond the end of + // allocation. Note that if the allocation size if not known + // AllocationSize is set to 0xffffffff. + // + + if ( Vbo >= FcbOrDcb->Header.AllocationSize.LowPart ) { + + *Allocated = FALSE; + + DebugTrace( 0, Dbg, "Vbo beyond end of file.\n", 0); + DebugTrace(-1, Dbg, "FatLookupFileAllocation -> (VOID)\n", 0); + return; + } + + // + // The Vbo is beyond the last Mcb entry. So we adjust Current Vbo/Lbo + // and FatEntry to describe the beginning of the last entry in the Mcb. + // This is used as initialization for the following loop. + // + // If the Mcb was empty, we start at the beginning of the file with + // CurrentVbo set to 0 to indicate a new run. + // + + if (FatLookupLastMcbEntry( Vcb, &FcbOrDcb->Mcb, &CurrentVbo, &CurrentLbo, &Runs )) { + + DebugTrace( 0, Dbg, "Current Mcb size = %8lx.\n", CurrentVbo + 1); + + CurrentVbo -= (BytesPerCluster - 1); + CurrentLbo -= (BytesPerCluster - 1); + + // + // Convert an index to a count. + // + + Runs += 1; + + } else { + + DebugTrace( 0, Dbg, "Mcb empty.\n", 0); + + // + // Check for an FcbOrDcb that has no allocation + // + + if (FcbOrDcb->FirstClusterOfFile == 0) { + + *Allocated = FALSE; + + DebugTrace( 0, Dbg, "File has no allocation.\n", 0); + DebugTrace(-1, Dbg, "FatLookupFileAllocation -> (VOID)\n", 0); + return; + + } else { + + CurrentVbo = 0; + CurrentLbo = FatGetLboFromIndex( Vcb, FcbOrDcb->FirstClusterOfFile ); + FirstVboOfCurrentRun = CurrentVbo; + FirstLboOfCurrentRun = CurrentLbo; + + Runs = 0; + + DebugTrace( 0, Dbg, "First Lbo of file = %8lx\n", CurrentLbo); + } + } + + // + // Now we know that we are looking up a valid Vbo, but it is + // not in the Mcb, which is a monotonically increasing list of + // Vbo's. Thus we have to go to the Fat, and update + // the Mcb as we go. We use a try-finally to unpin the page + // of fat hanging around. Also we mark *Allocated = FALSE, so that + // the caller wont try to use the data if we hit an exception. + // + + *Allocated = FALSE; + + _SEH2_TRY { + + FatEntry = (FAT_ENTRY)FatGetIndexFromLbo( Vcb, CurrentLbo ); + + // + // ASSERT that CurrentVbo and CurrentLbo are now cluster alligned. + // The assumption here, is that only whole clusters of Vbos and Lbos + // are mapped in the Mcb. + // + + NT_ASSERT( ((CurrentLbo - Vcb->AllocationSupport.FileAreaLbo) + % BytesPerCluster == 0) && + (CurrentVbo % BytesPerCluster == 0) ); + + // + // Starting from the first Vbo after the last Mcb entry, scan through + // the Fat looking for our Vbo. We continue through the Fat until we + // hit a noncontiguity beyond the desired Vbo, or the last cluster. + // + + while ( !LastCluster ) { + + // + // Get the next fat entry, and update our Current variables. + // + + FatLookupFatEntry( IrpContext, Vcb, FatEntry, (PULONG)&FatEntry, &Context ); + + PriorLbo = CurrentLbo; + CurrentLbo = FatGetLboFromIndex( Vcb, FatEntry ); + CurrentVbo += BytesPerCluster; + + switch ( FatInterpretClusterType( Vcb, FatEntry )) { + + // + // Check for a break in the Fat allocation chain. + // + + case FatClusterAvailable: + case FatClusterReserved: + case FatClusterBad: + + DebugTrace( 0, Dbg, "Break in allocation chain, entry = %d\n", FatEntry); + DebugTrace(-1, Dbg, "FatLookupFileAllocation -> Fat Corrupt. Raise Status.\n", 0); + + FatPopUpFileCorrupt( IrpContext, FcbOrDcb ); + FatRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR ); + break; + + // + // If this is the last cluster, we must update the Mcb and + // exit the loop. + // + + case FatClusterLast: + + // + // Assert we know where the current run started. If the + // Mcb was empty when we were called, thenFirstLboOfCurrentRun + // was set to the start of the file. If the Mcb contained an + // entry, then FirstLboOfCurrentRun was set on the first + // iteration through the loop. Thus if FirstLboOfCurrentRun + // is 0, then there was an Mcb entry and we are on our first + // iteration, meaing that the last cluster in the Mcb was + // really the last allocated cluster, but we checked Vbo + // against AllocationSize, and found it OK, thus AllocationSize + // must be too large. + // + // Note that, when we finally arrive here, CurrentVbo is actually + // the first Vbo beyond the file allocation and CurrentLbo is + // meaningless. + // + + DebugTrace( 0, Dbg, "Read last cluster of file.\n", 0); + + // + // Detect the case of the maximal file. Note that this really isn't + // a proper Vbo - those are zero-based, and this is a one-based number. + // The maximal file, of 2^32 - 1 bytes, has a maximum byte offset of + // 2^32 - 2. + // + // Just so we don't get confused here. + // + + if (CurrentVbo == 0) { + + *EndOnMax = TRUE; + CurrentVbo -= 1; + } + + LastCluster = TRUE; + + if (FirstLboOfCurrentRun != 0 ) { + + DebugTrace( 0, Dbg, "Adding a run to the Mcb.\n", 0); + DebugTrace( 0, Dbg, " Vbo = %08lx.\n", FirstVboOfCurrentRun); + DebugTrace( 0, Dbg, " Lbo = %08lx.\n", FirstLboOfCurrentRun); + DebugTrace( 0, Dbg, " Length = %08lx.\n", CurrentVbo - FirstVboOfCurrentRun); + + (VOID)FatAddMcbEntry( Vcb, + &FcbOrDcb->Mcb, + FirstVboOfCurrentRun, + FirstLboOfCurrentRun, + CurrentVbo - FirstVboOfCurrentRun ); + + Runs += 1; + } + + // + // Being at the end of allocation, make sure we have found + // the Vbo. If we haven't, seeing as we checked VBO + // against AllocationSize, the real disk allocation is less + // than that of AllocationSize. This comes about when the + // real allocation is not yet known, and AllocaitonSize + // contains MAXULONG. + // + // KLUDGE! - If we were called by FatLookupFileAllocationSize + // Vbo is set to MAXULONG - 1, and AllocationSize to the lookup + // hint. Thus we merrily go along looking for a match that isn't + // there, but in the meantime building an Mcb. If this is + // the case, fill in AllocationSize and return. + // + + if ( Vbo == MAXULONG - 1 ) { + + *Allocated = FALSE; + + FcbOrDcb->Header.AllocationSize.QuadPart = CurrentVbo; + + DebugTrace( 0, Dbg, "New file allocation size = %08lx.\n", CurrentVbo); + try_return ( NOTHING ); + } + + // + // We will lie ever so slightly if we really terminated on the + // maximal byte of a file. It is really allocated. + // + + if (Vbo >= CurrentVbo && !*EndOnMax) { + + *Allocated = FALSE; + try_return ( NOTHING ); + } + + break; + + // + // This is a continuation in the chain. If the run has a + // discontiguity at this point, update the Mcb, and if we are beyond + // the desired Vbo, this is the end of the run, so set LastCluster + // and exit the loop. + // + + case FatClusterNext: + + // + // This is the loop check. The Vbo must not be bigger than the size of + // the volume, and the Vbo must not have a) wrapped and b) not been at the + // very last cluster in the chain, for the case of the maximal file. + // + + if ( CurrentVbo == 0 || + (BytesOnVolume.HighPart == 0 && CurrentVbo > BytesOnVolume.LowPart)) { + + FatPopUpFileCorrupt( IrpContext, FcbOrDcb ); + FatRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR ); + } + + if ( PriorLbo + BytesPerCluster != CurrentLbo ) { + + // + // Note that on the first time through the loop + // (FirstLboOfCurrentRun == 0), we don't add the + // run to the Mcb since it curresponds to the last + // run already stored in the Mcb. + // + + if ( FirstLboOfCurrentRun != 0 ) { + + DebugTrace( 0, Dbg, "Adding a run to the Mcb.\n", 0); + DebugTrace( 0, Dbg, " Vbo = %08lx.\n", FirstVboOfCurrentRun); + DebugTrace( 0, Dbg, " Lbo = %08lx.\n", FirstLboOfCurrentRun); + DebugTrace( 0, Dbg, " Length = %08lx.\n", CurrentVbo - FirstVboOfCurrentRun); + + FatAddMcbEntry( Vcb, + &FcbOrDcb->Mcb, + FirstVboOfCurrentRun, + FirstLboOfCurrentRun, + CurrentVbo - FirstVboOfCurrentRun ); + + Runs += 1; + } + + // + // Since we are at a run boundry, with CurrentLbo and + // CurrentVbo being the first cluster of the next run, + // we see if the run we just added encompases the desired + // Vbo, and if so exit. Otherwise we set up two new + // First*boOfCurrentRun, and continue. + // + + if (CurrentVbo > Vbo) { + + LastCluster = TRUE; + + } else { + + FirstVboOfCurrentRun = CurrentVbo; + FirstLboOfCurrentRun = CurrentLbo; + } + } + break; + + default: + + DebugTrace(0, Dbg, "Illegal Cluster Type.\n", FatEntry); + +#ifdef _MSC_VER +#pragma prefast( suppress: 28159, "we bugcheck here because our internal data structures are seriously corrupted if this happens" ) +#endif + FatBugCheck( 0, 0, 0 ); + + break; + + } // switch() + } // while() + + // + // Load up the return parameters. + // + // On exit from the loop, Vbo still contains the desired Vbo, and + // CurrentVbo is the first byte after the run that contained the + // desired Vbo. + // + + *Allocated = TRUE; + + *Lbo = FirstLboOfCurrentRun + (Vbo - FirstVboOfCurrentRun); + + *ByteCount = CurrentVbo - Vbo; + + if (ARGUMENT_PRESENT(Index)) { + + // + // Note that Runs only needs to be accurate with respect to where we + // ended. Since partial-lookup cases will occur without exclusive + // synchronization, the Mcb itself may be much bigger by now. + // + + *Index = Runs - 1; + } + + try_exit: NOTHING; + + } _SEH2_FINALLY { + + DebugUnwind( FatLookupFileAllocation ); + + // + // We are done reading the Fat, so unpin the last page of fat + // that is hanging around + // + + FatUnpinBcb( IrpContext, Context.Bcb ); + + DebugTrace(-1, Dbg, "FatLookupFileAllocation -> (VOID)\n", 0); + } _SEH2_END; + + return; +} + + +_Requires_lock_held_(_Global_critical_region_) +VOID +FatAddFileAllocation ( + IN PIRP_CONTEXT IrpContext, + IN PFCB FcbOrDcb, + IN PFILE_OBJECT FileObject OPTIONAL, + IN ULONG DesiredAllocationSize + ) + +/*++ + +Routine Description: + + This routine adds additional allocation to the specified file/directory. + Additional allocation is added by appending clusters to the file/directory. + + If the file already has a sufficient allocation then this procedure + is effectively a noop. + +Arguments: + + FcbOrDcb - Supplies the Fcb/Dcb of the file/directory being modified. + This parameter must not specify the root dcb. + + FileObject - If supplied inform the cache manager of the change. + + DesiredAllocationSize - Supplies the minimum size, in bytes, that we want + allocated to the file/directory. + +--*/ + +{ + PVCB Vcb; + LARGE_MCB NewMcb = {0}; + PLARGE_MCB McbToCleanup = NULL; + PDIRENT Dirent = NULL; + ULONG NewAllocation = 0; + PBCB Bcb = NULL; + BOOLEAN UnwindWeAllocatedDiskSpace = FALSE; + BOOLEAN UnwindAllocationSizeSet = FALSE; + BOOLEAN UnwindCacheManagerInformed = FALSE; + BOOLEAN UnwindWeInitializedMcb = FALSE; + + PAGED_CODE(); + + DebugTrace(+1, Dbg, "FatAddFileAllocation\n", 0); + DebugTrace( 0, Dbg, " FcbOrDcb = %p\n", FcbOrDcb); + DebugTrace( 0, Dbg, " DesiredAllocationSize = %8lx\n", DesiredAllocationSize); + + Vcb = FcbOrDcb->Vcb; + + // + // If we haven't yet set the correct AllocationSize, do so. + // + + if (FcbOrDcb->Header.AllocationSize.QuadPart == FCB_LOOKUP_ALLOCATIONSIZE_HINT) { + + FatLookupFileAllocationSize( IrpContext, FcbOrDcb ); + } + + // + // Check for the benign case that the desired allocation is already + // within the allocation size. + // + + if (DesiredAllocationSize <= FcbOrDcb->Header.AllocationSize.LowPart) { + + DebugTrace(0, Dbg, "Desired size within current allocation.\n", 0); + + DebugTrace(-1, Dbg, "FatAddFileAllocation -> (VOID)\n", 0); + return; + } + + DebugTrace( 0, Dbg, "InitialAllocation = %08lx.\n", FcbOrDcb->Header.AllocationSize.LowPart); + + // + // Get a chunk of disk space that will fullfill our needs. If there + // was no initial allocation, start from the hint in the Vcb, otherwise + // try to allocate from the cluster after the initial allocation. + // + // If there was no initial allocation to the file, we can just use the + // Mcb in the FcbOrDcb, otherwise we have to use a new one, and merge + // it to the one in the FcbOrDcb. + // + + _SEH2_TRY { + + if (FcbOrDcb->Header.AllocationSize.LowPart == 0) { + + LBO FirstLboOfFile; + + NT_ASSERT( FcbOrDcb->FcbCondition == FcbGood ); + + FatGetDirentFromFcbOrDcb( IrpContext, + FcbOrDcb, + FALSE, + &Dirent, + &Bcb ); + // + // Set this dirty right now since this call can fail. + // + + FatSetDirtyBcb( IrpContext, Bcb, Vcb, TRUE ); + + FatAllocateDiskSpace( IrpContext, + Vcb, + 0, + &DesiredAllocationSize, + FALSE, + &FcbOrDcb->Mcb ); + + UnwindWeAllocatedDiskSpace = TRUE; + McbToCleanup = &FcbOrDcb->Mcb; + + // + // We have to update the dirent and FcbOrDcb copies of + // FirstClusterOfFile since before it was 0 + // + + FatLookupMcbEntry( FcbOrDcb->Vcb, + &FcbOrDcb->Mcb, + 0, + &FirstLboOfFile, + (PULONG)NULL, + NULL ); + + DebugTrace( 0, Dbg, "First Lbo of file will be %08lx.\n", FirstLboOfFile ); + + FcbOrDcb->FirstClusterOfFile = FatGetIndexFromLbo( Vcb, FirstLboOfFile ); + + Dirent->FirstClusterOfFile = (USHORT)FcbOrDcb->FirstClusterOfFile; + + if ( FatIsFat32(Vcb) ) { + + Dirent->FirstClusterOfFileHi = (USHORT)(FcbOrDcb->FirstClusterOfFile >> 16); + } + + // + // Note the size of the allocation we need to tell the cache manager about. + // + + NewAllocation = DesiredAllocationSize; + + } else { + + LBO LastAllocatedLbo; + VBO DontCare; + + // + // Get the first cluster following the current allocation. It is possible + // the Mcb is empty (or short, etc.) so we need to be slightly careful + // about making sure we don't lie with the hint. + // + + (void)FatLookupLastMcbEntry( FcbOrDcb->Vcb, &FcbOrDcb->Mcb, &DontCare, &LastAllocatedLbo, NULL ); + + // + // Try to get some disk space starting from there. + // + + NewAllocation = DesiredAllocationSize - FcbOrDcb->Header.AllocationSize.LowPart; + + FsRtlInitializeLargeMcb( &NewMcb, PagedPool ); + UnwindWeInitializedMcb = TRUE; + McbToCleanup = &NewMcb; + + FatAllocateDiskSpace( IrpContext, + Vcb, + (LastAllocatedLbo != ~0 ? + FatGetIndexFromLbo(Vcb,LastAllocatedLbo + 1) : + 0), + &NewAllocation, + FALSE, + &NewMcb ); + + UnwindWeAllocatedDiskSpace = TRUE; + } + + // + // Now that we increased the allocation of the file, mark it in the + // FcbOrDcb. Carefully prepare to handle an inability to grow the cache + // structures. + // + + FcbOrDcb->Header.AllocationSize.LowPart += NewAllocation; + + // + // Handle the maximal file case, where we may have just wrapped. Note + // that this must be the precise boundary case wrap, i.e. by one byte, + // so that the new allocation is actually one byte "less" as far as we're + // concerned. This is important for the extension case. + // + + if (FcbOrDcb->Header.AllocationSize.LowPart == 0) { + + NewAllocation -= 1; + FcbOrDcb->Header.AllocationSize.LowPart = 0xffffffff; + } + + UnwindAllocationSizeSet = TRUE; + + // + // Inform the cache manager to increase the section size + // + + if ( ARGUMENT_PRESENT(FileObject) && CcIsFileCached(FileObject) ) { + + CcSetFileSizes( FileObject, + (PCC_FILE_SIZES)&FcbOrDcb->Header.AllocationSize ); + UnwindCacheManagerInformed = TRUE; + } + + // + // In the extension case, we have held off actually gluing the new + // allocation onto the file. This simplifies exception cleanup since + // if it was already added and the section grow failed, we'd have to + // do extra work to unglue it. This way, we can assume that if we + // raise the only thing we need to do is deallocate the disk space. + // + // Merge the allocation now. + // + + if (FcbOrDcb->Header.AllocationSize.LowPart != NewAllocation) { + + // + // Tack the new Mcb onto the end of the FcbOrDcb one. + // + + FatMergeAllocation( IrpContext, + Vcb, + &FcbOrDcb->Mcb, + &NewMcb ); + } + + } _SEH2_FINALLY { + + DebugUnwind( FatAddFileAllocation ); + + // + // Give FlushFileBuffer/Cleanup a clue here, regardless of success/fail.. + // + + SetFlag(FcbOrDcb->FcbState, FCB_STATE_FLUSH_FAT); + + // + // If we were dogged trying to complete this operation, we need to go + // back various things out. + // + + if (_SEH2_AbnormalTermination()) { + + // + // Pull off the allocation size we tried to add to this object if + // we failed to grow cache structures or Mcb structures. + // + + if (UnwindAllocationSizeSet) { + + FcbOrDcb->Header.AllocationSize.LowPart -= NewAllocation; + } + + if (UnwindCacheManagerInformed) { + + CcSetFileSizes( FileObject, + (PCC_FILE_SIZES)&FcbOrDcb->Header.AllocationSize ); + } + + // + // In the case of initial allocation, we used the Fcb's Mcb and have + // to clean that up as well as the FAT chain references. + // + + if (FcbOrDcb->Header.AllocationSize.LowPart == 0) { + + if (Dirent != NULL) { + + FcbOrDcb->FirstClusterOfFile = 0; + Dirent->FirstClusterOfFile = 0; + + if ( FatIsFat32(Vcb) ) { + + Dirent->FirstClusterOfFileHi = 0; + } + } + } + + // + // ... and drop the dirent Bcb if we got it. Do it now + // so we can afford to take the exception if we have to. + // + + FatUnpinBcb( IrpContext, Bcb ); + + _SEH2_TRY { + + // + // Note this can re-raise. + // + + if ( UnwindWeAllocatedDiskSpace ) { + + FatDeallocateDiskSpace( IrpContext, Vcb, McbToCleanup, FALSE ); + } + + } _SEH2_FINALLY { + + // + // We always want to clean up the non-initial allocation temporary Mcb, + // otherwise we have the Fcb's Mcb and we just truncate it away. + // + + if (UnwindWeInitializedMcb == TRUE) { + + // + // Note that we already know a raise is in progress. No danger + // of encountering the normal case code below and doing this again. + // + + FsRtlUninitializeLargeMcb( McbToCleanup ); + + } else { + + if (McbToCleanup) { + + FsRtlTruncateLargeMcb( McbToCleanup, 0 ); + } + } + } _SEH2_END; + } + + DebugTrace(-1, Dbg, "FatAddFileAllocation -> (VOID)\n", 0); + } _SEH2_END; + + // + // Non-exceptional cleanup we always want to do. In handling the re-raise possibilities + // during exceptions we had to make sure these two steps always happened there beforehand. + // So now we handle the usual case. + // + + FatUnpinBcb( IrpContext, Bcb ); + + if (UnwindWeInitializedMcb == TRUE) { + + FsRtlUninitializeLargeMcb( &NewMcb ); + } +} + +_Requires_lock_held_(_Global_critical_region_) +VOID +FatTruncateFileAllocation ( + IN PIRP_CONTEXT IrpContext, + IN PFCB FcbOrDcb, + IN ULONG DesiredAllocationSize + ) + +/*++ + +Routine Description: + + This routine truncates the allocation to the specified file/directory. + + If the file is already smaller than the indicated size then this procedure + is effectively a noop. + + +Arguments: + + FcbOrDcb - Supplies the Fcb/Dcb of the file/directory being modified + This parameter must not specify the root dcb. + + DesiredAllocationSize - Supplies the maximum size, in bytes, that we want + allocated to the file/directory. It is rounded + up to the nearest cluster. + +Return Value: + + VOID - TRUE if the operation completed and FALSE if it had to + block but could not. + +--*/ + +{ + PVCB Vcb; + PBCB Bcb = NULL; + LARGE_MCB RemainingMcb = {0}; + ULONG BytesPerCluster; + PDIRENT Dirent = NULL; + BOOLEAN UpdatedDirent = FALSE; + + ULONG UnwindInitialAllocationSize; + ULONG UnwindInitialFirstClusterOfFile; + BOOLEAN UnwindWeAllocatedMcb = FALSE; + + PAGED_CODE(); + + Vcb = FcbOrDcb->Vcb; + + DebugTrace(+1, Dbg, "FatTruncateFileAllocation\n", 0); + DebugTrace( 0, Dbg, " FcbOrDcb = %p\n", FcbOrDcb); + DebugTrace( 0, Dbg, " DesiredAllocationSize = %8lx\n", DesiredAllocationSize); + + // + // If the Fcb isn't in good condition, we have no business whacking around on + // the disk after "its" clusters. + // + // Inspired by a Prefix complaint. + // + + NT_ASSERT( FcbOrDcb->FcbCondition == FcbGood ); + + // + // If we haven't yet set the correct AllocationSize, do so. + // + + if (FcbOrDcb->Header.AllocationSize.QuadPart == FCB_LOOKUP_ALLOCATIONSIZE_HINT) { + + FatLookupFileAllocationSize( IrpContext, FcbOrDcb ); + } + + // + // Round up the Desired Allocation Size to the next cluster size + // + + BytesPerCluster = 1 << Vcb->AllocationSupport.LogOfBytesPerCluster; + + // + // Note if the desired allocation is zero, to distinguish this from + // the wrap case below. + // + + if (DesiredAllocationSize != 0) { + + DesiredAllocationSize = (DesiredAllocationSize + (BytesPerCluster - 1)) & + ~(BytesPerCluster - 1); + // + // Check for the benign case that the file is already smaller than + // the desired truncation. Note that if it wraps, then a) it was + // specifying an offset in the maximally allocatable cluster and + // b) we're not asking to extend the file, either. So stop. + // + + if (DesiredAllocationSize == 0 || + DesiredAllocationSize >= FcbOrDcb->Header.AllocationSize.LowPart) { + + DebugTrace(0, Dbg, "Desired size within current allocation.\n", 0); + + DebugTrace(-1, Dbg, "FatTruncateFileAllocation -> (VOID)\n", 0); + return; + } + + } + + // + // This is a no-op if the allocation size is already what we want. + // + + if (DesiredAllocationSize == FcbOrDcb->Header.AllocationSize.LowPart) { + + DebugTrace(0, Dbg, "Desired size equals current allocation.\n", 0); + DebugTrace(-1, Dbg, "FatTruncateFileAllocation -> (VOID)\n", 0); + return; + } + + UnwindInitialAllocationSize = FcbOrDcb->Header.AllocationSize.LowPart; + UnwindInitialFirstClusterOfFile = FcbOrDcb->FirstClusterOfFile; + + // + // Update the FcbOrDcb allocation size. If it is now zero, we have the + // additional task of modifying the FcbOrDcb and Dirent copies of + // FirstClusterInFile. + // + // Note that we must pin the dirent before actually deallocating the + // disk space since, in unwind, it would not be possible to reallocate + // deallocated disk space as someone else may have reallocated it and + // may cause an exception when you try to get some more disk space. + // Thus FatDeallocateDiskSpace must be the final dangerous operation. + // + + _SEH2_TRY { + + FcbOrDcb->Header.AllocationSize.QuadPart = DesiredAllocationSize; + + // + // Special case 0 + // + + if (DesiredAllocationSize == 0) { + + // + // We have to update the dirent and FcbOrDcb copies of + // FirstClusterOfFile since before it was 0 + // + + NT_ASSERT( FcbOrDcb->FcbCondition == FcbGood ); + + FatGetDirentFromFcbOrDcb( IrpContext, FcbOrDcb, FALSE, &Dirent, &Bcb ); + + Dirent->FirstClusterOfFile = 0; + + if (FatIsFat32(Vcb)) { + + Dirent->FirstClusterOfFileHi = 0; + } + + FcbOrDcb->FirstClusterOfFile = 0; + + FatSetDirtyBcb( IrpContext, Bcb, Vcb, TRUE ); + UpdatedDirent = TRUE; + + FatDeallocateDiskSpace( IrpContext, Vcb, &FcbOrDcb->Mcb, ((FcbOrDcb->FcbState & FCB_STATE_ZERO_ON_DEALLOCATION) != 0)); + + FatRemoveMcbEntry( FcbOrDcb->Vcb, &FcbOrDcb->Mcb, 0, 0xFFFFFFFF ); + + } else { + + // + // Split the existing allocation into two parts, one we will keep, and + // one we will deallocate. + // + + FsRtlInitializeLargeMcb( &RemainingMcb, PagedPool ); + UnwindWeAllocatedMcb = TRUE; + + FatSplitAllocation( IrpContext, + Vcb, + &FcbOrDcb->Mcb, + DesiredAllocationSize, + &RemainingMcb ); + + FatDeallocateDiskSpace( IrpContext, Vcb, &RemainingMcb, ((FcbOrDcb->FcbState & FCB_STATE_ZERO_ON_DEALLOCATION) != 0) ); + + FsRtlUninitializeLargeMcb( &RemainingMcb ); + } + + } _SEH2_FINALLY { + + DebugUnwind( FatTruncateFileAllocation ); + + // + // Is this really the right backout strategy? It would be nice if we could + // pretend the truncate worked if we knew that the file had gotten into + // a consistent state. Leaving dangled clusters is probably quite preferable. + // + + if ( _SEH2_AbnormalTermination() ) { + + FcbOrDcb->Header.AllocationSize.LowPart = UnwindInitialAllocationSize; + + if ( (DesiredAllocationSize == 0) && (Dirent != NULL)) { + + if (UpdatedDirent) { + + // + // If the dirent has been updated ok and marked dirty, then we + // failed in deallocatediscspace, and don't know what state + // the on disc fat chain is in. So we throw away the mcb, + // and potentially loose a few clusters until the next + // chkdsk. The operation has succeeded, but the exception + // will still propogate. 5.1 + // + + FatRemoveMcbEntry( Vcb, &FcbOrDcb->Mcb, 0, 0xFFFFFFFF ); + FcbOrDcb->Header.AllocationSize.QuadPart = 0; + } + else if (FcbOrDcb->FirstClusterOfFile == 0) { + + Dirent->FirstClusterOfFile = (USHORT)UnwindInitialFirstClusterOfFile; + + if ( FatIsFat32(Vcb) ) { + + Dirent->FirstClusterOfFileHi = + (USHORT)(UnwindInitialFirstClusterOfFile >> 16); + } + + FcbOrDcb->FirstClusterOfFile = UnwindInitialFirstClusterOfFile; + } + } + + if ( UnwindWeAllocatedMcb ) { + + FsRtlUninitializeLargeMcb( &RemainingMcb ); + } + + // + // Note that in the non zero truncation case, we will also + // leak clusters. However, apart from this, the in memory and on disc + // structures will agree. + } + + FatUnpinBcb( IrpContext, Bcb ); + + // + // Give FlushFileBuffer/Cleanup a clue here, regardless of success/fail. + // + + SetFlag(FcbOrDcb->FcbState, FCB_STATE_FLUSH_FAT); + + DebugTrace(-1, Dbg, "FatTruncateFileAllocation -> (VOID)\n", 0); + } _SEH2_END; +} + + +_Requires_lock_held_(_Global_critical_region_) +VOID +FatLookupFileAllocationSize ( + IN PIRP_CONTEXT IrpContext, + IN PFCB FcbOrDcb + ) + +/*++ + +Routine Description: + + This routine retrieves the current file allocatio size for the + specified file/directory. + +Arguments: + + FcbOrDcb - Supplies the Fcb/Dcb of the file/directory being modified + +--*/ + +{ + LBO Lbo; + ULONG ByteCount; + BOOLEAN DontCare; + + PAGED_CODE(); + + DebugTrace(+1, Dbg, "FatLookupAllocationSize\n", 0); + DebugTrace( 0, Dbg, " FcbOrDcb = %p\n", FcbOrDcb); + + // + // We call FatLookupFileAllocation with Vbo of 0xffffffff - 1. + // + + FatLookupFileAllocation( IrpContext, + FcbOrDcb, + MAXULONG - 1, + &Lbo, + &ByteCount, + &DontCare, + &DontCare, + NULL ); + + // + // FileSize was set at Fcb creation time from the contents of the directory entry, + // and we are only now looking up the real length of the allocation chain. If it + // cannot be contained, this is trash. Probably more where that came from. + // + + if (FcbOrDcb->Header.FileSize.LowPart > FcbOrDcb->Header.AllocationSize.LowPart) { + + FatPopUpFileCorrupt( IrpContext, FcbOrDcb ); + FatRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR ); + } + + DebugTrace(-1, Dbg, "FatLookupFileAllocationSize -> (VOID)\n", 0); + return; +} + + +_Requires_lock_held_(_Global_critical_region_) +VOID +FatAllocateDiskSpace ( + IN PIRP_CONTEXT IrpContext, + IN PVCB Vcb, + IN ULONG AbsoluteClusterHint, + IN PULONG ByteCount, + IN BOOLEAN ExactMatchRequired, + OUT PLARGE_MCB Mcb + ) + +/*++ + +Routine Description: + + This procedure allocates additional disk space and builds an mcb + representing the newly allocated space. If the space cannot be + allocated then this procedure raises an appropriate status. + + Searching starts from the hint index in the Vcb unless an alternative + non-zero hint is given in AlternateClusterHint. If we are using the + hint field in the Vcb, it is set to the cluster following our allocation + when we are done. + + Disk space can only be allocated in cluster units so this procedure + will round up any byte count to the next cluster boundary. + + Pictorially what is done is the following (where ! denotes the end of + the fat chain (i.e., FAT_CLUSTER_LAST)): + + + Mcb (empty) + + becomes + + Mcb |--a--|--b--|--c--! + + ^ + ByteCount ----------+ + +Arguments: + + Vcb - Supplies the VCB being modified + + AbsoluteClusterHint - Supplies an alternate hint index to start the + search from. If this is zero we use, and update, + the Vcb hint field. + + ByteCount - Supplies the number of bytes that we are requesting, and + receives the number of bytes that we got. + + ExactMatchRequired - Caller should set this to TRUE if only the precise run requested + is acceptable. + + Mcb - Receives the MCB describing the newly allocated disk space. The + caller passes in an initialized Mcb that is filled in by this procedure. + + Return Value: + + TRUE - Allocated ok + FALSE - Failed to allocate exactly as requested (=> ExactMatchRequired was TRUE) + +--*/ + +{ + UCHAR LogOfBytesPerCluster; + ULONG BytesPerCluster; + ULONG StartingCluster; + ULONG ClusterCount; + ULONG WindowRelativeHint; +#if DBG + ULONG PreviousClear = 0; +#endif + + PFAT_WINDOW Window; + BOOLEAN Wait = FALSE; + BOOLEAN Result = TRUE; + + PAGED_CODE(); + + DebugTrace(+1, Dbg, "FatAllocateDiskSpace\n", 0); + DebugTrace( 0, Dbg, " Vcb = %p\n", Vcb); + DebugTrace( 0, Dbg, " *ByteCount = %8lx\n", *ByteCount); + DebugTrace( 0, Dbg, " Mcb = %p\n", Mcb); + DebugTrace( 0, Dbg, " Hint = %8lx\n", AbsoluteClusterHint); + + NT_ASSERT((AbsoluteClusterHint <= Vcb->AllocationSupport.NumberOfClusters + 2) && (1 != AbsoluteClusterHint)); + + // + // Make sure byte count is not zero + // + + if (*ByteCount == 0) { + + DebugTrace(0, Dbg, "Nothing to allocate.\n", 0); + + DebugTrace(-1, Dbg, "FatAllocateDiskSpace -> (VOID)\n", 0); + return; + } + + // + // Compute the cluster count based on the byte count, rounding up + // to the next cluster if there is any remainder. Note that the + // pathalogical case BytesCount == 0 has been eliminated above. + // + + LogOfBytesPerCluster = Vcb->AllocationSupport.LogOfBytesPerCluster; + BytesPerCluster = 1 << LogOfBytesPerCluster; + + *ByteCount = (*ByteCount + (BytesPerCluster - 1)) + & ~(BytesPerCluster - 1); + + // + // If ByteCount is NOW zero, then we were asked for the maximal + // filesize (or at least for bytes in the last allocatable sector). + // + + if (*ByteCount == 0) { + + *ByteCount = 0xffffffff; + ClusterCount = 1 << (32 - LogOfBytesPerCluster); + + } else { + + ClusterCount = (*ByteCount >> LogOfBytesPerCluster); + } + + // + // Analysis tools don't figure out that ClusterCount is not zero because + // of the ByteCount == 0 checks, so give them a hint. + // + _Analysis_assume_(ClusterCount > 0); + + // + // Make sure there are enough free clusters to start with, and + // take them now so that nobody else takes them from us. + // + + ExAcquireResourceSharedLite(&Vcb->ChangeBitMapResource, TRUE); + FatLockFreeClusterBitMap( Vcb ); + + if (ClusterCount <= Vcb->AllocationSupport.NumberOfFreeClusters) { + + Vcb->AllocationSupport.NumberOfFreeClusters -= ClusterCount; + + } else { + + FatUnlockFreeClusterBitMap( Vcb ); + ExReleaseResourceLite(&Vcb->ChangeBitMapResource); + + DebugTrace(0, Dbg, "Disk Full. Raise Status.\n", 0); + FatRaiseStatus( IrpContext, STATUS_DISK_FULL ); + } + + // + // Did the caller supply a hint? + // + + if ((0 != AbsoluteClusterHint) && (AbsoluteClusterHint < (Vcb->AllocationSupport.NumberOfClusters + 2))) { + + if (Vcb->NumberOfWindows > 1) { + + // + // If we're being called upon to allocate clusters outside the + // current window (which happens only via MoveFile), it's a problem. + // We address this by changing the current window to be the one which + // contains the alternate cluster hint. Note that if the user's + // request would cross a window boundary, he doesn't really get what + // he wanted. + // + + if (AbsoluteClusterHint < Vcb->CurrentWindow->FirstCluster || + AbsoluteClusterHint > Vcb->CurrentWindow->LastCluster) { + + ULONG BucketNum = FatWindowOfCluster( AbsoluteClusterHint ); + + NT_ASSERT( BucketNum < Vcb->NumberOfWindows); + + // + // Drop our shared lock on the ChangeBitMapResource, and pick it up again + // exclusive in preparation for making the window swap. + // + + FatUnlockFreeClusterBitMap(Vcb); + ExReleaseResourceLite(&Vcb->ChangeBitMapResource); + ExAcquireResourceExclusiveLite(&Vcb->ChangeBitMapResource, TRUE); + FatLockFreeClusterBitMap(Vcb); + + Window = &Vcb->Windows[BucketNum]; + + // + // Again, test the current window against the one we want - some other + // thread could have sneaked in behind our backs and kindly set it to the one + // we need, when we dropped and reacquired the ChangeBitMapResource above. + // + + if (Window != Vcb->CurrentWindow) { + + _SEH2_TRY { + + Wait = BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT); + SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT); + + // + // Change to the new window (update Vcb->CurrentWindow) and scan it + // to build up a freespace bitmap etc. + // + + FatExamineFatEntries( IrpContext, Vcb, + 0, + 0, + FALSE, + Window, + NULL); + + } _SEH2_FINALLY { + + if (!Wait) { + + ClearFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT); + } + + if (_SEH2_AbnormalTermination()) { + + // + // We will have raised as a result of failing to pick up the + // chunk of the FAT for this window move. Release our resources + // and return the cluster count to the volume. + // + + Vcb->AllocationSupport.NumberOfFreeClusters += ClusterCount; + + FatUnlockFreeClusterBitMap( Vcb ); + ExReleaseResourceLite(&Vcb->ChangeBitMapResource); + } + } _SEH2_END; + } + } + + // + // Make the hint cluster number relative to the base of the current window... + // + // Currentwindow->Firstcluster is baised by +2 already, so we will lose the + // bias already in AbsoluteClusterHint. Put it back.... + // + + WindowRelativeHint = AbsoluteClusterHint - Vcb->CurrentWindow->FirstCluster + 2; + } + else { + + // + // Only one 'window', ie fat16/12. No modification necessary. + // + + WindowRelativeHint = AbsoluteClusterHint; + } + } + else { + + // + // Either no hint supplied, or it was out of range, so grab one from the Vcb + // + // NOTE: Clusterhint in the Vcb is not guaranteed to be set (may be -1) + // + + WindowRelativeHint = Vcb->ClusterHint; + AbsoluteClusterHint = 0; + + // + // Vcb hint may not have been initialized yet. Force to valid cluster. + // + + if (-1 == WindowRelativeHint) { + + WindowRelativeHint = 2; + } + } + + NT_ASSERT((WindowRelativeHint >= 2) && (WindowRelativeHint < Vcb->FreeClusterBitMap.SizeOfBitMap + 2)); + + // + // Keep track of the window we're allocating from, so we can clean + // up correctly if the current window changes after we unlock the + // bitmap. + // + + Window = Vcb->CurrentWindow; + + // + // Try to find a run of free clusters large enough for us. + // + + StartingCluster = FatFindFreeClusterRun( IrpContext, + Vcb, + ClusterCount, + WindowRelativeHint ); + // + // If the above call was successful, we can just update the fat + // and Mcb and exit. Otherwise we have to look for smaller free + // runs. + // + // This test is a bit funky. Note that the error return from + // RtlFindClearBits is -1, and adding two to that is 1. + // + + if ((StartingCluster != 1) && + ((0 == AbsoluteClusterHint) || (StartingCluster == WindowRelativeHint)) + ) { + +#if DBG + PreviousClear = RtlNumberOfClearBits( &Vcb->FreeClusterBitMap ); +#endif // DBG + + // + // Take the clusters we found, and unlock the bit map. + // + + FatReserveClusters(IrpContext, Vcb, StartingCluster, ClusterCount); + + Window->ClustersFree -= ClusterCount; + + StartingCluster += Window->FirstCluster; + StartingCluster -= 2; + + NT_ASSERT( PreviousClear - ClusterCount == Window->ClustersFree ); + + FatUnlockFreeClusterBitMap( Vcb ); + + // + // Note that this call will never fail since there is always + // room for one entry in an empty Mcb. + // + + FatAddMcbEntry( Vcb, Mcb, + 0, + FatGetLboFromIndex( Vcb, StartingCluster ), + *ByteCount); + _SEH2_TRY { + + // + // Update the fat. + // + + FatAllocateClusters(IrpContext, Vcb, + StartingCluster, + ClusterCount); + + } _SEH2_FINALLY { + + DebugUnwind( FatAllocateDiskSpace ); + + // + // If the allocate clusters failed, remove the run from the Mcb, + // unreserve the clusters, and reset the free cluster count. + // + + if (_SEH2_AbnormalTermination()) { + + FatRemoveMcbEntry( Vcb, Mcb, 0, *ByteCount ); + + FatLockFreeClusterBitMap( Vcb ); + + // Only clear bits if the bitmap window is the same. + + if (Window == Vcb->CurrentWindow) { + + // Both values (startingcluster and window->firstcluster) are + // already biased by 2, so will cancel, so we need to add in the 2 again. + + FatUnreserveClusters( IrpContext, Vcb, + StartingCluster - Window->FirstCluster + 2, + ClusterCount ); + } + + Window->ClustersFree += ClusterCount; + Vcb->AllocationSupport.NumberOfFreeClusters += ClusterCount; + + FatUnlockFreeClusterBitMap( Vcb ); + } + + ExReleaseResourceLite(&Vcb->ChangeBitMapResource); + } _SEH2_END; + + } else { + + // + // Note that Index is a zero-based window-relative number. When appropriate + // it'll get converted into a true cluster number and put in Cluster, which + // will be a volume relative true cluster number. + // + + ULONG Index = 0; + ULONG Cluster = 0; + ULONG CurrentVbo = 0; + ULONG PriorLastCluster = 0; + ULONG BytesFound = 0; + + ULONG ClustersFound = 0; + ULONG ClustersRemaining = 0; + + BOOLEAN LockedBitMap = FALSE; + BOOLEAN SelectNextContigWindow = FALSE; + + // + // Drop our shared lock on the ChangeBitMapResource, and pick it up again + // exclusive in preparation for making a window swap. + // + + FatUnlockFreeClusterBitMap(Vcb); + ExReleaseResourceLite(&Vcb->ChangeBitMapResource); + ExAcquireResourceExclusiveLite(&Vcb->ChangeBitMapResource, TRUE); + FatLockFreeClusterBitMap(Vcb); + LockedBitMap = TRUE; + + _SEH2_TRY { + + if ( ExactMatchRequired && (1 == Vcb->NumberOfWindows)) { + + // + // Give up right now, there are no more windows to search! RtlFindClearBits + // searchs the whole bitmap, so we would have found any contiguous run + // large enough. + // + + try_leave( Result = FALSE); + } + + // + // While the request is still incomplete, look for the largest + // run of free clusters, mark them taken, allocate the run in + // the Mcb and Fat, and if this isn't the first time through + // the loop link it to prior run on the fat. The Mcb will + // coalesce automatically. + // + + ClustersRemaining = ClusterCount; + CurrentVbo = 0; + PriorLastCluster = 0; + + while (ClustersRemaining != 0) { + + // + // If we just entered the loop, the bit map is already locked + // + + if ( !LockedBitMap ) { + + FatLockFreeClusterBitMap( Vcb ); + LockedBitMap = TRUE; + } + + // + // Find the largest run of free clusters. If the run is + // bigger than we need, only use what we need. Note that + // this will then be the last while() iteration. + // + + // 12/3/95: need to bias bitmap by 2 bits for the defrag + // hooks and the below macro became impossible to do without in-line + // procedures. + // + // ClustersFound = FatLongestFreeClusterRun( IrpContext, Vcb, &Index ); + + ClustersFound = 0; + + if (!SelectNextContigWindow) { + + if ( 0 != WindowRelativeHint) { + + ULONG Desired = Vcb->FreeClusterBitMap.SizeOfBitMap - (WindowRelativeHint - 2); + + // + // We will try to allocate contiguously. Try from the current hint the to + // end of current window. Don't try for more than we actually need. + // + + if (Desired > ClustersRemaining) { + + Desired = ClustersRemaining; + } + + if (RtlAreBitsClear( &Vcb->FreeClusterBitMap, + WindowRelativeHint - 2, + Desired)) + { + // + // Clusters from hint->...windowend are free. Take them. + // + + Index = WindowRelativeHint - 2; + ClustersFound = Desired; + + if (FatIsFat32(Vcb)) { + + // + // We're now up against the end of the current window, so indicate that we + // want the next window in the sequence next time around. (If we're not up + // against the end of the window, then we got what we needed and won't be + // coming around again anyway). + // + + SelectNextContigWindow = TRUE; + WindowRelativeHint = 2; + } + else { + + // + // FAT 12/16 - we've run up against the end of the volume. Clear the + // hint, since we now have no idea where to look. + // + + WindowRelativeHint = 0; + } +#if DBG + PreviousClear = RtlNumberOfClearBits( &Vcb->FreeClusterBitMap ); +#endif // DBG + } + else { + + if (ExactMatchRequired) { + + // + // If our caller required an exact match, then we're hosed. Bail out now. + // + + try_leave( Result = FALSE); + } + + // + // Hint failed, drop back to pot luck + // + + WindowRelativeHint = 0; + } + } + + if ((0 == WindowRelativeHint) && (0 == ClustersFound)) { + + if (ClustersRemaining <= Vcb->CurrentWindow->ClustersFree) { + + // + // The remaining allocation could be satisfied entirely from this + // window. We will ask only for what we need, to try and avoid + // unnecessarily fragmenting large runs of space by always using + // (part of) the largest run we can find. This call will return the + // first run large enough. + // + + Index = RtlFindClearBits( &Vcb->FreeClusterBitMap, ClustersRemaining, 0); + + if (-1 != Index) { + + ClustersFound = ClustersRemaining; + } + } + + if (0 == ClustersFound) { + + // + // Still nothing, so just take the largest free run we can find. + // + + ClustersFound = RtlFindLongestRunClear( &Vcb->FreeClusterBitMap, &Index ); + + } +#if DBG + PreviousClear = RtlNumberOfClearBits( &Vcb->FreeClusterBitMap ); +#endif // DBG + if (ClustersFound >= ClustersRemaining) { + + ClustersFound = ClustersRemaining; + } + else { + + // + // If we just ran up to the end of a window, set up a hint that + // we'd like the next consecutive window after this one. (FAT32 only) + // + + if ( ((Index + ClustersFound) == Vcb->FreeClusterBitMap.SizeOfBitMap) && + FatIsFat32( Vcb) + ) { + + SelectNextContigWindow = TRUE; + WindowRelativeHint = 2; + } + } + } + } + + if (ClustersFound == 0) { + + ULONG FaveWindow = 0; + BOOLEAN SelectedWindow; + + // + // If we found no free clusters on a single-window FAT, + // there was a bad problem with the free cluster count. + // + + if (1 == Vcb->NumberOfWindows) { + +#ifdef _MSC_VER +#pragma prefast( suppress: 28159, "we bugcheck here because our internal data structures are seriously corrupted if this happens" ) +#endif + FatBugCheck( 0, 5, 0 ); + } + + // + // Switch to a new bucket. Possibly the next one if we're + // currently on a roll (allocating contiguously) + // + + SelectedWindow = FALSE; + + if ( SelectNextContigWindow) { + + ULONG NextWindow; + + NextWindow = (((ULONG)((PUCHAR)Vcb->CurrentWindow - (PUCHAR)Vcb->Windows)) / sizeof( FAT_WINDOW)) + 1; + + if ((NextWindow < Vcb->NumberOfWindows) && + ( Vcb->Windows[ NextWindow].ClustersFree > 0) + ) { + + FaveWindow = NextWindow; + SelectedWindow = TRUE; + } + else { + + if (ExactMatchRequired) { + + // + // Some dope tried to allocate a run past the end of the volume... + // + + try_leave( Result = FALSE); + } + + // + // Give up on the contiguous allocation attempts + // + + WindowRelativeHint = 0; + } + + SelectNextContigWindow = FALSE; + } + + if (!SelectedWindow) { + + // + // Select a new window to begin allocating from + // + + FaveWindow = FatSelectBestWindow( Vcb); + } + + // + // By now we'd better have found a window with some free clusters + // + + if (0 == Vcb->Windows[ FaveWindow].ClustersFree) { + +#ifdef _MSC_VER +#pragma prefast( suppress: 28159, "we bugcheck here because our internal data structures are seriously corrupted if this happens" ) +#endif + FatBugCheck( 0, 5, 1 ); + } + + Wait = BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT); + SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT); + + FatExamineFatEntries( IrpContext, Vcb, + 0, + 0, + FALSE, + &Vcb->Windows[FaveWindow], + NULL); + + if (!Wait) { + + ClearFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT); + } + + // + // Now we'll just go around the loop again, having switched windows, + // and allocate.... + // +#if DBG + PreviousClear = RtlNumberOfClearBits( &Vcb->FreeClusterBitMap ); +#endif //DBG + } // if (clustersfound == 0) + else { + + // + // Take the clusters we found, convert our index to a cluster number + // and unlock the bit map. + // + + Window = Vcb->CurrentWindow; + + FatReserveClusters( IrpContext, Vcb, (Index + 2), ClustersFound ); + + Cluster = Index + Window->FirstCluster; + + Window->ClustersFree -= ClustersFound; + NT_ASSERT( PreviousClear - ClustersFound == Window->ClustersFree ); + + FatUnlockFreeClusterBitMap( Vcb ); + LockedBitMap = FALSE; + + // + // Add the newly alloced run to the Mcb. + // + + BytesFound = ClustersFound << LogOfBytesPerCluster; + + FatAddMcbEntry( Vcb, Mcb, + CurrentVbo, + FatGetLboFromIndex( Vcb, Cluster ), + BytesFound ); + + // + // Connect the last allocated run with this one, and allocate + // this run on the Fat. + // + + if (PriorLastCluster != 0) { + + FatSetFatEntry( IrpContext, + Vcb, + PriorLastCluster, + (FAT_ENTRY)Cluster ); + } + + // + // Update the fat + // + + FatAllocateClusters( IrpContext, Vcb, Cluster, ClustersFound ); + + // + // Prepare for the next iteration. + // + + CurrentVbo += BytesFound; + ClustersRemaining -= ClustersFound; + PriorLastCluster = Cluster + ClustersFound - 1; + } + } // while (clustersremaining) + + } _SEH2_FINALLY { + + DebugUnwind( FatAllocateDiskSpace ); + + ExReleaseResourceLite(&Vcb->ChangeBitMapResource); + + // + // Is there any unwinding to do? + // + + if ( _SEH2_AbnormalTermination() || (FALSE == Result)) { + + // + // Flag to the caller that they're getting nothing + // + + *ByteCount = 0; + + // + // There are three places we could have taken this exception: + // when switching the window (FatExamineFatEntries), adding + // a found run to the Mcb (FatAddMcbEntry), or when writing + // the changes to the FAT (FatSetFatEntry). In the first case + // we don't have anything to unwind before deallocation, and + // can detect this by seeing if we have the ClusterBitmap + // mutex out. + + if (!LockedBitMap) { + + FatLockFreeClusterBitMap( Vcb ); + + // + // In these cases, we have the possiblity that the FAT + // window is still in place and we need to clear the bits. + // If the Mcb entry isn't there (we raised trying to add + // it), the effect of trying to remove it is a noop. + // + + if (Window == Vcb->CurrentWindow) { + + // + // Cluster reservation works on cluster 2 based window-relative + // numbers, so we must convert. The subtraction will lose the + // cluster 2 base, so bias the result. + // + + FatUnreserveClusters( IrpContext, Vcb, + (Cluster - Window->FirstCluster) + 2, + ClustersFound ); + } + + // + // Note that FatDeallocateDiskSpace will take care of adjusting + // to account for the entries in the Mcb. All we have to account + // for is the last run that didn't make it. + // + + Window->ClustersFree += ClustersFound; + Vcb->AllocationSupport.NumberOfFreeClusters += ClustersFound; + + FatUnlockFreeClusterBitMap( Vcb ); + + FatRemoveMcbEntry( Vcb, Mcb, CurrentVbo, BytesFound ); + + } else { + + // + // Just drop the mutex now - we didn't manage to do anything + // that needs to be backed out. + // + + FatUnlockFreeClusterBitMap( Vcb ); + } + + _SEH2_TRY { + + // + // Now we have tidied up, we are ready to just send the Mcb + // off to deallocate disk space + // + + FatDeallocateDiskSpace( IrpContext, Vcb, Mcb, FALSE ); + + } _SEH2_FINALLY { + + // + // Now finally (really), remove all the entries from the mcb + // + + FatRemoveMcbEntry( Vcb, Mcb, 0, 0xFFFFFFFF ); + } _SEH2_END; + } + + DebugTrace(-1, Dbg, "FatAllocateDiskSpace -> (VOID)\n", 0); + + } _SEH2_END; // finally + } + + return; +} + + + +// +// Limit our zeroing writes to 1 MB. +// + +#define MAX_ZERO_MDL_SIZE (1*1024*1024) + +_Requires_lock_held_(_Global_critical_region_) +VOID +FatDeallocateDiskSpace ( + IN PIRP_CONTEXT IrpContext, + IN PVCB Vcb, + IN PLARGE_MCB Mcb, + IN BOOLEAN ZeroOnDeallocate + ) + +/*++ + +Routine Description: + + This procedure deallocates the disk space denoted by an input + mcb. Note that the input MCB does not need to necessarily describe + a chain that ends with a FAT_CLUSTER_LAST entry. + + Pictorially what is done is the following + + Fat |--a--|--b--|--c--| + Mcb |--a--|--b--|--c--| + + becomes + + Fat |--0--|--0--|--0--| + Mcb |--a--|--b--|--c--| + +Arguments: + + Vcb - Supplies the VCB being modified + + Mcb - Supplies the MCB describing the disk space to deallocate. Note + that Mcb is unchanged by this procedure. + + +Return Value: + + None. + +--*/ + +{ + LBO Lbo; + VBO Vbo; + + ULONG RunsInMcb; + ULONG ByteCount; + ULONG ClusterCount = 0; + ULONG ClusterIndex = 0; + ULONG McbIndex = 0; + + UCHAR LogOfBytesPerCluster; + + PFAT_WINDOW Window; + + NTSTATUS ZeroingStatus = STATUS_SUCCESS; + + PAGED_CODE(); + + DebugTrace(+1, Dbg, "FatDeallocateDiskSpace\n", 0); + DebugTrace( 0, Dbg, " Vcb = %p\n", Vcb); + DebugTrace( 0, Dbg, " Mcb = %p\n", Mcb); + + LogOfBytesPerCluster = Vcb->AllocationSupport.LogOfBytesPerCluster; + + RunsInMcb = FsRtlNumberOfRunsInLargeMcb( Mcb ); + + if ( RunsInMcb == 0 ) { + + DebugTrace(-1, Dbg, "FatDeallocateDiskSpace -> (VOID)\n", 0); + return; + } + + // + // If we are supposed to zero out the allocation before freeing it, do so. + // + + if (ZeroOnDeallocate) { + + _SEH2_TRY { + + PIRP IoIrp; + KEVENT IoEvent; + IO_STATUS_BLOCK Iosb; + PVOID Buffer = NULL; + PMDL Mdl; + ULONG ByteCountToZero; + ULONG MdlSizeMapped; + + // + // Issue the writes down for each run in the Mcb + // + + KeInitializeEvent( &IoEvent, + NotificationEvent, + FALSE ); + + for ( McbIndex = 0; McbIndex < RunsInMcb; McbIndex++ ) { + + FatGetNextMcbEntry( Vcb, Mcb, McbIndex, &Vbo, &Lbo, &ByteCount ); + + // + // Assert that Fat files have no holes. + // + + NT_ASSERT( Lbo != 0 ); + + // + // Setup our MDL for the this run. + // + + if (ByteCount > MAX_ZERO_MDL_SIZE) { + Mdl = FatBuildZeroMdl( IrpContext, MAX_ZERO_MDL_SIZE); + } else { + Mdl = FatBuildZeroMdl( IrpContext, ByteCount); + } + + if (!Mdl) { + ZeroingStatus = STATUS_INSUFFICIENT_RESOURCES; + goto try_exit; + } + + _SEH2_TRY { + + // + // Map the MDL. + // + +#ifndef __REACTOS__ + Buffer = MmGetSystemAddressForMdlSafe(Mdl, HighPagePriority|MdlMappingNoExecute); +#else + Buffer = MmGetSystemAddressForMdlSafe(Mdl, HighPagePriority); +#endif + if (!Buffer) { + NT_ASSERT( FALSE ); + ZeroingStatus = STATUS_INSUFFICIENT_RESOURCES; + goto try_exit2; + } + + // + // We might not have not been able to get an MDL big enough to map the whole + // run. In this case, break up the write. + // + + MdlSizeMapped = min( ByteCount, Mdl->ByteCount ); + ByteCountToZero = ByteCount; + + // + // Loop until there are no bytes left to write + // + + while (ByteCountToZero != 0) { + + // + // Write zeros to each run. + // + + KeClearEvent( &IoEvent ); + + IoIrp = IoBuildSynchronousFsdRequest( IRP_MJ_WRITE, + Vcb->TargetDeviceObject, + Buffer, + MdlSizeMapped, + (PLARGE_INTEGER)&Lbo, + &IoEvent, + &Iosb ); + + if (IoIrp == NULL) { + NT_ASSERT( FALSE ); + ZeroingStatus = STATUS_INSUFFICIENT_RESOURCES; + goto try_exit2; + } + + // + // Set a flag indicating that we want to write through any + // cache on the controller. This eliminates the need for + // an explicit flush-device after the write. + // + + SetFlag( IoGetNextIrpStackLocation(IoIrp)->Flags, SL_WRITE_THROUGH ); + + ZeroingStatus = IoCallDriver( Vcb->TargetDeviceObject, IoIrp ); + + if (ZeroingStatus == STATUS_PENDING) { + + (VOID)KeWaitForSingleObject( &IoEvent, + Executive, + KernelMode, + FALSE, + (PLARGE_INTEGER)NULL ); + + ZeroingStatus = Iosb.Status; + } + + if (!NT_SUCCESS( ZeroingStatus )) { + NT_ASSERT( FALSE ); + goto try_exit2; + } + + // + // Increment the starting offset where we will zero. + // + + Lbo += MdlSizeMapped; + + // + // Decrement ByteCount + // + + ByteCountToZero -= MdlSizeMapped; + + if (ByteCountToZero < MdlSizeMapped) { + MdlSizeMapped = ByteCountToZero; + } + + } + + try_exit2: + + NOTHING; + + } _SEH2_FINALLY { + + if (!FlagOn( Mdl->MdlFlags, MDL_SOURCE_IS_NONPAGED_POOL) && + FlagOn( Mdl->MdlFlags, MDL_MAPPED_TO_SYSTEM_VA )) { + + MmUnmapLockedPages( Mdl->MappedSystemVa, Mdl ); + } + IoFreeMdl( Mdl ); + } _SEH2_END; + + } + + try_exit: + + NOTHING; + + } _SEH2_EXCEPT(FatExceptionFilter( NULL, _SEH2_GetExceptionInformation() )) { + + // + // If we failed to zero for some reason, still go ahead and deallocate + // the clusters. Otherwise we'll leak space from the volume. + // + + ZeroingStatus = _SEH2_GetExceptionCode(); + + } _SEH2_END; + + } + + NT_ASSERT( NT_SUCCESS(ZeroingStatus) ); + + _SEH2_TRY { + + // + // Run though the Mcb, freeing all the runs in the fat. + // + // We do this in two steps (first update the fat, then the bitmap + // (which can't fail)) to prevent other people from taking clusters + // that we need to re-allocate in the event of unwind. + // + + ExAcquireResourceSharedLite(&Vcb->ChangeBitMapResource, TRUE); + + RunsInMcb = FsRtlNumberOfRunsInLargeMcb( Mcb ); + + for ( McbIndex = 0; McbIndex < RunsInMcb; McbIndex++ ) { + + FatGetNextMcbEntry( Vcb, Mcb, McbIndex, &Vbo, &Lbo, &ByteCount ); + + // + // Assert that Fat files have no holes. + // + + NT_ASSERT( Lbo != 0 ); + + // + // Write FAT_CLUSTER_AVAILABLE to each cluster in the run. + // + + if (ByteCount == 0xFFFFFFFF) { + + // + // Special case the computation of ClusterCout + // when file is of max size (4GiB - 1). + // + + ClusterCount = (1 << (32 - LogOfBytesPerCluster)); + + } else { + + ClusterCount = ByteCount >> LogOfBytesPerCluster; + } + + ClusterIndex = FatGetIndexFromLbo( Vcb, Lbo ); + + FatFreeClusters( IrpContext, Vcb, ClusterIndex, ClusterCount ); + } + + // + // From now on, nothing can go wrong .... (as in raise) + // + + FatLockFreeClusterBitMap( Vcb ); + + for ( McbIndex = 0; McbIndex < RunsInMcb; McbIndex++ ) { + + ULONG ClusterEnd; + ULONG MyStart, MyLength, count; +#if DBG +#ifndef __REACTOS__ + ULONG PreviousClear = 0; +#endif + ULONG i = 0; +#endif + + FatGetNextMcbEntry( Vcb, Mcb, McbIndex, &Vbo, &Lbo, &ByteCount ); + + // + // Mark the bits clear in the FreeClusterBitMap. + // + + if (ByteCount == 0xFFFFFFFF) { + + // + // Special case the computation of ClusterCout + // when file is of max size (2^32 - 1). + // + + ClusterCount = (1 << (32 - LogOfBytesPerCluster)); + + } else { + + ClusterCount = ByteCount >> LogOfBytesPerCluster; + } + + ClusterIndex = FatGetIndexFromLbo( Vcb, Lbo ); + + Window = Vcb->CurrentWindow; + + // + // If we've divided the bitmap, elide bitmap manipulation for + // runs that are outside the current bucket. + // + + ClusterEnd = ClusterIndex + ClusterCount - 1; + + if (!(ClusterIndex > Window->LastCluster || + ClusterEnd < Window->FirstCluster)) { + + // + // The run being freed overlaps the current bucket, so we'll + // have to clear some bits. + // + + if (ClusterIndex < Window->FirstCluster && + ClusterEnd > Window->LastCluster) { + + MyStart = Window->FirstCluster; + MyLength = Window->LastCluster - Window->FirstCluster + 1; + + } else if (ClusterIndex < Window->FirstCluster) { + + MyStart = Window->FirstCluster; + MyLength = ClusterEnd - Window->FirstCluster + 1; + + } else { + + // + // The range being freed starts in the bucket, and may possibly + // extend beyond the bucket. + // + + MyStart = ClusterIndex; + + if (ClusterEnd <= Window->LastCluster) { + + MyLength = ClusterCount; + + } else { + + MyLength = Window->LastCluster - ClusterIndex + 1; + } + } + + if (MyLength == 0) { + + continue; + } + +#if DBG +#ifndef __REACTOS__ +#ifdef _MSC_VER +#pragma prefast( suppress:28931, "this is DBG build only" ) +#endif + PreviousClear = RtlNumberOfClearBits( &Vcb->FreeClusterBitMap ); +#endif + + + // + // Verify that the Bits are all really set. + // + + NT_ASSERT( MyStart + MyLength - Window->FirstCluster <= Vcb->FreeClusterBitMap.SizeOfBitMap ); + + for (i = 0; i < MyLength; i++) { + + NT_ASSERT( RtlCheckBit(&Vcb->FreeClusterBitMap, + MyStart - Window->FirstCluster + i) == 1 ); + } +#endif // DBG + + FatUnreserveClusters( IrpContext, Vcb, + MyStart - Window->FirstCluster + 2, + MyLength ); + } + + // + // Adjust the ClustersFree count for each bitmap window, even the ones + // that are not the current window. + // + + if (FatIsFat32(Vcb)) { + + Window = &Vcb->Windows[FatWindowOfCluster( ClusterIndex )]; + + } else { + + Window = &Vcb->Windows[0]; + } + + MyStart = ClusterIndex; + + for (MyLength = ClusterCount; MyLength > 0; MyLength -= count) { + + count = FatMin(Window->LastCluster - MyStart + 1, MyLength); + Window->ClustersFree += count; + + // + // If this was not the last window this allocation spanned, + // advance to the next. + // + + if (MyLength != count) { + + Window++; + MyStart = Window->FirstCluster; + } + } + + // + // Deallocation is now complete. Adjust the free cluster count. + // + + Vcb->AllocationSupport.NumberOfFreeClusters += ClusterCount; + } + +#if DBG + if (Vcb->CurrentWindow->ClustersFree != + RtlNumberOfClearBits(&Vcb->FreeClusterBitMap)) { + + DbgPrint("%x vs %x\n", Vcb->CurrentWindow->ClustersFree, + RtlNumberOfClearBits(&Vcb->FreeClusterBitMap)); + + DbgPrint("%x for %x\n", ClusterIndex, ClusterCount); + } +#endif + + FatUnlockFreeClusterBitMap( Vcb ); + + + } _SEH2_FINALLY { + + DebugUnwind( FatDeallocateDiskSpace ); + + // + // Is there any unwinding to do? + // + + ExReleaseResourceLite(&Vcb->ChangeBitMapResource); + + if ( _SEH2_AbnormalTermination() ) { + + LBO LocalLbo; + VBO LocalVbo; + + ULONG Index; + ULONG Clusters; + ULONG FatIndex; + ULONG PriorLastIndex; + + // + // For each entry we already deallocated, reallocate it, + // chaining together as nessecary. Note that we continue + // up to and including the last "for" iteration even though + // the SetFatRun could not have been successful. This + // allows us a convienent way to re-link the final successful + // SetFatRun. + // + // It is possible that the reason we got here will prevent us + // from succeeding in this operation. + // + + PriorLastIndex = 0; + + for (Index = 0; Index <= McbIndex; Index++) { + + FatGetNextMcbEntry(Vcb, Mcb, Index, &LocalVbo, &LocalLbo, &ByteCount); + + if (ByteCount == 0xFFFFFFFF) { + + // + // Special case the computation of ClusterCout + // when file is of max size (2^32 - 1). + // + + Clusters = (1 << (32 - LogOfBytesPerCluster)); + + } else { + + Clusters = ByteCount >> LogOfBytesPerCluster; + } + + FatIndex = FatGetIndexFromLbo( Vcb, LocalLbo ); + + // + // We must always restore the prior iteration's last + // entry, pointing it to the first cluster of this run. + // + + if (PriorLastIndex != 0) { + + FatSetFatEntry( IrpContext, + Vcb, + PriorLastIndex, + (FAT_ENTRY)FatIndex ); + } + + // + // If this is not the last entry (the one that failed) + // then reallocate the disk space on the fat. + // + + if ( Index < McbIndex ) { + + FatAllocateClusters(IrpContext, Vcb, FatIndex, Clusters); + + PriorLastIndex = FatIndex + Clusters - 1; + } + } + } + + DebugTrace(-1, Dbg, "FatDeallocateDiskSpace -> (VOID)\n", 0); + } _SEH2_END; + + return; +} + + +_Requires_lock_held_(_Global_critical_region_) +VOID +FatSplitAllocation ( + IN PIRP_CONTEXT IrpContext, + IN PVCB Vcb, + IN OUT PLARGE_MCB Mcb, + IN VBO SplitAtVbo, + OUT PLARGE_MCB RemainingMcb + ) + +/*++ + +Routine Description: + + This procedure takes a single mcb and splits its allocation into + two separate allocation units. The separation must only be done + on cluster boundaries, otherwise we bugcheck. + + On the disk this actually works by inserting a FAT_CLUSTER_LAST into + the last index of the first part being split out. + + Pictorially what is done is the following (where ! denotes the end of + the fat chain (i.e., FAT_CLUSTER_LAST)): + + + Mcb |--a--|--b--|--c--|--d--|--e--|--f--| + + ^ + SplitAtVbo ---------------------+ + + RemainingMcb (empty) + + becomes + + Mcb |--a--|--b--|--c--! + + + RemainingMcb |--d--|--e--|--f--| + +Arguments: + + Vcb - Supplies the VCB being modified + + Mcb - Supplies the MCB describing the allocation being split into + two parts. Upon return this Mcb now contains the first chain. + + SplitAtVbo - Supplies the VBO of the first byte for the second chain + that we creating. + + RemainingMcb - Receives the MCB describing the second chain of allocated + disk space. The caller passes in an initialized Mcb that + is filled in by this procedure STARTING AT VBO 0. + +Return Value: + + VOID - TRUE if the operation completed and FALSE if it had to + block but could not. + +--*/ + +{ + VBO SourceVbo; + VBO TargetVbo; + VBO DontCare; + + LBO Lbo; + + ULONG ByteCount; + +#if DBG + ULONG BytesPerCluster; +#endif + + PAGED_CODE(); + + DebugTrace(+1, Dbg, "FatSplitAllocation\n", 0); + DebugTrace( 0, Dbg, " Vcb = %p\n", Vcb); + DebugTrace( 0, Dbg, " Mcb = %p\n", Mcb); + DebugTrace( 0, Dbg, " SplitAtVbo = %8lx\n", SplitAtVbo); + DebugTrace( 0, Dbg, " RemainingMcb = %p\n", RemainingMcb); + +#if DBG + BytesPerCluster = 1 << Vcb->AllocationSupport.LogOfBytesPerCluster; +#endif + + // + // Assert that the split point is cluster alligned + // + + NT_ASSERT( (SplitAtVbo & (BytesPerCluster - 1)) == 0 ); + + // + // We should never be handed an empty source MCB and asked to split + // at a non zero point. + // + + NT_ASSERT( !((0 != SplitAtVbo) && (0 == FsRtlNumberOfRunsInLargeMcb( Mcb)))); + + // + // Assert we were given an empty target Mcb. + // + + // + // This assert is commented out to avoid hitting in the Ea error + // path. In that case we will be using the same Mcb's to split the + // allocation that we used to merge them. The target Mcb will contain + // the runs that the split will attempt to insert. + // + // + // NT_ASSERT( FsRtlNumberOfRunsInMcb( RemainingMcb ) == 0 ); + // + + _SEH2_TRY { + + // + // Move the runs after SplitAtVbo from the souce to the target + // + + SourceVbo = SplitAtVbo; + TargetVbo = 0; + + while (FatLookupMcbEntry(Vcb, Mcb, SourceVbo, &Lbo, &ByteCount, NULL)) { + + FatAddMcbEntry( Vcb, RemainingMcb, TargetVbo, Lbo, ByteCount ); + + FatRemoveMcbEntry( Vcb, Mcb, SourceVbo, ByteCount ); + + TargetVbo += ByteCount; + SourceVbo += ByteCount; + + // + // If SourceVbo overflows, we were actually snipping off the end + // of the maximal file ... and are now done. + // + + if (SourceVbo == 0) { + + break; + } + } + + // + // Mark the last pre-split cluster as a FAT_LAST_CLUSTER + // + + if ( SplitAtVbo != 0 ) { + + FatLookupLastMcbEntry( Vcb, Mcb, &DontCare, &Lbo, NULL ); + + FatSetFatEntry( IrpContext, + Vcb, + FatGetIndexFromLbo( Vcb, Lbo ), + FAT_CLUSTER_LAST ); + } + + } _SEH2_FINALLY { + + DebugUnwind( FatSplitAllocation ); + + // + // If we got an exception, we must glue back together the Mcbs + // + + if ( _SEH2_AbnormalTermination() ) { + + TargetVbo = SplitAtVbo; + SourceVbo = 0; + + while (FatLookupMcbEntry(Vcb, RemainingMcb, SourceVbo, &Lbo, &ByteCount, NULL)) { + + FatAddMcbEntry( Vcb, Mcb, TargetVbo, Lbo, ByteCount ); + + FatRemoveMcbEntry( Vcb, RemainingMcb, SourceVbo, ByteCount ); + + TargetVbo += ByteCount; + SourceVbo += ByteCount; + } + } + + DebugTrace(-1, Dbg, "FatSplitAllocation -> (VOID)\n", 0); + } _SEH2_END; + + return; +} + + +_Requires_lock_held_(_Global_critical_region_) +VOID +FatMergeAllocation ( + IN PIRP_CONTEXT IrpContext, + IN PVCB Vcb, + IN OUT PLARGE_MCB Mcb, + IN PLARGE_MCB SecondMcb + ) + +/*++ + +Routine Description: + + This routine takes two separate allocations described by two MCBs and + joins them together into one allocation. + + Pictorially what is done is the following (where ! denotes the end of + the fat chain (i.e., FAT_CLUSTER_LAST)): + + + Mcb |--a--|--b--|--c--! + + SecondMcb |--d--|--e--|--f--| + + becomes + + Mcb |--a--|--b--|--c--|--d--|--e--|--f--| + + SecondMcb |--d--|--e--|--f--| + + +Arguments: + + Vcb - Supplies the VCB being modified + + Mcb - Supplies the MCB of the first allocation that is being modified. + Upon return this Mcb will also describe the newly enlarged + allocation + + SecondMcb - Supplies the ZERO VBO BASED MCB of the second allocation + that is being appended to the first allocation. This + procedure leaves SecondMcb unchanged. + +Return Value: + + VOID - TRUE if the operation completed and FALSE if it had to + block but could not. + +--*/ + +{ + VBO SpliceVbo = 0; + LBO SpliceLbo; + + VBO SourceVbo; + VBO TargetVbo = 0; + + LBO Lbo; + + ULONG ByteCount; + + PAGED_CODE(); + + DebugTrace(+1, Dbg, "FatMergeAllocation\n", 0); + DebugTrace( 0, Dbg, " Vcb = %p\n", Vcb); + DebugTrace( 0, Dbg, " Mcb = %p\n", Mcb); + DebugTrace( 0, Dbg, " SecondMcb = %p\n", SecondMcb); + + _SEH2_TRY { + + // + // Append the runs from SecondMcb to Mcb + // + + (void)FatLookupLastMcbEntry( Vcb, Mcb, &SpliceVbo, &SpliceLbo, NULL ); + + SourceVbo = 0; + TargetVbo = SpliceVbo + 1; + + while (FatLookupMcbEntry(Vcb, SecondMcb, SourceVbo, &Lbo, &ByteCount, NULL)) { + + FatAddMcbEntry( Vcb, Mcb, TargetVbo, Lbo, ByteCount ); + + SourceVbo += ByteCount; + TargetVbo += ByteCount; + } + + // + // Link the last pre-merge cluster to the first cluster of SecondMcb + // + + FatLookupMcbEntry( Vcb, SecondMcb, 0, &Lbo, (PULONG)NULL, NULL ); + + FatSetFatEntry( IrpContext, + Vcb, + FatGetIndexFromLbo( Vcb, SpliceLbo ), + (FAT_ENTRY)FatGetIndexFromLbo( Vcb, Lbo ) ); + + } _SEH2_FINALLY { + + DebugUnwind( FatMergeAllocation ); + + // + // If we got an exception, we must remove the runs added to Mcb + // + + if ( _SEH2_AbnormalTermination() ) { + + ULONG CutLength; + + if ((CutLength = TargetVbo - (SpliceVbo + 1)) != 0) { + + FatRemoveMcbEntry( Vcb, Mcb, SpliceVbo + 1, CutLength); + } + } + + DebugTrace(-1, Dbg, "FatMergeAllocation -> (VOID)\n", 0); + } _SEH2_END; + + return; +} + + +// +// Internal support routine +// + +CLUSTER_TYPE +FatInterpretClusterType ( + IN PVCB Vcb, + IN FAT_ENTRY Entry + ) + +/*++ + +Routine Description: + + This procedure tells the caller how to interpret the input fat table + entry. It will indicate if the fat cluster is available, resereved, + bad, the last one, or the another fat index. This procedure can deal + with both 12 and 16 bit fat. + +Arguments: + + Vcb - Supplies the Vcb to examine, yields 12/16 bit info + + Entry - Supplies the fat entry to examine + +Return Value: + + CLUSTER_TYPE - Is the type of the input Fat entry + +--*/ + +{ + DebugTrace(+1, Dbg, "InterpretClusterType\n", 0); + DebugTrace( 0, Dbg, " Vcb = %p\n", Vcb); + DebugTrace( 0, Dbg, " Entry = %8lx\n", Entry); + + PAGED_CODE(); + + switch(Vcb->AllocationSupport.FatIndexBitSize ) { + case 32: + Entry &= FAT32_ENTRY_MASK; + break; + + case 12: + NT_ASSERT( Entry <= 0xfff ); + if (Entry >= 0x0ff0) { + Entry |= 0x0FFFF000; + } + break; + + default: + case 16: + NT_ASSERT( Entry <= 0xffff ); + if (Entry >= 0x0fff0) { + Entry |= 0x0FFF0000; + } + break; + } + + if (Entry == FAT_CLUSTER_AVAILABLE) { + + DebugTrace(-1, Dbg, "FatInterpretClusterType -> FatClusterAvailable\n", 0); + + return FatClusterAvailable; + + } else if (Entry < FAT_CLUSTER_RESERVED) { + + DebugTrace(-1, Dbg, "FatInterpretClusterType -> FatClusterNext\n", 0); + + return FatClusterNext; + + } else if (Entry < FAT_CLUSTER_BAD) { + + DebugTrace(-1, Dbg, "FatInterpretClusterType -> FatClusterReserved\n", 0); + + return FatClusterReserved; + + } else if (Entry == FAT_CLUSTER_BAD) { + + DebugTrace(-1, Dbg, "FatInterpretClusterType -> FatClusterBad\n", 0); + + return FatClusterBad; + + } else { + + DebugTrace(-1, Dbg, "FatInterpretClusterType -> FatClusterLast\n", 0); + + return FatClusterLast; + } +} + + +// +// Internal support routine +// + +VOID +FatLookupFatEntry ( + IN PIRP_CONTEXT IrpContext, + IN PVCB Vcb, + IN ULONG FatIndex, + IN OUT PULONG FatEntry, + IN OUT PFAT_ENUMERATION_CONTEXT Context + ) + +/*++ + +Routine Description: + + This routine takes an index into the fat and gives back the value + in the Fat at this index. At any given time, for a 16 bit fat, this + routine allows only one page per volume of the fat to be pinned in + memory. For a 12 bit bit fat, the entire fat (max 6k) is pinned. This + extra layer of caching makes the vast majority of requests very + fast. The context for this caching stored in a structure in the Vcb. + +Arguments: + + Vcb - Supplies the Vcb to examine, yields 12/16 bit info, + fat access context, etc. + + FatIndex - Supplies the fat index to examine. + + FatEntry - Receives the fat entry pointed to by FatIndex. Note that + it must point to non-paged pool. + + Context - This structure keeps track of a page of pinned fat between calls. + +--*/ + +{ + PAGED_CODE(); + + DebugTrace(+1, Dbg, "FatLookupFatEntry\n", 0); + DebugTrace( 0, Dbg, " Vcb = %p\n", Vcb); + DebugTrace( 0, Dbg, " FatIndex = %4x\n", FatIndex); + DebugTrace( 0, Dbg, " FatEntry = %8lx\n", FatEntry); + + // + // Make sure they gave us a valid fat index. + // + + FatVerifyIndexIsValid(IrpContext, Vcb, FatIndex); + + // + // Case on 12 or 16 bit fats. + // + // In the 12 bit case (mostly floppies) we always have the whole fat + // (max 6k bytes) pinned during allocation operations. This is possibly + // a wee bit slower, but saves headaches over fat entries with 8 bits + // on one page, and 4 bits on the next. + // + // The 16 bit case always keeps the last used page pinned until all + // operations are done and it is unpinned. + // + + // + // DEAL WITH 12 BIT CASE + // + + if (Vcb->AllocationSupport.FatIndexBitSize == 12) { + + // + // Check to see if the fat is already pinned, otherwise pin it. + // + + if (Context->Bcb == NULL) { + + FatReadVolumeFile( IrpContext, + Vcb, + FatReservedBytes( &Vcb->Bpb ), + FatBytesPerFat( &Vcb->Bpb ), + &Context->Bcb, + &Context->PinnedPage ); + } + + // + // Load the return value. + // + + + FatLookup12BitEntry( Context->PinnedPage, FatIndex, FatEntry ); + + } else if (Vcb->AllocationSupport.FatIndexBitSize == 32) { + + // + // DEAL WITH 32 BIT CASE + // + + ULONG PageEntryOffset; + ULONG OffsetIntoVolumeFile; + + // + // Initialize two local variables that help us. + // + OffsetIntoVolumeFile = FatReservedBytes(&Vcb->Bpb) + FatIndex * sizeof(FAT_ENTRY); + PageEntryOffset = (OffsetIntoVolumeFile % PAGE_SIZE) / sizeof(FAT_ENTRY); + + // + // Check to see if we need to read in a new page of fat + // + + if ((Context->Bcb == NULL) || + (OffsetIntoVolumeFile / PAGE_SIZE != Context->VboOfPinnedPage / PAGE_SIZE)) { + + // + // The entry wasn't in the pinned page, so must we unpin the current + // page (if any) and read in a new page. + // + + FatUnpinBcb( IrpContext, Context->Bcb ); + + FatReadVolumeFile( IrpContext, + Vcb, + OffsetIntoVolumeFile & ~(PAGE_SIZE - 1), + PAGE_SIZE, + &Context->Bcb, + &Context->PinnedPage ); + + Context->VboOfPinnedPage = OffsetIntoVolumeFile & ~(PAGE_SIZE - 1); + } + + // + // Grab the fat entry from the pinned page, and return + // + + *FatEntry = ((PULONG)(Context->PinnedPage))[PageEntryOffset] & FAT32_ENTRY_MASK; + + } else { + + // + // DEAL WITH 16 BIT CASE + // + + ULONG PageEntryOffset; + ULONG OffsetIntoVolumeFile; + + // + // Initialize two local variables that help us. + // + + OffsetIntoVolumeFile = FatReservedBytes(&Vcb->Bpb) + FatIndex * sizeof(USHORT); + PageEntryOffset = (OffsetIntoVolumeFile % PAGE_SIZE) / sizeof(USHORT); + + // + // Check to see if we need to read in a new page of fat + // + + if ((Context->Bcb == NULL) || + (OffsetIntoVolumeFile / PAGE_SIZE != Context->VboOfPinnedPage / PAGE_SIZE)) { + + // + // The entry wasn't in the pinned page, so must we unpin the current + // page (if any) and read in a new page. + // + + FatUnpinBcb( IrpContext, Context->Bcb ); + + FatReadVolumeFile( IrpContext, + Vcb, + OffsetIntoVolumeFile & ~(PAGE_SIZE - 1), + PAGE_SIZE, + &Context->Bcb, + &Context->PinnedPage ); + + Context->VboOfPinnedPage = OffsetIntoVolumeFile & ~(PAGE_SIZE - 1); + } + + // + // Grab the fat entry from the pinned page, and return + // + + *FatEntry = ((PUSHORT)(Context->PinnedPage))[PageEntryOffset]; + } + + DebugTrace(-1, Dbg, "FatLookupFatEntry -> (VOID)\n", 0); + return; +} + + +_Requires_lock_held_(_Global_critical_region_) +VOID +FatSetFatEntry ( + IN PIRP_CONTEXT IrpContext, + IN PVCB Vcb, + IN ULONG FatIndex, + IN FAT_ENTRY FatEntry + ) + +/*++ + +Routine Description: + + This routine takes an index into the fat and puts a value in the Fat + at this index. The routine special cases 12, 16 and 32 bit fats. In + all cases we go to the cache manager for a piece of the fat. + + We have a special form of this call for setting the DOS-style dirty bit. + Unlike the dirty bit in the boot sector, we do not go to special effort + to make sure that this hits the disk synchronously - if the system goes + down in the window between the dirty bit being set in the boot sector + and the FAT index zero dirty bit being lazy written, then life is tough. + + The only possible scenario is that Win9x may see what it thinks is a clean + volume that really isn't (hopefully Memphis will pay attention to our dirty + bit as well). The dirty bit will get out quickly, and if heavy activity is + occurring, then the dirty bit should actually be there virtually all of the + time since the act of cleaning the volume is the "rare" occurance. + + There are synchronization concerns that would crop up if we tried to make + this synchronous. This thread may already own the Bcb shared for the first + sector of the FAT (so we can't get it exclusive for a writethrough). This + would require some more serious replumbing to work around than I want to + consider at this time. + + We can and do, however, synchronously set the bit clean. + + At this point the reader should understand why the NT dirty bit is where it is. + +Arguments: + + Vcb - Supplies the Vcb to examine, yields 12/16/32 bit info, etc. + + FatIndex - Supplies the destination fat index. + + FatEntry - Supplies the source fat entry. + +--*/ + +{ + LBO Lbo; + PBCB Bcb = NULL; + ULONG SectorSize; + ULONG OffsetIntoVolumeFile; + ULONG WasWait = TRUE; + BOOLEAN RegularOperation = TRUE; + BOOLEAN CleaningOperation = FALSE; + BOOLEAN ReleaseMutex = FALSE; + + PAGED_CODE(); + + DebugTrace(+1, Dbg, "FatSetFatEntry\n", 0); + DebugTrace( 0, Dbg, " Vcb = %p\n", Vcb); + DebugTrace( 0, Dbg, " FatIndex = %4x\n", FatIndex); + DebugTrace( 0, Dbg, " FatEntry = %4x\n", FatEntry); + + // + // Make sure they gave us a valid fat index if this isn't the special + // clean-bit modifying call. + // + + if (FatIndex == FAT_DIRTY_BIT_INDEX) { + + // + // We are setting the clean bit state. Of course, we could + // have corruption that would cause us to try to fiddle the + // reserved index - we guard against this by having the + // special entry values use the reserved high 4 bits that + // we know that we'll never try to set. + // + + // + // We don't want to repin the FAT pages involved here. Just + // let the lazy writer hit them when it can. + // + + RegularOperation = FALSE; + + switch (FatEntry) { + case FAT_CLEAN_VOLUME: + FatEntry = (FAT_ENTRY)FAT_CLEAN_ENTRY; + CleaningOperation = TRUE; + break; + + case FAT_DIRTY_VOLUME: + switch (Vcb->AllocationSupport.FatIndexBitSize) { + case 12: + FatEntry = FAT12_DIRTY_ENTRY; + break; + + case 32: + FatEntry = FAT32_DIRTY_ENTRY; + break; + + default: + FatEntry = FAT16_DIRTY_ENTRY; + break; + } + break; + + default: + FatRaiseStatus( IrpContext, STATUS_FILE_CORRUPT_ERROR ); + break; + } + + // + // Disable dirtying semantics for the duration of this operation. Force this + // operation to wait for the duration. + // + + WasWait = FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT ); + SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT | IRP_CONTEXT_FLAG_DISABLE_DIRTY ); + + } else { + + NT_ASSERT( !(FatEntry & ~FAT32_ENTRY_MASK) ); + FatVerifyIndexIsValid(IrpContext, Vcb, FatIndex); + } + + // + // Set Sector Size + // + + SectorSize = 1 << Vcb->AllocationSupport.LogOfBytesPerSector; + + // + // Case on 12 or 16 bit fats. + // + // In the 12 bit case (mostly floppies) we always have the whole fat + // (max 6k bytes) pinned during allocation operations. This is possibly + // a wee bit slower, but saves headaches over fat entries with 8 bits + // on one page, and 4 bits on the next. + // + // In the 16 bit case we only read the page that we need to set the fat + // entry. + // + + // + // DEAL WITH 12 BIT CASE + // + + _SEH2_TRY { + + if (Vcb->AllocationSupport.FatIndexBitSize == 12) { + + PVOID PinnedFat; + + // + // Make sure we have a valid entry + // + + FatEntry &= 0xfff; + + // + // We read in the entire fat. Note that using prepare write marks + // the bcb pre-dirty, so we don't have to do it explicitly. + // + + OffsetIntoVolumeFile = FatReservedBytes( &Vcb->Bpb ) + FatIndex * 3 / 2; + + FatPrepareWriteVolumeFile( IrpContext, + Vcb, + FatReservedBytes( &Vcb->Bpb ), + FatBytesPerFat( &Vcb->Bpb ), + &Bcb, + &PinnedFat, + RegularOperation, + FALSE ); + + // + // Mark the sector(s) dirty in the DirtyFatMcb. This call is + // complicated somewhat for the 12 bit case since a single + // entry write can span two sectors (and pages). + // + // Get the Lbo for the sector where the entry starts, and add it to + // the dirty fat Mcb. + // + + Lbo = OffsetIntoVolumeFile & ~(SectorSize - 1); + + FatAddMcbEntry( Vcb, &Vcb->DirtyFatMcb, (VBO) Lbo, Lbo, SectorSize); + + // + // If the entry started on the last byte of the sector, it continues + // to the next sector, so mark the next sector dirty as well. + // + // Note that this entry will simply coalese with the last entry, + // so this operation cannot fail. Also if we get this far, we have + // made it, so no unwinding will be needed. + // + + if ( (OffsetIntoVolumeFile & (SectorSize - 1)) == (SectorSize - 1) ) { + + Lbo += SectorSize; + + FatAddMcbEntry( Vcb, &Vcb->DirtyFatMcb, (VBO) Lbo, Lbo, SectorSize ); + } + + // + // Store the entry into the fat; we need a little synchonization + // here and can't use a spinlock since the bytes might not be + // resident. + // + + FatLockFreeClusterBitMap( Vcb ); + ReleaseMutex = TRUE; + + FatSet12BitEntry( PinnedFat, FatIndex, FatEntry ); + + FatUnlockFreeClusterBitMap( Vcb ); + ReleaseMutex = FALSE; + + } else if (Vcb->AllocationSupport.FatIndexBitSize == 32) { + + // + // DEAL WITH 32 BIT CASE + // + + PULONG PinnedFatEntry32; + + // + // Read in a new page of fat + // + + OffsetIntoVolumeFile = FatReservedBytes( &Vcb->Bpb ) + + FatIndex * sizeof( FAT_ENTRY ); + + FatPrepareWriteVolumeFile( IrpContext, + Vcb, + OffsetIntoVolumeFile, + sizeof(FAT_ENTRY), + &Bcb, + (PVOID *)&PinnedFatEntry32, + RegularOperation, + FALSE ); + // + // Mark the sector dirty in the DirtyFatMcb + // + + Lbo = OffsetIntoVolumeFile & ~(SectorSize - 1); + + FatAddMcbEntry( Vcb, &Vcb->DirtyFatMcb, (VBO) Lbo, Lbo, SectorSize); + + // + // Store the FatEntry to the pinned page. + // + // Preserve the reserved bits in FAT32 entries in the file heap. + // + +#ifdef ALPHA + FatLockFreeClusterBitMap( Vcb ); + ReleaseMutex = TRUE; +#endif // ALPHA + + if (FatIndex != FAT_DIRTY_BIT_INDEX) { + + *PinnedFatEntry32 = ((*PinnedFatEntry32 & ~FAT32_ENTRY_MASK) | FatEntry); + + } else { + + *PinnedFatEntry32 = FatEntry; + } + +#ifdef ALPHA + FatUnlockFreeClusterBitMap( Vcb ); + ReleaseMutex = FALSE; +#endif // ALPHA + + } else { + + // + // DEAL WITH 16 BIT CASE + // + + PUSHORT PinnedFatEntry; + + // + // Read in a new page of fat + // + + OffsetIntoVolumeFile = FatReservedBytes( &Vcb->Bpb ) + + FatIndex * sizeof(USHORT); + + FatPrepareWriteVolumeFile( IrpContext, + Vcb, + OffsetIntoVolumeFile, + sizeof(USHORT), + &Bcb, + (PVOID *)&PinnedFatEntry, + RegularOperation, + FALSE ); + // + // Mark the sector dirty in the DirtyFatMcb + // + + Lbo = OffsetIntoVolumeFile & ~(SectorSize - 1); + + FatAddMcbEntry( Vcb, &Vcb->DirtyFatMcb, (VBO) Lbo, Lbo, SectorSize); + + // + // Store the FatEntry to the pinned page. + // + // We need extra synchronization here for broken architectures + // like the ALPHA that don't support atomic 16 bit writes. + // + +#ifdef ALPHA + FatLockFreeClusterBitMap( Vcb ); + ReleaseMutex = TRUE; +#endif // ALPHA + + *PinnedFatEntry = (USHORT)FatEntry; + +#ifdef ALPHA + FatUnlockFreeClusterBitMap( Vcb ); + ReleaseMutex = FALSE; +#endif // ALPHA + } + + } _SEH2_FINALLY { + + DebugUnwind( FatSetFatEntry ); + + // + // Re-enable volume dirtying in case this was a dirty bit operation. + // + + ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_DIRTY ); + + // + // Make this operation asynchronous again if needed. + // + + if (!WasWait) { + + ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT ); + } + + // + // If we still somehow have the Mutex, release it. + // + + if (ReleaseMutex) { + + NT_ASSERT( _SEH2_AbnormalTermination() ); + + FatUnlockFreeClusterBitMap( Vcb ); + } + + // + // Unpin the Bcb. For cleaning operations or if the corruption was detected while mounting we make this write-through. + // + + if ((CleaningOperation || + FlagOn(Vcb->VcbState, VCB_STATE_FLAG_MOUNT_IN_PROGRESS)) && + Bcb) { + + IO_STATUS_BLOCK IgnoreStatus; + + CcRepinBcb( Bcb ); + CcUnpinData( Bcb ); + DbgDoit( IrpContext->PinCount -= 1 ); + CcUnpinRepinnedBcb( Bcb, TRUE, &IgnoreStatus ); + + } else { + + FatUnpinBcb(IrpContext, Bcb); + } + + DebugTrace(-1, Dbg, "FatSetFatEntry -> (VOID)\n", 0); + } _SEH2_END; + + return; +} + + +// +// Internal support routine +// + +VOID +FatSetFatRun ( + IN PIRP_CONTEXT IrpContext, + IN PVCB Vcb, + IN ULONG StartingFatIndex, + IN ULONG ClusterCount, + IN BOOLEAN ChainTogether + ) + +/*++ + +Routine Description: + + This routine sets a continuous run of clusters in the fat. If ChainTogether + is TRUE, then the clusters are linked together as in normal Fat fasion, + with the last cluster receiving FAT_CLUSTER_LAST. If ChainTogether is + FALSE, all the entries are set to FAT_CLUSTER_AVAILABLE, effectively + freeing all the clusters in the run. + +Arguments: + + Vcb - Supplies the Vcb to examine, yields 12/16 bit info, etc. + + StartingFatIndex - Supplies the destination fat index. + + ClusterCount - Supplies the number of contiguous clusters to work on. + + ChainTogether - Tells us whether to fill the entries with links, or + FAT_CLUSTER_AVAILABLE + + +Return Value: + + VOID + +--*/ + +{ +#define MAXCOUNTCLUS 0x10000 +#define COUNTSAVEDBCBS ((MAXCOUNTCLUS * sizeof(FAT_ENTRY) / PAGE_SIZE) + 2) + PBCB SavedBcbs[COUNTSAVEDBCBS][2]; + + ULONG SectorSize; + ULONG Cluster; + + LBO StartSectorLbo; + LBO FinalSectorLbo; + LBO Lbo; + + PVOID PinnedFat; + + BOOLEAN ReleaseMutex = FALSE; + + ULONG SavedStartingFatIndex = StartingFatIndex; + + PAGED_CODE(); + + DebugTrace(+1, Dbg, "FatSetFatRun\n", 0); + DebugTrace( 0, Dbg, " Vcb = %p\n", Vcb); + DebugTrace( 0, Dbg, " StartingFatIndex = %8x\n", StartingFatIndex); + DebugTrace( 0, Dbg, " ClusterCount = %8lx\n", ClusterCount); + DebugTrace( 0, Dbg, " ChainTogether = %s\n", ChainTogether ? "TRUE":"FALSE"); + + // + // Make sure they gave us a valid fat run. + // + + FatVerifyIndexIsValid(IrpContext, Vcb, StartingFatIndex); + FatVerifyIndexIsValid(IrpContext, Vcb, StartingFatIndex + ClusterCount - 1); + + // + // Check special case + // + + if (ClusterCount == 0) { + + DebugTrace(-1, Dbg, "FatSetFatRun -> (VOID)\n", 0); + return; + } + + // + // Set Sector Size + // + + SectorSize = 1 << Vcb->AllocationSupport.LogOfBytesPerSector; + + // + // Case on 12 or 16 bit fats. + // + // In the 12 bit case (mostly floppies) we always have the whole fat + // (max 6k bytes) pinned during allocation operations. This is possibly + // a wee bit slower, but saves headaches over fat entries with 8 bits + // on one page, and 4 bits on the next. + // + // In the 16 bit case we only read one page at a time, as needed. + // + + // + // DEAL WITH 12 BIT CASE + // + + _SEH2_TRY { + + if (Vcb->AllocationSupport.FatIndexBitSize == 12) { + + // + // We read in the entire fat. Note that using prepare write marks + // the bcb pre-dirty, so we don't have to do it explicitly. + // + + RtlZeroMemory( &SavedBcbs[0][0], 2 * sizeof(PBCB) * 2); + + FatPrepareWriteVolumeFile( IrpContext, + Vcb, + FatReservedBytes( &Vcb->Bpb ), + FatBytesPerFat( &Vcb->Bpb ), + &SavedBcbs[0][0], + &PinnedFat, + TRUE, + FALSE ); + + // + // Mark the affected sectors dirty. Note that FinalSectorLbo is + // the Lbo of the END of the entry (Thus * 3 + 2). This makes sure + // we catch the case of a dirty fat entry straddling a sector boundry. + // + // Note that if the first AddMcbEntry succeeds, all following ones + // will simply coalese, and thus also succeed. + // + + StartSectorLbo = (FatReservedBytes( &Vcb->Bpb ) + StartingFatIndex * 3 / 2) + & ~(SectorSize - 1); + + FinalSectorLbo = (FatReservedBytes( &Vcb->Bpb ) + ((StartingFatIndex + + ClusterCount) * 3 + 2) / 2) & ~(SectorSize - 1); + + for (Lbo = StartSectorLbo; Lbo <= FinalSectorLbo; Lbo += SectorSize) { + + FatAddMcbEntry( Vcb, &Vcb->DirtyFatMcb, (VBO) Lbo, Lbo, SectorSize ); + } + + // + // Store the entries into the fat; we need a little + // synchonization here and can't use a spinlock since the bytes + // might not be resident. + // + + FatLockFreeClusterBitMap( Vcb ); + ReleaseMutex = TRUE; + + for (Cluster = StartingFatIndex; + Cluster < StartingFatIndex + ClusterCount - 1; + Cluster++) { + + FatSet12BitEntry( PinnedFat, + Cluster, + ChainTogether ? Cluster + 1 : FAT_CLUSTER_AVAILABLE ); + } + + // + // Save the last entry + // + + FatSet12BitEntry( PinnedFat, + Cluster, + ChainTogether ? + FAT_CLUSTER_LAST & 0xfff : FAT_CLUSTER_AVAILABLE ); + + FatUnlockFreeClusterBitMap( Vcb ); + ReleaseMutex = FALSE; + + } else if (Vcb->AllocationSupport.FatIndexBitSize == 32) { + + // + // DEAL WITH 32 BIT CASE + // + + for (;;) { + + VBO StartOffsetInVolume; + VBO FinalOffsetInVolume; + + ULONG Page; + ULONG FinalCluster; + PULONG FatEntry = NULL; + ULONG ClusterCountThisRun; + + StartOffsetInVolume = FatReservedBytes(&Vcb->Bpb) + + StartingFatIndex * sizeof(FAT_ENTRY); + + if (ClusterCount > MAXCOUNTCLUS) { + ClusterCountThisRun = MAXCOUNTCLUS; + } else { + ClusterCountThisRun = ClusterCount; + } + + FinalOffsetInVolume = StartOffsetInVolume + + (ClusterCountThisRun - 1) * sizeof(FAT_ENTRY); + + { + ULONG NumberOfPages; + ULONG Offset; + + NumberOfPages = (FinalOffsetInVolume / PAGE_SIZE) - + (StartOffsetInVolume / PAGE_SIZE) + 1; + + RtlZeroMemory( &SavedBcbs[0][0], (NumberOfPages + 1) * sizeof(PBCB) * 2 ); + + for ( Page = 0, Offset = StartOffsetInVolume & ~(PAGE_SIZE - 1); + Page < NumberOfPages; + Page++, Offset += PAGE_SIZE ) { + + FatPrepareWriteVolumeFile( IrpContext, + Vcb, + Offset, + PAGE_SIZE, + &SavedBcbs[Page][0], + (PVOID *)&SavedBcbs[Page][1], + TRUE, + FALSE ); + + if (Page == 0) { + + FatEntry = (PULONG)((PUCHAR)SavedBcbs[0][1] + + (StartOffsetInVolume % PAGE_SIZE)); + } + } + } + + // + // Mark the run dirty + // + + StartSectorLbo = StartOffsetInVolume & ~(SectorSize - 1); + FinalSectorLbo = FinalOffsetInVolume & ~(SectorSize - 1); + + for (Lbo = StartSectorLbo; Lbo <= FinalSectorLbo; Lbo += SectorSize) { + + FatAddMcbEntry( Vcb, &Vcb->DirtyFatMcb, (VBO)Lbo, Lbo, SectorSize ); + } + + // + // Store the entries + // + // We need extra synchronization here for broken architectures + // like the ALPHA that don't support atomic 16 bit writes. + // + +#ifdef ALPHA + FatLockFreeClusterBitMap( Vcb ); + ReleaseMutex = TRUE; +#endif // ALPHA + + FinalCluster = StartingFatIndex + ClusterCountThisRun - 1; + Page = 0; + + for (Cluster = StartingFatIndex; + Cluster <= FinalCluster; + Cluster++, FatEntry++) { + + // + // If we just crossed a page boundry (as opposed to starting + // on one), update our idea of FatEntry. ... 70541 lines suppressed ...

1 0

[reactos] 01/02: [PSDK] Add various defines needed to build fastfat_new
by Pierre Schweitzer 23 Nov '17

23 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=d8a15d0cc739197143cef… commit d8a15d0cc739197143cefe50a083466964809a8a Author: Pierre Schweitzer <pierre(a)reactos.org> AuthorDate: Thu Nov 23 23:23:16 2017 +0100 [PSDK] Add various defines needed to build fastfat_new --- sdk/include/psdk/ntdddisk.h | 3 +++ sdk/include/psdk/ntddscsi.h | 22 ++++++++++++++++++++++ sdk/include/psdk/ntstatus.h | 1 + 3 files changed, 26 insertions(+) diff --git a/sdk/include/psdk/ntdddisk.h b/sdk/include/psdk/ntdddisk.h index 44ab027a22..064ebbfd76 100644 --- a/sdk/include/psdk/ntdddisk.h +++ b/sdk/include/psdk/ntdddisk.h @@ -182,6 +182,9 @@ extern "C" { #define IOCTL_DISK_VERIFY \ CTL_CODE(IOCTL_DISK_BASE, 0x0005, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_DISK_COPY_DATA \ + CTL_CODE(IOCTL_DISK_BASE, 0x0019, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS) + #define SMART_GET_VERSION \ CTL_CODE(IOCTL_DISK_BASE, 0x0020, METHOD_BUFFERED, FILE_READ_ACCESS) diff --git a/sdk/include/psdk/ntddscsi.h b/sdk/include/psdk/ntddscsi.h index 2e8e5d9ab8..14a9cef230 100644 --- a/sdk/include/psdk/ntddscsi.h +++ b/sdk/include/psdk/ntddscsi.h @@ -34,6 +34,8 @@ extern "C" { #define IOCTL_SCSI_RESCAN_BUS CTL_CODE(IOCTL_SCSI_BASE,0x0407,METHOD_BUFFERED,FILE_ANY_ACCESS) #define IOCTL_SCSI_GET_DUMP_POINTERS CTL_CODE(IOCTL_SCSI_BASE,0x0408,METHOD_BUFFERED,FILE_ANY_ACCESS) #define IOCTL_SCSI_FREE_DUMP_POINTERS CTL_CODE(IOCTL_SCSI_BASE,0x0409,METHOD_BUFFERED,FILE_ANY_ACCESS) +#define IOCTL_SCSI_PASS_THROUGH_EX CTL_CODE(IOCTL_SCSI_BASE, 0x0411, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS) +#define IOCTL_SCSI_PASS_THROUGH_DIRECT_EX CTL_CODE(IOCTL_SCSI_BASE, 0x0412, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS) #define IOCTL_IDE_PASS_THROUGH CTL_CODE(IOCTL_SCSI_BASE,0x040a,METHOD_BUFFERED,FILE_READ_ACCESS | FILE_WRITE_ACCESS) #define IOCTL_ATA_PASS_THROUGH CTL_CODE(IOCTL_SCSI_BASE,0x040b,METHOD_BUFFERED,FILE_READ_ACCESS | FILE_WRITE_ACCESS) #define IOCTL_ATA_PASS_THROUGH_DIRECT CTL_CODE(IOCTL_SCSI_BASE,0x040c,METHOD_BUFFERED,FILE_READ_ACCESS | FILE_WRITE_ACCESS) @@ -104,6 +106,26 @@ extern "C" { } SCSI_PASS_THROUGH_DIRECT32,*PSCSI_PASS_THROUGH_DIRECT32; #endif /* _WIN64 */ + + typedef struct _SCSI_PASS_THROUGH_EX { + ULONG Version; + ULONG Length; + ULONG CdbLength; + ULONG StorAddressLength; + UCHAR ScsiStatus; + UCHAR SenseInfoLength; + UCHAR DataDirection; + UCHAR Reserved; + ULONG TimeOutValue; + ULONG StorAddressOffset; + ULONG SenseInfoOffset; + ULONG DataOutTransferLength; + ULONG DataInTransferLength; + ULONG_PTR DataOutBufferOffset; + ULONG_PTR DataInBufferOffset; + UCHAR Cdb[ANYSIZE_ARRAY]; + } SCSI_PASS_THROUGH_EX, *PSCSI_PASS_THROUGH_EX; + typedef struct _ATA_PASS_THROUGH_EX { USHORT Length; USHORT AtaFlags; diff --git a/sdk/include/psdk/ntstatus.h b/sdk/include/psdk/ntstatus.h index a9552633e7..1879503517 100644 --- a/sdk/include/psdk/ntstatus.h +++ b/sdk/include/psdk/ntstatus.h @@ -947,6 +947,7 @@ extern "C" { #define STATUS_CALLBACK_POP_STACK ((NTSTATUS)0xC0000423) #define STATUS_HIVE_UNLOADED ((NTSTATUS)0xC0000425) #define STATUS_ELEVATION_REQUIRED ((NTSTATUS)0xC000042C) +#define STATUS_PURGE_FAILED ((NTSTATUS)0xC0000435) #define STATUS_ALREADY_REGISTERED ((NTSTATUS)0xC0000718) #define STATUS_WOW_ASSERTION ((NTSTATUS)0xC0009898) #define STATUS_INVALID_SIGNATURE ((NTSTATUS)0xC000A000)

1 0

[reactos] 01/01: [COMCTL32] syslink: Don't free the return value of WM_CTLCOLORSTATIC. CORE-13605 -This is a bug in wine and should be sent upstream
by Giannis Adamopoulos 23 Nov '17

23 Nov '17

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=4a843c4e855b6c05c6ea1… commit 4a843c4e855b6c05c6ea1bc381851f16f899935b Author: Giannis Adamopoulos <gadamopoulos(a)reactos.org> AuthorDate: Fri Nov 24 00:15:57 2017 +0200 [COMCTL32] syslink: Don't free the return value of WM_CTLCOLORSTATIC. CORE-13605 -This is a bug in wine and should be sent upstream --- dll/win32/comctl32/syslink.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/dll/win32/comctl32/syslink.c b/dll/win32/comctl32/syslink.c index 6ba1a0b5b1..675ef62422 100644 --- a/dll/win32/comctl32/syslink.c +++ b/dll/win32/comctl32/syslink.c @@ -791,7 +791,9 @@ static LRESULT SYSLINK_Draw (const SYSLINK_INFO *infoPtr, HDC hdc) } else SetBkMode( hdc, TRANSPARENT ); +#ifndef __REACTOS__ DeleteObject(hBrush); +#endif LIST_FOR_EACH_ENTRY(Current, &infoPtr->Items, DOC_ITEM, entry) {

1 0

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs