2910 lines
69 KiB
C
2910 lines
69 KiB
C
/*++
|
||
|
||
Copyright (c) 1989 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
StrucSup.c
|
||
|
||
Abstract:
|
||
|
||
This module implements the Fat in-memory data structure manipulation
|
||
routines
|
||
|
||
Author:
|
||
|
||
Gary Kimura [GaryKi] 22-Jan-1990
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "FatProcs.h"
|
||
|
||
//
|
||
//**** include this file for our quick hacked quota check in NtfsFreePagedPool
|
||
//
|
||
|
||
// #include <pool.h>
|
||
|
||
//
|
||
// The Bug check file id for this module
|
||
//
|
||
|
||
#define BugCheckFileId (FAT_BUG_CHECK_STRUCSUP)
|
||
|
||
//
|
||
// The debug trace level
|
||
//
|
||
|
||
#define Dbg (DEBUG_TRACE_STRUCSUP)
|
||
|
||
#define FillMemory(BUF,SIZ,MASK) { \
|
||
ULONG i; \
|
||
for (i = 0; i < (((SIZ)/4) - 1); i += 2) { \
|
||
((PULONG)(BUF))[i] = (MASK); \
|
||
((PULONG)(BUF))[i+1] = (ULONG)PsGetCurrentThread(); \
|
||
} \
|
||
}
|
||
|
||
#define IRP_CONTEXT_HEADER (sizeof( IRP_CONTEXT ) * 0x10000 + FAT_NTC_IRP_CONTEXT)
|
||
|
||
#ifdef ALLOC_PRAGMA
|
||
#pragma alloc_text(PAGE, FatInitializeVcb)
|
||
#pragma alloc_text(PAGE, FatDeleteVcb_Real)
|
||
#pragma alloc_text(PAGE, FatCreateRootDcb)
|
||
#pragma alloc_text(PAGE, FatCreateFcb)
|
||
#pragma alloc_text(PAGE, FatCreateDcb)
|
||
#pragma alloc_text(PAGE, FatDeleteFcb_Real)
|
||
#pragma alloc_text(PAGE, FatCreateCcb)
|
||
#pragma alloc_text(PAGE, FatDeleteCcb_Real)
|
||
#pragma alloc_text(PAGE, FatGetNextFcb)
|
||
#pragma alloc_text(PAGE, FatConstructNamesInFcb)
|
||
#pragma alloc_text(PAGE, FatCheckFreeDirentBitmap)
|
||
#pragma alloc_text(PAGE, FatCreateIrpContext)
|
||
#pragma alloc_text(PAGE, FatDeleteIrpContext_Real)
|
||
#pragma alloc_text(PAGE, FatIsHandleCountZero)
|
||
#endif
|
||
|
||
|
||
VOID
|
||
FatInitializeVcb (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN OUT PVCB Vcb,
|
||
IN PDEVICE_OBJECT TargetDeviceObject,
|
||
IN PVPB Vpb,
|
||
IN PDSCB Dscb OPTIONAL
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine initializes and inserts a new Vcb record into the in-memory
|
||
data structure. The Vcb record "hangs" off the end of the Volume device
|
||
object and must be allocated by our caller.
|
||
|
||
Arguments:
|
||
|
||
Vcb - Supplies the address of the Vcb record being initialized.
|
||
|
||
TargetDeviceObject - Supplies the address of the target device object to
|
||
associate with the Vcb record.
|
||
|
||
Vpb - Supplies the address of the Vpb to associate with the Vcb record.
|
||
|
||
Dscb - If present supplies the associated Double Space control block
|
||
|
||
Return Value:
|
||
|
||
None.
|
||
|
||
--*/
|
||
|
||
{
|
||
CC_FILE_SIZES FileSizes;
|
||
PDEVICE_OBJECT RealDevice;
|
||
LONG i;
|
||
|
||
//
|
||
// The following variables are used for abnormal unwind
|
||
//
|
||
|
||
PLIST_ENTRY UnwindEntryList = NULL;
|
||
PERESOURCE UnwindResource = NULL;
|
||
PERESOURCE UnwindVolFileResource = NULL;
|
||
PFILE_OBJECT UnwindFileObject = NULL;
|
||
PFILE_OBJECT UnwindCacheMap = NULL;
|
||
BOOLEAN UnwindWeAllocated0x24Bytes = FALSE;
|
||
BOOLEAN UnwindWeAllocatedMcb = FALSE;
|
||
PFILESYSTEM_STATISTICS UnwindStatistics = NULL;
|
||
|
||
DebugTrace(+1, Dbg, "FatInitializeVcb, Vcb = %08lx\n", Vcb);
|
||
|
||
try {
|
||
|
||
//
|
||
// We start by first zeroing out all of the VCB, this will guarantee
|
||
// that any stale data is wiped clean
|
||
//
|
||
|
||
RtlZeroMemory( Vcb, sizeof(VCB) );
|
||
|
||
//
|
||
// Set the proper node type code and node byte size
|
||
//
|
||
|
||
Vcb->VolumeFileHeader.NodeTypeCode = FAT_NTC_VCB;
|
||
Vcb->VolumeFileHeader.NodeByteSize = sizeof(VCB);
|
||
|
||
//
|
||
// Initialize the tunneling cache
|
||
//
|
||
|
||
FsRtlInitializeTunnelCache(&Vcb->Tunnel);
|
||
|
||
//
|
||
// Insert this Vcb record on the FatData.VcbQueue
|
||
//
|
||
|
||
ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
|
||
|
||
(VOID)FatAcquireExclusiveGlobal( IrpContext );
|
||
InsertTailList( &FatData.VcbQueue, &Vcb->VcbLinks );
|
||
FatReleaseGlobal( IrpContext );
|
||
UnwindEntryList = &Vcb->VcbLinks;
|
||
|
||
//
|
||
// Set the Target Device Object, Vpb, and Vcb State fields
|
||
//
|
||
|
||
Vcb->TargetDeviceObject = TargetDeviceObject;
|
||
Vcb->Vpb = Vpb;
|
||
|
||
//
|
||
// If this is a DoubleSpace volume note our "special" device.
|
||
//
|
||
|
||
Vcb->CurrentDevice = ARGUMENT_PRESENT(Dscb) ?
|
||
Dscb->NewDevice : Vpb->RealDevice;
|
||
|
||
//
|
||
// Set the removable media and floppy flag based on the real device's
|
||
// characteristics.
|
||
//
|
||
|
||
if (FlagOn(Vpb->RealDevice->Characteristics, FILE_REMOVABLE_MEDIA)) {
|
||
|
||
SetFlag( Vcb->VcbState, VCB_STATE_FLAG_REMOVABLE_MEDIA );
|
||
}
|
||
|
||
if (FlagOn(Vpb->RealDevice->Characteristics, FILE_FLOPPY_DISKETTE)) {
|
||
|
||
SetFlag( Vcb->VcbState, VCB_STATE_FLAG_FLOPPY );
|
||
}
|
||
|
||
Vcb->VcbCondition = VcbGood;
|
||
|
||
//
|
||
// Initialize the resource variable for the Vcb
|
||
//
|
||
|
||
ExInitializeResource( &Vcb->Resource );
|
||
UnwindResource = &Vcb->Resource;
|
||
|
||
//
|
||
// Initialize the free cluster bitmap mutex.
|
||
//
|
||
|
||
ExInitializeFastMutex( &Vcb->FreeClusterBitMapMutex );
|
||
|
||
//
|
||
// Now, put the Dscb parameter in the Vcb. If NULL, this is a normal
|
||
// mount and non-cached IO will go directly to the target device
|
||
// object. If non-NULL, the DSCB structure contains all the
|
||
// information needed to do the redirected reads and writes.
|
||
//
|
||
|
||
InitializeListHead(&Vcb->ParentDscbLinks);
|
||
|
||
if (ARGUMENT_PRESENT(Dscb)) {
|
||
|
||
Vcb->Dscb = Dscb;
|
||
Dscb->Vcb = Vcb;
|
||
|
||
SetFlag( Vcb->VcbState, VCB_STATE_FLAG_COMPRESSED_VOLUME );
|
||
}
|
||
|
||
//
|
||
// Create the special file object for the virtual volume file, and set
|
||
// up its pointers back to the Vcb and the section object pointer
|
||
//
|
||
|
||
RealDevice = Vcb->CurrentDevice;
|
||
|
||
Vcb->VirtualVolumeFile = UnwindFileObject = IoCreateStreamFileObject( NULL, RealDevice );
|
||
|
||
FatSetFileObject( Vcb->VirtualVolumeFile,
|
||
VirtualVolumeFile,
|
||
Vcb,
|
||
NULL );
|
||
|
||
Vcb->VirtualVolumeFile->SectionObjectPointer = &Vcb->SectionObjectPointers;
|
||
|
||
Vcb->VirtualVolumeFile->ReadAccess = TRUE;
|
||
Vcb->VirtualVolumeFile->WriteAccess = TRUE;
|
||
Vcb->VirtualVolumeFile->DeleteAccess = TRUE;
|
||
|
||
//
|
||
// Initialize the notify structures.
|
||
//
|
||
|
||
InitializeListHead( &Vcb->DirNotifyList );
|
||
|
||
FsRtlNotifyInitializeSync( &Vcb->NotifySync );
|
||
|
||
//
|
||
// Initialize the Cache Map for the volume file. The size is
|
||
// initially set to that of our first read. It will be extended
|
||
// when we know how big the Fat is.
|
||
//
|
||
|
||
FileSizes.AllocationSize.QuadPart =
|
||
FileSizes.FileSize.QuadPart = sizeof(PACKED_BOOT_SECTOR);
|
||
FileSizes.ValidDataLength = FatMaxLarge;
|
||
|
||
CcInitializeCacheMap( Vcb->VirtualVolumeFile,
|
||
&FileSizes,
|
||
TRUE,
|
||
&FatData.CacheManagerNoOpCallbacks,
|
||
Vcb );
|
||
UnwindCacheMap = Vcb->VirtualVolumeFile;
|
||
|
||
//
|
||
// Initialize the structure that will keep track of dirty fat sectors.
|
||
// The largest possible Mcb structures are less than 1K, so we use
|
||
// non paged pool.
|
||
//
|
||
|
||
FsRtlInitializeMcb( &Vcb->DirtyFatMcb, PagedPool );
|
||
|
||
UnwindWeAllocatedMcb = TRUE;
|
||
|
||
//
|
||
// Set the cluster index hint to the first valid cluster of a fat: 2
|
||
//
|
||
|
||
Vcb->ClusterHint = 2;
|
||
|
||
//
|
||
// Allocate space for the stashed Bpb.
|
||
//
|
||
|
||
Vcb->First0x24BytesOfBootSector =
|
||
FsRtlAllocatePool( PagedPool, 0x24 );
|
||
|
||
UnwindWeAllocated0x24Bytes = TRUE;
|
||
|
||
//
|
||
// Initialize the directory stream file object creation event.
|
||
// This event is also "borrowed" for async non-cached writes.
|
||
//
|
||
|
||
ExInitializeFastMutex( &Vcb->DirectoryFileCreationMutex );
|
||
|
||
//
|
||
// Initialize the clean volume callback Timer and DPC.
|
||
//
|
||
|
||
KeInitializeTimer( &Vcb->CleanVolumeTimer );
|
||
|
||
KeInitializeDpc( &Vcb->CleanVolumeDpc, FatCleanVolumeDpc, Vcb );
|
||
|
||
//
|
||
// Initialize the performance counters.
|
||
//
|
||
|
||
Vcb->Statistics = FsRtlAllocatePool( NonPagedPool,
|
||
sizeof(FILESYSTEM_STATISTICS) * *KeNumberProcessors );
|
||
UnwindStatistics = Vcb->Statistics;
|
||
|
||
RtlZeroMemory( Vcb->Statistics, sizeof(FILESYSTEM_STATISTICS) * *KeNumberProcessors );
|
||
|
||
for (i = 0; i < *KeNumberProcessors; i += 1) {
|
||
Vcb->Statistics[i].FileSystemType = FILESYSTEM_STATISTICS_TYPE_FAT;
|
||
Vcb->Statistics[i].Version = 1;
|
||
}
|
||
|
||
|
||
} finally {
|
||
|
||
DebugUnwind( FatInitializeVcb );
|
||
|
||
//
|
||
// If this is an abnormal termination then undo our work
|
||
//
|
||
|
||
if (AbnormalTermination()) {
|
||
|
||
if (UnwindCacheMap != NULL) { FatSyncUninitializeCacheMap( IrpContext, UnwindCacheMap ); }
|
||
if (UnwindFileObject != NULL) { ObDereferenceObject( UnwindFileObject ); }
|
||
if (UnwindVolFileResource != NULL) { FatDeleteResource( UnwindVolFileResource ); }
|
||
if (UnwindResource != NULL) { FatDeleteResource( UnwindResource ); }
|
||
if (UnwindWeAllocatedMcb) { FsRtlUninitializeMcb( &Vcb->DirtyFatMcb ); }
|
||
if (UnwindWeAllocated0x24Bytes) { ExFreePool(Vcb->First0x24BytesOfBootSector); }
|
||
if (UnwindEntryList != NULL) {
|
||
(VOID)FatAcquireExclusiveGlobal( IrpContext );
|
||
RemoveEntryList( UnwindEntryList );
|
||
FatReleaseGlobal( IrpContext );
|
||
}
|
||
if (UnwindStatistics != NULL) { ExFreePool( UnwindStatistics ); }
|
||
}
|
||
|
||
DebugTrace(-1, Dbg, "FatInitializeVcb -> VOID\n", 0);
|
||
}
|
||
|
||
//
|
||
// and return to our caller
|
||
//
|
||
|
||
UNREFERENCED_PARAMETER( IrpContext );
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
VOID
|
||
FatDeleteVcb_Real (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PVCB Vcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine removes the Vcb record from Fat's in-memory data
|
||
structures. It also will remove all associated underlings
|
||
(i.e., FCB records).
|
||
|
||
Arguments:
|
||
|
||
Vcb - Supplies the Vcb to be removed
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
DebugTrace(+1, Dbg, "FatDeleteVcb, Vcb = %08lx\n", Vcb);
|
||
|
||
//
|
||
// Uninitialize the cache
|
||
//
|
||
|
||
FatSyncUninitializeCacheMap( IrpContext, Vcb->VirtualVolumeFile );
|
||
|
||
//
|
||
// Dereference the virtual volume file. This will cause a close
|
||
// Irp to be processed, so we need to do this before we destory
|
||
// the Vcb
|
||
//
|
||
|
||
FatSetFileObject( Vcb->VirtualVolumeFile, UnopenedFileObject, NULL, NULL );
|
||
ObDereferenceObject( Vcb->VirtualVolumeFile );
|
||
|
||
//
|
||
// Remove this record from the global list of all Vcb records
|
||
//
|
||
|
||
(VOID)FatAcquireExclusiveGlobal( IrpContext );
|
||
RemoveEntryList( &(Vcb->VcbLinks) );
|
||
FatReleaseGlobal( IrpContext );
|
||
|
||
//
|
||
// Make sure the direct access open count is zero, and the open file count
|
||
// is also zero.
|
||
//
|
||
|
||
if ((Vcb->DirectAccessOpenCount != 0) || (Vcb->OpenFileCount != 0)) {
|
||
|
||
FatBugCheck( 0, 0, 0 );
|
||
}
|
||
|
||
ASSERT( IsListEmpty( &Vcb->ParentDscbLinks ) );
|
||
|
||
//
|
||
// Remove the EaFcb and dereference the Fcb for the Ea file if it
|
||
// exists.
|
||
//
|
||
|
||
if (Vcb->VirtualEaFile != NULL) {
|
||
|
||
FatSetFileObject( Vcb->VirtualEaFile, UnopenedFileObject, NULL, NULL );
|
||
FatSyncUninitializeCacheMap( IrpContext, Vcb->VirtualEaFile );
|
||
ObDereferenceObject( Vcb->VirtualEaFile );
|
||
}
|
||
|
||
if (Vcb->EaFcb != NULL) {
|
||
|
||
Vcb->EaFcb->OpenCount = 0;
|
||
FatDeleteFcb( IrpContext, Vcb->EaFcb );
|
||
|
||
Vcb->EaFcb = NULL;
|
||
}
|
||
|
||
//
|
||
// Remove the Root Dcb
|
||
//
|
||
|
||
if (Vcb->RootDcb != NULL) {
|
||
|
||
PFILE_OBJECT DirectoryFileObject = Vcb->RootDcb->Specific.Dcb.DirectoryFile;
|
||
|
||
if (DirectoryFileObject != NULL) {
|
||
|
||
FatSyncUninitializeCacheMap( IrpContext, DirectoryFileObject );
|
||
|
||
//
|
||
// Dereference the directory file. This will cause a close
|
||
// Irp to be processed, so we need to do this before we destory
|
||
// the Fcb
|
||
//
|
||
|
||
Vcb->RootDcb->Specific.Dcb.DirectoryFile = NULL;
|
||
Vcb->RootDcb->Specific.Dcb.DirectoryFileOpenCount -= 1;
|
||
FatSetFileObject( DirectoryFileObject, UnopenedFileObject, NULL, NULL );
|
||
ObDereferenceObject( DirectoryFileObject );
|
||
}
|
||
|
||
FatDeleteFcb( IrpContext, Vcb->RootDcb );
|
||
}
|
||
|
||
//
|
||
// Uninitialize the notify sychronization object.
|
||
//
|
||
|
||
FsRtlNotifyUninitializeSync( &Vcb->NotifySync );
|
||
|
||
//
|
||
// Uninitialize the resource variable for the Vcb
|
||
//
|
||
|
||
FatDeleteResource( &Vcb->Resource );
|
||
|
||
//
|
||
// If allocation support has been setup, free it.
|
||
//
|
||
|
||
if (Vcb->FreeClusterBitMap.Buffer != NULL) {
|
||
|
||
FatTearDownAllocationSupport( IrpContext, Vcb );
|
||
}
|
||
|
||
//
|
||
// UnInitialize the Mcb structure that kept track of dirty fat sectors.
|
||
//
|
||
|
||
FsRtlUninitializeMcb( &Vcb->DirtyFatMcb );
|
||
|
||
//
|
||
// Free the pool for the stached copy of the boot sector
|
||
//
|
||
|
||
ExFreePool( Vcb->First0x24BytesOfBootSector );
|
||
|
||
//
|
||
// Cancel the CleanVolume Timer and Dpc
|
||
//
|
||
|
||
(VOID)KeCancelTimer( &Vcb->CleanVolumeTimer );
|
||
|
||
(VOID)KeRemoveQueueDpc( &Vcb->CleanVolumeDpc );
|
||
|
||
//
|
||
// Free the performance counters memory
|
||
//
|
||
|
||
ExFreePool( Vcb->Statistics );
|
||
|
||
#ifdef WE_WON_ON_APPEAL
|
||
//
|
||
// If there is a Dscb, dismount and delete it.
|
||
//
|
||
|
||
if (Vcb->Dscb) {
|
||
|
||
FatDblsDismount( IrpContext, &Vcb->Dscb );
|
||
}
|
||
#endif // WE_WON_ON_APPEAL
|
||
|
||
//
|
||
// Clean out the tunneling cache
|
||
//
|
||
|
||
FsRtlDeleteTunnelCache(&Vcb->Tunnel);
|
||
|
||
//
|
||
// And zero out the Vcb, this will help ensure that any stale data is
|
||
// wiped clean
|
||
//
|
||
|
||
RtlZeroMemory( Vcb, sizeof(VCB) );
|
||
|
||
//
|
||
// return and tell the caller
|
||
//
|
||
|
||
DebugTrace(-1, Dbg, "FatDeleteVcb -> VOID\n", 0);
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
PDCB
|
||
FatCreateRootDcb (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PVCB Vcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine allocates, initializes, and inserts a new root DCB record
|
||
into the in memory data structure.
|
||
|
||
Arguments:
|
||
|
||
Vcb - Supplies the Vcb to associate the new DCB under
|
||
|
||
Return Value:
|
||
|
||
PDCB - returns pointer to the newly allocated root DCB.
|
||
|
||
--*/
|
||
|
||
{
|
||
PDCB Dcb;
|
||
|
||
//
|
||
// The following variables are used for abnormal unwind
|
||
//
|
||
|
||
PVOID UnwindStorage[5] = { NULL, NULL, NULL, NULL, NULL };
|
||
PERESOURCE UnwindResource = NULL;
|
||
PMCB UnwindMcb = NULL;
|
||
PFILE_OBJECT UnwindFileObject = NULL;
|
||
|
||
DebugTrace(+1, Dbg, "FatCreateRootDcb, Vcb = %08lx\n", Vcb);
|
||
|
||
try {
|
||
|
||
//
|
||
// Make sure we don't already have a root dcb for this vcb
|
||
//
|
||
|
||
if (Vcb->RootDcb != NULL) {
|
||
|
||
DebugDump("Error trying to create multiple root dcbs\n", 0, Vcb);
|
||
FatBugCheck( 0, 0, 0 );
|
||
}
|
||
|
||
//
|
||
// Allocate a new DCB and zero it out, we use Dcb locally so we don't
|
||
// have to continually reference through the Vcb
|
||
//
|
||
|
||
UnwindStorage[0] = Dcb = Vcb->RootDcb = FsRtlAllocatePool(NonPagedPool, sizeof(DCB));
|
||
|
||
RtlZeroMemory( Dcb, sizeof(DCB));
|
||
|
||
UnwindStorage[1] =
|
||
Dcb->NonPaged = FatAllocateNonPagedFcb();
|
||
|
||
RtlZeroMemory( Dcb->NonPaged, sizeof( NON_PAGED_FCB ) );
|
||
|
||
//
|
||
// Set the proper node type code, node byte size, and call backs
|
||
//
|
||
|
||
Dcb->Header.NodeTypeCode = FAT_NTC_ROOT_DCB;
|
||
Dcb->Header.NodeByteSize = sizeof(DCB);
|
||
|
||
Dcb->FcbCondition = FcbGood;
|
||
|
||
//
|
||
// The parent Dcb, initial state, open count, dirent location
|
||
// information, and directory change count fields are already zero so
|
||
// we can skip setting them
|
||
//
|
||
|
||
//
|
||
// Initialize the resource variable
|
||
//
|
||
|
||
UnwindStorage[2] =
|
||
Dcb->Header.Resource = FatAllocateResource();
|
||
|
||
UnwindResource = Dcb->Header.Resource;
|
||
|
||
//
|
||
// Initialize the PagingIo Resource
|
||
//
|
||
|
||
Dcb->Header.PagingIoResource = FsRtlAllocateResource();
|
||
|
||
//
|
||
// The root Dcb has an empty parent dcb links field
|
||
//
|
||
|
||
InitializeListHead( &Dcb->ParentDcbLinks );
|
||
|
||
//
|
||
// Set the Vcb
|
||
//
|
||
|
||
Dcb->Vcb = Vcb;
|
||
|
||
//
|
||
// Initialize the Mcb, and setup its mapping. Note that the root
|
||
// directory is a fixed size so we can set it everything up now.
|
||
//
|
||
|
||
FsRtlInitializeMcb( &Dcb->Mcb, NonPagedPool );
|
||
UnwindMcb = &Dcb->Mcb;
|
||
|
||
FsRtlAddMcbEntry( &Dcb->Mcb,
|
||
0,
|
||
FatRootDirectoryLbo( &Vcb->Bpb ),
|
||
FatRootDirectorySize( &Vcb->Bpb ));
|
||
|
||
//
|
||
// set the allocation size to real size of the root directory
|
||
//
|
||
|
||
Dcb->Header.FileSize.QuadPart =
|
||
Dcb->Header.AllocationSize.QuadPart = FatRootDirectorySize( &Vcb->Bpb );
|
||
|
||
//
|
||
// initialize the notify queues, and the parent dcb queue.
|
||
//
|
||
|
||
InitializeListHead( &Dcb->Specific.Dcb.ParentDcbQueue );
|
||
|
||
//
|
||
// set the full file name. We actually allocate pool here to spare
|
||
// a compare and jump.
|
||
//
|
||
|
||
Dcb->FullFileName.Buffer = L"\\";
|
||
Dcb->FullFileName.Length = (USHORT)2;
|
||
Dcb->FullFileName.MaximumLength = (USHORT)4;
|
||
|
||
Dcb->ShortName.Name.Oem.Buffer = "\\";
|
||
Dcb->ShortName.Name.Oem.Length = (USHORT)1;
|
||
Dcb->ShortName.Name.Oem.MaximumLength = (USHORT)2;
|
||
|
||
//
|
||
// Set our two create dirent aids to represent that we have yet to
|
||
// enumerate the directory for never used or deleted dirents.
|
||
//
|
||
|
||
Dcb->Specific.Dcb.UnusedDirentVbo = 0xffffffff;
|
||
Dcb->Specific.Dcb.DeletedDirentHint = 0xffffffff;
|
||
|
||
//
|
||
// Setup the free dirent bitmap buffer.
|
||
//
|
||
|
||
RtlInitializeBitMap( &Dcb->Specific.Dcb.FreeDirentBitmap,
|
||
NULL,
|
||
0 );
|
||
|
||
FatCheckFreeDirentBitmap( IrpContext, Dcb );
|
||
|
||
} finally {
|
||
|
||
DebugUnwind( FatCreateRootDcb );
|
||
|
||
//
|
||
// If this is an abnormal termination then undo our work
|
||
//
|
||
|
||
if (AbnormalTermination()) {
|
||
|
||
ULONG i;
|
||
|
||
if (UnwindFileObject != NULL) { ObDereferenceObject( UnwindFileObject ); }
|
||
if (UnwindMcb != NULL) { FsRtlUninitializeMcb( UnwindMcb ); }
|
||
if (UnwindResource != NULL) { FatDeleteResource( UnwindResource ); }
|
||
|
||
for (i = 0; i < 4; i += 1) {
|
||
if (UnwindStorage[i] != NULL) { ExFreePool( UnwindStorage[i] ); }
|
||
}
|
||
}
|
||
|
||
DebugTrace(-1, Dbg, "FatCreateRootDcb -> %8lx\n", Dcb);
|
||
}
|
||
|
||
//
|
||
// return and tell the caller
|
||
//
|
||
|
||
return Dcb;
|
||
}
|
||
|
||
|
||
PFCB
|
||
FatCreateFcb (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PVCB Vcb,
|
||
IN PDCB ParentDcb,
|
||
IN ULONG LfnOffsetWithinDirectory,
|
||
IN ULONG DirentOffsetWithinDirectory,
|
||
IN PDIRENT Dirent,
|
||
IN PUNICODE_STRING Lfn OPTIONAL,
|
||
IN BOOLEAN IsPagingFile
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine allocates, initializes, and inserts a new Fcb record into
|
||
the in-memory data structures.
|
||
|
||
Arguments:
|
||
|
||
Vcb - Supplies the Vcb to associate the new FCB under.
|
||
|
||
ParentDcb - Supplies the parent dcb that the new FCB is under.
|
||
|
||
LfnOffsetWithinDirectory - Supplies the offset of the LFN. If there is
|
||
no LFN associated with this file then this value is same as
|
||
DirentOffsetWithinDirectory.
|
||
|
||
DirentOffsetWithinDirectory - Supplies the offset, in bytes from the
|
||
start of the directory file where the dirent for the fcb is located
|
||
|
||
Dirent - Supplies the dirent for the fcb being created
|
||
|
||
Lfn - Supplies a long UNICODE name associated with this file.
|
||
|
||
IsPagingFile - Indicates if we are creating an FCB for a paging file
|
||
or some other type of file.
|
||
|
||
Return Value:
|
||
|
||
PFCB - Returns a pointer to the newly allocated FCB
|
||
|
||
--*/
|
||
|
||
{
|
||
PFCB Fcb;
|
||
POOL_TYPE PoolType;
|
||
|
||
//
|
||
// The following variables are used for abnormal unwind
|
||
//
|
||
|
||
PVOID UnwindStorage[3] = { NULL, NULL, NULL };
|
||
PERESOURCE UnwindResource = NULL;
|
||
PLIST_ENTRY UnwindEntryList = NULL;
|
||
PMCB UnwindMcb = NULL;
|
||
PFILE_LOCK UnwindFileLock = NULL;
|
||
POPLOCK UnwindOplock = NULL;
|
||
|
||
DebugTrace(+1, Dbg, "FatCreateFcb\n", 0);
|
||
|
||
try {
|
||
|
||
//
|
||
// Determine the pool type we should be using for the fcb and the
|
||
// mcb structure
|
||
//
|
||
|
||
if (IsPagingFile) {
|
||
|
||
PoolType = NonPagedPool;
|
||
Fcb = UnwindStorage[0] = FsRtlAllocatePool( NonPagedPool, sizeof(FCB) );
|
||
|
||
} else {
|
||
|
||
PoolType = PagedPool;
|
||
Fcb = UnwindStorage[0] = FatAllocateFcb();
|
||
|
||
}
|
||
|
||
//
|
||
// ... and zero it out
|
||
//
|
||
|
||
RtlZeroMemory( Fcb, sizeof(FCB) );
|
||
|
||
UnwindStorage[1] =
|
||
Fcb->NonPaged = FatAllocateNonPagedFcb();
|
||
|
||
RtlZeroMemory( Fcb->NonPaged, sizeof( NON_PAGED_FCB ) );
|
||
|
||
//
|
||
// Set the proper node type code, node byte size, and call backs
|
||
//
|
||
|
||
Fcb->Header.NodeTypeCode = FAT_NTC_FCB;
|
||
Fcb->Header.NodeByteSize = sizeof(FCB);
|
||
|
||
Fcb->FcbCondition = FcbGood;
|
||
|
||
//
|
||
// Check to see if we need to set the Fcb state to indicate that this
|
||
// is a paging file
|
||
//
|
||
|
||
if (IsPagingFile) {
|
||
|
||
Fcb->FcbState |= FCB_STATE_PAGING_FILE;
|
||
}
|
||
|
||
//
|
||
// The initial state, open count, and segment objects fields are already
|
||
// zero so we can skip setting them
|
||
//
|
||
|
||
//
|
||
// Initialize the resource variable
|
||
//
|
||
|
||
UnwindStorage[2] =
|
||
Fcb->Header.Resource = FatAllocateResource();
|
||
|
||
UnwindResource = Fcb->Header.Resource;
|
||
|
||
//
|
||
// Initialize the PagingIo Resource
|
||
//
|
||
|
||
Fcb->Header.PagingIoResource = FsRtlAllocateResource();
|
||
|
||
//
|
||
// Insert this fcb into our parent dcb's queue
|
||
//
|
||
|
||
InsertTailList( &ParentDcb->Specific.Dcb.ParentDcbQueue,
|
||
&Fcb->ParentDcbLinks );
|
||
UnwindEntryList = &Fcb->ParentDcbLinks;
|
||
|
||
//
|
||
// Point back to our parent dcb
|
||
//
|
||
|
||
Fcb->ParentDcb = ParentDcb;
|
||
|
||
//
|
||
// Set the Vcb
|
||
//
|
||
|
||
Fcb->Vcb = Vcb;
|
||
|
||
//
|
||
// Set the dirent offset within the directory
|
||
//
|
||
|
||
Fcb->LfnOffsetWithinDirectory = LfnOffsetWithinDirectory;
|
||
Fcb->DirentOffsetWithinDirectory = DirentOffsetWithinDirectory;
|
||
|
||
//
|
||
// Set the DirentFatFlags and LastWriteTime
|
||
//
|
||
|
||
Fcb->DirentFatFlags = Dirent->Attributes;
|
||
|
||
Fcb->LastWriteTime = FatFatTimeToNtTime( IrpContext,
|
||
Dirent->LastWriteTime,
|
||
0 );
|
||
|
||
//
|
||
// These fields are only non-zero when in Chicago mode.
|
||
//
|
||
|
||
if (FatData.ChicagoMode) {
|
||
|
||
LARGE_INTEGER FatSystemJanOne1980;
|
||
|
||
//
|
||
// If either date is possibly zero, get the system
|
||
// version of 1/1/80.
|
||
//
|
||
|
||
if ((((PUSHORT)Dirent)[9] & ((PUSHORT)Dirent)[8]) == 0) {
|
||
|
||
ExLocalTimeToSystemTime( &FatJanOne1980,
|
||
&FatSystemJanOne1980 );
|
||
}
|
||
|
||
//
|
||
// Only do the really hard work if this field is non-zero.
|
||
//
|
||
|
||
if (((PUSHORT)Dirent)[9] != 0) {
|
||
|
||
Fcb->LastAccessTime =
|
||
FatFatDateToNtTime( IrpContext,
|
||
Dirent->LastAccessDate );
|
||
|
||
} else {
|
||
|
||
Fcb->LastAccessTime = FatSystemJanOne1980;
|
||
}
|
||
|
||
//
|
||
// Only do the really hard work if this field is non-zero.
|
||
//
|
||
|
||
if (((PUSHORT)Dirent)[8] != 0) {
|
||
|
||
Fcb->CreationTime =
|
||
FatFatTimeToNtTime( IrpContext,
|
||
Dirent->CreationTime,
|
||
Dirent->CreationMSec );
|
||
|
||
} else {
|
||
|
||
Fcb->CreationTime = FatSystemJanOne1980;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Initialize the Mcb
|
||
//
|
||
|
||
FsRtlInitializeMcb( &Fcb->Mcb, PoolType );
|
||
UnwindMcb = &Fcb->Mcb;
|
||
|
||
//
|
||
// Set the file size, valid data length, first cluster of file,
|
||
// and allocation size based on the information stored in the dirent
|
||
//
|
||
|
||
Fcb->Header.FileSize.LowPart = Dirent->FileSize;
|
||
|
||
Fcb->Header.ValidDataLength.LowPart = Dirent->FileSize;
|
||
|
||
Fcb->ValidDataToDisk = Dirent->FileSize;
|
||
|
||
Fcb->FirstClusterOfFile = (ULONG)Dirent->FirstClusterOfFile;
|
||
|
||
if ( Fcb->FirstClusterOfFile == 0 ) {
|
||
|
||
Fcb->Header.AllocationSize.QuadPart = 0;
|
||
|
||
} else {
|
||
|
||
Fcb->Header.AllocationSize.QuadPart = (LONG)-1;
|
||
}
|
||
|
||
//
|
||
// Initialize the Fcb's file lock record
|
||
//
|
||
|
||
FsRtlInitializeFileLock( &Fcb->Specific.Fcb.FileLock, NULL, NULL );
|
||
UnwindFileLock = &Fcb->Specific.Fcb.FileLock;
|
||
|
||
//
|
||
// Initialize the oplock structure.
|
||
//
|
||
|
||
FsRtlInitializeOplock( &Fcb->Specific.Fcb.Oplock );
|
||
UnwindOplock = &Fcb->Specific.Fcb.Oplock;
|
||
|
||
//
|
||
// Indicate that Fast I/O is possible
|
||
//
|
||
|
||
Fcb->Header.IsFastIoPossible = TRUE;
|
||
|
||
//
|
||
// Set the file names. This must be the last thing we do.
|
||
//
|
||
|
||
FatConstructNamesInFcb( IrpContext,
|
||
Fcb,
|
||
Dirent,
|
||
Lfn );
|
||
|
||
//
|
||
// Drop the shortname hint so prefix searches can figure out
|
||
// what they found
|
||
//
|
||
|
||
Fcb->ShortName.FileNameDos = TRUE;
|
||
|
||
} finally {
|
||
|
||
DebugUnwind( FatCreateFcb );
|
||
|
||
//
|
||
// If this is an abnormal termination then undo our work
|
||
//
|
||
|
||
if (AbnormalTermination()) {
|
||
|
||
ULONG i;
|
||
|
||
if (UnwindOplock != NULL) { FsRtlUninitializeOplock( UnwindOplock ); }
|
||
if (UnwindFileLock != NULL) { FsRtlUninitializeFileLock( UnwindFileLock ); }
|
||
if (UnwindMcb != NULL) { FsRtlUninitializeMcb( UnwindMcb ); }
|
||
if (UnwindEntryList != NULL) { RemoveEntryList( UnwindEntryList ); }
|
||
if (UnwindResource != NULL) { FatDeleteResource( UnwindResource ); }
|
||
|
||
for (i = 0; i < 3; i += 1) {
|
||
if (UnwindStorage[i] != NULL) { ExFreePool( UnwindStorage[i] ); }
|
||
}
|
||
}
|
||
|
||
DebugTrace(-1, Dbg, "FatCreateFcb -> %08lx\n", Fcb);
|
||
}
|
||
|
||
//
|
||
// return and tell the caller
|
||
//
|
||
|
||
return Fcb;
|
||
}
|
||
|
||
|
||
PDCB
|
||
FatCreateDcb (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PVCB Vcb,
|
||
IN PDCB ParentDcb,
|
||
IN ULONG LfnOffsetWithinDirectory,
|
||
IN ULONG DirentOffsetWithinDirectory,
|
||
IN PDIRENT Dirent,
|
||
IN PUNICODE_STRING Lfn OPTIONAL
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine allocates, initializes, and inserts a new Dcb record into
|
||
the in memory data structures.
|
||
|
||
Arguments:
|
||
|
||
Vcb - Supplies the Vcb to associate the new DCB under.
|
||
|
||
ParentDcb - Supplies the parent dcb that the new DCB is under.
|
||
|
||
LfnOffsetWithinDirectory - Supplies the offset of the LFN. If there is
|
||
no LFN associated with this file then this value is same as
|
||
DirentOffsetWithinDirectory.
|
||
|
||
DirentOffsetWithinDirectory - Supplies the offset, in bytes from the
|
||
start of the directory file where the dirent for the fcb is located
|
||
|
||
Dirent - Supplies the dirent for the dcb being created
|
||
|
||
FileName - Supplies the file name of the file relative to the directory
|
||
it's in (e.g., the file \config.sys is called "CONFIG.SYS" without
|
||
the preceding backslash).
|
||
|
||
Lfn - Supplies a long UNICODE name associated with this directory.
|
||
|
||
Return Value:
|
||
|
||
PDCB - Returns a pointer to the newly allocated DCB
|
||
|
||
--*/
|
||
|
||
{
|
||
PDCB Dcb;
|
||
|
||
//
|
||
// The following variables are used for abnormal unwind
|
||
//
|
||
|
||
PVOID UnwindStorage[4] = { NULL, NULL, NULL, NULL };
|
||
PERESOURCE UnwindResource = NULL;
|
||
PLIST_ENTRY UnwindEntryList = NULL;
|
||
PMCB UnwindMcb = NULL;
|
||
|
||
DebugTrace(+1, Dbg, "FatCreateDcb\n", 0);
|
||
|
||
try {
|
||
|
||
//
|
||
// assert that the only time we are called is if wait is true
|
||
//
|
||
|
||
ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
|
||
|
||
//
|
||
// Allocate a new DCB, and zero it out
|
||
//
|
||
|
||
UnwindStorage[0] = Dcb = FatAllocateFcb();
|
||
|
||
RtlZeroMemory( Dcb, sizeof(DCB) );
|
||
|
||
UnwindStorage[1] =
|
||
Dcb->NonPaged = FatAllocateNonPagedFcb();
|
||
|
||
RtlZeroMemory( Dcb->NonPaged, sizeof( NON_PAGED_FCB ) );
|
||
|
||
//
|
||
// Set the proper node type code, node byte size and call backs
|
||
//
|
||
|
||
Dcb->Header.NodeTypeCode = FAT_NTC_DCB;
|
||
Dcb->Header.NodeByteSize = sizeof(DCB);
|
||
|
||
Dcb->FcbCondition = FcbGood;
|
||
|
||
//
|
||
// The initial state, open count, and directory change count fields are
|
||
// already zero so we can skip setting them
|
||
//
|
||
|
||
//
|
||
// Initialize the resource variable
|
||
//
|
||
|
||
UnwindStorage[2] =
|
||
Dcb->Header.Resource = FatAllocateResource();
|
||
|
||
UnwindResource = Dcb->Header.Resource;
|
||
|
||
//
|
||
// Initialize the PagingIo Resource
|
||
//
|
||
|
||
Dcb->Header.PagingIoResource = FsRtlAllocateResource();
|
||
|
||
//
|
||
// Insert this Dcb into our parent dcb's queue
|
||
//
|
||
|
||
InsertTailList( &ParentDcb->Specific.Dcb.ParentDcbQueue,
|
||
&Dcb->ParentDcbLinks );
|
||
UnwindEntryList = &Dcb->ParentDcbLinks;
|
||
|
||
//
|
||
// Point back to our parent dcb
|
||
//
|
||
|
||
Dcb->ParentDcb = ParentDcb;
|
||
|
||
//
|
||
// Set the Vcb
|
||
//
|
||
|
||
Dcb->Vcb = Vcb;
|
||
|
||
//
|
||
// Set the dirent offset within the directory
|
||
//
|
||
|
||
Dcb->LfnOffsetWithinDirectory = LfnOffsetWithinDirectory;
|
||
Dcb->DirentOffsetWithinDirectory = DirentOffsetWithinDirectory;
|
||
|
||
//
|
||
// Set the DirentFatFlags and LastWriteTime
|
||
//
|
||
|
||
Dcb->DirentFatFlags = Dirent->Attributes;
|
||
|
||
Dcb->LastWriteTime = FatFatTimeToNtTime( IrpContext,
|
||
Dirent->LastWriteTime,
|
||
0 );
|
||
|
||
//
|
||
// These fields are only non-zero when in Chicago mode.
|
||
//
|
||
|
||
if (FatData.ChicagoMode) {
|
||
|
||
LARGE_INTEGER FatSystemJanOne1980;
|
||
|
||
//
|
||
// If either date is possibly zero, get the system
|
||
// version of 1/1/80.
|
||
//
|
||
|
||
if ((((PUSHORT)Dirent)[9] & ((PUSHORT)Dirent)[8]) == 0) {
|
||
|
||
ExLocalTimeToSystemTime( &FatJanOne1980,
|
||
&FatSystemJanOne1980 );
|
||
}
|
||
|
||
//
|
||
// Only do the really hard work if this field is non-zero.
|
||
//
|
||
|
||
if (((PUSHORT)Dirent)[9] != 0) {
|
||
|
||
Dcb->LastAccessTime =
|
||
FatFatDateToNtTime( IrpContext,
|
||
Dirent->LastAccessDate );
|
||
|
||
} else {
|
||
|
||
Dcb->LastAccessTime = FatSystemJanOne1980;
|
||
}
|
||
|
||
//
|
||
// Only do the really hard work if this field is non-zero.
|
||
//
|
||
|
||
if (((PUSHORT)Dirent)[8] != 0) {
|
||
|
||
Dcb->CreationTime =
|
||
FatFatTimeToNtTime( IrpContext,
|
||
Dirent->CreationTime,
|
||
Dirent->CreationMSec );
|
||
|
||
} else {
|
||
|
||
Dcb->CreationTime = FatSystemJanOne1980;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Initialize the Mcb
|
||
//
|
||
|
||
FsRtlInitializeMcb( &Dcb->Mcb, PagedPool );
|
||
UnwindMcb = &Dcb->Mcb;
|
||
|
||
//
|
||
// Set the file size, first cluster of file, and allocation size
|
||
// based on the information stored in the dirent
|
||
//
|
||
|
||
Dcb->FirstClusterOfFile = (ULONG)Dirent->FirstClusterOfFile;
|
||
|
||
if ( Dcb->FirstClusterOfFile == 0 ) {
|
||
|
||
Dcb->Header.AllocationSize.QuadPart = 0;
|
||
|
||
} else {
|
||
|
||
Dcb->Header.AllocationSize.QuadPart = (LONG)-1;
|
||
}
|
||
|
||
// initialize the notify queues, and the parent dcb queue.
|
||
//
|
||
|
||
InitializeListHead( &Dcb->Specific.Dcb.ParentDcbQueue );
|
||
|
||
//
|
||
// Setup the free dirent bitmap buffer. Since we don't know the
|
||
// size of the directory, leave it zero for now.
|
||
//
|
||
|
||
RtlInitializeBitMap( &Dcb->Specific.Dcb.FreeDirentBitmap,
|
||
NULL,
|
||
0 );
|
||
|
||
//
|
||
// Set our two create dirent aids to represent that we have yet to
|
||
// enumerate the directory for never used or deleted dirents.
|
||
//
|
||
|
||
Dcb->Specific.Dcb.UnusedDirentVbo = 0xffffffff;
|
||
Dcb->Specific.Dcb.DeletedDirentHint = 0xffffffff;
|
||
|
||
//
|
||
// Postpone initializing the cache map until we need to do a read/write
|
||
// of the directory file.
|
||
|
||
|
||
//
|
||
// set the file names. This must be the last thing we do.
|
||
//
|
||
|
||
FatConstructNamesInFcb( IrpContext,
|
||
Dcb,
|
||
Dirent,
|
||
Lfn );
|
||
|
||
} finally {
|
||
|
||
DebugUnwind( FatCreateDcb );
|
||
|
||
//
|
||
// If this is an abnormal termination then undo our work
|
||
//
|
||
|
||
if (AbnormalTermination()) {
|
||
|
||
ULONG i;
|
||
|
||
if (UnwindMcb != NULL) { FsRtlUninitializeMcb( UnwindMcb ); }
|
||
if (UnwindEntryList != NULL) { RemoveEntryList( UnwindEntryList ); }
|
||
if (UnwindResource != NULL) { FatDeleteResource( UnwindResource ); }
|
||
|
||
for (i = 0; i < 4; i += 1) {
|
||
if (UnwindStorage[i] != NULL) { ExFreePool( UnwindStorage[i] ); }
|
||
}
|
||
}
|
||
|
||
DebugTrace(-1, Dbg, "FatCreateDcb -> %08lx\n", Dcb);
|
||
}
|
||
|
||
//
|
||
// return and tell the caller
|
||
//
|
||
|
||
DebugTrace(-1, Dbg, "FatCreateDcb -> %08lx\n", Dcb);
|
||
|
||
return Dcb;
|
||
}
|
||
|
||
|
||
VOID
|
||
FatDeleteFcb_Real (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PFCB Fcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine deallocates and removes an FCB, DCB, or ROOT DCB record
|
||
from Fat's in-memory data structures. It also will remove all
|
||
associated underlings (i.e., Notify irps, and child FCB/DCB records).
|
||
|
||
Arguments:
|
||
|
||
Fcb - Supplies the FCB/DCB/ROOT DCB to be removed
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
DebugTrace(+1, Dbg, "FatDeleteFcb, Fcb = %08lx\n", Fcb);
|
||
|
||
//
|
||
// We can only delete this record if the open count is zero.
|
||
//
|
||
|
||
if (Fcb->OpenCount != 0) {
|
||
|
||
DebugDump("Error deleting Fcb, Still Open\n", 0, Fcb);
|
||
FatBugCheck( 0, 0, 0 );
|
||
}
|
||
|
||
//
|
||
// If this is a DCB then remove every Notify record from the two
|
||
// notify queues
|
||
//
|
||
|
||
if ((Fcb->Header.NodeTypeCode == FAT_NTC_DCB) ||
|
||
(Fcb->Header.NodeTypeCode == FAT_NTC_ROOT_DCB)) {
|
||
|
||
//
|
||
// If we allocated a free dirent bitmap buffer, free it.
|
||
//
|
||
|
||
if ((Fcb->Specific.Dcb.FreeDirentBitmap.Buffer != NULL) &&
|
||
(Fcb->Specific.Dcb.FreeDirentBitmap.Buffer !=
|
||
&Fcb->Specific.Dcb.FreeDirentBitmapBuffer[0])) {
|
||
|
||
ExFreePool(Fcb->Specific.Dcb.FreeDirentBitmap.Buffer);
|
||
}
|
||
|
||
ASSERT( Fcb->Specific.Dcb.DirectoryFileOpenCount == 0 );
|
||
ASSERT( IsListEmpty(&Fcb->Specific.Dcb.ParentDcbQueue) );
|
||
|
||
} else {
|
||
|
||
//
|
||
// Uninitialize the byte range file locks and opportunistic locks
|
||
//
|
||
|
||
FsRtlUninitializeFileLock( &Fcb->Specific.Fcb.FileLock );
|
||
FsRtlUninitializeOplock( &Fcb->Specific.Fcb.Oplock );
|
||
}
|
||
|
||
//
|
||
// Uninitialize the Mcb
|
||
//
|
||
|
||
FsRtlUninitializeMcb( &Fcb->Mcb );
|
||
|
||
//
|
||
// If this is not the root dcb then we need to remove ourselves from
|
||
// our parents Dcb queue
|
||
//
|
||
|
||
if (Fcb->Header.NodeTypeCode != FAT_NTC_ROOT_DCB) {
|
||
|
||
RemoveEntryList( &(Fcb->ParentDcbLinks) );
|
||
}
|
||
|
||
//
|
||
// Remove the entry from the splay table if there is still is one.
|
||
//
|
||
|
||
if (FlagOn( Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE )) {
|
||
|
||
FatRemoveNames( IrpContext, Fcb );
|
||
}
|
||
|
||
//
|
||
// Free the file name pool if allocated.
|
||
//
|
||
|
||
if (Fcb->Header.NodeTypeCode != FAT_NTC_ROOT_DCB) {
|
||
|
||
ExFreePool( Fcb->ShortName.Name.Oem.Buffer );
|
||
|
||
if (Fcb->FullFileName.Buffer) {
|
||
|
||
ExFreePool( Fcb->FullFileName.Buffer );
|
||
}
|
||
}
|
||
|
||
if (Fcb->ExactCaseLongName.Buffer) {
|
||
|
||
ExFreePool(Fcb->ExactCaseLongName.Buffer);
|
||
}
|
||
|
||
//
|
||
// Free up the resource variable. If we are below FatForceCacheMiss(),
|
||
// release the resource here.
|
||
//
|
||
|
||
if (FlagOn( Fcb->FcbState, FCB_STATE_FORCE_MISS_IN_PROGRESS) ) {
|
||
|
||
// FatReleaseFcb( IrpContext, Fcb );
|
||
// DavidGoe 5/26/94 - No reason to release the resource here.
|
||
}
|
||
|
||
//
|
||
// Finally deallocate the Fcb and non-paged fcb records
|
||
//
|
||
|
||
FatFreeResource( Fcb->Header.Resource );
|
||
FatFreeNonPagedFcb( Fcb->NonPaged );
|
||
FatFreeFcb( Fcb );
|
||
|
||
//
|
||
// and return to our caller
|
||
//
|
||
|
||
DebugTrace(-1, Dbg, "FatDeleteFcb -> VOID\n", 0);
|
||
|
||
return;
|
||
}
|
||
|
||
PCCB
|
||
FatCreateCcb (
|
||
IN PIRP_CONTEXT IrpContext
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine creates a new CCB record
|
||
|
||
Arguments:
|
||
|
||
Return Value:
|
||
|
||
CCB - returns a pointer to the newly allocate CCB
|
||
|
||
--*/
|
||
|
||
{
|
||
PCCB Ccb;
|
||
|
||
DebugTrace(+1, Dbg, "FatCreateCcb\n", 0);
|
||
|
||
//
|
||
// Allocate a new CCB Record
|
||
//
|
||
|
||
Ccb = FatAllocateCcb();
|
||
|
||
RtlZeroMemory( Ccb, sizeof(CCB) );
|
||
|
||
//
|
||
// Set the proper node type code and node byte size
|
||
//
|
||
|
||
Ccb->NodeTypeCode = FAT_NTC_CCB;
|
||
Ccb->NodeByteSize = sizeof(CCB);
|
||
|
||
//
|
||
// return and tell the caller
|
||
//
|
||
|
||
DebugTrace(-1, Dbg, "FatCreateCcb -> %08lx\n", Ccb);
|
||
|
||
UNREFERENCED_PARAMETER( IrpContext );
|
||
|
||
return Ccb;
|
||
}
|
||
|
||
|
||
VOID
|
||
FatDeleteCcb_Real (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PCCB Ccb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine deallocates and removes the specified CCB record
|
||
from the Fat in memory data structures
|
||
|
||
Arguments:
|
||
|
||
Ccb - Supplies the CCB to remove
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
DebugTrace(+1, Dbg, "FatDeleteCcb, Ccb = %08lx\n", Ccb);
|
||
|
||
//
|
||
// If we allocated query template buffers, deallocate them now.
|
||
//
|
||
|
||
if (FlagOn(Ccb->Flags, CCB_FLAG_FREE_UNICODE)) {
|
||
|
||
ASSERT( Ccb->UnicodeQueryTemplate.Buffer );
|
||
RtlFreeUnicodeString( &Ccb->UnicodeQueryTemplate );
|
||
}
|
||
|
||
if (FlagOn(Ccb->Flags, CCB_FLAG_FREE_OEM_BEST_FIT)) {
|
||
|
||
ASSERT( Ccb->OemQueryTemplate.Wild.Buffer );
|
||
FatFreeOemString( &Ccb->OemQueryTemplate.Wild );
|
||
}
|
||
|
||
//
|
||
// Deallocate the Ccb record
|
||
//
|
||
|
||
FatFreeCcb( Ccb );
|
||
|
||
//
|
||
// return and tell the caller
|
||
//
|
||
|
||
DebugTrace(-1, Dbg, "FatDeleteCcb -> VOID\n", 0);
|
||
|
||
UNREFERENCED_PARAMETER( IrpContext );
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
PIRP_CONTEXT
|
||
FatCreateIrpContext (
|
||
IN PIRP Irp,
|
||
IN BOOLEAN Wait
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine creates a new IRP_CONTEXT record
|
||
|
||
Arguments:
|
||
|
||
Irp - Supplies the originating Irp.
|
||
|
||
Wait - Supplies the wait value to store in the context
|
||
|
||
Return Value:
|
||
|
||
PIRP_CONTEXT - returns a pointer to the newly allocate IRP_CONTEXT Record
|
||
|
||
--*/
|
||
|
||
{
|
||
PIRP_CONTEXT IrpContext;
|
||
PIO_STACK_LOCATION IrpSp;
|
||
|
||
DebugTrace(+1, Dbg, "FatCreateIrpContext\n", 0);
|
||
|
||
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
||
|
||
//
|
||
// If we were called with our file system device object instead of a
|
||
// volume device object and this is not a mount, the request is illegal.
|
||
//
|
||
|
||
if ((IrpSp->DeviceObject->Size == (USHORT)sizeof(DEVICE_OBJECT)) &&
|
||
(IrpSp->FileObject != NULL)) {
|
||
|
||
ExRaiseStatus( STATUS_INVALID_DEVICE_REQUEST );
|
||
}
|
||
|
||
//
|
||
// Attemtp to allocate from the region first and failing that allocate
|
||
// from pool.
|
||
//
|
||
|
||
DebugDoit( FatFsdEntryCount += 1);
|
||
|
||
IrpContext = ExAllocateFromNPagedLookasideList( &FatIrpContextLookasideList );
|
||
|
||
if (IrpContext == NULL) {
|
||
|
||
IrpContext = FsRtlAllocatePool( NonPagedPool, sizeof(IRP_CONTEXT) );
|
||
|
||
//
|
||
// Zero out the irp context and indicate that it is from pool and
|
||
// not region allocated
|
||
//
|
||
|
||
RtlZeroMemory( IrpContext, sizeof(IRP_CONTEXT) );
|
||
|
||
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_FROM_POOL );
|
||
|
||
} else {
|
||
|
||
//
|
||
// Zero out the irp context and indicate that it is from zone and
|
||
// not pool allocated
|
||
//
|
||
|
||
RtlZeroMemory( IrpContext, sizeof(IRP_CONTEXT) );
|
||
}
|
||
|
||
//
|
||
// Set the proper node type code and node byte size
|
||
//
|
||
|
||
IrpContext->NodeTypeCode = FAT_NTC_IRP_CONTEXT;
|
||
IrpContext->NodeByteSize = sizeof(IRP_CONTEXT);
|
||
|
||
//
|
||
// Set the originating Irp field
|
||
//
|
||
|
||
IrpContext->OriginatingIrp = Irp;
|
||
|
||
//
|
||
// Major/Minor Function codes
|
||
//
|
||
|
||
IrpContext->MajorFunction = IrpSp->MajorFunction;
|
||
IrpContext->MinorFunction = IrpSp->MinorFunction;
|
||
|
||
//
|
||
// Copy RealDevice for workque algorithms, and also set Write Through
|
||
// and Removable Media if there is a file object. Only file system
|
||
// control Irps won't have a file object, and they should all have
|
||
// a Vpb as the first IrpSp location.
|
||
//
|
||
|
||
if (IrpSp->FileObject != NULL) {
|
||
|
||
PVCB Vcb;
|
||
PVOLUME_DEVICE_OBJECT VolumeDeviceObject;
|
||
PFILE_OBJECT FileObject = IrpSp->FileObject;
|
||
|
||
IrpContext->RealDevice = FileObject->DeviceObject;
|
||
|
||
//
|
||
// Locate the volume device object and Vcb that we are trying to access
|
||
// so we can see if the request is Write Through.
|
||
//
|
||
|
||
VolumeDeviceObject = (PVOLUME_DEVICE_OBJECT)IrpSp->DeviceObject;
|
||
|
||
Vcb = &VolumeDeviceObject->Vcb;
|
||
|
||
if (IsFileWriteThrough( FileObject, Vcb )) {
|
||
|
||
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH);
|
||
}
|
||
|
||
if (FlagOn(Vcb->VcbState, VCB_STATE_FLAG_FLOPPY)) {
|
||
|
||
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_FLOPPY);
|
||
}
|
||
|
||
} else if (IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL) {
|
||
|
||
IrpContext->RealDevice = IrpSp->Parameters.MountVolume.Vpb->RealDevice;
|
||
}
|
||
|
||
//
|
||
// Set the wait parameter
|
||
//
|
||
|
||
if (Wait) { SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT); }
|
||
|
||
//
|
||
// Set the recursive file system call parameter. We set it true if
|
||
// the TopLevelIrp field in the thread local storage is not the current
|
||
// irp, otherwise we leave it as FALSE.
|
||
//
|
||
|
||
if ( IoGetTopLevelIrp() != Irp) {
|
||
|
||
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_RECURSIVE_CALL);
|
||
}
|
||
|
||
//
|
||
// return and tell the caller
|
||
//
|
||
|
||
DebugTrace(-1, Dbg, "FatCreateIrpContext -> %08lx\n", IrpContext);
|
||
|
||
return IrpContext;
|
||
}
|
||
|
||
|
||
|
||
VOID
|
||
FatDeleteIrpContext_Real (
|
||
IN PIRP_CONTEXT IrpContext
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine deallocates and removes the specified IRP_CONTEXT record
|
||
from the Fat in memory data structures. It should only be called
|
||
by FatCompleteRequest.
|
||
|
||
Arguments:
|
||
|
||
IrpContext - Supplies the IRP_CONTEXT to remove
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
DebugTrace(+1, Dbg, "FatDeleteIrpContext, IrpContext = %08lx\n", IrpContext);
|
||
|
||
ASSERT( IrpContext->NodeTypeCode == FAT_NTC_IRP_CONTEXT );
|
||
|
||
ASSERT( IrpContext->PinCount == 0 );
|
||
|
||
//
|
||
// If there is a FatIoContext that was allocated, free it.
|
||
//
|
||
|
||
if ((IrpContext->FatIoContext != NULL) &&
|
||
!FlagOn(IrpContext->Flags, IRP_CONTEXT_STACK_IO_CONTEXT)) {
|
||
|
||
ExFreePool( IrpContext->FatIoContext );
|
||
}
|
||
|
||
//
|
||
// Return the Irp context record to the region or to pool depending on
|
||
// its flag
|
||
//
|
||
|
||
if (FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_FROM_POOL)) {
|
||
|
||
ExFreePool( IrpContext );
|
||
|
||
} else {
|
||
|
||
ExFreeToNPagedLookasideList( &FatIrpContextLookasideList, IrpContext );
|
||
}
|
||
|
||
//
|
||
// return and tell the caller
|
||
//
|
||
|
||
DebugTrace(-1, Dbg, "FatDeleteIrpContext -> VOID\n", 0);
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
PFCB
|
||
FatGetNextFcb (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PFCB Fcb,
|
||
IN PFCB TerminationFcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is used to itterate through Fcbs in a tree.
|
||
|
||
The rule is very simple:
|
||
|
||
A) If you have a child, go to it, else
|
||
B) If you have an older sibling, go to it, else
|
||
C) Go to your parent's older sibling.
|
||
|
||
If this routine is called with in invalid TerminationFcb it will fail,
|
||
badly.
|
||
|
||
Arguments:
|
||
|
||
Fcb - Supplies the current Fcb
|
||
|
||
TerminationFcb - The Fcb at which the enumeration should (non-inclusivly)
|
||
stop. Assumed to be a directory.
|
||
|
||
Return Value:
|
||
|
||
The next Fcb in the enumeration, or NULL if Fcb was the final one.
|
||
|
||
--*/
|
||
|
||
{
|
||
PFCB Sibling;
|
||
|
||
ASSERT( FatVcbAcquiredExclusive( IrpContext, Fcb->Vcb ) ||
|
||
FlagOn( Fcb->Vcb->VcbState, VCB_STATE_FLAG_LOCKED ) );
|
||
|
||
//
|
||
// If this was a directory (ie. not a file), get the child. If
|
||
// there aren't any children and this is our termination Fcb,
|
||
// return NULL.
|
||
//
|
||
|
||
if ( ((NodeType(Fcb) == FAT_NTC_DCB) ||
|
||
(NodeType(Fcb) == FAT_NTC_ROOT_DCB)) &&
|
||
!IsListEmpty(&Fcb->Specific.Dcb.ParentDcbQueue) ) {
|
||
|
||
return FatGetFirstChild( Fcb );
|
||
}
|
||
|
||
//
|
||
// Were we only meant to do one itteration?
|
||
//
|
||
|
||
if ( Fcb == TerminationFcb ) {
|
||
|
||
return NULL;
|
||
}
|
||
|
||
Sibling = FatGetNextSibling(Fcb);
|
||
|
||
while (TRUE) {
|
||
|
||
//
|
||
// Do we still have an "older" sibling in this directory who is
|
||
// not the termination Fcb?
|
||
//
|
||
|
||
if ( Sibling != NULL ) {
|
||
|
||
return (Sibling != TerminationFcb) ? Sibling : NULL;
|
||
}
|
||
|
||
//
|
||
// OK, let's move on to out parent and see if he is the termination
|
||
// node or has any older siblings.
|
||
//
|
||
|
||
if ( Fcb->ParentDcb == TerminationFcb ) {
|
||
|
||
return NULL;
|
||
}
|
||
|
||
Fcb = Fcb->ParentDcb;
|
||
|
||
Sibling = FatGetNextSibling(Fcb);
|
||
}
|
||
}
|
||
|
||
|
||
BOOLEAN
|
||
FatCheckForDismount (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
PVCB Vcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine determines if a volume is ready for deletion. It
|
||
correctly synchronizes with creates en-route to the file system.
|
||
|
||
Arguments:
|
||
|
||
Vcb - Supplies the volue to examine
|
||
|
||
Return Value:
|
||
|
||
BOOLEAN - TRUE if the volume was deleted, FALSE otherwise.
|
||
|
||
--*/
|
||
|
||
{
|
||
KIRQL SavedIrql;
|
||
ULONG ResidualReferenceCount;
|
||
|
||
//
|
||
// Compute if the volume is OK to tear down. There should only be two
|
||
// residual file objects, one for the volume file and one for the root
|
||
// directory. If we are in the midst of a create (of an unmounted
|
||
// volume that has failed verify) then there will be an additional
|
||
// reference.
|
||
//
|
||
|
||
if ((IrpContext->MajorFunction == IRP_MJ_CREATE) &&
|
||
(IrpContext->RealDevice == Vcb->CurrentDevice)) {
|
||
|
||
ResidualReferenceCount = 3;
|
||
|
||
} else {
|
||
|
||
ResidualReferenceCount = 2;
|
||
}
|
||
|
||
//
|
||
// Now check for a zero Vpb count on an unmounted volume. These
|
||
// volumes will be deleted as they now have no file objects and
|
||
// there are no creates en route to this volume.
|
||
//
|
||
|
||
IoAcquireVpbSpinLock( &SavedIrql );
|
||
|
||
if (Vcb->Vpb->ReferenceCount == ResidualReferenceCount) {
|
||
|
||
PVPB Vpb = Vcb->Vpb;
|
||
|
||
#if DBG
|
||
UNICODE_STRING VolumeLabel;
|
||
|
||
//
|
||
// Setup the VolumeLabel string
|
||
//
|
||
|
||
VolumeLabel.Length = Vcb->Vpb->VolumeLabelLength;
|
||
VolumeLabel.MaximumLength = MAXIMUM_VOLUME_LABEL_LENGTH;
|
||
VolumeLabel.Buffer = &Vcb->Vpb->VolumeLabel[0];
|
||
|
||
KdPrint(("FASTFAT: Dismounting Volume %Z\n", &VolumeLabel));
|
||
#endif // DBG
|
||
|
||
//
|
||
// Clear the VPB_MOUNTED bit so that new creates will not come
|
||
// to this volume. We must leave the Vpb->DeviceObject field
|
||
// set until after the DeleteVcb call as two closes will
|
||
// have to make their back to us.
|
||
//
|
||
// Note also that if we were called from close, it will take care
|
||
// of freeing the Vpb if it is not the primary one, otherwise
|
||
// if we were called from Create->Verify, IopParseDevice will
|
||
// take care of freeing the Vpb in its Reparse path.
|
||
//
|
||
|
||
ClearFlag( Vpb->Flags, VPB_MOUNTED );
|
||
|
||
//
|
||
// If this Vpb was locked, clear this flag now.
|
||
//
|
||
|
||
ClearFlag( Vpb->Flags, VPB_LOCKED );
|
||
|
||
//
|
||
// This will prevent anybody else from attempting to mount this
|
||
// volume. Also if this volume was mounted on a "wanna-be" real
|
||
// device object, keep anybody from following the link, and the Io
|
||
// system from deleting the Vpb.
|
||
//
|
||
|
||
if ((Vcb->CurrentDevice != Vpb->RealDevice) &&
|
||
(Vcb->CurrentDevice->Vpb == Vpb)) {
|
||
|
||
SetFlag( Vcb->CurrentDevice->Flags, DO_DEVICE_INITIALIZING );
|
||
SetFlag( Vpb->Flags, VPB_PERSISTENT );
|
||
}
|
||
|
||
IoReleaseVpbSpinLock( SavedIrql );
|
||
|
||
FatDeleteVcb( IrpContext, Vcb );
|
||
|
||
Vpb->DeviceObject = NULL;
|
||
|
||
IoDeleteDevice( (PDEVICE_OBJECT)
|
||
CONTAINING_RECORD( Vcb,
|
||
VOLUME_DEVICE_OBJECT,
|
||
Vcb ) );
|
||
|
||
return TRUE;
|
||
|
||
} else {
|
||
|
||
IoReleaseVpbSpinLock( SavedIrql );
|
||
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
|
||
VOID
|
||
FatConstructNamesInFcb (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
PFCB Fcb,
|
||
PDIRENT Dirent,
|
||
PUNICODE_STRING Lfn OPTIONAL
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine places the short name in the dirent in the first set of
|
||
STRINGs in the Fcb. If a long file name (Lfn) was specified, then
|
||
we must decide whether we will store its Oem equivolent in the same
|
||
prefix table as the short name, or rather just save the upcased
|
||
version of the UNICODE string in the FCB.
|
||
|
||
For looking up Fcbs, the first approach will be faster, so we want to
|
||
do this as much as possible. Here are the rules that I have thought
|
||
through extensively to determine when it is safe to store only Oem
|
||
version of the UNICODE name.
|
||
|
||
- If the UNICODE name contains no extended characters (>0x80), use Oem.
|
||
|
||
- Let U be the upcased version of the UNICODE name.
|
||
Let Up(x) be the function that upcases a UNICODE string.
|
||
Let Down(x) be the function that upcases a UNICODE string.
|
||
Let OemToUni(x) be the function that converts an Oem string to Unicode.
|
||
Let UniToOem(x) be the function that converts a Unicode string to Oem.
|
||
Let BestOemFit(x) be the function that creates the Best uppercase Oem
|
||
fit for the UNICODE string x.
|
||
|
||
BestOemFit(x) = UniToOem(Up(OemToUni(UniToOem(x)))) <1>
|
||
|
||
if (BestOemFit(U) == BestOemFit(Down(U)) <2>
|
||
|
||
then I know that there exists no UNICODE string Y such that:
|
||
|
||
Up(Y) == Up(U) <3>
|
||
|
||
AND
|
||
|
||
BestOemFit(U) != BestOemFit(Y) <4>
|
||
|
||
Consider string U as a collection of one character strings. The
|
||
conjecture is clearly true for each sub-string, thus it is true
|
||
for the entire string.
|
||
|
||
Equation <1> is what we use to convert an incoming unicode name in
|
||
FatCommonCreate() to Oem. The double conversion is done to provide
|
||
better visual best fitting for characters in the Ansi code page but
|
||
not in the Oem code page. A single Nls routine is provided to do
|
||
this conversion efficiently.
|
||
|
||
The idea is that with U, I only have to worry about a case varient Y
|
||
matching it in a unicode compare, and I have shown that any case varient
|
||
of U (the set Y defined in equation <3>), when filtered through <1>
|
||
(as in create), will match the Oem string defined in <1>.
|
||
|
||
Thus I do not have to worry about another UNICODE string missing in
|
||
the prefix lookup, but matching when comparing LFNs in the directory.
|
||
|
||
Arguments:
|
||
|
||
Fcb - The Fcb we are supposed to fill in. Note that ParentDcb must
|
||
already be filled in.
|
||
|
||
Dirent - The gives up the short name.
|
||
|
||
Lfn - If provided, this gives us the long name.
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
NTSTATUS Status;
|
||
ULONG i;
|
||
|
||
OEM_STRING OemA;
|
||
OEM_STRING OemB;
|
||
UNICODE_STRING Unicode;
|
||
POEM_STRING ShortName;
|
||
POEM_STRING LongOemName;
|
||
PUNICODE_STRING LongUniName;
|
||
|
||
ShortName = &Fcb->ShortName.Name.Oem;
|
||
|
||
try {
|
||
|
||
//
|
||
// First do the short name.
|
||
//
|
||
|
||
//
|
||
// Copy over the case flags for the short name of the file
|
||
//
|
||
|
||
if (FlagOn(Dirent->NtByte, FAT_DIRENT_NT_BYTE_8_LOWER_CASE)) {
|
||
|
||
SetFlag(Fcb->FcbState, FCB_STATE_8_LOWER_CASE);
|
||
|
||
} else {
|
||
|
||
ClearFlag(Fcb->FcbState, FCB_STATE_8_LOWER_CASE);
|
||
}
|
||
|
||
if (FlagOn(Dirent->NtByte, FAT_DIRENT_NT_BYTE_3_LOWER_CASE)) {
|
||
|
||
SetFlag(Fcb->FcbState, FCB_STATE_3_LOWER_CASE);
|
||
|
||
} else {
|
||
|
||
ClearFlag(Fcb->FcbState, FCB_STATE_3_LOWER_CASE);
|
||
}
|
||
|
||
ShortName->MaximumLength = 16;
|
||
ShortName->Buffer = FsRtlAllocatePool( PagedPool, 16);
|
||
|
||
Fat8dot3ToString( IrpContext, Dirent, FALSE, ShortName );
|
||
|
||
//
|
||
// If no Lfn was specified, we are done. In either case, set the
|
||
// final name length.
|
||
//
|
||
|
||
if (!ARGUMENT_PRESENT(Lfn) || (Lfn->Length == 0)) {
|
||
|
||
Fcb->FinalNameLength = (USHORT)
|
||
RtlOemStringToCountedUnicodeSize( ShortName );
|
||
|
||
Fcb->ExactCaseLongName.Length = 0;
|
||
|
||
try_return( NOTHING );
|
||
|
||
} else {
|
||
|
||
Fcb->FinalNameLength = Lfn->Length;
|
||
}
|
||
|
||
//
|
||
// Save away a copy of the real Lfn
|
||
//
|
||
|
||
if (Lfn && Lfn->Length) {
|
||
|
||
Fcb->ExactCaseLongName.Length = Fcb->ExactCaseLongName.MaximumLength = Lfn->Length;
|
||
Fcb->ExactCaseLongName.Buffer = FsRtlAllocatePool( PagedPool, Lfn->Length );
|
||
RtlCopyMemory(Fcb->ExactCaseLongName.Buffer, Lfn->Buffer, Lfn->Length);
|
||
}
|
||
|
||
//
|
||
// First check for no extended characters.
|
||
//
|
||
|
||
for (i=0; i < Lfn->Length/sizeof(WCHAR); i++) {
|
||
|
||
if (Lfn->Buffer[i] >= 0x80) {
|
||
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (i == Lfn->Length/sizeof(WCHAR)) {
|
||
|
||
//
|
||
// Cool, I can go with the Oem, upcase it fast by hand.
|
||
//
|
||
|
||
LongOemName = &Fcb->LongName.Oem.Name.Oem;
|
||
|
||
|
||
LongOemName->Buffer = FsRtlAllocatePool( PagedPool,
|
||
Lfn->Length/sizeof(WCHAR) );
|
||
LongOemName->Length =
|
||
LongOemName->MaximumLength = Lfn->Length/sizeof(WCHAR);
|
||
|
||
for (i=0; i < Lfn->Length/sizeof(WCHAR); i++) {
|
||
|
||
WCHAR c;
|
||
|
||
c = Lfn->Buffer[i];
|
||
|
||
LongOemName->Buffer[i] = c < 'a' ?
|
||
(UCHAR)c :
|
||
c <= 'z' ?
|
||
c - (UCHAR)('a'-'A') :
|
||
(UCHAR) c;
|
||
}
|
||
|
||
//
|
||
// If this name happens to be exactly the same as the short
|
||
// name, don't add it to the splay table.
|
||
//
|
||
|
||
if (FatAreNamesEqual(IrpContext, *ShortName, *LongOemName) ||
|
||
(FatFindFcb( IrpContext,
|
||
&Fcb->ParentDcb->Specific.Dcb.RootOemNode,
|
||
LongOemName,
|
||
NULL) != NULL)) {
|
||
|
||
ExFreePool( LongOemName->Buffer );
|
||
|
||
LongOemName->Buffer = NULL;
|
||
LongOemName->Length =
|
||
LongOemName->MaximumLength = 0;
|
||
|
||
} else {
|
||
|
||
SetFlag( Fcb->FcbState, FCB_STATE_HAS_OEM_LONG_NAME );
|
||
}
|
||
|
||
try_return( NOTHING );
|
||
}
|
||
|
||
//
|
||
// Now we have the fun part. Make a copy of the Lfn.
|
||
//
|
||
|
||
OemA.Buffer = NULL;
|
||
OemB.Buffer = NULL;
|
||
Unicode.Buffer = NULL;
|
||
|
||
Unicode.Length =
|
||
Unicode.MaximumLength = Lfn->Length;
|
||
Unicode.Buffer = FsRtlAllocatePool( PagedPool, Lfn->Length );
|
||
|
||
RtlCopyMemory( Unicode.Buffer, Lfn->Buffer, Lfn->Length );
|
||
|
||
Status = STATUS_SUCCESS;
|
||
|
||
//
|
||
// Downcase and convert to upcased Oem. Only continue if we can
|
||
// convert without error. Any error other than UNMAPPABLE_CHAR
|
||
// is a fatal error and we raise.
|
||
//
|
||
// Note that even if the conversion fails, we must leave Unicode
|
||
// in an upcased state.
|
||
//
|
||
// NB: The Rtl doesn't NULL .Buffer on error.
|
||
//
|
||
|
||
(VOID)FatDowncaseUnicodeString( &Unicode, &Unicode, FALSE );
|
||
Status = FatUpcaseUnicodeStringToCountedOemString( &OemA, &Unicode, TRUE );
|
||
(VOID)FatUpcaseUnicodeString( &Unicode, &Unicode, FALSE );
|
||
|
||
if (!NT_SUCCESS(Status)) {
|
||
|
||
if (Status != STATUS_UNMAPPABLE_CHARACTER) {
|
||
|
||
ASSERT( Status == STATUS_NO_MEMORY );
|
||
ExFreePool(Unicode.Buffer);
|
||
FatNormalizeAndRaiseStatus( IrpContext, Status );
|
||
}
|
||
|
||
} else {
|
||
|
||
//
|
||
// The same as above except upcase.
|
||
//
|
||
|
||
Status = FatUpcaseUnicodeStringToCountedOemString( &OemB, &Unicode, TRUE );
|
||
|
||
if (!NT_SUCCESS(Status)) {
|
||
|
||
FatFreeOemString( &OemA );
|
||
|
||
if (Status != STATUS_UNMAPPABLE_CHARACTER) {
|
||
|
||
ASSERT( Status == STATUS_NO_MEMORY );
|
||
ExFreePool(Unicode.Buffer);
|
||
FatNormalizeAndRaiseStatus( IrpContext, Status );
|
||
}
|
||
}
|
||
}
|
||
|
||
//
|
||
// If the final OemNames are equal, I can use save only the Oem
|
||
// name. If the name did not map, then I have to go with the UNICODE
|
||
// name because I could get a case varient that didn't convert
|
||
// in create, but did match the LFN.
|
||
//
|
||
|
||
if (NT_SUCCESS(Status) && FatAreNamesEqual( IrpContext, OemA, OemB )) {
|
||
|
||
//
|
||
// Cool, I can go with the Oem. If we didn't convert correctly,
|
||
// get a fresh convert from the original LFN.
|
||
//
|
||
|
||
ExFreePool(Unicode.Buffer);
|
||
|
||
|
||
FatFreeOemString( &OemB );
|
||
|
||
Fcb->LongName.Oem.Name.Oem = OemA;
|
||
|
||
//
|
||
// If this name happens to be exactly the same as the short
|
||
// name, or a similar short name already exists don't add it
|
||
// to the splay table (note the final condition implies a
|
||
// currupt disk.
|
||
//
|
||
|
||
if (FatAreNamesEqual(IrpContext, *ShortName, OemA) ||
|
||
(FatFindFcb( IrpContext,
|
||
&Fcb->ParentDcb->Specific.Dcb.RootOemNode,
|
||
&OemA,
|
||
NULL) != NULL)) {
|
||
|
||
FatFreeOemString( &OemA );
|
||
|
||
} else {
|
||
|
||
SetFlag( Fcb->FcbState, FCB_STATE_HAS_OEM_LONG_NAME );
|
||
}
|
||
|
||
try_return( NOTHING );
|
||
}
|
||
|
||
//
|
||
// The long name must be left in UNICODE. Free the two Oem strings
|
||
// if we got here just because they weren't equal.
|
||
//
|
||
|
||
if (NT_SUCCESS(Status)) {
|
||
|
||
FatFreeOemString( &OemA );
|
||
FatFreeOemString( &OemB );
|
||
}
|
||
|
||
LongUniName = &Fcb->LongName.Unicode.Name.Unicode;
|
||
|
||
LongUniName->Length =
|
||
LongUniName->MaximumLength = Unicode.Length;
|
||
LongUniName->Buffer = Unicode.Buffer;
|
||
|
||
SetFlag(Fcb->FcbState, FCB_STATE_HAS_UNICODE_LONG_NAME);
|
||
|
||
try_exit: NOTHING;
|
||
} finally {
|
||
|
||
if (AbnormalTermination()) {
|
||
|
||
if (ShortName->Buffer != NULL) {
|
||
|
||
ExFreePool( ShortName->Buffer );
|
||
}
|
||
|
||
} else {
|
||
|
||
//
|
||
// Creating all the names worked, so add all the names
|
||
// to the splay tree.
|
||
//
|
||
|
||
FatInsertName( IrpContext,
|
||
&Fcb->ParentDcb->Specific.Dcb.RootOemNode,
|
||
&Fcb->ShortName );
|
||
|
||
Fcb->ShortName.Fcb = Fcb;
|
||
|
||
if (FlagOn(Fcb->FcbState, FCB_STATE_HAS_OEM_LONG_NAME)) {
|
||
|
||
FatInsertName( IrpContext,
|
||
&Fcb->ParentDcb->Specific.Dcb.RootOemNode,
|
||
&Fcb->LongName.Oem );
|
||
|
||
Fcb->LongName.Oem.Fcb = Fcb;
|
||
}
|
||
|
||
if (FlagOn(Fcb->FcbState, FCB_STATE_HAS_UNICODE_LONG_NAME)) {
|
||
|
||
FatInsertName( IrpContext,
|
||
&Fcb->ParentDcb->Specific.Dcb.RootUnicodeNode,
|
||
&Fcb->LongName.Unicode );
|
||
|
||
Fcb->LongName.Unicode.Fcb = Fcb;
|
||
}
|
||
|
||
SetFlag(Fcb->FcbState, FCB_STATE_NAMES_IN_SPLAY_TREE)
|
||
}
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
VOID
|
||
FatCheckFreeDirentBitmap (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PDCB Dcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine checks if the size of the free dirent bitmap is
|
||
sufficient to for the current directory size. It is called
|
||
whenever we grow a directory.
|
||
|
||
Arguments:
|
||
|
||
Dcb - Supplies the directory in question.
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG OldNumberOfDirents;
|
||
ULONG NewNumberOfDirents;
|
||
|
||
//
|
||
// Setup the Bitmap buffer if it is not big enough already
|
||
//
|
||
|
||
OldNumberOfDirents = Dcb->Specific.Dcb.FreeDirentBitmap.SizeOfBitMap;
|
||
NewNumberOfDirents = Dcb->Header.AllocationSize.LowPart / sizeof(DIRENT);
|
||
|
||
ASSERT( Dcb->Header.AllocationSize.LowPart != 0xffffffff );
|
||
|
||
if (NewNumberOfDirents > OldNumberOfDirents) {
|
||
|
||
PULONG OldBitmapBuffer;
|
||
PULONG BitmapBuffer;
|
||
|
||
ULONG BytesInBitmapBuffer;
|
||
ULONG BytesInOldBitmapBuffer;
|
||
|
||
//
|
||
// Remember the old bitmap
|
||
//
|
||
|
||
OldBitmapBuffer = Dcb->Specific.Dcb.FreeDirentBitmap.Buffer;
|
||
|
||
//
|
||
// Now make a new bitmap bufffer
|
||
//
|
||
|
||
BytesInBitmapBuffer = NewNumberOfDirents / 8;
|
||
|
||
BytesInOldBitmapBuffer = OldNumberOfDirents / 8;
|
||
|
||
if (DCB_UNION_SLACK_SPACE >= BytesInBitmapBuffer) {
|
||
|
||
BitmapBuffer = &Dcb->Specific.Dcb.FreeDirentBitmapBuffer[0];
|
||
|
||
} else {
|
||
|
||
BitmapBuffer = FsRtlAllocatePool( PagedPool,
|
||
BytesInBitmapBuffer );
|
||
}
|
||
|
||
//
|
||
// Copy the old buffer to the new buffer, free the old one, and zero
|
||
// the rest of the new one. Only do the first two steps though if
|
||
// we moved out of the initial buffer.
|
||
//
|
||
|
||
if ((OldNumberOfDirents != 0) &&
|
||
(BitmapBuffer != &Dcb->Specific.Dcb.FreeDirentBitmapBuffer[0])) {
|
||
|
||
RtlCopyMemory( BitmapBuffer,
|
||
OldBitmapBuffer,
|
||
BytesInOldBitmapBuffer );
|
||
|
||
if (OldBitmapBuffer != &Dcb->Specific.Dcb.FreeDirentBitmapBuffer[0]) {
|
||
|
||
ExFreePool( OldBitmapBuffer );
|
||
}
|
||
}
|
||
|
||
ASSERT( BytesInBitmapBuffer > BytesInOldBitmapBuffer );
|
||
|
||
RtlZeroMemory( (PUCHAR)BitmapBuffer + BytesInOldBitmapBuffer,
|
||
BytesInBitmapBuffer - BytesInOldBitmapBuffer );
|
||
|
||
//
|
||
// Now initialize the new bitmap.
|
||
//
|
||
|
||
RtlInitializeBitMap( &Dcb->Specific.Dcb.FreeDirentBitmap,
|
||
BitmapBuffer,
|
||
NewNumberOfDirents );
|
||
}
|
||
}
|
||
|
||
|
||
PCCB
|
||
FatAllocateCcb (
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine allocates a Ccb for Fat. It uses a cached number of
|
||
free blocks to speed itself up.
|
||
|
||
Arguments:
|
||
|
||
Return Value:
|
||
|
||
PCCB - returns a pointer to the allocated Ccb
|
||
|
||
--*/
|
||
|
||
{
|
||
KIRQL SavedIrql;
|
||
PCCB Ccb;
|
||
|
||
KeAcquireSpinLock( &FatData.StrucSupSpinLock, &SavedIrql );
|
||
|
||
if (FatData.FreeCcbSize > 0) {
|
||
|
||
Ccb = FatData.FreeCcbArray[--FatData.FreeCcbSize];
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
|
||
} else {
|
||
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
Ccb = FsRtlAllocatePool( PagedPool, sizeof(CCB) );
|
||
}
|
||
|
||
return Ccb;
|
||
}
|
||
|
||
|
||
VOID
|
||
FatFreeCcb (
|
||
IN PCCB Ccb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine frees a previously allocated Ccb using a small cache
|
||
of free blocks to speed itself up
|
||
|
||
Arguments:
|
||
|
||
Ccb - Supplies a pointer to the Ccb being freed
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
KIRQL SavedIrql;
|
||
|
||
KeAcquireSpinLock( &FatData.StrucSupSpinLock, &SavedIrql );
|
||
|
||
if (FatData.FreeCcbSize < FREE_CCB_SIZE) {
|
||
|
||
FatData.FreeCcbArray[FatData.FreeCcbSize++] = Ccb;
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
|
||
} else {
|
||
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
ExFreePool( Ccb );
|
||
}
|
||
}
|
||
|
||
PFCB
|
||
FatAllocateFcb (
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine allocates a Fcb for Fat. It uses a cached number of
|
||
free blocks to speed itself up.
|
||
|
||
Arguments:
|
||
|
||
Return Value:
|
||
|
||
PFCB - returns a pointer to the allocated Fcb
|
||
|
||
--*/
|
||
|
||
{
|
||
KIRQL SavedIrql;
|
||
PFCB Fcb;
|
||
|
||
KeAcquireSpinLock( &FatData.StrucSupSpinLock, &SavedIrql );
|
||
|
||
if (FatData.FreeFcbSize > 0) {
|
||
|
||
Fcb = FatData.FreeFcbArray[--FatData.FreeFcbSize];
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
|
||
} else {
|
||
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
Fcb = FsRtlAllocatePool( PagedPool, sizeof(FCB) );
|
||
}
|
||
|
||
return Fcb;
|
||
}
|
||
|
||
|
||
VOID
|
||
FatFreeFcb (
|
||
IN PFCB Fcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine frees a previously allocated Fcb using a small cache
|
||
of free blocks to speed itself up
|
||
|
||
Arguments:
|
||
|
||
Fcb - Supplies a pointer to the Fcb being freed
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
KIRQL SavedIrql;
|
||
|
||
KeAcquireSpinLock( &FatData.StrucSupSpinLock, &SavedIrql );
|
||
|
||
if (FatData.FreeFcbSize < FREE_FCB_SIZE) {
|
||
|
||
FatData.FreeFcbArray[FatData.FreeFcbSize++] = Fcb;
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
|
||
} else {
|
||
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
ExFreePool( Fcb );
|
||
}
|
||
}
|
||
|
||
PNON_PAGED_FCB
|
||
FatAllocateNonPagedFcb (
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine allocates a NonPagedFcb for Fat. It uses a cached
|
||
number of free blocks to speed itself up.
|
||
|
||
Arguments:
|
||
|
||
Return Value:
|
||
|
||
PNON_PAGED_FCB - returns a pointer to the allocated NonPagedFcb
|
||
|
||
--*/
|
||
|
||
{
|
||
KIRQL SavedIrql;
|
||
PNON_PAGED_FCB NonPagedFcb;
|
||
|
||
KeAcquireSpinLock( &FatData.StrucSupSpinLock, &SavedIrql );
|
||
|
||
if (FatData.FreeNonPagedFcbSize > 0) {
|
||
|
||
NonPagedFcb = FatData.FreeNonPagedFcbArray[--FatData.FreeNonPagedFcbSize];
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
|
||
} else {
|
||
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
NonPagedFcb = FsRtlAllocatePool( NonPagedPool, sizeof(NON_PAGED_FCB) );
|
||
}
|
||
|
||
return NonPagedFcb;
|
||
}
|
||
|
||
|
||
VOID
|
||
FatFreeNonPagedFcb (
|
||
PNON_PAGED_FCB NonPagedFcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine frees a previously allocated NonPagedFcb using a
|
||
small cache of free blocks to speed itself up
|
||
|
||
Arguments:
|
||
|
||
SectObjPtr - Supplies a pointer to the SOP being freed
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
KIRQL SavedIrql;
|
||
|
||
//
|
||
// If an Event was allocated, get rid of it.
|
||
//
|
||
|
||
if (NonPagedFcb->OutstandingAsyncEvent) {
|
||
ExFreePool( NonPagedFcb->OutstandingAsyncEvent );
|
||
}
|
||
|
||
KeAcquireSpinLock( &FatData.StrucSupSpinLock, &SavedIrql );
|
||
|
||
if (FatData.FreeNonPagedFcbSize < FREE_NON_PAGED_FCB_SIZE) {
|
||
|
||
FatData.FreeNonPagedFcbArray[FatData.FreeNonPagedFcbSize++] = NonPagedFcb;
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
|
||
} else {
|
||
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
|
||
ExFreePool( NonPagedFcb );
|
||
}
|
||
}
|
||
|
||
PERESOURCE
|
||
FatAllocateResource (
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine allocates an ERESOURCE for Fat. It uses a cached
|
||
number of free blocks to speed itself up.
|
||
|
||
Arguments:
|
||
|
||
Return Value:
|
||
|
||
PERESOURCE - returns a pointer to the allocated resource
|
||
|
||
--*/
|
||
|
||
{
|
||
KIRQL SavedIrql;
|
||
PERESOURCE Resource;
|
||
|
||
KeAcquireSpinLock( &FatData.StrucSupSpinLock, &SavedIrql );
|
||
|
||
if (FatData.FreeEresourceSize > 0) {
|
||
|
||
Resource = FatData.FreeEresourceArray[--FatData.FreeEresourceSize];
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
|
||
} else {
|
||
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
Resource = FsRtlAllocatePool( NonPagedPool, sizeof(ERESOURCE) );
|
||
}
|
||
|
||
ExInitializeResource( Resource );
|
||
|
||
return Resource;
|
||
}
|
||
|
||
VOID
|
||
FatFreeResource (
|
||
IN PERESOURCE Resource
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine frees a previously allocated resource using a
|
||
small cache of free blocks to speed itself up
|
||
|
||
Arguments:
|
||
|
||
Resource - Supplies a pointer to the Resource being freed
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
|
||
{
|
||
KIRQL SavedIrql;
|
||
|
||
ExDeleteResource( Resource );
|
||
|
||
KeAcquireSpinLock( &FatData.StrucSupSpinLock, &SavedIrql );
|
||
|
||
if (FatData.FreeEresourceSize < FREE_ERESOURCE_SIZE) {
|
||
|
||
FatData.FreeEresourceArray[FatData.FreeEresourceSize++] = Resource;
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
|
||
} else {
|
||
|
||
KeReleaseSpinLock( &FatData.StrucSupSpinLock, SavedIrql );
|
||
ExFreePool( Resource );
|
||
}
|
||
}
|
||
|
||
BOOLEAN
|
||
FatIsHandleCountZero (
|
||
IN PIRP_CONTEXT IrpContext,
|
||
IN PVCB Vcb
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine decides if the handle count on the volume is zero.
|
||
|
||
Arguments:
|
||
|
||
Vcb - The volume in question
|
||
|
||
Return Value:
|
||
|
||
BOOLEAN - TRUE if there are no open handles on the volume, FALSE
|
||
otherwise.
|
||
|
||
--*/
|
||
|
||
{
|
||
PFCB Fcb;
|
||
|
||
Fcb = Vcb->RootDcb;
|
||
|
||
while (Fcb != NULL) {
|
||
|
||
if (Fcb->UncleanCount != 0) {
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
Fcb = FatGetNextFcb(IrpContext, Fcb, Vcb->RootDcb);
|
||
}
|
||
|
||
return TRUE;
|
||
}
|