/*
* NAME: DriverEntry
* FUNCTION: Called by the system to initalize the driver
*
* ARGUMENTS:
* DriverObject = object describing this driver
* RegistryPath = path to our configuration entries
* RETURNS: Success or failure
*/
NTSTATUS
DriverEntry (
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
{
PDEVICE_OBJECT DiskdevObject = NULL;
PDEVICE_OBJECT CdromdevObject = NULL;
UNICODE_STRING DeviceName;
UNICODE_STRING DosDeviceName;
PFAST_IO_DISPATCH FastIoDispatch;
PCACHE_MANAGER_CALLBACKS CacheManagerCallbacks;
NTSTATUS Status;
int rc = 0;
BOOLEAN linux_lib_inited = FALSE;
BOOLEAN journal_module_inited = FALSE;
/* Verity super block ... */
ASSERT(sizeof(EXT2_SUPER_BLOCK) == 1024);
ASSERT(FIELD_OFFSET(EXT2_SUPER_BLOCK, s_magic) == 56);
DbgPrint(
"Ext2Fsd --"
#ifdef _WIN2K_TARGET_
" Win2k --"
#endif
" Version "
EXT2FSD_VERSION
#if EXT2_DEBUG
" Checked"
#else
" Free"
#endif
" -- "
__DATE__ " "
__TIME__ ".\n");
DEBUG(DL_FUN, ( "Ext2 DriverEntry ...\n"));
/* initialize winlib structures */
if (ext2_init_linux()) {
Status = STATUS_INSUFFICIENT_RESOURCES;
goto errorout;
}
linux_lib_inited = TRUE;
/* initialize journal module structures */
LOAD_MODULE(journal_init);
if (rc != 0) {
Status = STATUS_INSUFFICIENT_RESOURCES;
goto errorout;
}
journal_module_inited = TRUE;
/* allocate memory for Ext2Global */
Ext2Global = Ext2AllocatePool(NonPagedPool, sizeof(EXT2_GLOBAL), 'LG2E');
if (!Ext2Global) {
Status = STATUS_INSUFFICIENT_RESOURCES;
goto errorout;
}
/* initialize Ext2Global */
RtlZeroMemory(Ext2Global, sizeof(EXT2_GLOBAL));
Ext2Global->Identifier.Type = EXT2FGD;
Ext2Global->Identifier.Size = sizeof(EXT2_GLOBAL);
InitializeListHead(&(Ext2Global->VcbList));
ExInitializeResourceLite(&(Ext2Global->Resource));
/* query registry settings */
Ext2QueryRegistrySettings(RegistryPath);
/* create Ext2Fsd cdrom fs deivce */
RtlInitUnicodeString(&DeviceName, CDROM_NAME);
Status = IoCreateDevice(
DriverObject,
0,
&DeviceName,
FILE_DEVICE_CD_ROM_FILE_SYSTEM,
0,
FALSE,
&CdromdevObject );
if (!NT_SUCCESS(Status)) {
DEBUG(DL_ERR, ( "IoCreateDevice cdrom device object error.\n"));
goto errorout;
}
/* create Ext2Fsd disk fs deivce */
RtlInitUnicodeString(&DeviceName, DEVICE_NAME);
Status = IoCreateDevice(
DriverObject,
0,
&DeviceName,
FILE_DEVICE_DISK_FILE_SYSTEM,
0,
FALSE,
&DiskdevObject );
if (!NT_SUCCESS(Status)) {
DEBUG(DL_ERR, ( "IoCreateDevice disk device object error.\n"));
goto errorout;
}
Status= Ext2StartReaper(
&Ext2Global->FcbReaper,
Ext2FcbReaperThread);
if (!NT_SUCCESS(Status)) {
goto errorout;
}
/* start resource reaper thread */
Status= Ext2StartReaper(
&Ext2Global->McbReaper,
Ext2McbReaperThread);
if (!NT_SUCCESS(Status)) {
Ext2StopReaper(&Ext2Global->FcbReaper);
goto errorout;
}
Status= Ext2StartReaper(
&Ext2Global->bhReaper,
Ext2bhReaperThread);
if (!NT_SUCCESS(Status)) {
Ext2StopReaper(&Ext2Global->FcbReaper);
Ext2StopReaper(&Ext2Global->McbReaper);
goto errorout;
}
/* initializing */
Ext2Global->DiskdevObject = DiskdevObject;
Ext2Global->CdromdevObject = CdromdevObject;
DriverObject->MajorFunction[IRP_MJ_CREATE] = Ext2BuildRequest;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = Ext2BuildRequest;
DriverObject->MajorFunction[IRP_MJ_READ] = Ext2BuildRequest;
DriverObject->MajorFunction[IRP_MJ_WRITE] = Ext2BuildRequest;
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = Ext2BuildRequest;
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = Ext2BuildRequest;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = Ext2BuildRequest;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = Ext2BuildRequest;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = Ext2BuildRequest;
DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] = Ext2BuildRequest;
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = Ext2BuildRequest;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = Ext2BuildRequest;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = Ext2BuildRequest;
DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = Ext2BuildRequest;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = Ext2BuildRequest;
#if (_WIN32_WINNT >= 0x0500)
DriverObject->MajorFunction[IRP_MJ_PNP] = Ext2BuildRequest;
#endif //(_WIN32_WINNT >= 0x0500)
#if EXT2_UNLOAD
DriverObject->DriverUnload = DriverUnload;
#else
DriverObject->DriverUnload = NULL;
#endif
//
// Initialize the fast I/O entry points
//
FastIoDispatch = &(Ext2Global->FastIoDispatch);
FastIoDispatch->SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
FastIoDispatch->FastIoCheckIfPossible = Ext2FastIoCheckIfPossible;
FastIoDispatch->FastIoRead = Ext2FastIoRead;
FastIoDispatch->FastIoWrite = Ext2FastIoWrite;
FastIoDispatch->FastIoQueryBasicInfo = Ext2FastIoQueryBasicInfo;
FastIoDispatch->FastIoQueryStandardInfo = Ext2FastIoQueryStandardInfo;
FastIoDispatch->FastIoLock = Ext2FastIoLock;
FastIoDispatch->FastIoUnlockSingle = Ext2FastIoUnlockSingle;
FastIoDispatch->FastIoUnlockAll = Ext2FastIoUnlockAll;
FastIoDispatch->FastIoUnlockAllByKey = Ext2FastIoUnlockAllByKey;
FastIoDispatch->FastIoQueryNetworkOpenInfo = Ext2FastIoQueryNetworkOpenInfo;
FastIoDispatch->AcquireForModWrite = Ext2AcquireFileForModWrite;
FastIoDispatch->ReleaseForModWrite = Ext2ReleaseFileForModWrite;
FastIoDispatch->AcquireForModWrite = Ext2AcquireFileForModWrite;
FastIoDispatch->ReleaseForModWrite = Ext2ReleaseFileForModWrite;
FastIoDispatch->AcquireForCcFlush = Ext2AcquireFileForCcFlush;
FastIoDispatch->ReleaseForCcFlush = Ext2ReleaseFileForCcFlush;
FastIoDispatch->AcquireFileForNtCreateSection = Ext2AcquireForCreateSection;
FastIoDispatch->ReleaseFileForNtCreateSection = Ext2ReleaseForCreateSection;
DriverObject->FastIoDispatch = FastIoDispatch;
//
// initializing structure sizes for statistics
// 1 means flexible/not fixed for all allocations (for different volumes).
//
Ext2Global->PerfStat.Magic = EXT2_PERF_STAT_MAGIC;
Ext2Global->PerfStat.Version = EXT2_PERF_STAT_VER2;
Ext2Global->PerfStat.Length = sizeof(EXT2_PERF_STATISTICS_V2);
Ext2Global->PerfStat.Unit.Slot[PS_IRP_CONTEXT] = sizeof(EXT2_IRP_CONTEXT); /* 0 */
Ext2Global->PerfStat.Unit.Slot[PS_VCB] = sizeof(EXT2_VCB); /* 1 */
Ext2Global->PerfStat.Unit.Slot[PS_FCB] = sizeof(EXT2_FCB); /* 2 */
Ext2Global->PerfStat.Unit.Slot[PS_CCB] = sizeof(EXT2_CCB); /* 3 */
Ext2Global->PerfStat.Unit.Slot[PS_MCB] = sizeof(EXT2_MCB); /* 4 */
Ext2Global->PerfStat.Unit.Slot[PS_EXTENT] = sizeof(EXT2_EXTENT); /* 5 */
Ext2Global->PerfStat.Unit.Slot[PS_RW_CONTEXT] = sizeof(EXT2_RW_CONTEXT); /* 6 */
Ext2Global->PerfStat.Unit.Slot[PS_VPB] = sizeof(VPB); /* 7 */
Ext2Global->PerfStat.Unit.Slot[PS_FILE_NAME] = 1; /* 8 */
Ext2Global->PerfStat.Unit.Slot[PS_MCB_NAME] = 1; /* 9 */
Ext2Global->PerfStat.Unit.Slot[PS_INODE_NAME] = 1; /* a */
Ext2Global->PerfStat.Unit.Slot[PS_DIR_ENTRY] = sizeof(EXT2_DIR_ENTRY2); /* b */
Ext2Global->PerfStat.Unit.Slot[PS_DIR_PATTERN] = 1; /* c */
Ext2Global->PerfStat.Unit.Slot[PS_DISK_EVENT] = sizeof(KEVENT); /* d */
Ext2Global->PerfStat.Unit.Slot[PS_DISK_BUFFER] = 1; /* e */
Ext2Global->PerfStat.Unit.Slot[PS_BLOCK_DATA] = 1; /* f */
Ext2Global->PerfStat.Unit.Slot[PS_EXT2_INODE] = 1; /* 10 */
Ext2Global->PerfStat.Unit.Slot[PS_DENTRY] = sizeof(struct dentry); /* 11 */
Ext2Global->PerfStat.Unit.Slot[PS_BUFF_HEAD] = sizeof(struct buffer_head); /* 12 */
switch ( MmQuerySystemSize() ) {
case MmSmallSystem:
Ext2Global->MaxDepth = 64;
break;
case MmMediumSystem:
Ext2Global->MaxDepth = 128;
break;
case MmLargeSystem:
Ext2Global->MaxDepth = 256;
break;
}
//
// Initialize the Cache Manager callbacks
//
CacheManagerCallbacks = &(Ext2Global->CacheManagerCallbacks);
CacheManagerCallbacks->AcquireForLazyWrite = Ext2AcquireForLazyWrite;
CacheManagerCallbacks->ReleaseFromLazyWrite = Ext2ReleaseFromLazyWrite;
CacheManagerCallbacks->AcquireForReadAhead = Ext2AcquireForReadAhead;
CacheManagerCallbacks->ReleaseFromReadAhead = Ext2ReleaseFromReadAhead;
Ext2Global->CacheManagerNoOpCallbacks.AcquireForLazyWrite = Ext2NoOpAcquire;
Ext2Global->CacheManagerNoOpCallbacks.ReleaseFromLazyWrite = Ext2NoOpRelease;
Ext2Global->CacheManagerNoOpCallbacks.AcquireForReadAhead = Ext2NoOpAcquire;
Ext2Global->CacheManagerNoOpCallbacks.ReleaseFromReadAhead = Ext2NoOpRelease;
#ifndef _WIN2K_TARGET_
//
// Initialize FS Filter callbacks
//
RtlZeroMemory(&Ext2Global->FilterCallbacks, sizeof(FS_FILTER_CALLBACKS));
Ext2Global->FilterCallbacks.SizeOfFsFilterCallbacks = sizeof(FS_FILTER_CALLBACKS);
Ext2Global->FilterCallbacks.PreAcquireForSectionSynchronization = Ext2PreAcquireForCreateSection;
FsRtlRegisterFileSystemFilterCallbacks(DriverObject, &Ext2Global->FilterCallbacks );
#endif
//
// Initialize the global data
//
ExInitializeNPagedLookasideList( &(Ext2Global->Ext2IrpContextLookasideList),
NULL,
NULL,
0,
sizeof(EXT2_IRP_CONTEXT),
'PRIE',
0 );
ExInitializeNPagedLookasideList( &(Ext2Global->Ext2FcbLookasideList),
NULL,
NULL,
0,
sizeof(EXT2_FCB),
'BCFE',
0 );
ExInitializeNPagedLookasideList( &(Ext2Global->Ext2CcbLookasideList),
NULL,
NULL,
0,
sizeof(EXT2_CCB),
'BCCE',
0 );
ExInitializeNPagedLookasideList( &(Ext2Global->Ext2McbLookasideList),
NULL,
NULL,
0,
sizeof(EXT2_MCB),
'BCME',
0 );
ExInitializeNPagedLookasideList( &(Ext2Global->Ext2ExtLookasideList),
NULL,
NULL,
0,
sizeof(EXT2_EXTENT),
'STXE',
0 );
ExInitializeNPagedLookasideList( &(Ext2Global->Ext2DentryLookasideList),
NULL,
NULL,
0,
sizeof(struct dentry),
'TNED',
0 );
RtlInitUnicodeString(&DosDeviceName, DOS_DEVICE_NAME);
IoCreateSymbolicLink(&DosDeviceName, &DeviceName);
#if EXT2_DEBUG
ProcessNameOffset = Ext2GetProcessNameOffset();
#endif
Ext2LoadAllNls();
Ext2Global->Codepage.PageTable =
load_nls(Ext2Global->Codepage.AnsiName);
/* register file system devices for disk and cdrom */
IoRegisterFileSystem(DiskdevObject);
ObReferenceObject(DiskdevObject);
IoRegisterFileSystem(CdromdevObject);
ObReferenceObject(CdromdevObject);
errorout:
if (!NT_SUCCESS(Status)) {
/*
* stop reaper thread ...
*/
/*
* cleanup resources ...
*/
if (Ext2Global) {
ExDeleteResourceLite(&Ext2Global->Resource);
Ext2FreePool(Ext2Global, 'LG2E');
}
if (CdromdevObject) {
IoDeleteDevice(CdromdevObject);
}
if (DiskdevObject) {
IoDeleteDevice(DiskdevObject);
}
if (journal_module_inited) {
/* cleanup journal related caches */
UNLOAD_MODULE(journal_exit);
}
if (linux_lib_inited) {
/* cleanup linux lib */
ext2_destroy_linux();
}
}
return Status;
}
NTSTATUS NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath)
/*
* FUNCTION: Called by the system to initalize the driver
* ARGUMENTS:
* DriverObject = object describing this driver
* RegistryPath = path to our configuration entries
* RETURNS: Success or failure
*/
{
NTSTATUS Status;
UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(DEVICE_NAME);
TRACE_(NTFS, "DriverEntry(%p, '%wZ')\n", DriverObject, RegistryPath);
/* Initialize global data */
NtfsGlobalData = ExAllocatePoolWithTag(NonPagedPool, sizeof(NTFS_GLOBAL_DATA), 'GRDN');
if (!NtfsGlobalData)
{
Status = STATUS_INSUFFICIENT_RESOURCES;
goto ErrorEnd;
}
RtlZeroMemory(NtfsGlobalData, sizeof(NTFS_GLOBAL_DATA));
NtfsGlobalData->Identifier.Type = NTFS_TYPE_GLOBAL_DATA;
NtfsGlobalData->Identifier.Size = sizeof(NTFS_GLOBAL_DATA);
ExInitializeResourceLite(&NtfsGlobalData->Resource);
/* Keep trace of Driver Object */
NtfsGlobalData->DriverObject = DriverObject;
/* Initialize IRP functions array */
NtfsInitializeFunctionPointers(DriverObject);
/* Initialize CC functions array */
NtfsGlobalData->CacheMgrCallbacks.AcquireForLazyWrite = NtfsAcqLazyWrite;
NtfsGlobalData->CacheMgrCallbacks.ReleaseFromLazyWrite = NtfsRelLazyWrite;
NtfsGlobalData->CacheMgrCallbacks.AcquireForReadAhead = NtfsAcqReadAhead;
NtfsGlobalData->CacheMgrCallbacks.ReleaseFromReadAhead = NtfsRelReadAhead;
/* Driver can't be unloaded */
DriverObject->DriverUnload = NULL;
Status = IoCreateDevice(DriverObject,
sizeof(NTFS_GLOBAL_DATA),
&DeviceName,
FILE_DEVICE_DISK_FILE_SYSTEM,
0,
FALSE,
&NtfsGlobalData->DeviceObject);
if (!NT_SUCCESS(Status))
{
WARN_(NTFS, "IoCreateDevice failed with status: %lx\n", Status);
goto ErrorEnd;
}
NtfsGlobalData->DeviceObject->Flags |= DO_DIRECT_IO;
/* Register file system */
IoRegisterFileSystem(NtfsGlobalData->DeviceObject);
ObReferenceObject(NtfsGlobalData->DeviceObject);
ErrorEnd:
if (!NT_SUCCESS(Status))
{
if (NtfsGlobalData)
{
ExDeleteResourceLite(&NtfsGlobalData->Resource);
ExFreePoolWithTag(NtfsGlobalData, 'GRDN');
}
}
return Status;
}
NTSTATUS NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath)
/*
* FUNCTION: Called by the system to initialize the driver
* ARGUMENTS:
* DriverObject = object describing this driver
* RegistryPath = path to our configuration entries
* RETURNS: Success or failure
*/
{
PDEVICE_OBJECT DeviceObject;
NTSTATUS Status;
UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Cdfs");
UNREFERENCED_PARAMETER(RegistryPath);
DPRINT("CDFS 0.0.3\n");
Status = IoCreateDevice(DriverObject,
sizeof(CDFS_GLOBAL_DATA),
&DeviceName,
FILE_DEVICE_CD_ROM_FILE_SYSTEM,
0,
FALSE,
&DeviceObject);
if (!NT_SUCCESS(Status))
{
return(Status);
}
/* Initialize global data */
CdfsGlobalData = DeviceObject->DeviceExtension;
RtlZeroMemory(CdfsGlobalData,
sizeof(CDFS_GLOBAL_DATA));
CdfsGlobalData->DriverObject = DriverObject;
CdfsGlobalData->DeviceObject = DeviceObject;
/* Initialize driver data */
DeviceObject->Flags = DO_DIRECT_IO;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = CdfsClose;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = CdfsCleanup;
DriverObject->MajorFunction[IRP_MJ_CREATE] = CdfsCreate;
DriverObject->MajorFunction[IRP_MJ_READ] = CdfsRead;
DriverObject->MajorFunction[IRP_MJ_WRITE] = CdfsWrite;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] =
CdfsFileSystemControl;
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] =
CdfsDirectoryControl;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] =
CdfsQueryInformation;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] =
CdfsSetInformation;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] =
CdfsQueryVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] =
CdfsSetVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] =
CdfsDeviceControl;
DriverObject->DriverUnload = NULL;
/* Cache manager */
CdfsGlobalData->CacheMgrCallbacks.AcquireForLazyWrite = CdfsAcquireForLazyWrite;
CdfsGlobalData->CacheMgrCallbacks.ReleaseFromLazyWrite = CdfsReleaseFromLazyWrite;
CdfsGlobalData->CacheMgrCallbacks.AcquireForReadAhead = CdfsAcquireForLazyWrite;
CdfsGlobalData->CacheMgrCallbacks.ReleaseFromReadAhead = CdfsReleaseFromLazyWrite;
DeviceObject->Flags |= DO_LOW_PRIORITY_FILESYSTEM;
IoRegisterFileSystem(DeviceObject);
DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
return(STATUS_SUCCESS);
}
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
AFSInitRDRDevice()
{
NTSTATUS ntStatus = STATUS_SUCCESS;
UNICODE_STRING uniDeviceName;
ULONG ulIndex = 0;
AFSDeviceExt *pDeviceExt = NULL;
AFSFileID stRootFid;
UNICODE_STRING uniFsRtlRegisterUncProviderEx;
FsRtlRegisterUncProviderEx_t pFsRtlRegisterUncProviderEx = NULL;
__Enter
{
RtlInitUnicodeString( &uniDeviceName,
AFS_RDR_DEVICE_NAME);
RtlInitUnicodeString( &uniFsRtlRegisterUncProviderEx,
L"FsRtlRegisterUncProviderEx");
pFsRtlRegisterUncProviderEx = (FsRtlRegisterUncProviderEx_t)MmGetSystemRoutineAddress(&uniFsRtlRegisterUncProviderEx);
ntStatus = IoCreateDevice( AFSDriverObject,
sizeof( AFSDeviceExt),
pFsRtlRegisterUncProviderEx ? NULL : &uniDeviceName,
FILE_DEVICE_NETWORK_FILE_SYSTEM,
FILE_REMOTE_DEVICE,
FALSE,
&AFSRDRDeviceObject);
if( !NT_SUCCESS( ntStatus))
{
AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSInitRDRDevice IoCreateDevice failure %08lX\n",
ntStatus);
try_return( ntStatus);
}
pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
RtlZeroMemory( pDeviceExt,
sizeof( AFSDeviceExt));
//
// Initialize resources
//
pDeviceExt->Specific.RDR.VolumeTree.TreeLock = &pDeviceExt->Specific.RDR.VolumeTreeLock;
ExInitializeResourceLite( pDeviceExt->Specific.RDR.VolumeTree.TreeLock);
pDeviceExt->Specific.RDR.VolumeTree.TreeHead = NULL;
ExInitializeResourceLite( &pDeviceExt->Specific.RDR.VolumeListLock);
pDeviceExt->Specific.RDR.VolumeListHead = NULL;
pDeviceExt->Specific.RDR.VolumeListTail = NULL;
KeInitializeEvent( &pDeviceExt->Specific.RDR.QueuedReleaseExtentEvent,
NotificationEvent,
TRUE);
ExInitializeResourceLite( &pDeviceExt->Specific.RDR.RootCellTreeLock);
pDeviceExt->Specific.RDR.RootCellTree.TreeLock = &pDeviceExt->Specific.RDR.RootCellTreeLock;
pDeviceExt->Specific.RDR.RootCellTree.TreeHead = NULL;
ExInitializeResourceLite( &pDeviceExt->Specific.RDR.ProviderListLock);
//
// Clear the initializing bit
//
AFSRDRDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
//
// Register this device with MUP with FilterMgr if Vista or above
//
if( pFsRtlRegisterUncProviderEx)
{
ntStatus = pFsRtlRegisterUncProviderEx( &AFSMUPHandle,
&uniDeviceName,
AFSRDRDeviceObject,
0);
if ( !NT_SUCCESS( ntStatus))
{
AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSInitRDRDevice FsRtlRegisterUncProvider failure %08lX\n",
ntStatus);
}
}
else
{
ntStatus = FsRtlRegisterUncProvider( &AFSMUPHandle,
&uniDeviceName,
FALSE);
if ( NT_SUCCESS( ntStatus))
{
IoRegisterFileSystem( AFSRDRDeviceObject);
}
else
{
AFSDbgLogMsg( AFS_SUBSYSTEM_INIT_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSInitRDRDevice FsRtlRegisterUncProvider failure %08lX\n",
ntStatus);
}
}
if( !NT_SUCCESS( ntStatus))
{
//
// Delete our device and bail
//
ExDeleteResourceLite( pDeviceExt->Specific.RDR.VolumeTree.TreeLock);
ExDeleteResourceLite( &pDeviceExt->Specific.RDR.VolumeListLock);
ExDeleteResourceLite( &pDeviceExt->Specific.RDR.RootCellTreeLock);
ExDeleteResourceLite( &pDeviceExt->Specific.RDR.ProviderListLock);
IoDeleteDevice( AFSRDRDeviceObject);
AFSRDRDeviceObject = NULL;
try_return( ntStatus);
}
//
// Good to go, all registered and ready to start receiving requests
//
try_exit:
if( !NT_SUCCESS( ntStatus))
{
}
}
return ntStatus;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This is the initialization routine for the Ntfs 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 DeviceObject;
UNICODE_STRING KeyName;
UNICODE_STRING ValueName;
ULONG Value;
UNREFERENCED_PARAMETER( RegistryPath );
PAGED_CODE();
//
// Compute the last access increment. We convert the number of
// minutes to number of 1/100 of nanoseconds. We have to be careful
// not to overrun 32 bits for any multiplier.
//
// To reach 1/100 of nanoseconds per minute we take
//
// 1/100 nanoseconds * 10 = 1 microsecond
// * 1000 = 1 millesecond
// * 1000 = 1 second
// * 60 = 1 minute
//
// Then multiply this by the last access increment in minutes.
//
NtfsLastAccess = Int32x32To64( ( 10 * 1000 * 1000 * 60 ), LAST_ACCESS_INCREMENT_MINUTES );
//
// Create the device object.
//
RtlInitUnicodeString( &UnicodeString, L"\\Ntfs" );
Status = IoCreateDevice( DriverObject,
0,
&UnicodeString,
FILE_DEVICE_DISK_FILE_SYSTEM,
0,
FALSE,
&DeviceObject );
if (!NT_SUCCESS( Status )) {
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.
//
DriverObject->MajorFunction[IRP_MJ_CREATE] = (PDRIVER_DISPATCH)NtfsFsdCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = (PDRIVER_DISPATCH)NtfsFsdClose;
DriverObject->MajorFunction[IRP_MJ_READ] = (PDRIVER_DISPATCH)NtfsFsdRead;
DriverObject->MajorFunction[IRP_MJ_WRITE] = (PDRIVER_DISPATCH)NtfsFsdWrite;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = (PDRIVER_DISPATCH)NtfsFsdQueryInformation;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = (PDRIVER_DISPATCH)NtfsFsdSetInformation;
DriverObject->MajorFunction[IRP_MJ_QUERY_EA] = (PDRIVER_DISPATCH)NtfsFsdQueryEa;
DriverObject->MajorFunction[IRP_MJ_SET_EA] = (PDRIVER_DISPATCH)NtfsFsdSetEa;
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = (PDRIVER_DISPATCH)NtfsFsdFlushBuffers;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = (PDRIVER_DISPATCH)NtfsFsdQueryVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] = (PDRIVER_DISPATCH)NtfsFsdSetVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = (PDRIVER_DISPATCH)NtfsFsdDirectoryControl;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = (PDRIVER_DISPATCH)NtfsFsdFileSystemControl;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = (PDRIVER_DISPATCH)NtfsFsdDeviceControl;
DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = (PDRIVER_DISPATCH)NtfsFsdLockControl;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = (PDRIVER_DISPATCH)NtfsFsdCleanup;
DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY] = (PDRIVER_DISPATCH)NtfsFsdQuerySecurityInfo;
DriverObject->MajorFunction[IRP_MJ_SET_SECURITY] = (PDRIVER_DISPATCH)NtfsFsdSetSecurityInfo;
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = (PDRIVER_DISPATCH)NtfsFsdShutdown;
DriverObject->FastIoDispatch = &NtfsFastIoDispatch;
NtfsFastIoDispatch.SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
NtfsFastIoDispatch.FastIoCheckIfPossible = NtfsFastIoCheckIfPossible; // CheckForFastIo
NtfsFastIoDispatch.FastIoRead = NtfsCopyReadA; // Read
NtfsFastIoDispatch.FastIoWrite = NtfsCopyWriteA; // Write
NtfsFastIoDispatch.FastIoQueryBasicInfo = NtfsFastQueryBasicInfo; // QueryBasicInfo
NtfsFastIoDispatch.FastIoQueryStandardInfo = NtfsFastQueryStdInfo; // QueryStandardInfo
NtfsFastIoDispatch.FastIoLock = NtfsFastLock; // Lock
NtfsFastIoDispatch.FastIoUnlockSingle = NtfsFastUnlockSingle; // UnlockSingle
NtfsFastIoDispatch.FastIoUnlockAll = NtfsFastUnlockAll; // UnlockAll
NtfsFastIoDispatch.FastIoUnlockAllByKey = NtfsFastUnlockAllByKey; // UnlockAllByKey
NtfsFastIoDispatch.FastIoDeviceControl = NULL; // IoDeviceControl
NtfsFastIoDispatch.FastIoDetachDevice = NULL;
NtfsFastIoDispatch.FastIoQueryNetworkOpenInfo = NtfsFastQueryNetworkOpenInfo;
NtfsFastIoDispatch.AcquireFileForNtCreateSection = NtfsAcquireForCreateSection;
NtfsFastIoDispatch.ReleaseFileForNtCreateSection = NtfsReleaseForCreateSection;
NtfsFastIoDispatch.AcquireForModWrite = NtfsAcquireFileForModWrite;
NtfsFastIoDispatch.MdlRead = NtfsMdlReadA;
NtfsFastIoDispatch.MdlReadComplete = FsRtlMdlReadCompleteDev;
NtfsFastIoDispatch.PrepareMdlWrite = NtfsPrepareMdlWriteA;
NtfsFastIoDispatch.MdlWriteComplete = FsRtlMdlWriteCompleteDev;
#ifdef _CAIRO_
NtfsFastIoDispatch.FastIoReadCompressed = NtfsCopyReadC;
NtfsFastIoDispatch.FastIoWriteCompressed = NtfsCopyWriteC;
NtfsFastIoDispatch.MdlReadCompleteCompressed = NtfsMdlReadCompleteCompressed;
NtfsFastIoDispatch.MdlWriteCompleteCompressed = NtfsMdlWriteCompleteCompressed;
#endif _CAIRO_
NtfsFastIoDispatch.FastIoQueryOpen = NtfsNetworkOpenCreate;
NtfsFastIoDispatch.AcquireForCcFlush = NtfsAcquireFileForCcFlush;
NtfsFastIoDispatch.ReleaseForCcFlush = NtfsReleaseFileForCcFlush;
//
// Initialize the global ntfs data structure
//
NtfsInitializeNtfsData( DriverObject );
ExInitializeFastMutex( &StreamFileCreationFastMutex );
//
// Initialize the Ntfs Mcb global data queue and variables
//
ExInitializeFastMutex( &NtfsMcbFastMutex );
InitializeListHead( &NtfsMcbLruQueue );
NtfsMcbCleanupInProgress = FALSE;
switch ( MmQuerySystemSize() ) {
case MmSmallSystem:
NtfsMcbHighWaterMark = 1000;
NtfsMcbLowWaterMark = 500;
NtfsMcbCurrentLevel = 0;
break;
case MmMediumSystem:
NtfsMcbHighWaterMark = 1000;
NtfsMcbLowWaterMark = 500;
NtfsMcbCurrentLevel = 0;
break;
case MmLargeSystem:
default:
NtfsMcbHighWaterMark = 1000;
NtfsMcbLowWaterMark = 500;
NtfsMcbCurrentLevel = 0;
break;
}
//
// Allocate and initialize the free Eresource array
//
if ((NtfsData.FreeEresourceArray =
ExAllocatePoolWithTag(NonPagedPool, (NtfsData.FreeEresourceTotal * sizeof(PERESOURCE)), 'rftN')) == NULL) {
KeBugCheck( NTFS_FILE_SYSTEM );
}
RtlZeroMemory( NtfsData.FreeEresourceArray, NtfsData.FreeEresourceTotal * sizeof(PERESOURCE) );
//
//
// Register the file system with the I/O system
//
IoRegisterFileSystem(DeviceObject);
//
// Initialize logging.
//
NtfsInitializeLogging();
//
// Initialize global variables. (ntfsdata.c assumes 2-digit value for
// $FILE_NAME)
//
ASSERT(($FILE_NAME >= 0x10) && ($FILE_NAME < 0x100));
RtlInitUnicodeString( &NtfsFileNameIndex, NtfsFileNameIndexName );
//
// Support extended character in shortname
//
//
// Read the registry to determine if we are to create short names.
//
KeyName.Buffer = COMPATIBILITY_MODE_KEY_NAME;
KeyName.Length = sizeof( COMPATIBILITY_MODE_KEY_NAME ) - sizeof( WCHAR );
KeyName.MaximumLength = sizeof( COMPATIBILITY_MODE_KEY_NAME );
ValueName.Buffer = COMPATIBILITY_MODE_VALUE_NAME;
ValueName.Length = sizeof( COMPATIBILITY_MODE_VALUE_NAME ) - sizeof( WCHAR );
ValueName.MaximumLength = sizeof( COMPATIBILITY_MODE_VALUE_NAME );
Status = NtfsGet8dot3NameStatus( &KeyName, &ValueName, &Value );
//
// If we didn't find the value or the value is zero then create the 8.3
// names.
//
if (!NT_SUCCESS( Status ) || Value == 0) {
SetFlag( NtfsData.Flags, NTFS_FLAGS_CREATE_8DOT3_NAMES );
}
//
// Read the registry to determine if we allow extended character in short name.
//
ValueName.Buffer = EXTENDED_CHAR_MODE_VALUE_NAME;
ValueName.Length = sizeof( EXTENDED_CHAR_MODE_VALUE_NAME ) - sizeof( WCHAR );
ValueName.MaximumLength = sizeof( EXTENDED_CHAR_MODE_VALUE_NAME );
Status = NtfsGet8dot3NameStatus( &KeyName, &ValueName, &Value );
//
// If we didn't find the value or the value is zero then does not allow
// extended character in 8.3 names.
//
if (NT_SUCCESS( Status ) && Value == 1) {
SetFlag( NtfsData.Flags, NTFS_FLAGS_ALLOW_EXTENDED_CHAR );
}
//
// Read the registry to determine if we should disable last access updates.
//
ValueName.Buffer = DISABLE_LAST_ACCESS_VALUE_NAME;
ValueName.Length = sizeof( DISABLE_LAST_ACCESS_VALUE_NAME ) - sizeof( WCHAR );
ValueName.MaximumLength = sizeof( DISABLE_LAST_ACCESS_VALUE_NAME );
Status = NtfsGet8dot3NameStatus( &KeyName, &ValueName, &Value );
//
// If we didn't find the value or the value is zero then does not allow
// extended character in 8.3 names.
//
if (NT_SUCCESS( Status ) && Value == 1) {
SetFlag( NtfsData.Flags, NTFS_FLAGS_DISABLE_LAST_ACCESS );
}
//
// Setup the CheckPointAllVolumes callback item, timer, dpc, and
// status.
//
ExInitializeWorkItem( &NtfsData.VolumeCheckpointItem,
NtfsCheckpointAllVolumes,
(PVOID)NULL );
KeInitializeTimer( &NtfsData.VolumeCheckpointTimer );
KeInitializeDpc( &NtfsData.VolumeCheckpointDpc,
NtfsVolumeCheckpointDpc,
NULL );
NtfsData.TimerStatus = TIMER_NOT_SET;
//
// Allocate first reserved buffer for USA writes
//
NtfsReserved1 = NtfsAllocatePool( NonPagedPool, LARGE_BUFFER_SIZE );
NtfsReserved2 = NtfsAllocatePool( NonPagedPool, LARGE_BUFFER_SIZE );
NtfsReserved3 = NtfsAllocatePool( NonPagedPool, LARGE_BUFFER_SIZE );
ExInitializeFastMutex( &NtfsReservedBufferMutex );
ExInitializeResource( &NtfsReservedBufferResource );
//
// Zero out the global upcase table, that way we'll fill it in on
// our first successful mount
//
NtfsData.UpcaseTable = NULL;
NtfsData.UpcaseTableSize = 0;
#ifdef _CAIRO_
ExInitializeFastMutex( &NtfsScavengerLock );
NtfsScavengerWorkList = NULL;
NtfsScavengerRunning = FALSE;
//
// Request the load add-on routine be called after all the drivers have
// initialized.
//
IoRegisterDriverReinitialization( DriverObject, NtfsLoadAddOns, NULL);
#endif
//
// And return to our caller
//
return( STATUS_SUCCESS );
}
NTSTATUS
NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath)
{
PDEVICE_OBJECT DeviceObject;
UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Fat");
NTSTATUS Status;
/* Create a device object */
Status = IoCreateDevice(DriverObject,
0,
&DeviceName,
FILE_DEVICE_DISK_FILE_SYSTEM,
0,
FALSE,
&DeviceObject);
if (!NT_SUCCESS(Status)) return Status;
/* Zero global storage */
RtlZeroMemory(&FatGlobalData, sizeof(FAT_GLOBAL_DATA));
FatGlobalData.DriverObject = DriverObject;
FatGlobalData.DiskDeviceObject = DeviceObject;
FatGlobalData.SystemProcess = PsGetCurrentProcess();
/* Fill major function handlers */
DriverObject->MajorFunction[IRP_MJ_CLOSE] = FatClose;
DriverObject->MajorFunction[IRP_MJ_CREATE] = FatCreate;
DriverObject->MajorFunction[IRP_MJ_READ] = FatRead;
DriverObject->MajorFunction[IRP_MJ_WRITE] = FatWrite;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = FatFileSystemControl;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = FatQueryInformation;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = FatSetInformation;
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = FatDirectoryControl;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = FatQueryVolumeInfo;
DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] = FatSetVolumeInfo;
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = FatShutdown;
DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = FatLockControl;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = FatDeviceControl;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = FatCleanup;
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = FatFlushBuffers;
//DriverObject->MajorFunction[IRP_MJ_QUERY_EA]
//DriverObject->MajorFunction[IRP_MJ_SET_EA]
//DriverObject->MajorFunction[IRP_MJ_PNP]
DriverObject->DriverUnload = NULL;
/* Initialize cache manager callbacks */
FatGlobalData.CacheMgrCallbacks.AcquireForLazyWrite = FatAcquireForLazyWrite;
FatGlobalData.CacheMgrCallbacks.ReleaseFromLazyWrite = FatReleaseFromLazyWrite;
FatGlobalData.CacheMgrCallbacks.AcquireForReadAhead = FatAcquireForReadAhead;
FatGlobalData.CacheMgrCallbacks.ReleaseFromReadAhead = FatReleaseFromReadAhead;
FatGlobalData.CacheMgrNoopCallbacks.AcquireForLazyWrite = FatNoopAcquire;
FatGlobalData.CacheMgrNoopCallbacks.ReleaseFromLazyWrite = FatNoopRelease;
FatGlobalData.CacheMgrNoopCallbacks.AcquireForReadAhead = FatNoopAcquire;
FatGlobalData.CacheMgrNoopCallbacks.ReleaseFromReadAhead = FatNoopRelease;
/* Initialize Fast I/O dispatchers */
FatInitFastIoRoutines(&FatGlobalData.FastIoDispatch);
DriverObject->FastIoDispatch = &FatGlobalData.FastIoDispatch;
/* Initialize lookaside lists */
ExInitializeNPagedLookasideList(&FatGlobalData.NonPagedFcbList,
NULL,
NULL,
0,
sizeof(FCB),
TAG_FCB,
0);
ExInitializeNPagedLookasideList(&FatGlobalData.ResourceList,
NULL,
NULL,
0,
sizeof(ERESOURCE),
TAG_CCB,
0);
ExInitializeNPagedLookasideList(&FatGlobalData.IrpContextList,
NULL,
NULL,
0,
sizeof(FAT_IRP_CONTEXT),
TAG_IRP,
0);
/* Initialize synchronization resource for the global data */
ExInitializeResourceLite(&FatGlobalData.Resource);
/* Initialize queued close stuff */
InitializeListHead(&FatGlobalData.AsyncCloseList);
InitializeListHead(&FatGlobalData.DelayedCloseList);
FatGlobalData.FatCloseItem = IoAllocateWorkItem(DeviceObject);
ExInitializeFastMutex(&FatCloseQueueMutex);
/* Initialize global VCB list */
InitializeListHead(&FatGlobalData.VcbListHead);
/* Register and reference our filesystem */
IoRegisterFileSystem(DeviceObject);
ObReferenceObject(DeviceObject);
return STATUS_SUCCESS;
}
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 );
}
NTSTATUS
AFSInitRDRDevice()
{
NTSTATUS ntStatus = STATUS_SUCCESS;
UNICODE_STRING uniDeviceName;
AFSDeviceExt *pDeviceExt = NULL;
UNICODE_STRING uniFsRtlRegisterUncProviderEx;
FsRtlRegisterUncProviderEx_t pFsRtlRegisterUncProviderEx = NULL;
RTL_OSVERSIONINFOW sysVersion;
ULONG ulDeviceCharacteristics = FILE_REMOTE_DEVICE;
__Enter
{
RtlZeroMemory( &sysVersion,
sizeof( RTL_OSVERSIONINFOW));
sysVersion.dwOSVersionInfoSize = sizeof( RTL_OSVERSIONINFOW);
RtlGetVersion( &sysVersion);
RtlInitUnicodeString( &uniDeviceName,
AFS_RDR_DEVICE_NAME);
RtlInitUnicodeString( &uniFsRtlRegisterUncProviderEx,
L"FsRtlRegisterUncProviderEx");
pFsRtlRegisterUncProviderEx = (FsRtlRegisterUncProviderEx_t)MmGetSystemRoutineAddress(&uniFsRtlRegisterUncProviderEx);
//
// On 32-bit Windows XP, do not set FILE_DEVICE_SECURE_OPEN
// flag as it interferes with initial access to \\afs from
// limited user accounts.
//
if(!(sysVersion.dwMajorVersion == 5 &&
sysVersion.dwMinorVersion == 1))
{
ulDeviceCharacteristics |= FILE_DEVICE_SECURE_OPEN;
}
ntStatus = IoCreateDevice( AFSDriverObject,
sizeof( AFSDeviceExt),
pFsRtlRegisterUncProviderEx ? NULL : &uniDeviceName,
FILE_DEVICE_NETWORK_FILE_SYSTEM,
ulDeviceCharacteristics,
FALSE,
&AFSRDRDeviceObject);
if( !NT_SUCCESS( ntStatus))
{
AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSInitRDRDevice IoCreateDevice failure %08lX\n",
ntStatus));
try_return( ntStatus);
}
pDeviceExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
RtlZeroMemory( pDeviceExt,
sizeof( AFSDeviceExt));
//
// Initialize resources
//
pDeviceExt->Specific.RDR.VolumeTree.TreeLock = &pDeviceExt->Specific.RDR.VolumeTreeLock;
ExInitializeResourceLite( pDeviceExt->Specific.RDR.VolumeTree.TreeLock);
pDeviceExt->Specific.RDR.VolumeTree.TreeHead = NULL;
ExInitializeResourceLite( &pDeviceExt->Specific.RDR.VolumeListLock);
pDeviceExt->Specific.RDR.VolumeListHead = NULL;
pDeviceExt->Specific.RDR.VolumeListTail = NULL;
KeInitializeEvent( &pDeviceExt->Specific.RDR.QueuedReleaseExtentEvent,
NotificationEvent,
TRUE);
ExInitializeResourceLite( &pDeviceExt->Specific.RDR.RootCellTreeLock);
pDeviceExt->Specific.RDR.RootCellTree.TreeLock = &pDeviceExt->Specific.RDR.RootCellTreeLock;
pDeviceExt->Specific.RDR.RootCellTree.TreeHead = NULL;
ExInitializeResourceLite( &pDeviceExt->Specific.RDR.ProviderListLock);
ntStatus = AFSInitRdrFcb( &pDeviceExt->Fcb);
if ( !NT_SUCCESS(ntStatus))
{
AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSInitRDRDevice AFSInitRdrFcb failure %08lX\n",
ntStatus));
try_return( ntStatus);
}
//
// Clear the initializing bit
//
AFSRDRDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
//
// Increase the StackSize to support the extra stack frame required
// for use of IoCompletion routines.
//
AFSRDRDeviceObject->StackSize++;
//
// Register this device with MUP with FilterMgr if Vista or above
//
if( pFsRtlRegisterUncProviderEx)
{
ntStatus = pFsRtlRegisterUncProviderEx( &AFSMUPHandle,
&uniDeviceName,
AFSRDRDeviceObject,
0);
if ( !NT_SUCCESS( ntStatus))
{
AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSInitRDRDevice FsRtlRegisterUncProvider failure %08lX\n",
ntStatus));
}
}
else
{
ntStatus = FsRtlRegisterUncProvider( &AFSMUPHandle,
&uniDeviceName,
FALSE);
if ( NT_SUCCESS( ntStatus))
{
IoRegisterFileSystem( AFSRDRDeviceObject);
}
else
{
AFSDbgTrace(( AFS_SUBSYSTEM_INIT_PROCESSING,
AFS_TRACE_LEVEL_ERROR,
"AFSInitRDRDevice FsRtlRegisterUncProvider failure %08lX\n",
ntStatus));
}
}
//
// Good to go, all registered and ready to start receiving requests
//
try_exit:
if( !NT_SUCCESS( ntStatus))
{
//
// Delete our device and bail
//
ExDeleteResourceLite( pDeviceExt->Specific.RDR.VolumeTree.TreeLock);
ExDeleteResourceLite( &pDeviceExt->Specific.RDR.VolumeListLock);
ExDeleteResourceLite( &pDeviceExt->Specific.RDR.RootCellTreeLock);
ExDeleteResourceLite( &pDeviceExt->Specific.RDR.ProviderListLock);
IoDeleteDevice( AFSRDRDeviceObject);
AFSRDRDeviceObject = NULL;
try_return( ntStatus);
}
}
return ntStatus;
}
NTSTATUS
DriverEntry(
__in PDRIVER_OBJECT DriverObject,
__in PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This is the initialization routine for the Cdrom 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 CdfsFileSystemDeviceObject;
FS_FILTER_CALLBACKS FilterCallbacks;
UNREFERENCED_PARAMETER( RegistryPath );
//
// Create the device object.
//
RtlInitUnicodeString( &UnicodeString, L"\\Cdfs" );
Status = IoCreateDevice( DriverObject,
0,
&UnicodeString,
FILE_DEVICE_CD_ROM_FILE_SYSTEM,
0,
FALSE,
&CdfsFileSystemDeviceObject );
if (!NT_SUCCESS( Status )) {
return Status;
}
#pragma prefast(push)
#pragma prefast(disable: 28155, "the dispatch routine has the correct type, prefast is just being paranoid.")
#pragma prefast(disable: 28168, "the dispatch routine has the correct type, prefast is just being paranoid.")
#pragma prefast(disable: 28169, "the dispatch routine has the correct type, prefast is just being paranoid.")
#pragma prefast(disable: 28175, "we're allowed to change these.")
DriverObject->DriverUnload = CdUnload;
//
// Note that because of the way data caching is done, we set neither
// the Direct I/O or Buffered I/O bit in DeviceObject->Flags. If
// 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_WRITE] =
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] =
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = (PDRIVER_DISPATCH) CdFsdDispatch;
#pragma prefast(pop)
#pragma prefast(suppress: 28175, "this is a file system driver, we're allowed to touch FastIoDispatch.")
DriverObject->FastIoDispatch = &CdFastIoDispatch;
//
// Initialize the filter callbacks we use.
//
RtlZeroMemory( &FilterCallbacks,
sizeof(FS_FILTER_CALLBACKS) );
FilterCallbacks.SizeOfFsFilterCallbacks = sizeof(FS_FILTER_CALLBACKS);
FilterCallbacks.PreAcquireForSectionSynchronization = CdFilterCallbackAcquireForCreateSection;
Status = FsRtlRegisterFileSystemFilterCallbacks( DriverObject,
&FilterCallbacks );
if (!NT_SUCCESS( Status )) {
IoDeleteDevice( CdfsFileSystemDeviceObject );
return Status;
}
//
// Initialize the global data structures
//
Status = CdInitializeGlobalData( DriverObject, CdfsFileSystemDeviceObject );
if (!NT_SUCCESS (Status)) {
IoDeleteDevice (CdfsFileSystemDeviceObject);
return Status;
}
//
// Register the file system as low priority with the I/O system. This will cause
// CDFS to receive mount requests after a) other filesystems currently registered
// and b) other normal priority filesystems that may be registered later.
//
CdfsFileSystemDeviceObject->Flags |= DO_LOW_PRIORITY_FILESYSTEM;
IoRegisterFileSystem( CdfsFileSystemDeviceObject );
ObReferenceObject (CdfsFileSystemDeviceObject);
//
// And return to our caller
//
return( STATUS_SUCCESS );
}
NTSTATUS
DokanCreateGlobalDiskDevice(__in PDRIVER_OBJECT DriverObject,
__out PDOKAN_GLOBAL *DokanGlobal) {
WCHAR deviceNameBuf[] = DOKAN_GLOBAL_DEVICE_NAME;
WCHAR symbolicLinkBuf[] = DOKAN_GLOBAL_SYMBOLIC_LINK_NAME;
WCHAR fsDiskDeviceNameBuf[] = DOKAN_GLOBAL_FS_DISK_DEVICE_NAME;
WCHAR fsCdDeviceNameBuf[] = DOKAN_GLOBAL_FS_CD_DEVICE_NAME;
NTSTATUS status;
UNICODE_STRING deviceName;
UNICODE_STRING symbolicLinkName;
UNICODE_STRING fsDiskDeviceName;
UNICODE_STRING fsCdDeviceName;
PDEVICE_OBJECT deviceObject;
PDEVICE_OBJECT fsDiskDeviceObject;
PDEVICE_OBJECT fsCdDeviceObject;
PDOKAN_GLOBAL dokanGlobal;
RtlInitUnicodeString(&deviceName, deviceNameBuf);
RtlInitUnicodeString(&symbolicLinkName, symbolicLinkBuf);
RtlInitUnicodeString(&fsDiskDeviceName, fsDiskDeviceNameBuf);
RtlInitUnicodeString(&fsCdDeviceName, fsCdDeviceNameBuf);
status = IoCreateDeviceSecure(DriverObject, // DriverObject
sizeof(DOKAN_GLOBAL), // DeviceExtensionSize
&deviceName, // DeviceName
FILE_DEVICE_UNKNOWN, // DeviceType
0, // DeviceCharacteristics
FALSE, // Not Exclusive
&sddl, // Default SDDL String
NULL, // Device Class GUID
&deviceObject); // DeviceObject
if (!NT_SUCCESS(status)) {
DDbgPrint(" IoCreateDevice returned 0x%x\n", status);
return status;
}
DDbgPrint("DokanGlobalDevice: %wZ created\n", &deviceName);
// Create supported file system device types and register them
status = IoCreateDeviceSecure(DriverObject, // DriverObject
0, // DeviceExtensionSize
&fsDiskDeviceName, // DeviceName
FILE_DEVICE_DISK_FILE_SYSTEM, // DeviceType
0, // DeviceCharacteristics
FALSE, // Not Exclusive
&sddl, // Default SDDL String
NULL, // Device Class GUID
&fsDiskDeviceObject); // DeviceObject
if (!NT_SUCCESS(status)) {
DDbgPrint(" IoCreateDevice Disk FileSystem failed: 0x%x\n", status);
IoDeleteDevice(deviceObject);
return status;
}
DDbgPrint("DokanDiskFileSystemDevice: %wZ created\n", &fsDiskDeviceName);
status = IoCreateDeviceSecure(DriverObject, // DriverObject
0, // DeviceExtensionSize
&fsCdDeviceName, // DeviceName
FILE_DEVICE_CD_ROM_FILE_SYSTEM, // DeviceType
0, // DeviceCharacteristics
FALSE, // Not Exclusive
&sddl, // Default SDDL String
NULL, // Device Class GUID
&fsCdDeviceObject); // DeviceObject
if (!NT_SUCCESS(status)) {
DDbgPrint(" IoCreateDevice Cd FileSystem failed: 0x%x\n", status);
IoDeleteDevice(fsDiskDeviceObject);
IoDeleteDevice(deviceObject);
return status;
}
DDbgPrint("DokanCdFileSystemDevice: %wZ created\n", &fsCdDeviceName);
ObReferenceObject(deviceObject);
status = IoCreateSymbolicLink(&symbolicLinkName, &deviceName);
if (!NT_SUCCESS(status)) {
DDbgPrint(" IoCreateSymbolicLink returned 0x%x\n", status);
IoDeleteDevice(deviceObject);
return status;
}
DDbgPrint("SymbolicLink: %wZ -> %wZ created\n", &deviceName,
&symbolicLinkName);
dokanGlobal = deviceObject->DeviceExtension;
dokanGlobal->DeviceObject = deviceObject;
dokanGlobal->FsDiskDeviceObject = fsDiskDeviceObject;
dokanGlobal->FsCdDeviceObject = fsCdDeviceObject;
RtlZeroMemory(dokanGlobal, sizeof(DOKAN_GLOBAL));
DokanInitIrpList(&dokanGlobal->PendingService);
DokanInitIrpList(&dokanGlobal->NotifyService);
InitializeListHead(&dokanGlobal->MountPointList);
dokanGlobal->Identifier.Type = DGL;
dokanGlobal->Identifier.Size = sizeof(DOKAN_GLOBAL);
//
// Establish user-buffer access method.
//
fsDiskDeviceObject->Flags |= DO_DIRECT_IO;
fsDiskDeviceObject->Flags |= DO_LOW_PRIORITY_FILESYSTEM;
fsCdDeviceObject->Flags |= DO_DIRECT_IO;
fsCdDeviceObject->Flags |= DO_LOW_PRIORITY_FILESYSTEM;
fsDiskDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
fsCdDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
// Register file systems
IoRegisterFileSystem(fsDiskDeviceObject);
IoRegisterFileSystem(fsCdDeviceObject);
ObReferenceObject(fsDiskDeviceObject);
ObReferenceObject(fsCdDeviceObject);
*DokanGlobal = dokanGlobal;
return STATUS_SUCCESS;
}
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 );
}
/*
* FUNCTION: Called by the system to initialize the driver
* ARGUMENTS:
* DriverObject = object describing this driver
* RegistryPath = path to our configuration entries
* RETURNS: Success or failure
*/
NTSTATUS
NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
PDEVICE_OBJECT DeviceObject;
UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Fat");
NTSTATUS Status;
UNREFERENCED_PARAMETER(RegistryPath);
Status = IoCreateDevice(DriverObject,
sizeof(VFAT_GLOBAL_DATA),
&DeviceName,
FILE_DEVICE_DISK_FILE_SYSTEM,
0,
FALSE,
&DeviceObject);
if (Status == STATUS_OBJECT_NAME_EXISTS ||
Status == STATUS_OBJECT_NAME_COLLISION)
{
/* Try an other name, if 'Fat' is already in use. 'Fat' is also used by fastfat.sys on W2K */
RtlInitUnicodeString(&DeviceName, L"\\RosFat");
Status = IoCreateDevice(DriverObject,
sizeof(VFAT_GLOBAL_DATA),
&DeviceName,
FILE_DEVICE_DISK_FILE_SYSTEM,
0,
FALSE,
&DeviceObject);
}
if (!NT_SUCCESS(Status))
{
return Status;
}
VfatGlobalData = DeviceObject->DeviceExtension;
RtlZeroMemory (VfatGlobalData, sizeof(VFAT_GLOBAL_DATA));
VfatGlobalData->DriverObject = DriverObject;
VfatGlobalData->DeviceObject = DeviceObject;
DeviceObject->Flags |= DO_DIRECT_IO;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_CREATE] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_READ] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_WRITE] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = VfatShutdown;
DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_PNP] = VfatBuildRequest;
DriverObject->DriverUnload = NULL;
/* Cache manager */
VfatGlobalData->CacheMgrCallbacks.AcquireForLazyWrite = VfatAcquireForLazyWrite;
VfatGlobalData->CacheMgrCallbacks.ReleaseFromLazyWrite = VfatReleaseFromLazyWrite;
VfatGlobalData->CacheMgrCallbacks.AcquireForReadAhead = VfatAcquireForReadAhead;
VfatGlobalData->CacheMgrCallbacks.ReleaseFromReadAhead = VfatReleaseFromReadAhead;
/* Fast I/O */
VfatInitFastIoRoutines(&VfatGlobalData->FastIoDispatch);
DriverObject->FastIoDispatch = &VfatGlobalData->FastIoDispatch;
/* Private lists */
ExInitializeNPagedLookasideList(&VfatGlobalData->FcbLookasideList,
NULL, NULL, 0, sizeof(VFATFCB), TAG_FCB, 0);
ExInitializeNPagedLookasideList(&VfatGlobalData->CcbLookasideList,
NULL, NULL, 0, sizeof(VFATCCB), TAG_CCB, 0);
ExInitializeNPagedLookasideList(&VfatGlobalData->IrpContextLookasideList,
NULL, NULL, 0, sizeof(VFAT_IRP_CONTEXT), TAG_IRP, 0);
ExInitializeResourceLite(&VfatGlobalData->VolumeListLock);
InitializeListHead(&VfatGlobalData->VolumeListHead);
IoRegisterFileSystem(DeviceObject);
return STATUS_SUCCESS;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This is the initialization routine for the Cdrom 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 CdfsFileSystemDeviceObject;
//
// Create the device object.
//
RtlInitUnicodeString( &UnicodeString, L"\\Cdfs" );
Status = IoCreateDevice( DriverObject,
0,
&UnicodeString,
FILE_DEVICE_CD_ROM_FILE_SYSTEM,
0,
FALSE,
&CdfsFileSystemDeviceObject );
if (!NT_SUCCESS( Status )) {
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] = (PDRIVER_DISPATCH) CdFsdDispatch;
DriverObject->FastIoDispatch = &CdFastIoDispatch;
//
// Initialize the global data structures
//
CdInitializeGlobalData( DriverObject, CdfsFileSystemDeviceObject );
//
// Register the file system with the I/O system
//
IoRegisterFileSystem( CdfsFileSystemDeviceObject );
//
// And return to our caller
//
return( STATUS_SUCCESS );
}
NTSTATUS
DfsDriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
) {
NTSTATUS Status;
UNICODE_STRING UnicodeString;
PDEVICE_OBJECT DeviceObject;
OBJECT_ATTRIBUTES ObjectAttributes;
PWSTR p;
int i;
HANDLE hTemp;
HANDLE DirHandle;
IO_STATUS_BLOCK iosb;
//
// See if someone else has already created a File System Device object
// with the name we intend to use. If so, we bail.
//
RtlInitUnicodeString( &UnicodeString, DFS_DRIVER_NAME );
InitializeObjectAttributes(
&ObjectAttributes,
&UnicodeString,
OBJ_CASE_INSENSITIVE,
0,
NULL);
Status = ZwCreateFile(
&hTemp,
SYNCHRONIZE,
&ObjectAttributes,
&iosb,
NULL,
FILE_ATTRIBUTE_NORMAL,
FILE_SHARE_READ | FILE_SHARE_WRITE,
FILE_OPEN,
0,
NULL,
0);
if (NT_SUCCESS(Status)) {
ZwClose( hTemp );
DfsDbgTrace(0, Dbg, "Dfs driver already loaded!\n", 0);
return( STATUS_UNSUCCESSFUL );
}
//
// Create the filesystem device object.
//
Status = IoCreateDevice( DriverObject,
0,
&UnicodeString,
FILE_DEVICE_DFS_FILE_SYSTEM,
FILE_REMOTE_DEVICE,
FALSE,
&DeviceObject );
if ( !NT_SUCCESS( Status ) ) {
return Status;
}
//
// Create a permanent object directory in which the logical root
// device objects will reside. Make the directory temporary, so
// we can just close the handle to make it go away.
//
UnicodeString.Buffer = p = LogicalRootDevPath;
UnicodeString.Length = 0;
UnicodeString.MaximumLength = MAX_LOGICAL_ROOT_LEN;
while (*p++ != UNICODE_NULL)
UnicodeString.Length += sizeof (WCHAR);
InitializeObjectAttributes(
&ObjectAttributes,
&UnicodeString,
OBJ_PERMANENT,
NULL,
NULL );
Status = ZwCreateDirectoryObject(
&DirHandle,
DIRECTORY_ALL_ACCESS,
&ObjectAttributes);
if ( !NT_SUCCESS( Status ) ) {
return Status;
}
ZwMakeTemporaryObject(DirHandle);
p[-1] = UNICODE_PATH_SEP;
UnicodeString.Length += sizeof (WCHAR);
//
// Initialize the driver object with this driver's entry points.
// Most are simply passed through to some other device driver.
//
for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++) {
DriverObject->MajorFunction[i] = DfsVolumePassThrough;
}
DriverObject->MajorFunction[IRP_MJ_CREATE] = (PDRIVER_DISPATCH)DfsFsdCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = (PDRIVER_DISPATCH)DfsFsdClose;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = (PDRIVER_DISPATCH)DfsFsdCleanup;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = (PDRIVER_DISPATCH)DfsFsdQueryInformation;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = (PDRIVER_DISPATCH)DfsFsdSetInformation;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = (PDRIVER_DISPATCH)DfsFsdFileSystemControl;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION]= (PDRIVER_DISPATCH)DfsFsdQueryVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION]= (PDRIVER_DISPATCH)DfsFsdSetVolumeInformation;
DriverObject->FastIoDispatch = &FastIoDispatch;
//
// Initialize the global data structures
//
RtlZeroMemory(&DfsData, sizeof (DFS_DATA));
DfsData.NodeTypeCode = DSFS_NTC_DATA_HEADER;
DfsData.NodeByteSize = sizeof( DFS_DATA );
InitializeListHead( &DfsData.VcbQueue );
InitializeListHead( &DfsData.DeletedVcbQueue );
InitializeListHead( &DfsData.Credentials );
InitializeListHead( &DfsData.DeletedCredentials );
DfsData.DriverObject = DriverObject;
DfsData.FileSysDeviceObject = DeviceObject;
DfsData.LogRootDevName = UnicodeString;
ExInitializeResource( &DfsData.Resource );
KeInitializeEvent( &DfsData.PktWritePending, NotificationEvent, TRUE );
KeInitializeSemaphore( &DfsData.PktReferralRequests, 1, 1 );
DfsData.MachineState = DFS_CLIENT;
//
// Allocate Provider structures.
//
DfsData.pProvider = ExAllocatePool( PagedPool,
sizeof ( PROVIDER_DEF ) * MAX_PROVIDERS);
for (i = 0; i < MAX_PROVIDERS; i++) {
DfsData.pProvider[i].NodeTypeCode = DSFS_NTC_PROVIDER;
DfsData.pProvider[i].NodeByteSize = sizeof ( PROVIDER_DEF );
}
DfsData.cProvider = 0;
DfsData.maxProvider = MAX_PROVIDERS;
//
// Initialize the system wide PKT
//
PktInitialize(&DfsData.Pkt);
{
ULONG SystemSizeMultiplier;
ULONG ZoneSegmentSize;
switch (MmQuerySystemSize()) {
default:
case MmSmallSystem:
SystemSizeMultiplier = 4;
break;
case MmMediumSystem:
SystemSizeMultiplier = 8;
break;
case MmLargeSystem:
SystemSizeMultiplier = 16;
break;
}
//
// Allocate the DFS_FCB hash table structure. The number of hash buckets
// will depend upon the memory size of the system.
//
Status = DfsInitFcbs(SystemSizeMultiplier * 2);
//
// Now initialize the zone structures for allocating IRP context
// records. The size of the zone will depend upon the memory
// available in the system.
//
KeInitializeSpinLock( &DfsData.IrpContextSpinLock );
ZoneSegmentSize = (SystemSizeMultiplier *
QuadAlign(sizeof(IRP_CONTEXT))) +
sizeof(ZONE_SEGMENT_HEADER);
(VOID) ExInitializeZone( &DfsData.IrpContextZone,
QuadAlign(sizeof(IRP_CONTEXT)),
FsRtlAllocatePool( NonPagedPool,
ZoneSegmentSize ),
ZoneSegmentSize );
}
//
// Set up global pointer to the system process.
//
DfsData.OurProcess = PsGetCurrentProcess();
//
// Register the file system with the I/O system
//
IoRegisterFileSystem( DeviceObject );
//
// Initialize the provider definitions from the registry.
//
if (!NT_SUCCESS( ProviderInit() )) {
DfsDbgTrace(0,DEBUG_TRACE_ERROR,
"Could not initialize some or all providers!\n", 0);
}
//
// Initialize the logical roots device objects. These are what form the
// link between the outside world and the Dfs driver.
//
Status = DfsInitializeLogicalRoot( DD_DFS_DEVICE_NAME, NULL, NULL, 0);
if (!NT_SUCCESS(Status)) {
DfsDbgTrace(-1, DEBUG_TRACE_ERROR, "Failed creation of root logical root %08lx\n", Status);
return(Status);
}
//
// Let us start off the Timer Routine.
//
RtlZeroMemory(&DfsTimerContext, sizeof(DFS_TIMER_CONTEXT));
DfsTimerContext.InUse = FALSE;
DfsTimerContext.TickCount = 0;
IoInitializeTimer(DeviceObject, DfsIoTimerRoutine, &DfsTimerContext);
DfsDbgTrace(0, Dbg, "Initialized the Timer routine\n", 0);
//
// Let us start the timer now.
//
IoStartTimer(DeviceObject);
return STATUS_SUCCESS;
}