[fireball] 39033: Alex Vlasov - Implement FAT operations (scanning, finding continuous runs). - Implement and plug in VCB initialization.
Author: fireball Date: Fri Jan 23 04:19:57 2009 New Revision: 39033
URL: http://svn.reactos.org/svn/reactos?rev=39033&view=rev Log: Alex Vlasov - Implement FAT operations (scanning, finding continuous runs). - Implement and plug in VCB initialization.
Modified: trunk/reactos/drivers/filesystems/fastfat_new/fat.c trunk/reactos/drivers/filesystems/fastfat_new/fsctl.c
Modified: trunk/reactos/drivers/filesystems/fastfat_new/fat.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfat... ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fat.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fat.c [iso-8859-1] Fri Jan 23 04:19:57 2009 @@ -3,7 +3,7 @@ * LICENSE: GPL - See COPYING in the top level directory * FILE: drivers/filesystems/fastfat/fat.c * PURPOSE: FAT support routines - * PROGRAMMERS: + * PROGRAMMERS: Alexey Vlasov */
/* INCLUDES *****************************************************************/ @@ -11,7 +11,678 @@ #define NDEBUG #include "fastfat.h"
+/* PROTOTYPES ***************************************************************/ +typedef struct _FAT_SCAN_CONTEXT +{ + PFILE_OBJECT FileObject; + LARGE_INTEGER PageOffset; + LONGLONG BeyoundLastEntryOffset; + PVOID PageBuffer; + PBCB PageBcb; +} FAT_SCAN_CONTEXT; + +#define FatEntryToDataOffset(xEntry, xVcb) \ + ((xVcb)->DataArea + (((LONGLONG) ((xEntry) - 0x02)) << (xVcb)->BytesPerClusterLog)) + +#define FatDataOffsetToEntry(xOffset, xVcb) \ + ((ULONG) ((xOffset - (xVcb)->DataArea) >> (xVcb)->BytesPerClusterLog) + 0x02) + +ULONG +FatScanFat12ForContinousRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN OUT PULONG Index, + IN BOOLEAN CanWait); + +ULONG +FatSetFat12ContinousRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN ULONG Index, + IN ULONG Length, + IN BOOLEAN CanWait); + +ULONG +FatScanFat12ForValueRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN OUT PULONG Index, + IN ULONG IndexValue, + IN BOOLEAN CanWait); + +ULONG +FatSetFat12ValueRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN ULONG Index, + IN ULONG Length, + IN ULONG IndexValue, + IN BOOLEAN CanWait); + +ULONG +FatScanFat16ForContinousRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN OUT PULONG Index, + IN BOOLEAN CanWait); + +ULONG +FatSetFat16ContinousRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN ULONG Index, + IN ULONG Length, + IN BOOLEAN CanWait); + +ULONG +FatScanFat16ForValueRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN OUT PULONG Index, + IN ULONG IndexValue, + IN BOOLEAN CanWait); + +ULONG +FatSetFat16ValueRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN ULONG Index, + IN ULONG Length, + IN ULONG IndexValue, + IN BOOLEAN CanWait); + +ULONG +FatScanFat32ForContinousRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN OUT PULONG Index, + IN BOOLEAN CanWait); + +ULONG +FatSetFat32ContinousRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN ULONG Index, + IN ULONG Length, + IN BOOLEAN CanWait); + +ULONG +FatScanFat32ForValueRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN OUT PULONG Index, + IN ULONG IndexValue, + IN BOOLEAN CanWait); + +ULONG +FatSetFat32ValueRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN ULONG Index, + IN ULONG Length, + IN ULONG IndexValue, + IN BOOLEAN CanWait); + +BOOLEAN +NTAPI +FatValidBpb( + IN PBIOS_PARAMETER_BLOCK Bpb); + +/* VARIABLES ****************************************************************/ +FAT_METHODS Fat12Methods = { + FatScanFat12ForContinousRun, + FatSetFat12ContinousRun, + FatScanFat16ForValueRun, + FatSetFat12ValueRun +}; + +FAT_METHODS Fat16Methods = { + FatScanFat16ForContinousRun, + FatSetFat16ContinousRun, + FatScanFat16ForValueRun, + FatSetFat16ValueRun +}; + +FAT_METHODS Fat32Methods = { + FatScanFat32ForContinousRun, + FatSetFat32ContinousRun, + FatScanFat32ForValueRun, + FatSetFat32ValueRun +}; + /* FUNCTIONS ****************************************************************/ - +FORCEINLINE +ULONG +FatPowerOfTwo( + ULONG Number) +/* + * FUNCTION: + * Determines the index of the set bit. + * ARGUMENTS: + * Number = Number having a single bit set. + * RETURNS: Index of the set bit. + */ +{ + ULONG Temp; + Temp = Number + - ((Number >> 1) & 033333333333) + - ((Number >> 2) & 011111111111); + return (((Temp + (Temp >> 3)) & 030707070707) % 63); +} + +ULONG +FatScanFat12ForContinousRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN OUT PULONG Index, + IN BOOLEAN CanWait) +{ + ExRaiseStatus(STATUS_NOT_IMPLEMENTED); +} + +ULONG +FatSetFat12ContinousRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN ULONG Index, + IN ULONG Length, + IN BOOLEAN CanWait) +{ + ExRaiseStatus(STATUS_NOT_IMPLEMENTED); +} + +ULONG +FatScanFat12ForValueRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN OUT PULONG Index, + IN ULONG IndexValue, + IN BOOLEAN CanWait) +{ + ExRaiseStatus(STATUS_NOT_IMPLEMENTED); +} + +ULONG +FatSetFat12ValueRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN ULONG Index, + IN ULONG Length, + IN ULONG IndexValue, + IN BOOLEAN CanWait) +{ + ExRaiseStatus(STATUS_NOT_IMPLEMENTED); +} + +ULONG +FatScanFat16ForContinousRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN OUT PULONG Index, + IN BOOLEAN CanWait) +{ + ExRaiseStatus(STATUS_NOT_IMPLEMENTED); +} + +ULONG +FatSetFat16ContinousRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN ULONG Index, + IN ULONG Length, + IN BOOLEAN CanWait) +{ + ExRaiseStatus(STATUS_NOT_IMPLEMENTED); +} + +ULONG +FatScanFat16ForValueRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN OUT PULONG Index, + IN ULONG IndexValue, + IN BOOLEAN CanWait) +{ + ExRaiseStatus(STATUS_NOT_IMPLEMENTED); +} + +ULONG +FatSetFat16ValueRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN ULONG Index, + IN ULONG Length, + IN ULONG IndexValue, + IN BOOLEAN CanWait) +{ + ExRaiseStatus(STATUS_NOT_IMPLEMENTED); +} + +ULONG +FatScanFat32ForContinousRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN OUT PULONG Index, + IN BOOLEAN CanWait) +/* + * FUNCTION: + * Scans FAT32 for continous chain of clusters + * ARGUMENTS: + * Context = Pointer to FAT_SCAN_CONTEXT. + * Index = Supplies the Index of the first cluster + * and receves the last index after the last + * cluster in the chain. + * CanWait = Indicates if the context allows blocking. + * RETURNS: Value of the last claster terminated the scan. + * NOTES: Raises STATUS_CANT_WAIT race condition. + */ +{ + LONGLONG PageOffset; + SIZE_T OffsetWithinPage, PageValidLength; + PULONG Entry, BeyoudLastEntry; + /* + * Determine page offset and the offset within page + * for the first cluster. + */ + PageValidLength = PAGE_SIZE; + PageOffset = ((LONGLONG) *Index) << 0x2; + OffsetWithinPage = (SIZE_T) (PageOffset & (PAGE_SIZE - 1)); + PageOffset -= OffsetWithinPage; + /* + * Check if the context already has the required page mapped. + * Map the first page is necessary. + */ + if (PageOffset != Context->PageOffset.QuadPart) + { + Context->PageOffset.QuadPart = PageOffset; + if (Context->PageBcb != NULL) + { + CcUnpinData(Context->PageBcb); + Context->PageBcb = NULL; + } + if (!CcMapData(Context->FileObject, &Context->PageOffset, + PAGE_SIZE, CanWait, &Context->PageBcb, &Context->PageBuffer)) + { + Context->PageOffset.QuadPart = 0LL; + ExRaiseStatus(STATUS_CANT_WAIT); + } + } + Entry = Add2Ptr(Context->PageBuffer, OffsetWithinPage, PULONG); + /* + * Next Page Offset. + */ + PageOffset = Context->PageOffset.QuadPart + PAGE_SIZE; + if (PageOffset > Context->BeyoundLastEntryOffset) + PageValidLength = (SIZE_T) (Context->BeyoundLastEntryOffset + - Context->PageOffset.QuadPart); + BeyoudLastEntry = Add2Ptr(Context->PageBuffer, PageValidLength, PULONG); + while (TRUE) + { + do + { + if ((*Entry & FAT_CLUSTER_LAST) != ++(*Index) ) + return (*Entry & FAT_CLUSTER_LAST); + } + while (++Entry < BeyoudLastEntry); + /* + * Check if this is the last available entry. + */ + if (PageValidLength < PAGE_SIZE) + break; + /* + * We are getting beyound current page and + * are still in the continous run, map the next page. + */ + Context->PageOffset.QuadPart = PageOffset; + CcUnpinData(Context->PageBcb); + if (!CcMapData(Context->FileObject, + &Context->PageOffset, PAGE_SIZE, CanWait, + &Context->PageBcb, &Context->PageBuffer)) + { + Context->PageBcb = NULL; + Context->PageOffset.QuadPart = 0LL; + ExRaiseStatus(STATUS_CANT_WAIT); + } + Entry = (PULONG) Context->PageBuffer; + /* + * Next Page Offset. + */ + PageOffset = Context->PageOffset.QuadPart + PAGE_SIZE; + if (PageOffset > Context->BeyoundLastEntryOffset) + PageValidLength = (SIZE_T) (Context->BeyoundLastEntryOffset + - Context->PageOffset.QuadPart); + BeyoudLastEntry = Add2Ptr(Context->PageBuffer, PageValidLength, PULONG); + } + return (*Index - 1); +} + +ULONG +FatSetFat32ContinousRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN ULONG Index, + IN ULONG Length, + IN BOOLEAN CanWait) +{ + ExRaiseStatus(STATUS_NOT_IMPLEMENTED); +} + +ULONG +FatScanFat32ForValueRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN OUT PULONG Index, + IN ULONG IndexValue, + IN BOOLEAN CanWait) +{ + ExRaiseStatus(STATUS_NOT_IMPLEMENTED); +} + +ULONG +FatSetFat32ValueRun( + IN OUT PFAT_SCAN_CONTEXT Context, + IN ULONG Index, + IN ULONG Length, + IN ULONG IndexValue, + IN BOOLEAN CanWait) +{ + ExRaiseStatus(STATUS_NOT_IMPLEMENTED); +} + +ULONG +FatScanFat( + IN PFCB Fcb, + IN LONGLONG Vbo, + OUT PLONGLONG Lbo, + IN OUT PLONGLONG Length, + OUT PULONG Index, + IN BOOLEAN CanWait +) +/* + * FUNCTION: + * Queries file MCB for the specified region [Vbo, Vbo + Length], + * returns the number of runs in the region as well as the first + * run of the range itself. + * If the specified region is not fully cached in MCB the routine + * scans FAT for the file and fills the MCB until the file offset + * (defined as Vbo + Length) is reached. + * ARGUMENTS: + * Fcb = Pointer to FCB structure for the file. + * Vbo = Virtual Byte Offset in the file. + * Lbo = Receives the Value of Logical Byte offset corresponding + * to supplied Vbo Value. + * Length = Supplies file range length to be examined and recieves + * the length of first run. + * OutIndex = Recieves the index (in MCB cache) of first run. + * RETURNS: Incremented index of the last run (+1). + * NOTES: Should be called by I/O routines to split the I/O operation + * into sequential or parallel I/O operations. + */ +{ + LONGLONG CurrentLbo, CurrentVbo, BeyoundLastVbo, CurrentLength; + ULONG Entry, NextEntry, NumberOfEntries, CurrentIndex; + FAT_SCAN_CONTEXT Context; + PVCB Vcb; + + /* + * Some often used values + */ + Vcb = Fcb->Vcb; + CurrentIndex = 0; + BeyoundLastVbo = Vbo + *Length; + CurrentLength = ((LONGLONG) Vcb->Clusters) << Vcb->BytesPerClusterLog; + if (BeyoundLastVbo > CurrentLength) + BeyoundLastVbo = CurrentLength; + /* + * Try to locate first run. + */ + if (FsRtlLookupLargeMcbEntry(&Fcb->Mcb, Vbo, Lbo, Length, NULL, NULL, Index)) + { + /* + * Check if we have a single mapped run. + */ + if (Vbo >= BeyoundLastVbo) + goto FatScanFcbFatExit; + } else { + *Length = 0L; + } + /* + * Get the first scan startup values. + */ + if (FsRtlLookupLastLargeMcbEntryAndIndex( + &Fcb->Mcb, &CurrentVbo, &CurrentLbo, &CurrentIndex)) + { + Entry = FatDataOffsetToEntry(CurrentLbo, Vcb); + } + else + { + /* + * Map is empty, set up initial values. + */ + Entry = Fcb->FirstCluster; + if (Entry <= 0x2) + ExRaiseStatus(STATUS_FILE_CORRUPT_ERROR); + if (Entry >= Vcb->Clusters) + { + if (Entry < FAT_CLUSTER_LAST) + ExRaiseStatus(STATUS_FILE_CORRUPT_ERROR); + BeyoundLastVbo = 0LL; + } + CurrentIndex = 0L; + CurrentVbo = 0LL; + } + RtlZeroMemory(&Context, sizeof(Context)); + Context.FileObject = Vcb->VolumeFileObject; + while (CurrentVbo < BeyoundLastVbo) + { + /* + * Locate Continous run starting with the current entry. + */ + NumberOfEntries = Entry; + NextEntry = Vcb->Methods.ScanContinousRun( + &Context, &NumberOfEntries, CanWait); + NumberOfEntries -= Entry; + /* + * Check value that terminated the for being valid for FAT. + */ + if (NextEntry <= 0x2) + ExRaiseStatus(STATUS_FILE_CORRUPT_ERROR); + if (NextEntry >= Vcb->Clusters) + { + if (NextEntry < FAT_CLUSTER_LAST) + ExRaiseStatus(STATUS_FILE_CORRUPT_ERROR); + break; + } + /* + * Add new run. + */ + CurrentLength = ((LONGLONG) NumberOfEntries) + << Vcb->BytesPerClusterLog; + FsRtlAddLargeMcbEntry(&Fcb->Mcb, + CurrentVbo, + FatEntryToDataOffset(Entry, Vcb), + CurrentLength); + /* + * Setup next iteration. + */ + Entry = NextEntry; + CurrentVbo += CurrentLength; + CurrentIndex ++; + } + if (*Length == 0LL && CurrentIndex > 0) + { + if (!FsRtlLookupLargeMcbEntry(&Fcb->Mcb, + Vbo, Lbo, Length, NULL, NULL, Index)) + { + *Index = 0L; + *Lbo = 0LL; + } + } +FatScanFcbFatExit: + return CurrentIndex; +} + +BOOLEAN +NTAPI +FatValidBpb( + IN PBIOS_PARAMETER_BLOCK Bpb) +{ + return (FatValidBytesPerSector(Bpb->BytesPerSector) + && FatValidSectorsPerCluster(Bpb->SectorsPerCluster) + && Bpb->ReservedSectors > 0 + && Bpb->Fats > 0 + && (Bpb->Sectors > 0 || Bpb->LargeSectors > 0) + && (Bpb->SectorsPerFat > 0 + || (Bpb->LargeSectorsPerFat > 0 && Bpb->FsVersion == 0)) + && (Bpb->Media == 0xf0 + || Bpb->Media == 0xf8 + || Bpb->Media == 0xf9 + || Bpb->Media == 0xfb + || Bpb->Media == 0xfc + || Bpb->Media == 0xfd + || Bpb->Media == 0xfe + || Bpb->Media == 0xff) + && (Bpb->SectorsPerFat == 0 || Bpb->RootEntries > 0) + && (Bpb->SectorsPerFat > 0 || !Bpb->MirrorDisabled)); +} + +VOID +FatiInitializeVcb( + PVCB Vcb) +{ + ULONG ClustersCapacity; + + /* Various characteristics needed for navigation in FAT */ + if ((Vcb->Sectors = Vcb->Bpb.Sectors) == 0) + Vcb->Sectors = Vcb->Bpb.LargeSectors; + if ((Vcb->SectorsPerFat = Vcb->Bpb.SectorsPerFat) == 0) + Vcb->SectorsPerFat = Vcb->Bpb.LargeSectorsPerFat; + Vcb->RootDirent = Vcb->Bpb.ReservedSectors + Vcb->Bpb.Fats * Vcb->SectorsPerFat; + Vcb->RootDirentSectors = BytesToSectors(Vcb, + Vcb->Bpb.RootEntries * sizeof(DIR_ENTRY)); + Vcb->DataArea = Vcb->RootDirent + Vcb->RootDirentSectors; + Vcb->Clusters = (Vcb->Sectors - Vcb->Bpb.ReservedSectors + - Vcb->Bpb.Fats * Vcb->SectorsPerFat + - Vcb->RootDirentSectors) / Vcb->Bpb.SectorsPerCluster; + if (Vcb->BytesPerClusterLog < 4087) + { + Vcb->IndexDepth = 0x0c; + Vcb->Methods = Fat12Methods; + } + else + { + Vcb->IndexDepth = 0x10; + Vcb->Methods = Fat16Methods; + } + /* Large Sectors are used for FAT32 */ + if (Vcb->Bpb.Sectors == 0) { + Vcb->IndexDepth = 0x20; + Vcb->Methods = Fat32Methods; + } + ClustersCapacity = (SectorsToBytes(Vcb, Vcb->Sectors) * 0x8 / Vcb->IndexDepth) - 1; + if (Vcb->Clusters > ClustersCapacity) + Vcb->Clusters = ClustersCapacity; + Vcb->BytesPerCluster = SectorsToBytes(Vcb, Vcb->Bpb.SectorsPerCluster); + Vcb->BytesPerClusterLog = FatPowerOfTwo(Vcb->BytesPerCluster); + Vcb->BeyoundLastClusterInFat = ((LONGLONG) Vcb->Clusters) * Vcb->IndexDepth / 0x8; +} + +NTSTATUS +FatInitializeVcb( + IN PVCB Vcb, + IN PDEVICE_OBJECT TargetDeviceObject, + IN PVPB Vpb) +{ + NTSTATUS Status; + PBCB Bcb; + PVOID Buffer; + LARGE_INTEGER Offset; + + RtlZeroMemory(Vcb, sizeof(*Vcb)); + + /* + * Initialize list head, so that it will + * not fail in cleanup. + */ + InitializeListHead(&Vcb->VcbLinks); + + /* Setup FCB Header. */ + Vcb->Header.NodeTypeCode = FAT_NTC_VCB; + Vcb->Header.NodeByteSize = sizeof(*Vcb); + + /* Setup Vcb fields */ + Vcb->TargetDeviceObject = TargetDeviceObject; + ObReferenceObject(TargetDeviceObject); + + /* Setup FCB Header. */ + ExInitializeFastMutex(&Vcb->HeaderMutex); + FsRtlSetupAdvancedHeader(&Vcb->Header, &Vcb->HeaderMutex); + + /* Create Volume File Object. */ + Vcb->VolumeFileObject = IoCreateStreamFileObject(NULL, + Vcb->TargetDeviceObject); + + /* We have to setup all FCB fields needed for CC. */ + Vcb->VolumeFileObject->FsContext = Vcb; + Vcb->VolumeFileObject->SectionObjectPointer = &Vcb->SectionObjectPointers; + + + /* At least full boot sector should be available. */ + Vcb->Header.FileSize.QuadPart = sizeof(PACKED_BOOT_SECTOR); + Vcb->Header.AllocationSize.QuadPart = sizeof(PACKED_BOOT_SECTOR); + Vcb->Header.ValidDataLength.HighPart = MAXLONG; + Vcb->Header.ValidDataLength.LowPart = MAXULONG; + + /* Initialize CC. */ + CcInitializeCacheMap(Vcb->VolumeFileObject, + (PCC_FILE_SIZES) &Vcb->Header.AllocationSize, + FALSE, + &FatGlobalData.CacheMgrNoopCallbacks, + Vcb); + + /* Read boot sector */ + Offset.QuadPart = 0; + Bcb = NULL; + /* + * Note: Volume Read path does not require + * any of the parameters set further + * in this routine. + */ + if (CcMapData(Vcb->VolumeFileObject, + &Offset, + sizeof(PACKED_BOOT_SECTOR), + TRUE, + &Bcb, + &Buffer)) + { + PPACKED_BOOT_SECTOR BootSector = (PPACKED_BOOT_SECTOR) Buffer; + FatUnpackBios(&Vcb->Bpb, &BootSector->PackedBpb); + if (!(FatBootSectorJumpValid(BootSector->Jump) + && FatValidBpb(&Vcb->Bpb))) + { + Status = STATUS_UNRECOGNIZED_VOLUME; + } + CopyUchar4( &Vpb->SerialNumber, BootSector->Id ); + CcUnpinData(Bcb); + } + else + { + Status = STATUS_UNRECOGNIZED_VOLUME; + goto FatInitializeVcbCleanup; + } + FatiInitializeVcb(Vcb); + /* Add this Vcb to grobal Vcb list. */ + InsertTailList(&FatGlobalData.VcbListHead, &Vcb->VcbLinks); + return STATUS_SUCCESS; + +FatInitializeVcbCleanup: + + /* Unwind the routine actions */ + FatUninitializeVcb(Vcb); + return Status; +} + +VOID +FatUninitializeVcb( + IN PVCB Vcb) +{ + LARGE_INTEGER ZeroSize; + + ZeroSize.QuadPart = 0LL; + + /* Close volume file */ + if (Vcb->VolumeFileObject != NULL) + { + /* Uninitialize CC. */ + CcUninitializeCacheMap(Vcb->VolumeFileObject, &ZeroSize, NULL); + ObDereferenceObject(Vcb->VolumeFileObject); + Vcb->VolumeFileObject = NULL; + } + /* Unlink from global Vcb list. */ + RemoveEntryList(&Vcb->VcbLinks); + + /* Release Target Device */ + ObReferenceObject(Vcb->TargetDeviceObject); + Vcb->TargetDeviceObject = NULL; +}
/* EOF */ + +
Modified: trunk/reactos/drivers/filesystems/fastfat_new/fsctl.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/drivers/filesystems/fastfat... ============================================================================== --- trunk/reactos/drivers/filesystems/fastfat_new/fsctl.c [iso-8859-1] (original) +++ trunk/reactos/drivers/filesystems/fastfat_new/fsctl.c [iso-8859-1] Fri Jan 23 04:19:57 2009 @@ -109,10 +109,20 @@ /* Save device object in a VPB */ Vpb->DeviceObject = (PDEVICE_OBJECT)VolumeDevice;
- /* TODO: Initialize VCB for this volume */ + /* Initialize VCB for this volume */ + Status = FatInitializeVcb(&VolumeDevice->Vcb, TargetDeviceObject, Vpb); + if (!NT_SUCCESS(Status)) + goto FatMountVolumeCleanup;
/* Return success */ return STATUS_SUCCESS; + + +FatMountVolumeCleanup: + + /* Unwind the routine actions */ + IoDeleteDevice((PDEVICE_OBJECT)VolumeDevice); + return Status; }
-
fireball＠svn.reactos.org