VOID
ExInitPoolLookasidePointers (
VOID
)
/*++
Routine Description:
This function initializes the PRCB lookaside pointers to temporary
values that will be updated during phase 1 initialization.
Arguments:
None.
Return Value:
None.
--*/
{
ULONG Index;
PGENERAL_LOOKASIDE Lookaside;
PKPRCB Prcb;
//
// Initialize the paged and nonpaged small pool lookaside list
// pointers in the PRCB to temporarily point to the global pool
// lookaside lists. During phase 1 initialization per processor
// lookaside lists are allocated and the pointer to these lists
// are established in the PRCB of each processor.
//
Prcb = KeGetCurrentPrcb();
for (Index = 0; Index < POOL_SMALL_LISTS; Index += 1) {
Lookaside = &ExpSmallNPagedPoolLookasideLists[Index];
ExInitializeSListHead(&Lookaside->ListHead);
Prcb->PPNPagedLookasideList[Index].P = Lookaside;
Prcb->PPNPagedLookasideList[Index].L = Lookaside;
Lookaside = &ExpSmallPagedPoolLookasideLists[Index];
ExInitializeSListHead(&Lookaside->ListHead);
Prcb->PPPagedLookasideList[Index].P = Lookaside;
Prcb->PPPagedLookasideList[Index].L = Lookaside;
}
return;
}
int dc_init_fast_crypt()
{
int i;
/* enable thread pool */
if (lock_xchg(&pool_enabled, 1) != 0) {
return ST_OK;
}
/* initialize resources */
ExInitializeNPagedLookasideList(
&pool_req_mem, NULL, NULL, 0, sizeof(req_item), '3_cd', 0);
KeInitializeEvent(&pool_signal_event, NotificationEvent, FALSE);
ExInitializeSListHead(&pool_head);
KeInitializeSpinLock(&pool_lock);
/* start worker threads */
for (i = 0; i < dc_cpu_count; i++)
{
if (start_system_thread(dc_worker_thread, NULL, &pool_threads[i]) != ST_OK) {
dc_free_fast_crypt(); return ST_ERR_THREAD;
}
}
return ST_OK;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This is the initialization routine for the Fat 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.
--*/
{
USHORT MaxDepth;
NTSTATUS Status;
UNICODE_STRING UnicodeString;
FS_FILTER_CALLBACKS FilterCallbacks;
UNICODE_STRING ValueName;
ULONG Value;
#if __NDAS_FAT__
UNICODE_STRING linkString;
UNICODE_STRING functionName;
UNICODE_STRING tempUnicode;
#endif
#if DBG
DbgPrint( "NdasFat DriverEntry %s %s\n", __DATE__, __TIME__ );
#endif
#if __NDAS_FAT_DBG__
FatDebugTraceLevel |= DEBUG_TRACE_ERROR;
FatDebugTraceLevel |= DEBUG_TRACE_CLEANUP;
FatDebugTraceLevel |= DEBUG_TRACE_CLOSE;
FatDebugTraceLevel |= DEBUG_TRACE_CREATE;
FatDebugTraceLevel |= DEBUG_TRACE_DIRCTRL;
FatDebugTraceLevel |= DEBUG_TRACE_EA;
FatDebugTraceLevel |= DEBUG_TRACE_FILEINFO;
FatDebugTraceLevel |= DEBUG_TRACE_FSCTRL;
FatDebugTraceLevel |= DEBUG_TRACE_LOCKCTRL;
FatDebugTraceLevel |= DEBUG_TRACE_READ;
FatDebugTraceLevel |= DEBUG_TRACE_VOLINFO;
FatDebugTraceLevel |= DEBUG_TRACE_WRITE;
FatDebugTraceLevel |= DEBUG_TRACE_DEVCTRL;
FatDebugTraceLevel |= DEBUG_TRACE_FLUSH;
FatDebugTraceLevel |= DEBUG_TRACE_PNP;
FatDebugTraceLevel |= DEBUG_TRACE_SHUTDOWN;
FatDebugTraceLevel = 0x00000009;
//FatDebugTraceLevel |= DEBUG_TRACE_FSCTRL;
//FatDebugTraceLevel |= DEBUG_INFO_DEVCTRL;
FatDebugTraceLevel |= DEBUG_INFO_FSCTRL;
FatDebugTraceLevel |= DEBUG_INFO_READ;
FatDebugTraceLevel |= DEBUG_INFO_SECONDARY;
//FatDebugTraceLevel |= DEBUG_INFO_PRIMARY;
FatDebugTraceLevel |= DEBUG_INFO_FILOBSUP;
FatDebugTraceLevel |= DEBUG_TRACE_PNP;
FatDebugTraceLevel |= DEBUG_TRACE_SHUTDOWN;
FatDebugTraceLevel |= DEBUG_INFO_FILEINFO;
FatDebugTraceLevel |= DEBUG_INFO_CREATE;
FatDebugTraceLevel |= DEBUG_INFO_STRUCSUP;
FatDebugTraceLevel |= DEBUG_INFO_CLEANUP;
FatDebugTraceLevel |= DEBUG_INFO_CLOSE;
FatDebugTraceLevel |= DEBUG_INFO_ALL;
FatDebugTraceLevel |= DEBUG_INFO_WRITE;
//FatDebugTraceLevel |= DEBUG_TRACE_WRITE;
FatDebugTraceLevel &= ~DEBUG_TRACE_UNWIND;
//FatDebugTraceLevel = 0xFFFFFFFFFFFFFFFF;
//FatDebugTraceLevel |= DEBUG_TRACE_STRUCSUP;
FatDebugTraceLevel |= DEBUG_INFO_FILEINFO;
//FatDebugTraceLevel |= DEBUG_TRACE_FILEINFO;
DebugTrace2( 0, DEBUG_INFO_ALL, ("sizeof(NDFS_WINXP_REPLY_HEADER) = %d\n", sizeof(NDFS_WINXP_REPLY_HEADER)) );
#endif
#if __NDAS_FAT_WIN2K_SUPPORT__
PsGetVersion( &gOsMajorVersion,
&gOsMinorVersion,
NULL,
NULL );
RtlInitUnicodeString( &functionName, L"SeFilterToken" );
NdasFatSeFilterToken = MmGetSystemRoutineAddress( &functionName );
if (IS_WINDOWSXP_OR_LATER()) { // to prevent incomprehensible error
RtlInitUnicodeString( &functionName, L"CcMdlWriteAbort" );
NdasFatCcMdlWriteAbort = MmGetSystemRoutineAddress( &functionName );
}
RtlInitUnicodeString( &functionName, L"KeAreApcsDisabled" );
NdasFatKeAreApcsDisabled = MmGetSystemRoutineAddress( &functionName );
RtlInitUnicodeString( &functionName, L"KeAreAllApcsDisabled" );
NdasFatKeAreAllApcsDisabled = MmGetSystemRoutineAddress( &functionName );
RtlInitUnicodeString( &functionName, L"FsRtlRegisterFileSystemFilterCallbacks" );
NdasFatFsRtlRegisterFileSystemFilterCallbacks = MmGetSystemRoutineAddress( &functionName );
RtlInitUnicodeString( &functionName, L"FsRtlAreVolumeStartupApplicationsComplete" );
NdasFatFsRtlAreVolumeStartupApplicationsComplete = MmGetSystemRoutineAddress( &functionName );
RtlInitUnicodeString( &functionName, L"MmDoesFileHaveUserWritableReferences" );
NdasFatMmDoesFileHaveUserWritableReferences = MmGetSystemRoutineAddress( &functionName );
#endif
#if __NDAS_FAT__
RtlInitUnicodeString( &UnicodeString, NDAS_FAT_CONTROL_DEVICE_NAME );
Status = IoCreateDevice( DriverObject,
0, // has no device extension
&UnicodeString,
FILE_DEVICE_NULL,
0,
FALSE,
&FatControlDeviceObject );
if (!NT_SUCCESS( Status )) {
return Status;
}
RtlInitUnicodeString( &linkString, NDAS_FAT_CONTROL_LINK_NAME );
Status = IoCreateSymbolicLink( &linkString, &UnicodeString );
if (!NT_SUCCESS(Status)) {
IoDeleteDevice( FatControlDeviceObject );
return Status;
}
#endif
#if __NDAS_FAT__
RtlInitUnicodeString( &UnicodeString, NDAS_FAT_DEVICE_NAME );
Status = IoCreateDevice( DriverObject,
sizeof(VOLUME_DEVICE_OBJECT) - sizeof(DEVICE_OBJECT),
&UnicodeString,
FILE_DEVICE_DISK_FILE_SYSTEM,
0,
FALSE,
&FatDiskFileSystemDeviceObject );
if (!NT_SUCCESS(Status)) {
IoDeleteSymbolicLink( &linkString );
IoDeleteDevice( FatControlDeviceObject );
return Status;
}
RtlZeroMemory( (PUCHAR)FatDiskFileSystemDeviceObject+sizeof(DEVICE_OBJECT),
sizeof(VOLUME_DEVICE_OBJECT)-sizeof(DEVICE_OBJECT) );
#else
//
// Create the device object for disks. To avoid problems with filters who
// know this name, we must keep it.
//
RtlInitUnicodeString( &UnicodeString, L"\\Fat" );
Status = IoCreateDevice( DriverObject,
0,
&UnicodeString,
FILE_DEVICE_DISK_FILE_SYSTEM,
0,
FALSE,
&FatDiskFileSystemDeviceObject );
if (!NT_SUCCESS( Status )) {
return Status;
}
#endif
#if !__NDAS_FAT__
//
// Create the device object for "cdroms".
//
RtlInitUnicodeString( &UnicodeString, L"\\FatCdrom" );
Status = IoCreateDevice( DriverObject,
0,
&UnicodeString,
FILE_DEVICE_CD_ROM_FILE_SYSTEM,
0,
FALSE,
&FatCdromFileSystemDeviceObject );
if (!NT_SUCCESS( Status )) {
IoDeleteDevice( FatDiskFileSystemDeviceObject);
return Status;
}
#endif
DriverObject->DriverUnload = FatUnload;
//
// 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.
//
DriverObject->MajorFunction[IRP_MJ_CREATE] = (PDRIVER_DISPATCH)FatFsdCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = (PDRIVER_DISPATCH)FatFsdClose;
DriverObject->MajorFunction[IRP_MJ_READ] = (PDRIVER_DISPATCH)FatFsdRead;
DriverObject->MajorFunction[IRP_MJ_WRITE] = (PDRIVER_DISPATCH)FatFsdWrite;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = (PDRIVER_DISPATCH)FatFsdQueryInformation;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = (PDRIVER_DISPATCH)FatFsdSetInformation;
DriverObject->MajorFunction[IRP_MJ_QUERY_EA] = (PDRIVER_DISPATCH)FatFsdQueryEa;
DriverObject->MajorFunction[IRP_MJ_SET_EA] = (PDRIVER_DISPATCH)FatFsdSetEa;
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = (PDRIVER_DISPATCH)FatFsdFlushBuffers;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = (PDRIVER_DISPATCH)FatFsdQueryVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] = (PDRIVER_DISPATCH)FatFsdSetVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = (PDRIVER_DISPATCH)FatFsdCleanup;
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = (PDRIVER_DISPATCH)FatFsdDirectoryControl;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = (PDRIVER_DISPATCH)FatFsdFileSystemControl;
DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = (PDRIVER_DISPATCH)FatFsdLockControl;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = (PDRIVER_DISPATCH)FatFsdDeviceControl;
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = (PDRIVER_DISPATCH)FatFsdShutdown;
DriverObject->MajorFunction[IRP_MJ_PNP] = (PDRIVER_DISPATCH)FatFsdPnp;
DriverObject->FastIoDispatch = &FatFastIoDispatch;
RtlZeroMemory(&FatFastIoDispatch, sizeof(FatFastIoDispatch));
FatFastIoDispatch.SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
FatFastIoDispatch.FastIoCheckIfPossible = FatFastIoCheckIfPossible; // CheckForFastIo
FatFastIoDispatch.FastIoRead = FsRtlCopyRead; // Read
FatFastIoDispatch.FastIoWrite = FsRtlCopyWrite; // Write
FatFastIoDispatch.FastIoQueryBasicInfo = FatFastQueryBasicInfo; // QueryBasicInfo
FatFastIoDispatch.FastIoQueryStandardInfo = FatFastQueryStdInfo; // QueryStandardInfo
FatFastIoDispatch.FastIoLock = FatFastLock; // Lock
FatFastIoDispatch.FastIoUnlockSingle = FatFastUnlockSingle; // UnlockSingle
FatFastIoDispatch.FastIoUnlockAll = FatFastUnlockAll; // UnlockAll
FatFastIoDispatch.FastIoUnlockAllByKey = FatFastUnlockAllByKey; // UnlockAllByKey
FatFastIoDispatch.FastIoQueryNetworkOpenInfo = FatFastQueryNetworkOpenInfo;
FatFastIoDispatch.AcquireForCcFlush = FatAcquireForCcFlush;
FatFastIoDispatch.ReleaseForCcFlush = FatReleaseForCcFlush;
FatFastIoDispatch.MdlRead = FsRtlMdlReadDev;
FatFastIoDispatch.MdlReadComplete = FsRtlMdlReadCompleteDev;
FatFastIoDispatch.PrepareMdlWrite = FsRtlPrepareMdlWriteDev;
FatFastIoDispatch.MdlWriteComplete = FsRtlMdlWriteCompleteDev;
#if __NDAS_FAT_SECONDARY__
RtlZeroMemory(&FatFastIoDispatch, sizeof(FAST_IO_DISPATCH));
FatFastIoDispatch.SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
//FatFastIoDispatch.FastIoCheckIfPossible = FatFastIoCheckIfPossible; // CheckForFastIo
//FatFastIoDispatch.AcquireForModWrite = FatAcquireFileForModWrite;
//FatFastIoDispatch.AcquireFileForNtCreateSection = FatAcquireForCreateSection;
//FatFastIoDispatch.ReleaseFileForNtCreateSection = FatReleaseForCreateSection;
FatFastIoDispatch.AcquireForCcFlush = FatAcquireForCcFlush;
FatFastIoDispatch.ReleaseForCcFlush = FatReleaseForCcFlush;
#endif
//
// Initialize the filter callbacks we use.
//
#if __NDAS_FAT__
if (IS_WINDOWSVISTA_OR_LATER()) {
#if __NDAS_FAT_WIN2K_SUPPORT__
if (NdasFatFsRtlRegisterFileSystemFilterCallbacks) {
RtlZeroMemory( &FilterCallbacks,
sizeof(FS_FILTER_CALLBACKS) );
FilterCallbacks.SizeOfFsFilterCallbacks = sizeof(FS_FILTER_CALLBACKS);
FilterCallbacks.PreAcquireForSectionSynchronization = FatFilterCallbackAcquireForCreateSection;
Status = NdasFatFsRtlRegisterFileSystemFilterCallbacks( DriverObject,
&FilterCallbacks );
if (!NT_SUCCESS( Status )) {
IoDeleteDevice( FatDiskFileSystemDeviceObject );
IoDeleteDevice( FatCdromFileSystemDeviceObject );
return Status;
}
}
#else
RtlZeroMemory( &FilterCallbacks,
sizeof(FS_FILTER_CALLBACKS) );
FilterCallbacks.SizeOfFsFilterCallbacks = sizeof(FS_FILTER_CALLBACKS);
FilterCallbacks.PreAcquireForSectionSynchronization = FatFilterCallbackAcquireForCreateSection;
Status = FsRtlRegisterFileSystemFilterCallbacks( DriverObject,
&FilterCallbacks );
if (!NT_SUCCESS( Status )) {
IoDeleteDevice( FatDiskFileSystemDeviceObject );
IoDeleteDevice( FatCdromFileSystemDeviceObject );
return Status;
}
#endif
}
#endif
//
// Initialize the global data structures
//
//
// The FatData record
//
RtlZeroMemory( &FatData, sizeof(FAT_DATA));
FatData.NodeTypeCode = FAT_NTC_DATA_HEADER;
FatData.NodeByteSize = sizeof(FAT_DATA);
InitializeListHead(&FatData.VcbQueue);
FatData.DriverObject = DriverObject;
FatData.DiskFileSystemDeviceObject = FatDiskFileSystemDeviceObject;
FatData.CdromFileSystemDeviceObject = FatCdromFileSystemDeviceObject;
//
// This list head keeps track of closes yet to be done.
//
InitializeListHead( &FatData.AsyncCloseList );
InitializeListHead( &FatData.DelayedCloseList );
FatData.FatCloseItem = IoAllocateWorkItem( FatDiskFileSystemDeviceObject);
if (FatData.FatCloseItem == NULL) {
IoDeleteDevice (FatDiskFileSystemDeviceObject);
#if __NDAS_FAT__
if (FatCdromFileSystemDeviceObject)
#endif
IoDeleteDevice (FatCdromFileSystemDeviceObject);
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Now initialize our general purpose spinlock (gag) and figure out how
// deep and wide we want our delayed lists (along with fooling ourselves
// about the lookaside depths).
//
KeInitializeSpinLock( &FatData.GeneralSpinLock );
switch ( MmQuerySystemSize() ) {
case MmSmallSystem:
MaxDepth = 4;
FatMaxDelayedCloseCount = FAT_MAX_DELAYED_CLOSES;
break;
case MmMediumSystem:
MaxDepth = 8;
FatMaxDelayedCloseCount = 4 * FAT_MAX_DELAYED_CLOSES;
break;
case MmLargeSystem:
MaxDepth = 16;
FatMaxDelayedCloseCount = 16 * FAT_MAX_DELAYED_CLOSES;
break;
}
//
// Initialize the cache manager callback routines
//
FatData.CacheManagerCallbacks.AcquireForLazyWrite = &FatAcquireFcbForLazyWrite;
FatData.CacheManagerCallbacks.ReleaseFromLazyWrite = &FatReleaseFcbFromLazyWrite;
FatData.CacheManagerCallbacks.AcquireForReadAhead = &FatAcquireFcbForReadAhead;
FatData.CacheManagerCallbacks.ReleaseFromReadAhead = &FatReleaseFcbFromReadAhead;
FatData.CacheManagerNoOpCallbacks.AcquireForLazyWrite = &FatNoOpAcquire;
FatData.CacheManagerNoOpCallbacks.ReleaseFromLazyWrite = &FatNoOpRelease;
FatData.CacheManagerNoOpCallbacks.AcquireForReadAhead = &FatNoOpAcquire;
FatData.CacheManagerNoOpCallbacks.ReleaseFromReadAhead = &FatNoOpRelease;
//
// Set up global pointer to our process.
//
FatData.OurProcess = PsGetCurrentProcess();
//
// Read the registry to determine if we are in ChicagoMode.
//
ValueName.Buffer = COMPATIBILITY_MODE_VALUE_NAME;
ValueName.Length = sizeof(COMPATIBILITY_MODE_VALUE_NAME) - sizeof(WCHAR);
ValueName.MaximumLength = sizeof(COMPATIBILITY_MODE_VALUE_NAME);
Status = FatGetCompatibilityModeValue( &ValueName, &Value );
if (NT_SUCCESS(Status) && FlagOn(Value, 1)) {
FatData.ChicagoMode = FALSE;
} else {
FatData.ChicagoMode = TRUE;
}
//
// Read the registry to determine if we are going to generate LFNs
// for valid 8.3 names with extended characters.
//
ValueName.Buffer = CODE_PAGE_INVARIANCE_VALUE_NAME;
ValueName.Length = sizeof(CODE_PAGE_INVARIANCE_VALUE_NAME) - sizeof(WCHAR);
ValueName.MaximumLength = sizeof(CODE_PAGE_INVARIANCE_VALUE_NAME);
Status = FatGetCompatibilityModeValue( &ValueName, &Value );
if (NT_SUCCESS(Status) && FlagOn(Value, 1)) {
FatData.CodePageInvariant = FALSE;
} else {
FatData.CodePageInvariant = TRUE;
}
//
// Initialize our global resource and fire up the lookaside lists.
//
ExInitializeResourceLite( &FatData.Resource );
ExInitializeNPagedLookasideList( &FatIrpContextLookasideList,
NULL,
NULL,
POOL_RAISE_IF_ALLOCATION_FAILURE,
sizeof(IRP_CONTEXT),
TAG_IRP_CONTEXT,
MaxDepth );
ExInitializeNPagedLookasideList( &FatNonPagedFcbLookasideList,
NULL,
NULL,
POOL_RAISE_IF_ALLOCATION_FAILURE,
sizeof(NON_PAGED_FCB),
TAG_FCB_NONPAGED,
MaxDepth );
ExInitializeNPagedLookasideList( &FatEResourceLookasideList,
NULL,
NULL,
POOL_RAISE_IF_ALLOCATION_FAILURE,
sizeof(ERESOURCE),
TAG_ERESOURCE,
MaxDepth );
ExInitializeSListHead( &FatCloseContextSList );
ExInitializeFastMutex( &FatCloseQueueMutex );
KeInitializeEvent( &FatReserveEvent, SynchronizationEvent, TRUE );
//
// Register the file system with the I/O system
//
IoRegisterFileSystem(FatDiskFileSystemDeviceObject);
ObReferenceObject (FatDiskFileSystemDeviceObject);
#if __NDAS_FAT__
if (FatCdromFileSystemDeviceObject) {
IoRegisterFileSystem(FatCdromFileSystemDeviceObject);
ObReferenceObject (FatCdromFileSystemDeviceObject);
}
#else
IoRegisterFileSystem(FatCdromFileSystemDeviceObject);
ObReferenceObject (FatCdromFileSystemDeviceObject);
#endif
#if __NDAS_FAT__
FatData.FileSystemRegistered = TRUE;
RtlInitEmptyUnicodeString( &FatData.Root,
FatData.RootBuffer,
sizeof(FatData.RootBuffer) );
RtlInitUnicodeString( &tempUnicode, L"\\" );
RtlCopyUnicodeString( &FatData.Root, &tempUnicode );
RtlInitEmptyUnicodeString( &FatData.MountMgrRemoteDatabase,
FatData.MountMgrRemoteDatabaseBuffer,
sizeof(FatData.MountMgrRemoteDatabaseBuffer) );
RtlInitUnicodeString( &tempUnicode, L"\\:$MountMgrRemoteDatabase" );
RtlCopyUnicodeString( &FatData.MountMgrRemoteDatabase, &tempUnicode );
RtlInitEmptyUnicodeString( &FatData.ExtendReparse,
FatData.ExtendReparseBuffer,
sizeof(FatData.ExtendReparseBuffer) );
RtlInitUnicodeString( &tempUnicode, L"\\$Extend\\$Reparse:$R:$INDEX_ALLOCATION" );
RtlCopyUnicodeString( &FatData.ExtendReparse, &tempUnicode );
RtlInitEmptyUnicodeString( &FatData.MountPointManagerRemoteDatabase,
FatData.MountPointManagerRemoteDatabaseBuffer,
sizeof(FatData.MountPointManagerRemoteDatabaseBuffer) );
RtlInitUnicodeString( &tempUnicode, L"\\System Volume Information\\MountPointManagerRemoteDatabase" );
RtlCopyUnicodeString( &FatData.MountPointManagerRemoteDatabase, &tempUnicode );
#endif
//
// Find out if we are running an a FujitsuFMR machine.
//
FatData.FujitsuFMR = FatIsFujitsuFMR();
#if __NDAS_FAT__
//
// Check to see if new kernel is present to decide if we want
// to support advance fcb headers
//
RtlInitUnicodeString( &UnicodeString, L"FsRtlTeardownPerStreamContexts" );
FatFsRtlTeardownPerStreamContexts = MmGetSystemRoutineAddress( &UnicodeString );
#endif
//
// And return to our caller
//
return( STATUS_SUCCESS );
}
NTSTATUS
SpCreateLogicalUnit(
IN PDEVICE_OBJECT AdapterFdo,
UCHAR PathId,
UCHAR TargetId,
UCHAR Lun,
OUT PDEVICE_OBJECT *NewPdo
)
/*++
Routine Description:
This routine will create a physical device object for the specified device
Arguments:
AdapterFdo - the FDO this device was enumerated from
LunInfo - the scsi port lun info structure for this device
NewPdo - a location to store the pointer to the new device
Return Value:
status
--*/
{
PADAPTER_EXTENSION deviceExtension = AdapterFdo->DeviceExtension;
PIRP senseIrp;
PDEVICE_OBJECT pdo = NULL;
WCHAR wideDeviceName[64];
UNICODE_STRING unicodeDeviceName;
ULONG extensionSize;
NTSTATUS status;
PAGED_CODE();
//
// Attempt to allocate all the persistent resources we need before we
// try to create the device object itself.
//
//
// Allocate a request sense irp.
//
senseIrp = IoAllocateIrp(1, FALSE);
if(senseIrp == NULL) {
DebugPrint((0, "SpCreateLogicalUnit: Could not allocate request sense "
"irp\n"));
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Build the name for the device
//
swprintf(wideDeviceName,
L"%wsPort%xPath%xTarget%xLun%x",
deviceExtension->DeviceName,
deviceExtension->PortNumber,
PathId,
TargetId,
Lun);
RtlInitUnicodeString(&unicodeDeviceName, wideDeviceName);
//
// Round the size of the Hardware logical extension to the size of a
// PVOID and add it to the port driver's logical extension.
//
extensionSize =
(deviceExtension->HwLogicalUnitExtensionSize + sizeof(LONGLONG) - 1) &
~(sizeof(LONGLONG) -1);
extensionSize += sizeof(LOGICAL_UNIT_EXTENSION);
//
// Create a physical device object
//
status = IoCreateDevice(
AdapterFdo->DriverObject,
extensionSize,
&unicodeDeviceName,
FILE_DEVICE_MASS_STORAGE,
FILE_DEVICE_SECURE_OPEN,
FALSE,
&pdo
);
if(NT_SUCCESS(status)) {
PCOMMON_EXTENSION commonExtension;
PLOGICAL_UNIT_EXTENSION logicalUnitExtension;
UCHAR i;
ULONG bin;
UCHAR rawDeviceName[64];
ANSI_STRING ansiDeviceName;
//
// Set the device object's stack size
//
//
// We need one stack location for the PDO to do lock tracking and
// one stack location to issue scsi request to the FDO.
//
pdo->StackSize = 1;
pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
pdo->Flags |= DO_DIRECT_IO;
pdo->AlignmentRequirement = AdapterFdo->AlignmentRequirement;
//
// Initialize the device extension for the root device
//
commonExtension = pdo->DeviceExtension;
logicalUnitExtension = pdo->DeviceExtension;
RtlZeroMemory(logicalUnitExtension, extensionSize);
commonExtension->DeviceObject = pdo;
commonExtension->IsPdo = TRUE;
commonExtension->LowerDeviceObject = AdapterFdo;
commonExtension->MajorFunction = DeviceMajorFunctionTable;
commonExtension->WmiInitialized = FALSE;
commonExtension->WmiMiniPortSupport =
deviceExtension->CommonExtension.WmiMiniPortSupport;
commonExtension->WmiScsiPortRegInfoBuf = NULL;
commonExtension->WmiScsiPortRegInfoBufSize = 0;
//
// Initialize value to zero. It will be incremented once pnp is aware
// of its existance.
//
commonExtension->RemoveLock = 0;
#if DBG
KeInitializeSpinLock(&commonExtension->RemoveTrackingSpinlock);
commonExtension->RemoveTrackingList = NULL;
ExInitializeNPagedLookasideList(
&(commonExtension->RemoveTrackingLookasideList),
NULL,
NULL,
0,
sizeof(REMOVE_TRACKING_BLOCK),
SCSIPORT_TAG_LOCK_TRACKING,
64);
commonExtension->RemoveTrackingLookasideListInitialized = TRUE;
#else
commonExtension->RemoveTrackingSpinlock = (ULONG) -1L;
commonExtension->RemoveTrackingList = (PVOID) -1L;
#endif
commonExtension->CurrentPnpState = 0xff;
commonExtension->PreviousPnpState = 0xff;
//
// Initialize the remove lock event.
//
KeInitializeEvent(
&(logicalUnitExtension->CommonExtension.RemoveEvent),
SynchronizationEvent,
FALSE);
logicalUnitExtension->LuFlags |= LU_RESCAN_ACTIVE;
logicalUnitExtension->PortNumber = deviceExtension->PortNumber;
logicalUnitExtension->PathId = PathId;
logicalUnitExtension->TargetId = TargetId;
logicalUnitExtension->Lun = Lun;
logicalUnitExtension->HwLogicalUnitExtension =
(PVOID) (logicalUnitExtension + 1);
logicalUnitExtension->AdapterExtension = deviceExtension;
//
// Give the caller the benefit of the doubt.
//
logicalUnitExtension->IsMissing = FALSE;
//
// The device cannot have been enumerated yet.
//
logicalUnitExtension->IsEnumerated = FALSE;
//
// Set timer counters to -1 to inidicate that there are no outstanding
// requests.
//
logicalUnitExtension->RequestTimeoutCounter = -1;
//
// Initialize the maximum queue depth size.
//
logicalUnitExtension->MaxQueueDepth = 0xFF;
//
// Initialize the request list.
//
InitializeListHead(&logicalUnitExtension->RequestList);
//
// Initialize the push/pop list of SRB_DATA blocks for use with bypass
// requests.
//
KeInitializeSpinLock(&(logicalUnitExtension->BypassSrbDataSpinLock));
ExInitializeSListHead(&(logicalUnitExtension->BypassSrbDataList));
for(i = 0; i < NUMBER_BYPASS_SRB_DATA_BLOCKS; i++) {
ExInterlockedPushEntrySList(
&(logicalUnitExtension->BypassSrbDataList),
&(logicalUnitExtension->BypassSrbDataBlocks[i].Reserved),
&(logicalUnitExtension->BypassSrbDataSpinLock));
}
//
// Assume devices are powered on by default.
//
commonExtension->CurrentDeviceState = PowerDeviceD0;
commonExtension->DesiredDeviceState = PowerDeviceUnspecified;
//
// Assume that we're being initialized in a working system.
//
commonExtension->CurrentSystemState = PowerSystemWorking;
//
// Set the pnp state to unknown.
//
commonExtension->CurrentPnpState = 0xff;
commonExtension->PreviousPnpState = 0xff;
//
// Setup the request sense resources.
//
logicalUnitExtension->RequestSenseIrp = senseIrp;
KeInitializeSpinLock(&(logicalUnitExtension->RequestSenseLock));
//
// Link the device into the list of physical device objects
//
SpAddLogicalUnitToBin(deviceExtension, logicalUnitExtension);
//
// I guess this is as ready to be opened as it ever will be.
//
pdo->Flags &= ~DO_DEVICE_INITIALIZING;
} else {
DebugPrint((1, "ScsiBusCreatePdo: Error %#08lx creating device object\n",
status));
pdo = NULL;
}
*NewPdo = pdo;
return status;
}
NTSTATUS
IpxCreateAdapter(
IN PDEVICE Device,
IN PUNICODE_STRING AdapterName,
IN OUT PADAPTER *AdapterPtr
)
/*++
Routine Description:
This routine creates and initializes a device context structure.
Arguments:
DriverObject - pointer to the IO subsystem supplied driver object.
Adapter - Pointer to a pointer to a transport device context object.
AdapterName - pointer to the name of the device this device object points to.
Return Value:
STATUS_SUCCESS if all is well; STATUS_INSUFFICIENT_RESOURCES otherwise.
--*/
{
PADAPTER Adapter;
#if 0
UINT i, j;
#endif
Adapter = (PADAPTER)IpxAllocateMemory (sizeof(ADAPTER) + AdapterName->Length + sizeof(WCHAR), MEMORY_ADAPTER, "Adapter");
#ifdef _PNP_POWER
if (Adapter == NULL) {
if (KeGetCurrentIrql() == 0) {
IPX_DEBUG (ADAPTER, ("Create adapter %ws failed\n", AdapterName));
} else {
IPX_DEBUG (ADAPTER, ("Create adapter %lx failed\n", AdapterName));
}
return STATUS_INSUFFICIENT_RESOURCES;
}
IPX_DEBUG (ADAPTER, ("Create adapter %lx %lx succeeded\n", Adapter, AdapterName));
#else
if (Adapter == NULL) {
IPX_DEBUG (ADAPTER, ("Create adapter %ws failed\n", AdapterName->Buffer));
return STATUS_INSUFFICIENT_RESOURCES;
}
IPX_DEBUG (ADAPTER, ("Create adapter %ws succeeded\n", AdapterName->Buffer));
#endif
RtlZeroMemory(Adapter, sizeof(ADAPTER));
//
// Copy over the adapter name.
//
Adapter->AdapterNameLength = AdapterName->Length + sizeof(WCHAR);
Adapter->AdapterName = (PWCHAR)(Adapter+1);
RtlCopyMemory(
Adapter->AdapterName,
AdapterName->Buffer,
AdapterName->Length);
Adapter->AdapterName[AdapterName->Length/sizeof(WCHAR)] = UNICODE_NULL;
#if DBG
RtlCopyMemory(Adapter->Signature1, "IAD1", 4);
#endif
Adapter->Type = IPX_ADAPTER_SIGNATURE;
Adapter->Size = sizeof(ADAPTER);
CTEInitLock (&Adapter->Lock);
InitializeListHead (&Adapter->RequestCompletionQueue);
InitializeListHead (&Adapter->ReceiveBufferPoolList);
ExInitializeSListHead (&Adapter->ReceiveBufferList);
Adapter->Device = Device;
Adapter->DeviceLock = &Device->Lock;
IpxReferenceDevice (Device, DREF_ADAPTER);
#if 0
Adapter->ReceiveBufferPool.Next = NULL;
for (i = 0; i < ISN_FRAME_TYPE_MAX; i++) {
Adapter->Bindings[i] = NULL;
}
Adapter->BindingCount = 0;
for (i = 0; i < IDENTIFIER_TOTAL; i++) {
for (j = 0; j < SOURCE_ROUTE_HASH_SIZE; j++) {
Adapter->SourceRoutingHeads[i][j] = (PSOURCE_ROUTE)NULL;
}
}
#endif
//
// BUGBUG: For the moment, we have to do the source
// routing operation on any type where broadcast
// may not be used for discovery -- improve this
// hopefully.
//
Adapter->SourceRoutingEmpty[IDENTIFIER_RIP] = FALSE;
Adapter->SourceRoutingEmpty[IDENTIFIER_IPX] = FALSE;
Adapter->SourceRoutingEmpty[IDENTIFIER_SPX] = FALSE;
Adapter->SourceRoutingEmpty[IDENTIFIER_NB] = TRUE;
#ifdef _PNP_POWER
//
// Lock here? [BUGBUGZZ]
//
Adapter->ReferenceCount = 1;
#endif
*AdapterPtr = Adapter;
return STATUS_SUCCESS;
} /* IpxCreateAdapter */
NTSTATUS
DriverEntry(
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This is the initialization routine for the Fat 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.
--*/
{
USHORT MaxDepth;
NTSTATUS Status;
UNICODE_STRING UnicodeString;
FS_FILTER_CALLBACKS FilterCallbacks;
UNICODE_STRING ValueName;
ULONG Value;
UNREFERENCED_PARAMETER( RegistryPath );
//
// Create the device object for disks. To avoid problems with filters who
// know this name, we must keep it.
//
RtlInitUnicodeString( &UnicodeString, L"\\Fat" );
Status = IoCreateDevice( DriverObject,
0,
&UnicodeString,
FILE_DEVICE_DISK_FILE_SYSTEM,
0,
FALSE,
&FatDiskFileSystemDeviceObject );
if (!NT_SUCCESS( Status )) {
return Status;
}
//
// Create the device object for "cdroms".
//
RtlInitUnicodeString( &UnicodeString, L"\\FatCdrom" );
Status = IoCreateDevice( DriverObject,
0,
&UnicodeString,
FILE_DEVICE_CD_ROM_FILE_SYSTEM,
0,
FALSE,
&FatCdromFileSystemDeviceObject );
if (!NT_SUCCESS( Status )) {
IoDeleteDevice( FatDiskFileSystemDeviceObject);
return Status;
}
#pragma prefast( push )
#pragma prefast( disable:28155, "these are all correct" )
#pragma prefast( disable:28169, "these are all correct" )
#pragma prefast( disable:28175, "this is a filesystem, touching FastIoDispatch is allowed" )
DriverObject->DriverUnload = FatUnload;
//
// 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.
//
DriverObject->MajorFunction[IRP_MJ_CREATE] = (PDRIVER_DISPATCH)FatFsdCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = (PDRIVER_DISPATCH)FatFsdClose;
DriverObject->MajorFunction[IRP_MJ_READ] = (PDRIVER_DISPATCH)FatFsdRead;
DriverObject->MajorFunction[IRP_MJ_WRITE] = (PDRIVER_DISPATCH)FatFsdWrite;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = (PDRIVER_DISPATCH)FatFsdQueryInformation;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = (PDRIVER_DISPATCH)FatFsdSetInformation;
DriverObject->MajorFunction[IRP_MJ_QUERY_EA] = (PDRIVER_DISPATCH)FatFsdQueryEa;
DriverObject->MajorFunction[IRP_MJ_SET_EA] = (PDRIVER_DISPATCH)FatFsdSetEa;
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = (PDRIVER_DISPATCH)FatFsdFlushBuffers;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = (PDRIVER_DISPATCH)FatFsdQueryVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] = (PDRIVER_DISPATCH)FatFsdSetVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = (PDRIVER_DISPATCH)FatFsdCleanup;
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = (PDRIVER_DISPATCH)FatFsdDirectoryControl;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = (PDRIVER_DISPATCH)FatFsdFileSystemControl;
DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = (PDRIVER_DISPATCH)FatFsdLockControl;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = (PDRIVER_DISPATCH)FatFsdDeviceControl;
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = (PDRIVER_DISPATCH)FatFsdShutdown;
DriverObject->MajorFunction[IRP_MJ_PNP] = (PDRIVER_DISPATCH)FatFsdPnp;
DriverObject->FastIoDispatch = &FatFastIoDispatch;
RtlZeroMemory(&FatFastIoDispatch, sizeof(FatFastIoDispatch));
FatFastIoDispatch.SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
FatFastIoDispatch.FastIoCheckIfPossible = FatFastIoCheckIfPossible; // CheckForFastIo
FatFastIoDispatch.FastIoRead = FsRtlCopyRead; // Read
FatFastIoDispatch.FastIoWrite = FsRtlCopyWrite; // Write
FatFastIoDispatch.FastIoQueryBasicInfo = FatFastQueryBasicInfo; // QueryBasicInfo
FatFastIoDispatch.FastIoQueryStandardInfo = FatFastQueryStdInfo; // QueryStandardInfo
FatFastIoDispatch.FastIoLock = FatFastLock; // Lock
FatFastIoDispatch.FastIoUnlockSingle = FatFastUnlockSingle; // UnlockSingle
FatFastIoDispatch.FastIoUnlockAll = FatFastUnlockAll; // UnlockAll
FatFastIoDispatch.FastIoUnlockAllByKey = FatFastUnlockAllByKey; // UnlockAllByKey
FatFastIoDispatch.FastIoQueryNetworkOpenInfo = FatFastQueryNetworkOpenInfo;
FatFastIoDispatch.AcquireForCcFlush = FatAcquireForCcFlush;
FatFastIoDispatch.ReleaseForCcFlush = FatReleaseForCcFlush;
FatFastIoDispatch.MdlRead = FsRtlMdlReadDev;
FatFastIoDispatch.MdlReadComplete = FsRtlMdlReadCompleteDev;
FatFastIoDispatch.PrepareMdlWrite = FsRtlPrepareMdlWriteDev;
FatFastIoDispatch.MdlWriteComplete = FsRtlMdlWriteCompleteDev;
#pragma prefast( pop )
//
// Initialize the filter callbacks we use.
//
RtlZeroMemory( &FilterCallbacks,
sizeof(FS_FILTER_CALLBACKS) );
FilterCallbacks.SizeOfFsFilterCallbacks = sizeof(FS_FILTER_CALLBACKS);
FilterCallbacks.PreAcquireForSectionSynchronization = FatFilterCallbackAcquireForCreateSection;
Status = FsRtlRegisterFileSystemFilterCallbacks( DriverObject,
&FilterCallbacks );
if (!NT_SUCCESS( Status )) {
IoDeleteDevice( FatDiskFileSystemDeviceObject );
IoDeleteDevice( FatCdromFileSystemDeviceObject );
return Status;
}
//
// Initialize the global data structures
//
//
// The FatData record
//
RtlZeroMemory( &FatData, sizeof(FAT_DATA));
FatData.NodeTypeCode = FAT_NTC_DATA_HEADER;
FatData.NodeByteSize = sizeof(FAT_DATA);
InitializeListHead(&FatData.VcbQueue);
FatData.DriverObject = DriverObject;
FatData.DiskFileSystemDeviceObject = FatDiskFileSystemDeviceObject;
FatData.CdromFileSystemDeviceObject = FatCdromFileSystemDeviceObject;
//
// This list head keeps track of closes yet to be done.
//
InitializeListHead( &FatData.AsyncCloseList );
InitializeListHead( &FatData.DelayedCloseList );
FatData.FatCloseItem = IoAllocateWorkItem( FatDiskFileSystemDeviceObject);
if (FatData.FatCloseItem == NULL) {
IoDeleteDevice (FatDiskFileSystemDeviceObject);
IoDeleteDevice (FatCdromFileSystemDeviceObject);
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Allocate the zero page
//
FatData.ZeroPage = ExAllocatePoolWithTag( NonPagedPoolNx, PAGE_SIZE, 'ZtaF' );
if (FatData.ZeroPage == NULL) {
IoDeleteDevice (FatDiskFileSystemDeviceObject);
IoDeleteDevice (FatCdromFileSystemDeviceObject);
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory( FatData.ZeroPage, PAGE_SIZE );
//
// Now initialize our general purpose spinlock (gag) and figure out how
// deep and wide we want our delayed lists (along with fooling ourselves
// about the lookaside depths).
//
KeInitializeSpinLock( &FatData.GeneralSpinLock );
switch ( MmQuerySystemSize() ) {
case MmSmallSystem:
MaxDepth = 4;
FatMaxDelayedCloseCount = FAT_MAX_DELAYED_CLOSES;
break;
case MmMediumSystem:
MaxDepth = 8;
FatMaxDelayedCloseCount = 4 * FAT_MAX_DELAYED_CLOSES;
break;
case MmLargeSystem:
default:
MaxDepth = 16;
FatMaxDelayedCloseCount = 16 * FAT_MAX_DELAYED_CLOSES;
break;
}
//
// Initialize the cache manager callback routines
//
FatData.CacheManagerCallbacks.AcquireForLazyWrite = &FatAcquireFcbForLazyWrite;
FatData.CacheManagerCallbacks.ReleaseFromLazyWrite = &FatReleaseFcbFromLazyWrite;
FatData.CacheManagerCallbacks.AcquireForReadAhead = &FatAcquireFcbForReadAhead;
FatData.CacheManagerCallbacks.ReleaseFromReadAhead = &FatReleaseFcbFromReadAhead;
FatData.CacheManagerNoOpCallbacks.AcquireForLazyWrite = &FatNoOpAcquire;
FatData.CacheManagerNoOpCallbacks.ReleaseFromLazyWrite = &FatNoOpRelease;
FatData.CacheManagerNoOpCallbacks.AcquireForReadAhead = &FatNoOpAcquire;
FatData.CacheManagerNoOpCallbacks.ReleaseFromReadAhead = &FatNoOpRelease;
//
// Set up global pointer to our process.
//
FatData.OurProcess = PsGetCurrentProcess();
//
// Setup the number of processors we support for statistics as the current number
// running.
//
#if (NTDDI_VERSION >= NTDDI_VISTA)
FatData.NumberProcessors = KeQueryActiveProcessorCount( NULL );
#else
FatData.NumberProcessors = KeNumberProcessors;
#endif
//
// Read the registry to determine if we are in ChicagoMode.
//
ValueName.Buffer = COMPATIBILITY_MODE_VALUE_NAME;
ValueName.Length = sizeof(COMPATIBILITY_MODE_VALUE_NAME) - sizeof(WCHAR);
ValueName.MaximumLength = sizeof(COMPATIBILITY_MODE_VALUE_NAME);
Status = FatGetCompatibilityModeValue( &ValueName, &Value );
if (NT_SUCCESS(Status) && FlagOn(Value, 1)) {
FatData.ChicagoMode = FALSE;
} else {
FatData.ChicagoMode = TRUE;
}
//
// Read the registry to determine if we are going to generate LFNs
// for valid 8.3 names with extended characters.
//
ValueName.Buffer = CODE_PAGE_INVARIANCE_VALUE_NAME;
ValueName.Length = sizeof(CODE_PAGE_INVARIANCE_VALUE_NAME) - sizeof(WCHAR);
ValueName.MaximumLength = sizeof(CODE_PAGE_INVARIANCE_VALUE_NAME);
Status = FatGetCompatibilityModeValue( &ValueName, &Value );
if (NT_SUCCESS(Status) && FlagOn(Value, 1)) {
FatData.CodePageInvariant = FALSE;
} else {
FatData.CodePageInvariant = TRUE;
}
//
// Initialize our global resource and fire up the lookaside lists.
//
ExInitializeResourceLite( &FatData.Resource );
ExInitializeNPagedLookasideList( &FatIrpContextLookasideList,
NULL,
NULL,
POOL_NX_ALLOCATION | POOL_RAISE_IF_ALLOCATION_FAILURE,
sizeof(IRP_CONTEXT),
TAG_IRP_CONTEXT,
MaxDepth );
ExInitializeNPagedLookasideList( &FatNonPagedFcbLookasideList,
NULL,
NULL,
POOL_NX_ALLOCATION | POOL_RAISE_IF_ALLOCATION_FAILURE,
sizeof(NON_PAGED_FCB),
TAG_FCB_NONPAGED,
MaxDepth );
ExInitializeNPagedLookasideList( &FatEResourceLookasideList,
NULL,
NULL,
POOL_NX_ALLOCATION | POOL_RAISE_IF_ALLOCATION_FAILURE,
sizeof(ERESOURCE),
TAG_ERESOURCE,
MaxDepth );
ExInitializeSListHead( &FatCloseContextSList );
ExInitializeFastMutex( &FatCloseQueueMutex );
KeInitializeEvent( &FatReserveEvent, SynchronizationEvent, TRUE );
//
// Register the file system with the I/O system
//
IoRegisterFileSystem(FatDiskFileSystemDeviceObject);
ObReferenceObject (FatDiskFileSystemDeviceObject);
IoRegisterFileSystem(FatCdromFileSystemDeviceObject);
ObReferenceObject (FatCdromFileSystemDeviceObject);
//
// Find out if we are running an a FujitsuFMR machine.
//
FatData.FujitsuFMR = FatIsFujitsuFMR();
#if (NTDDI_VERSION >= NTDDI_WIN8)
//
// Find out global disk accounting state, cache the result
//
FatDiskAccountingEnabled = PsIsDiskCountersEnabled();
#endif
//
// And return to our caller
//
return( STATUS_SUCCESS );
}
VOID
ExInitializePagedLookasideList (
IN PPAGED_LOOKASIDE_LIST Lookaside,
IN PALLOCATE_FUNCTION Allocate,
IN PFREE_FUNCTION Free,
IN ULONG Flags,
IN SIZE_T Size,
IN ULONG Tag,
IN USHORT Depth
)
/*++
Routine Description:
This function initializes a paged lookaside list structure and inserts
the structure in the system paged lookaside list.
Arguments:
Lookaside - Supplies a pointer to a paged lookaside list structure.
Allocate - Supplies an optional pointer to an allocate function.
Free - Supplies an optional pointer to a free function.
Flags - Supplies the pool allocation flags which are merged with the
pool allocation type (NonPagedPool) to control pool allocation.
Size - Supplies the size for the lookaside list entries.
Tag - Supplies the pool tag for the lookaside list entries.
Depth - Supplies the maximum depth of the lookaside list.
Return Value:
None.
--*/
{
//
// Initialize the lookaside list structure.
//
ExInitializeSListHead(&Lookaside->L.ListHead);
Lookaside->L.Depth = MINIMUM_LOOKASIDE_DEPTH;
Lookaside->L.MaximumDepth = 256; //Depth;
Lookaside->L.TotalAllocates = 0;
Lookaside->L.AllocateMisses = 0;
Lookaside->L.TotalFrees = 0;
Lookaside->L.FreeMisses = 0;
Lookaside->L.Type = PagedPool | Flags;
Lookaside->L.Tag = Tag;
Lookaside->L.Size = (ULONG)Size;
if (Allocate == NULL) {
Lookaside->L.Allocate = ExAllocatePoolWithTag;
} else {
Lookaside->L.Allocate = Allocate;
}
if (Free == NULL) {
Lookaside->L.Free = ExFreePool;
} else {
Lookaside->L.Free = Free;
}
Lookaside->L.LastTotalAllocates = 0;
Lookaside->L.LastAllocateMisses = 0;
ExInitializeFastMutex(&Lookaside->Lock);
//
// Insert the lookaside list structure in the system paged lookaside
// list.
//
ExInterlockedInsertTailList(&ExPagedLookasideListHead,
&Lookaside->L.ListEntry,
&ExPagedLookasideLock);
return;
}
VOID
ExInitializeSystemLookasideList (
IN PGENERAL_LOOKASIDE Lookaside,
IN POOL_TYPE Type,
IN ULONG Size,
IN ULONG Tag,
IN USHORT Depth,
IN PLIST_ENTRY ListHead
)
/*++
Routine Description:
This function initializes a system lookaside list structure and inserts
the structure in the specified lookaside list.
Arguments:
Lookaside - Supplies a pointer to a nonpaged lookaside list structure.
Type - Supplies the pool type of the lookaside list.
Size - Supplies the size of the lookaside list entries.
Tag - Supplies the pool tag for the lookaside list entries.
Depth - Supplies the maximum depth of the lookaside list.
ListHead - Supplies a pointer to the lookaside list into which the
lookaside list structure is to be inserted.
Return Value:
None.
--*/
{
//
// Initialize pool lookaside list structure and insert the structure
// in the pool lookaside list.
//
ExInitializeSListHead(&Lookaside->ListHead);
Lookaside->Allocate = &ExAllocatePoolWithTag;
Lookaside->Free = &ExFreePool;
Lookaside->Depth = 2;
Lookaside->MaximumDepth = Depth;
Lookaside->TotalAllocates = 0;
Lookaside->AllocateHits = 0;
Lookaside->TotalFrees = 0;
Lookaside->FreeHits = 0;
Lookaside->Type = Type;
Lookaside->Tag = Tag;
Lookaside->Size = Size;
Lookaside->LastTotalAllocates = 0;
Lookaside->LastAllocateHits = 0;
InsertTailList(ListHead, &Lookaside->ListEntry);
return;
}
NTSTATUS
NTAPI
CdRomAllocateMmcResources(
IN PDEVICE_OBJECT Fdo
)
{
PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
PCDROM_DATA cddata = commonExtension->DriverData;
PCDROM_MMC_EXTENSION mmcData = &cddata->Mmc;
PIO_STACK_LOCATION irpStack;
NTSTATUS status;
ASSERT(mmcData->CapabilitiesWorkItem == NULL);
ASSERT(mmcData->CapabilitiesIrp == NULL);
ASSERT(mmcData->CapabilitiesMdl == NULL);
ASSERT(mmcData->CapabilitiesBuffer == NULL);
ASSERT(mmcData->CapabilitiesBufferSize == 0);
status = CdRomGetConfiguration(Fdo,
&mmcData->CapabilitiesBuffer,
&mmcData->CapabilitiesBufferSize,
FeatureProfileList,
SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL);
if (!NT_SUCCESS(status)) {
ASSERT(mmcData->CapabilitiesBuffer == NULL);
ASSERT(mmcData->CapabilitiesBufferSize == 0);
return status;
}
ASSERT(mmcData->CapabilitiesBuffer != NULL);
ASSERT(mmcData->CapabilitiesBufferSize != 0);
mmcData->CapabilitiesMdl = IoAllocateMdl(mmcData->CapabilitiesBuffer,
mmcData->CapabilitiesBufferSize,
FALSE, FALSE, NULL);
if (mmcData->CapabilitiesMdl == NULL) {
ExFreePool(mmcData->CapabilitiesBuffer);
mmcData->CapabilitiesBufferSize = 0;
return STATUS_INSUFFICIENT_RESOURCES;
}
mmcData->CapabilitiesIrp = IoAllocateIrp(Fdo->StackSize + 2, FALSE);
if (mmcData->CapabilitiesIrp == NULL) {
IoFreeMdl(mmcData->CapabilitiesMdl);
ExFreePool(mmcData->CapabilitiesBuffer);
mmcData->CapabilitiesBufferSize = 0;
return STATUS_INSUFFICIENT_RESOURCES;
}
mmcData->CapabilitiesWorkItem = IoAllocateWorkItem(Fdo);
if (mmcData->CapabilitiesWorkItem == NULL) {
IoFreeIrp(mmcData->CapabilitiesIrp);
IoFreeMdl(mmcData->CapabilitiesMdl);
ExFreePool(mmcData->CapabilitiesBuffer);
mmcData->CapabilitiesBufferSize = 0;
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// everything has been allocated, so now prepare it all....
//
MmBuildMdlForNonPagedPool(mmcData->CapabilitiesMdl);
ExInitializeSListHead(&mmcData->DelayedIrps);
KeInitializeSpinLock(&mmcData->DelayedLock);
//
// use the extra stack for internal bookkeeping
//
IoSetNextIrpStackLocation(mmcData->CapabilitiesIrp);
irpStack = IoGetCurrentIrpStackLocation(mmcData->CapabilitiesIrp);
irpStack->Parameters.Others.Argument1 = Fdo;
irpStack->Parameters.Others.Argument2 = mmcData->CapabilitiesBuffer;
irpStack->Parameters.Others.Argument3 = &(mmcData->CapabilitiesSrb);
// arg 4 is the retry count
//
// set the completion event to FALSE for now
//
KeInitializeEvent(&mmcData->CapabilitiesEvent,
SynchronizationEvent, FALSE);
return STATUS_SUCCESS;
}
NTSTATUS
SpWmiInitializeFreeRequestList(
IN PDEVICE_OBJECT DeviceObject,
IN ULONG NumberOfItems
)
/*++
Routine Description:
Call that initializes the WmiFreeMiniPortRequestList, this call MUST
be completed prior to any manipulatio of the WmiFreeMiniPortRequestList
The list will be initialized with at most the number of cells requested.
If the list has already been initialized, we raise the watermark by the number
of Items requested.
Arguments:
DeviceObject - Device Object that this list belongs to
NumberOfItems - requested number of free cells
Return Value:
Return the SUCESS if list was initialized succesfully
STATUS_INSUFFICIENT_REOSOURCES - Indicates that we could not allocate
enough memory for the list header
Notes:
--*/
{
PADAPTER_EXTENSION fdoExtension;
ULONG itemsInserted;
KIRQL oldIrql;
PAGED_CODE(); // Routine is paged until locked down.
//
// Obtain a pointer to the functional device extension (for the adapter).
//
if ( ((PCOMMON_EXTENSION)DeviceObject->DeviceExtension)->IsPdo ) {
fdoExtension = ((PLOGICAL_UNIT_EXTENSION)DeviceObject->DeviceExtension)
->AdapterExtension;
} else {
fdoExtension = DeviceObject->DeviceExtension;
}
// If the list has been initalized increase the watermark
if (fdoExtension->WmiFreeMiniPortRequestInitialized) {
DebugPrint((2, "SpWmiInitializeFreeRequestList:"
" Increased watermark for : %p\n", fdoExtension));
InterlockedExchangeAdd
(&(fdoExtension->WmiFreeMiniPortRequestWatermark),
NumberOfItems);
while (fdoExtension->WmiFreeMiniPortRequestCount <
fdoExtension->WmiFreeMiniPortRequestWatermark) {
// Add free cells until the count reaches the watermark
SpWmiPushFreeRequestItem(fdoExtension);
}
return (STATUS_SUCCESS);
}
// Only PDO's should be calling when the list has not been initialized
ASSERT_FDO(DeviceObject);
// Assignt he list we just initialized to the pointer in the
// fdoExtension (and save the lock pointer also)
KeInitializeSpinLock(&(fdoExtension->WmiFreeMiniPortRequestLock));
ExInitializeSListHead(&(fdoExtension->WmiFreeMiniPortRequestList));
DebugPrint((1, "SpWmiInitializeFreeRequestList:"
" Initialized WmiFreeRequestList for: %p\n", fdoExtension));
// Set the initialized flag
fdoExtension->WmiFreeMiniPortRequestInitialized = TRUE;
// Set the watermark, and the count to 0
fdoExtension->WmiFreeMiniPortRequestWatermark = 0;
fdoExtension->WmiFreeMiniPortRequestCount = 0;
// Attempt to add free cells to the free list
for (itemsInserted = 0; itemsInserted < NumberOfItems;
itemsInserted++) {
// Make a request to push a NULL item, so that the
// allocation will be done by the next function
//
// At this point we don't care about the return value
// because after we set the watermark, scsiport's free-cell
// repopulation code will try to get the free list cell count
// back to the watermark. (So if we fail to add all the requested
// free cells, the repopulation code will attempt again for us
// at a later time)
SpWmiPushFreeRequestItem(fdoExtension);
}
// Now set the watermark to the correct value
fdoExtension->WmiFreeMiniPortRequestWatermark = NumberOfItems;
return(STATUS_SUCCESS);
}