/*++ Copyright (c) 1996 Microsoft Corporation Module Name: UdfInit.c Abstract: This module implements the DRIVER_INITIALIZATION routine for Udfs Author: Dan Lovinger [DanLo] 24-May-1996 Revision History: --*/ #include "UdfProcs.h" // The Bug check file id for this module #define BugCheckFileId (UDFS_BUG_CHECK_UDFINIT) // The local debug trace level #define Dbg (UDFS_DEBUG_LEVEL_UDFINIT) NTSTATUS DriverEntry( IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath ); VOID UdfInitializeGlobalData ( IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT *FileSystemDeviceObjects ); #ifdef ALLOC_PRAGMA #pragma alloc_text(INIT, DriverEntry) #pragma alloc_text(INIT, UdfInitializeGlobalData) #endif // Local support routine NTSTATUS DriverEntry( IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath ) /*++ Routine Description: This is the initialization routine for the UDF file system device driver. This routine creates the device object for the FileSystem device and performs all other driver initialization. Arguments: DriverObject - Pointer to driver object created by the system. Return Value: NTSTATUS - The function value is the final status from the initialization operation. --*/ { NTSTATUS Status; UNICODE_STRING UnicodeString; PDEVICE_OBJECT UdfsFileSystemDeviceObjects[NUMBER_OF_FS_OBJECTS]; PDEVICE_OBJECT UdfsDiskFileSystemDeviceObject; // Create the device objects for both device "types". Since // UDF is a legitimate filesystem for media underlying device // drivers claiming both DVD/CDROMs and disks, we must register // this filesystem twice. ASSERT( NUMBER_OF_FS_OBJECTS >= 2 ); RtlZeroMemory( &UdfsFileSystemDeviceObjects, sizeof(PDEVICE_OBJECT) * NUMBER_OF_FS_OBJECTS ); RtlInitUnicodeString( &UnicodeString, L"\\UdfsCdRom" ); Status = IoCreateDevice( DriverObject, 0, &UnicodeString, FILE_DEVICE_CD_ROM_FILE_SYSTEM, 0, FALSE, &UdfsFileSystemDeviceObjects[0] ); if (!NT_SUCCESS( Status )) { return Status; } RtlInitUnicodeString( &UnicodeString, L"\\UdfsDisk" ); Status = IoCreateDevice( DriverObject, 0, &UnicodeString, FILE_DEVICE_DISK_FILE_SYSTEM, 0, FALSE, &UdfsFileSystemDeviceObjects[1] ); if (!NT_SUCCESS( Status )) { ObDereferenceObject( UdfsFileSystemDeviceObjects[0] ); return Status; } // 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 // data is not in the cache, or the request is not buffered, we may, // set up for Direct I/O by hand. // Initialize the driver object with this driver's entry points. // NOTE - Each entry in the dispatch table must have an entry in // the Fsp/Fsd dispatch switch statements. DriverObject->MajorFunction[IRP_MJ_CREATE] = DriverObject->MajorFunction[IRP_MJ_CLOSE] = DriverObject->MajorFunction[IRP_MJ_READ] = DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION]= DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = DriverObject->MajorFunction[IRP_MJ_CLEANUP] = DriverObject->MajorFunction[IRP_MJ_PNP] = (PDRIVER_DISPATCH) UdfFsdDispatch; DriverObject->FastIoDispatch = &UdfFastIoDispatch; // Initialize the global data structures UdfInitializeGlobalData( DriverObject, UdfsFileSystemDeviceObjects ); // Register the file system with the I/O system IoRegisterFileSystem( UdfsFileSystemDeviceObjects[0] ); IoRegisterFileSystem( UdfsFileSystemDeviceObjects[1] ); // And return to our caller return( STATUS_SUCCESS ); } // Local support routine VOID UdfInitializeGlobalData ( IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT *UdfsFileSystemDeviceObjects ) /*++ Routine Description: This routine initializes the global Udfs data structures. Arguments: DriverObject - Supplies the driver object for UDFS. FileSystemDeviceObjects - Supplies a vector of device objects for UDFS. Return Value: None. --*/ { USHORT CcbMaxDepth; USHORT FcbDataMaxDepth; USHORT FcbIndexMaxDepth; USHORT FcbNonPagedMaxDepth; USHORT IrpContextMaxDepth; USHORT LcbMaxDepth; // Start by initializing the FastIoDispatch Table. RtlZeroMemory( &UdfFastIoDispatch, sizeof( FAST_IO_DISPATCH )); UdfFastIoDispatch.SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH); UdfFastIoDispatch.AcquireFileForNtCreateSection = UdfAcquireForCreateSection; UdfFastIoDispatch.ReleaseFileForNtCreateSection = UdfReleaseForCreateSection; UdfFastIoDispatch.FastIoCheckIfPossible = UdfFastIoCheckIfPossible; // CheckForFastIo UdfFastIoDispatch.FastIoRead = FsRtlCopyRead; // Read UdfFastIoDispatch.FastIoQueryBasicInfo = NULL; // QueryBasicInfo UdfFastIoDispatch.FastIoQueryStandardInfo = NULL; // QueryStandardInfo UdfFastIoDispatch.FastIoLock = NULL; // Lock UdfFastIoDispatch.FastIoUnlockSingle = NULL; // UnlockSingle UdfFastIoDispatch.FastIoUnlockAll = NULL; // UnlockAll UdfFastIoDispatch.FastIoUnlockAllByKey = NULL; // UnlockAllByKey UdfFastIoDispatch.FastIoQueryNetworkOpenInfo = NULL; // QueryNetworkInfo // Initialize the CRC table. Per UDF 1.01, we use the seed 10041 octal (4129 dec). UdfInitializeCrc16( 4129 ); // Initialize the UdfData structure. RtlZeroMemory( &UdfData, sizeof( UDF_DATA )); UdfData.NodeTypeCode = UDFS_NTC_DATA_HEADER; UdfData.NodeByteSize = sizeof( UDF_DATA ); UdfData.DriverObject = DriverObject; RtlCopyMemory( &UdfData.FileSystemDeviceObjects, UdfsFileSystemDeviceObjects, sizeof(PDEVICE_OBJECT) * NUMBER_OF_FS_OBJECTS ); InitializeListHead( &UdfData.VcbQueue ); ExInitializeResource( &UdfData.DataResource ); // Initialize the cache manager callback routines UdfData.CacheManagerCallbacks.AcquireForLazyWrite = &UdfAcquireForCache; UdfData.CacheManagerCallbacks.ReleaseFromLazyWrite = &UdfReleaseFromCache; UdfData.CacheManagerCallbacks.AcquireForReadAhead = &UdfAcquireForCache; UdfData.CacheManagerCallbacks.ReleaseFromReadAhead = &UdfReleaseFromCache; UdfData.CacheManagerVolumeCallbacks.AcquireForLazyWrite = &UdfNoopAcquire; UdfData.CacheManagerVolumeCallbacks.ReleaseFromLazyWrite = &UdfNoopRelease; UdfData.CacheManagerVolumeCallbacks.AcquireForReadAhead = &UdfNoopAcquire; UdfData.CacheManagerVolumeCallbacks.ReleaseFromReadAhead = &UdfNoopRelease; // Initialize the lock mutex and the async and delay close queues. ExInitializeFastMutex( &UdfData.UdfDataMutex ); InitializeListHead( &UdfData.AsyncCloseQueue ); InitializeListHead( &UdfData.DelayedCloseQueue ); ExInitializeWorkItem( &UdfData.CloseItem, (PWORKER_THREAD_ROUTINE) UdfFspClose, NULL ); // Do the initialization based on the system size. switch (MmQuerySystemSize()) { case MmSmallSystem: IrpContextMaxDepth = 4; UdfData.MaxDelayedCloseCount = 10; UdfData.MinDelayedCloseCount = 2; break; case MmLargeSystem: IrpContextMaxDepth = 24; UdfData.MaxDelayedCloseCount = 72; UdfData.MinDelayedCloseCount = 18; break; default: case MmMediumSystem: IrpContextMaxDepth = 8; UdfData.MaxDelayedCloseCount = 32; UdfData.MinDelayedCloseCount = 8; break; } // Size lookasides to match what will commonly be dumped into them when we // run down the delayed close queues. LcbMaxDepth = CcbMaxDepth = FcbDataMaxDepth = FcbNonPagedMaxDepth = (USHORT) (UdfData.MaxDelayedCloseCount - UdfData.MinDelayedCloseCount); // We should tend to have fewer indices than files. FcbIndexMaxDepth = FcbNonPagedMaxDepth / 2; #define NPagedInit(L,S,T,D) { ExInitializeNPagedLookasideList( (L), NULL, NULL, POOL_RAISE_IF_ALLOCATION_FAILURE, S, T, D); } #define PagedInit(L,S,T,D) { ExInitializePagedLookasideList( (L), NULL, NULL, POOL_RAISE_IF_ALLOCATION_FAILURE, S, T, D); } NPagedInit( &UdfIrpContextLookasideList, sizeof( IRP_CONTEXT ), TAG_IRP_CONTEXT, IrpContextMaxDepth ); NPagedInit( &UdfFcbNonPagedLookasideList, sizeof( FCB_NONPAGED ), TAG_FCB_NONPAGED, FcbNonPagedMaxDepth ); PagedInit( &UdfCcbLookasideList, sizeof( CCB ), TAG_CCB, CcbMaxDepth ); PagedInit( &UdfFcbIndexLookasideList, SIZEOF_FCB_INDEX, TAG_FCB_INDEX, FcbIndexMaxDepth ); PagedInit( &UdfFcbDataLookasideList, SIZEOF_FCB_DATA, TAG_FCB_DATA, FcbDataMaxDepth ); PagedInit( &UdfLcbLookasideList, SIZEOF_LOOKASIDE_LCB, TAG_LCB, LcbMaxDepth ); }