/*XXX: use NETMAP_BUF_SIZE(ifp->na), for virtual interfaces gives BSOD
* remember to set the same value in filter.c :: FilterAttach() when
* doing ExInitializeNPagedLookasideList()
*/
void win32_init_lookaside_buffers(struct net_device *ifp){
if (!ifp->lookasideListsAlreadyAllocated) {
ifp->lookasideListsAlreadyAllocated = TRUE;
ExInitializeNPagedLookasideList(&ifp->mbuf_pool, NULL, NULL, 0, sizeof(struct mbuf), M_DEVBUF, 0);
ExInitializeNPagedLookasideList(&ifp->mbuf_packets_pool, NULL, NULL, 0, 2048, M_DEVBUF, 0);
}
}
void
sys_init(void)
{
KeInitializeSpinLock(&ThreadListLock);
InitializeListHead(&ThreadListHead);
KeQuerySystemTime(&StartTime);
KeInitializeEvent(&TerminationEvent, NotificationEvent, FALSE);
ExInitializeNPagedLookasideList(&MessageLookasideList,
NULL,
NULL,
0,
sizeof(struct lwip_callback_msg),
LWIP_MESSAGE_TAG,
0);
ExInitializeNPagedLookasideList(&QueueEntryLookasideList,
NULL,
NULL,
0,
sizeof(QUEUE_ENTRY),
LWIP_QUEUE_TAG,
0);
}
NTSTATUS TCPStartup(VOID)
/*
* FUNCTION: Initializes the TCP subsystem
* RETURNS:
* Status of operation
*/
{
NTSTATUS Status;
Status = PortsStartup( &TCPPorts, 1, 0xfffe );
if (!NT_SUCCESS(Status))
{
return Status;
}
ExInitializeNPagedLookasideList(&TdiBucketLookasideList,
NULL,
NULL,
0,
sizeof(TDI_BUCKET),
TDI_BUCKET_TAG,
0);
/* Initialize our IP library */
LibIPInitialize();
/* Register this protocol with IP layer */
IPRegisterProtocol(IPPROTO_TCP, TCPReceive);
TCPInitialized = TRUE;
return STATUS_SUCCESS;
}
VOID SymInit(void)
{
KeEnterCriticalRegion();
if(bIsSymEngineInitialized == TRUE)
{
KeLeaveCriticalRegion();
return;
}
// initialize all required data structures
ExInitializeNPagedLookasideList(&SymbolsLookasideList, // list to initialize
NULL, // allocate function - OS supplied
NULL, // free function - OS supplied
0, // flags - always zero
sizeof(SYMBOL_ENTRY), // size of each entry to be allocated
TAG_SYMBOL_LOOKASIDE, // SymL(ookaside) tag
0 // depth - always zero
);
InitializeListHead(&SymbolsListHead);
ASSERTMSG("Fast mutex must be initialized at or below DISPATCH_LEVEL", KeGetCurrentIrql() <= DISPATCH_LEVEL);
ExInitializeFastMutex(&SymbolsListMutex);
bIsSymEngineInitialized = TRUE;
KeLeaveCriticalRegion();
}
void InitNotificationQueue(NOTIFICATION_QUEUE *queue) {
InitializeListHead(&queue->irp_list);
InitializeListHead(&queue->notification_list);
ExInitializeNPagedLookasideList(&queue->lookaside, NULL, NULL, 0, sizeof(PGLISTNODE), '02GP', 0);
KeInitializeSpinLock(&queue->lock);
queue->queued = 0;
}
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;
}
/* KphProtectInit
*
* Initializes process protection.
*
* IRQL: <= APC_LEVEL
*/
NTSTATUS KphProtectInit()
{
NTSTATUS status;
/* Initialize rundown protection. */
ExInitializeRundownProtection(&ProtectedProcessRundownProtect);
/* Initialize list structures. */
InitializeListHead(&ProtectedProcessListHead);
KeInitializeSpinLock(&ProtectedProcessListLock);
ExInitializeNPagedLookasideList(
&ProtectedProcessLookasideList,
NULL,
NULL,
0,
sizeof(KPH_PROCESS_ENTRY),
TAG_PROTECTION_ENTRY,
0
);
/* Hook various functions. */
/* Hooking the open procedure calls for processes and threads allows
* us to intercept handle creation/duplication/inheritance. */
KphInitializeObOpenHook(&ProcessOpenHook, *PsProcessType, KphNewOpenProcedure51, KphNewOpenProcedure60);
if (!NT_SUCCESS(status = KphObOpenHook(&ProcessOpenHook)))
return status;
KphInitializeObOpenHook(&ThreadOpenHook, *PsThreadType, KphNewOpenProcedure51, KphNewOpenProcedure60);
if (!NT_SUCCESS(status = KphObOpenHook(&ThreadOpenHook)))
return status;
return STATUS_SUCCESS;
}
NTSTATUS DriverEntry(__in PDRIVER_OBJECT DriverObject, __in PUNICODE_STRING RegistryPath)
{
Bus_KdPrint(("Driver Entry\n"));
ExInitializeNPagedLookasideList(&g_LookAside, NULL, NULL, 0, sizeof(PENDING_IRP), BUSENUM_POOL_TAG, 0);
Globals.RegistryPath.MaximumLength = RegistryPath->Length + sizeof(UNICODE_NULL);
Globals.RegistryPath.Length = RegistryPath->Length;
Globals.RegistryPath.Buffer = ExAllocatePoolWithTag(PagedPool, Globals.RegistryPath.MaximumLength, BUSENUM_POOL_TAG);
if (!Globals.RegistryPath.Buffer)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlCopyUnicodeString(&Globals.RegistryPath, RegistryPath);
DriverObject->MajorFunction [IRP_MJ_CREATE ] =
DriverObject->MajorFunction [IRP_MJ_CLOSE ] = Bus_CreateClose;
DriverObject->MajorFunction [IRP_MJ_PNP ] = Bus_PnP;
DriverObject->MajorFunction [IRP_MJ_POWER ] = Bus_Power;
DriverObject->MajorFunction [IRP_MJ_DEVICE_CONTROL ] = Bus_IoCtl;
DriverObject->MajorFunction [IRP_MJ_INTERNAL_DEVICE_CONTROL] = Bus_Internal_IoCtl;
DriverObject->DriverUnload = Bus_DriverUnload;
DriverObject->DriverExtension->AddDevice = Bus_AddDevice;
return STATUS_SUCCESS;
}
kmem_cache_t *
kmem_cache_create (const char *name, size_t size, size_t offset,
unsigned long flags, void (*ctor)(void*, kmem_cache_t *, unsigned long),
void (*dtor)(void*, kmem_cache_t *, unsigned long))
{
kmem_cache_t *cachep = NULL;
ULONG tag = sadyc_tag(name);
if ((!name) || ((strlen(name) >= CACHE_NAMELEN - 1)) ||
(size < BYTES_PER_WORD) ||
(offset > size))
BUG();
printk("kmem_cache: %s: created size=%u tag=%u\n", name, (unsigned)size, tag);
cachep = kmalloc(sizeof(kmem_cache_t), GFP_KERNEL);
memset(cachep, 0, sizeof(kmem_cache_t));
#ifdef USE_NONPAGED_MEMORY
ExInitializeNPagedLookasideList(&cachep->lookaside, NULL, NULL, 0, size, tag, 0);
#else
ExInitializePagedLookasideList(&cachep->lookaside, NULL, NULL, 0, size, tag, 0);
#endif
cachep->objsize = size;
strcpy(cachep->name, name);
cachep->ctor = ctor;
cachep->dtor = dtor;
#if DBG
cachep->objects_allocated = 0;
#endif
return cachep;
}
void printk_init(void)
{
// initialization for logging. the function '_prink' shouldn't be called before this initialization.
ExInitializeNPagedLookasideList(&drbd_printk_msg, NULL, NULL, 0, MAX_ELOG_BUF, '65DW', 0);
#ifdef _WIN32_LOGLINK
LogLink_MakeUsable();
#endif
}
void mm_init()
{
int i;
for (i = 0; i < NUM_MEM_LISTS; i++) {
ExInitializeNPagedLookasideList(&mem_lists[i], NULL, NULL, 0, ALLOC_SIZE(512u << i), '2_cd', 0);
}
}
//----- (08000C5A) --------------------------------------------------------
NTSTATUS
DriverEntry(
PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath
)
{
NTSTATUS status;
UNICODE_STRING DeviceName;
UNICODE_STRING SymbolicLinkName;
g_pDriverObject = DriverObject;
RtlInitUnicodeString(&DeviceName, L"\\Device\\Dmon");
status = IoCreateDevice(DriverObject, 0, &DeviceName, 0x8310, 0, TRUE, &g_pDeviceObject);
if ( NT_SUCCESS(status) )
{
RtlInitUnicodeString(&SymbolicLinkName, L"\\DosDevices\\Dmon");
if ( !NT_SUCCESS(IoCreateSymbolicLink(&SymbolicLinkName, &DeviceName)))
{
DbgPrint("Diskmon.SYS: IoCreateSymbolicLink failed\n");
}
DriverObject->MajorFunction[IRP_MJ_CREATE] = (PDRIVER_DISPATCH)DMCreateClose;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = (PDRIVER_DISPATCH)DMCreateClose;
DriverObject->MajorFunction[IRP_MJ_READ] = (PDRIVER_DISPATCH)DMReadWrite;
DriverObject->MajorFunction[IRP_MJ_WRITE] = (PDRIVER_DISPATCH)DMReadWrite;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = (PDRIVER_DISPATCH)DMDeviceControl;
DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = (PDRIVER_DISPATCH)DMDeviceControl;
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = (PDRIVER_DISPATCH)DMShutDownFlushBuffer;
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = (PDRIVER_DISPATCH)DMShutDownFlushBuffer;
KeInitializeSpinLock(&LogBufferLock);
KeInitializeSpinLock(&HashLock);
LogBuffer = ExAllocatePool(NonPagedPool, sizeof(*LogBuffer));
if ( LogBuffer )
{
LogBuffer->Len = 0;
LogBuffer->Next = NULL;
NumLogBuffer = 1;
ExInitializeNPagedLookasideList(&ContextLookaside, NULL, NULL, 0, sizeof( MYCONTEXT ), 'nmkD', 0);
HookDispatch(DriverObject, 0);
status = STATUS_SUCCESS;
}
else
{
IoDeleteDevice(g_pDeviceObject);
status = STATUS_INSUFFICIENT_RESOURCES;
}
}
return status;
}
VOID
InitPacketLookaside()
{
ExInitializeNPagedLookasideList(
&g_PktLookaside,
NULL, NULL, 0,
sizeof(FLT_PKT),
MODULE_TAG1,
0
);
ExInitializeNPagedLookasideList(
&g_DataLookaside,
NULL, NULL, 0,
MAX_ETHER_SIZE,
MODULE_TAG2,
0
);
}
void InitNotificationQueue(NOTIFICATION_QUEUE *queue)
{
DbgPrint("pbfilter: > Entering InitNotificationQueue()\n");
InitializeListHead(&queue->irp_list);
InitializeListHead(&queue->notification_list);
ExInitializeNPagedLookasideList(&queue->lookaside, NULL, NULL, 0, sizeof(PBLISTNODE), '02GP', 0);
KeInitializeSpinLock(&queue->lock);
queue->queued = 0;
DbgPrint("pbfilter: < Leaving InitNotificationQueue()\n");
}
BOOLEAN InitialiseEventHandlerManager(EventHandlerManager* event_handler_manager, ConnectionManager* connection_manager)
{
event_handler_manager->connection_manager = connection_manager;
InitialiseHashMap(&event_handler_manager->event_handlers);
ExInitializeNPagedLookasideList(&event_handler_manager->event_handlers_pool, NULL, NULL, 0, sizeof(NodeEventHandler), CONNECTION_POOL_TAG, 0);
event_handler_manager->initialised = TRUE;
return TRUE;
}
VOID
OcObInitializeObjectType(
IN POC_OBJECT_TYPE_INITIALIZER PtrObjectTypeInitializer,
IN OUT POC_OBJECT_TYPE PtrObjectType
)
/*
The caller must allocate the room for the object type
from the nonpaged pool
*/
{
ASSERT( KeGetCurrentIrql() <= DISPATCH_LEVEL );
ASSERT( 0x0 != PtrObjectTypeInitializer->ObjectsBodySize );
ASSERT( 0x0 == ( PtrObjectTypeInitializer->Flags & OcObjectTypeMarkedForDeletion ) );
ASSERT( TRUE == g_OcObManagerInitialized );
RtlZeroMemory( PtrObjectType, sizeof( *PtrObjectType ) );
InitializeListHead( &PtrObjectType->ListHead );
KeInitializeSpinLock( &PtrObjectType->SpinLock );
PtrObjectType->ObjectsBodySize = PtrObjectTypeInitializer->ObjectsBodySize;
PtrObjectType->Methods = PtrObjectTypeInitializer->Methods;
PtrObjectType->Tag = PtrObjectTypeInitializer->Tag;
//PtrObjectType->Context = PtrObjectTypeInitializer->Context;
//
// instead OcObjectTypeMarkedForDeletion flag the clients must use
// the OcObDeleteObjectType function
//
PtrObjectType->Flags = PtrObjectTypeInitializer->Flags & ~(OcObjectTypeMarkedForDeletion);
if( !OcIsFlagOn( PtrObjectType->Flags, OcObjectTypeUseStdPoolAllocator ) ){
ExInitializeNPagedLookasideList( &PtrObjectType->LookasideList,
NULL,
NULL,
0x0,
PtrObjectType->ObjectsBodySize + sizeof( OC_OBJECT_HEADER ),
PtrObjectType->Tag,
0x0 );
}
#if DBG
PtrObjectType->OldIrql = DISPATCH_LEVEL + 0x1;
PtrObjectType->CommonHeader.Type = OcTypeObjectType;
#endif//DBG
}
VOID
OcFilterInitializeHookerEngine()
{
ASSERT( KeGetCurrentIrql() <= DISPATCH_LEVEL );
KeInitializeSpinLock( &g_HookedDriversListSpinLock );
InitializeListHead( &g_HookedDriversList );
ExInitializeNPagedLookasideList( &g_HookedDriversDescriptorsMemoryPool,
NULL,
NULL,
0x0,
sizeof( PNP_FILTER_HOOKED_DRIVER ),
'HFcO',
0x0 );
}
PKSTREAM KStreamAllocate(VOID)
{
PKSTREAM pStream = ExAllocatePoolWithTag(NonPagedPool, sizeof(KSTREAM), TAG_KSTREAM);
if (pStream)
{
pStream->Position = 0;
pStream->Length = 0;
InitializeListHead(&pStream->BuffersListHead);
KeInitializeEvent(&pStream->DataReadyEvent, NotificationEvent, FALSE);
KeInitializeMutex(&pStream->Lock, 0);
ExInitializeNPagedLookasideList(&pStream->Buffers, NULL, NULL, 0, (sizeof(LBUFFER) + KSTREAM_BUFFER_SIZE), TAG_KSTREAM, 0);
#if DBG
pStream->Magic = KSTREAM_MAGIC;
#endif
}
return(pStream);
}
struct kmem_cache *kmem_cache_create(const char *name, size_t size,
size_t offset, unsigned long flags,
void *ctor)
{
struct kmem_cache *kmc = NULL;
/* The name of the SLAB could not exceed 20 chars */
if (name && strlen(name) >= 20)
goto errorout;
/* Allocate and initialize the SLAB strcture */
kmc = kmalloc(sizeof(struct kmem_cache), 0);
if (NULL == kmc)
goto errorout;
memset(kmc, 0, sizeof(struct kmem_cache));
kmc->flags = flags;
if (name) {
strcpy(&kmc->name[0], name);
}
/* Initialize the corresponding LookAside list */
ExInitializeNPagedLookasideList(
&(kmc->npll),
NULL,
NULL,
0,
size,
'pnmk',
0);
errorout:
return kmc;
}
/*
* @implemented
*/
VOID
NTAPI
FsRtlInitializeLargeMcbs(VOID)
{
/* Initialize the list for the MCB */
ExInitializePagedLookasideList(&FsRtlFirstMappingLookasideList,
NULL,
NULL,
POOL_RAISE_IF_ALLOCATION_FAILURE,
sizeof(LARGE_MCB_MAPPING),
IFS_POOL_TAG,
0); /* FIXME: Should be 4 */
/* Initialize the list for the guarded mutex */
ExInitializeNPagedLookasideList(&FsRtlFastMutexLookasideList,
NULL,
NULL,
POOL_RAISE_IF_ALLOCATION_FAILURE,
sizeof(KGUARDED_MUTEX),
IFS_POOL_TAG,
0); /* FIXME: Should be 32 */
}
SORAAPI
allocate_thread_safe_enlist() {
struct thread_safe_enlist* tslist;
tslist = (struct thread_safe_enlist*)ExAllocatePoolWithTag(NonPagedPool,
sizeof(struct thread_safe_enlist),
Tag);
if (tslist) {
ExInitializeNPagedLookasideList(&tslist->m_lookaside,
NULL,
NULL,
0,
sizeof(LIST_ENTRY_EX),
Tag,
0);
InitializeListHead(&tslist->m_head.m_entry);
KeInitializeSpinLock(&tslist->m_sync);
tslist->m_head.m_value = NULL;
tslist->m_count = 0;
}
return tslist;
}
VOID NTAPI ClassInitializeSrbLookasideList(IN PCOMMON_DEVICE_EXTENSION CommonExtension,
IN ULONG NumberElements)
{
PAGED_CODE();
// This function is obsolete, but still called by DISK.SYS .
// DBGWARN(("ClassInitializeSrbLookasideList is OBSOLETE !"));
ASSERT(!CommonExtension->IsSrbLookasideListInitialized);
if (!CommonExtension->IsSrbLookasideListInitialized){
ExInitializeNPagedLookasideList(&CommonExtension->SrbLookasideList,
NULL,
NULL,
NonPagedPool,
sizeof(SCSI_REQUEST_BLOCK),
'$scS',
(USHORT)NumberElements);
CommonExtension->IsSrbLookasideListInitialized = TRUE;
}
}
VOID ClassInitializeSrbLookasideList( __inout PCOMMON_DEVICE_EXTENSION CommonExtension,
__in ULONG NumberElements)
{
PAGED_CODE();
// This function is obsolete, but still called by DISK.SYS .
// TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClassInitializeSrbLookasideList is OBSOLETE !"));
ASSERT(!CommonExtension->IsSrbLookasideListInitialized);
if (!CommonExtension->IsSrbLookasideListInitialized){
ExInitializeNPagedLookasideList(&CommonExtension->SrbLookasideList,
NULL,
NULL,
NonPagedPool,
sizeof(SCSI_REQUEST_BLOCK),
'$scS',
(USHORT)NumberElements);
CommonExtension->IsSrbLookasideListInitialized = TRUE;
}
}
VOID
FtpInitializeRcbLookasideListHead(
IN PDEVICE_EXTENSION FtRootExtension
)
/*++
Routine Description:
This routine sets up a lookaside listhead for request control blocks.
Arguments:
FtRootExtension - FtRoot device extension.
Return Value:
None.
--*/
{
//
// Initialize Rcb lookaide listhead.
//
ExInitializeNPagedLookasideList(&FtRootExtension->RcbLookasideListHead,
NULL,
NULL,
0,
sizeof(RCB),
'crTF',
4096 / sizeof(RCB));
return;
} // end FtpInitializeRcbLookasideListHead()
BOOLEAN InitEventHandler()
/*++
Routine Description:
初始化工作
Arguments:
None.
Return Value:
TRUE if successful, and FALSE if not.
Author:
Fypher
--*/
{
PAGED_CODE();
KeInitializeSemaphore(&g_EventDataSemaphore, 0 , MAXLONG);
KeInitializeSpinLock(&g_EventDataLock);
InitializeListHead(&g_EventDataLinkListHead);
ExInitializeNPagedLookasideList(&g_EventDataPageList, NULL, NULL, 0, sizeof(EVENTDATA), ALLOC_TAG, 0);
g_ulEventDataCount = 0;
g_ulMajorProtectedMask = 0;
SetMajorProtectedType(CRIME_MAJOR_ALL, TRUE);
return TRUE;
}
/*
* 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;
}
PHASHTABLE InitializeTable(unsigned int tableSize)
{
PHASHTABLE pHashTable = NULL;
PTWOWAY pNode = NULL;
unsigned int i;
// Allocate space for the hashtable
pHashTable = ExAllocatePoolWithTag(NonPagedPool, sizeof(HASHTABLE), DRIVERTAG1);
if (pHashTable == NULL)
{
DbgPrint("ExAllocatePoolWithTag returned NULL!\n");
return NULL;
}
pHashTable->tableSize = NextPrime(tableSize);
// Allocate array of pointers to linkedlists
pHashTable->pListHeads = ExAllocatePoolWithTag(NonPagedPool, sizeof(PLIST_ENTRY) * pHashTable->tableSize, DRIVERTAG1);
if (pHashTable->pListHeads == NULL)
{
DbgPrint("ExAllocatePoolWithTag returned NULL!\n");
return NULL;
}
// Allocate space for the lookaside list for the TWOWAY-structures.
pLookasideList_TWOWAY = ExAllocatePoolWithTag(NonPagedPool, sizeof(NPAGED_LOOKASIDE_LIST), DRIVERTAG1);
if (pLookasideList_TWOWAY == NULL)
{
DbgPrint("ExAllocatePoolWithTag returned NULL!\n");
return NULL;
}
// Initialize the lookaside list.
ExInitializeNPagedLookasideList(
pLookasideList_TWOWAY,
NULL,
NULL,
0,
sizeof(TWOWAY),
DRIVERTAG1,
0);
// Allocate empty nodes for the each linked list.
for (i = 0; i < pHashTable->tableSize; i++)
{
pNode = ExAllocateFromNPagedLookasideList(pLookasideList_TWOWAY);
if (pNode == NULL)
{
DbgPrint("ExAllocateFromNPagedLookasideList returned NULL!\n");
return NULL;
}
else
{
pNode->key = 0x00000000;
RtlZeroMemory(&pNode->data, sizeof(ELEMENT));
InitializeListHead(&pNode->linkfield);
}
pHashTable->pListHeads[i] = &pNode->linkfield;
}
return pHashTable;
}
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
DriverEntry (
_In_ PDRIVER_OBJECT DriverObject,
_In_ PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This routine is called when a driver first loads. Its purpose is to
initialize global state and then register with FltMgr to start filtering.
Arguments:
DriverObject - Pointer to driver object created by the system to
represent this driver.
RegistryPath - Unicode string identifying where the parameters for this
driver are located in the registry.
Return Value:
Status of the operation.
--*/
{
PSECURITY_DESCRIPTOR sd;
OBJECT_ATTRIBUTES oa;
UNICODE_STRING uniString;
NTSTATUS status = STATUS_SUCCESS;
try {
//
// Initialize global data structures.
//
MiniSpyData.LogSequenceNumber = 0;
MiniSpyData.MaxRecordsToAllocate = DEFAULT_MAX_RECORDS_TO_ALLOCATE;
MiniSpyData.RecordsAllocated = 0;
MiniSpyData.NameQueryMethod = DEFAULT_NAME_QUERY_METHOD;
MiniSpyData.DriverObject = DriverObject;
InitializeListHead( &MiniSpyData.OutputBufferList );
KeInitializeSpinLock( &MiniSpyData.OutputBufferLock );
ExInitializeNPagedLookasideList( &MiniSpyData.FreeBufferList,
NULL,
NULL,
0,
RECORD_SIZE,
SPY_TAG,
0 );
#if MINISPY_VISTA
//
// Dynamically import FilterMgr APIs for transaction support
//
#pragma warning(push)
#pragma warning(disable:4055) // type cast from data pointer to function pointer
MiniSpyData.PFltSetTransactionContext = (PFLT_SET_TRANSACTION_CONTEXT) FltGetRoutineAddress( "FltSetTransactionContext" );
MiniSpyData.PFltGetTransactionContext = (PFLT_GET_TRANSACTION_CONTEXT) FltGetRoutineAddress( "FltGetTransactionContext" );
MiniSpyData.PFltEnlistInTransaction = (PFLT_ENLIST_IN_TRANSACTION) FltGetRoutineAddress( "FltEnlistInTransaction" );
#pragma warning(pop)
#endif
//
// Read the custom parameters for MiniSpy from the registry
//
SpyReadDriverParameters(RegistryPath);
//
// Now that our global configuration is complete, register with FltMgr.
//
status = FltRegisterFilter( DriverObject,
&FilterRegistration,
&MiniSpyData.Filter );
if (!NT_SUCCESS( status )) {
leave;
}
status = FltBuildDefaultSecurityDescriptor( &sd,
FLT_PORT_ALL_ACCESS );
if (!NT_SUCCESS( status )) {
leave;
}
RtlInitUnicodeString( &uniString, MINISPY_PORT_NAME );
InitializeObjectAttributes( &oa,
&uniString,
OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
NULL,
sd );
status = FltCreateCommunicationPort( MiniSpyData.Filter,
&MiniSpyData.ServerPort,
&oa,
NULL,
SpyConnect,
SpyDisconnect,
SpyMessage,
1 );
FltFreeSecurityDescriptor( sd );
if (!NT_SUCCESS( status )) {
leave;
}
//
// We are now ready to start filtering
//
status = FltStartFiltering( MiniSpyData.Filter );
//If all went ok, register a process creation notification cb.
if (NT_SUCCESS(status))
{
status = PsSetCreateProcessNotifyRoutine(ProcessCreationCB, FALSE);
}
//If all went ok, register also a register filter.
if (NT_SUCCESS(status))
{
status = CmRegisterCallback(RegistryCallback, NULL, &g_CmCookie);
}
} finally {
if (!NT_SUCCESS( status ) ) {
if (NULL != MiniSpyData.ServerPort) {
FltCloseCommunicationPort( MiniSpyData.ServerPort );
}
if (NULL != MiniSpyData.Filter) {
FltUnregisterFilter( MiniSpyData.Filter );
}
ExDeleteNPagedLookasideList( &MiniSpyData.FreeBufferList );
}
}
return status;
}
NTSTATUS
DriverEntry(
__in PDRIVER_OBJECT DriverObject,
__in PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This routine gets called by the system to initialize the driver.
Arguments:
DriverObject - the system supplied driver object.
RegistryPath - the system supplied registry path for this driver.
Return Value:
NTSTATUS
--*/
{
PDEVICE_OBJECT deviceObject;
NTSTATUS status;
PFAST_IO_DISPATCH fastIoDispatch;
UNICODE_STRING functionName;
FS_FILTER_CALLBACKS filterCallbacks;
PDOKAN_GLOBAL dokanGlobal = NULL;
DDbgPrint("==> DriverEntry ver.%x, %s %s\n", DOKAN_DRIVER_VERSION, __DATE__, __TIME__);
status = DokanCreateGlobalDiskDevice(DriverObject, &dokanGlobal);
if (status != STATUS_SUCCESS) {
return status;
}
//
// Set up dispatch entry points for the driver.
//
DriverObject->DriverUnload = DokanUnload;
DriverObject->MajorFunction[IRP_MJ_CREATE] = DokanDispatchCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = DokanDispatchClose;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = DokanDispatchCleanup;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DokanDispatchDeviceControl;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = DokanDispatchFileSystemControl;
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = DokanDispatchDirectoryControl;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = DokanDispatchQueryInformation;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = DokanDispatchSetInformation;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = DokanDispatchQueryVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] = DokanDispatchSetVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_READ] = DokanDispatchRead;
DriverObject->MajorFunction[IRP_MJ_WRITE] = DokanDispatchWrite;
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = DokanDispatchFlush;
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = DokanDispatchShutdown;
DriverObject->MajorFunction[IRP_MJ_PNP] = DokanDispatchPnp;
DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = DokanDispatchLock;
DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY] = DokanDispatchQuerySecurity;
DriverObject->MajorFunction[IRP_MJ_SET_SECURITY] = DokanDispatchSetSecurity;
fastIoDispatch = ExAllocatePool(sizeof(FAST_IO_DISPATCH));
// TODO: check fastIoDispatch
RtlZeroMemory(fastIoDispatch, sizeof(FAST_IO_DISPATCH));
fastIoDispatch->SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
fastIoDispatch->FastIoCheckIfPossible = DokanFastIoCheckIfPossible;
//fastIoDispatch->FastIoRead = DokanFastIoRead;
fastIoDispatch->FastIoRead = FsRtlCopyRead;
fastIoDispatch->FastIoWrite = FsRtlCopyWrite;
fastIoDispatch->AcquireFileForNtCreateSection = DokanAcquireForCreateSection;
fastIoDispatch->ReleaseFileForNtCreateSection = DokanReleaseForCreateSection;
fastIoDispatch->MdlRead = FsRtlMdlReadDev;
fastIoDispatch->MdlReadComplete = FsRtlMdlReadCompleteDev;
fastIoDispatch->PrepareMdlWrite = FsRtlPrepareMdlWriteDev;
fastIoDispatch->MdlWriteComplete = FsRtlMdlWriteCompleteDev;
DriverObject->FastIoDispatch = fastIoDispatch;
ExInitializeNPagedLookasideList(
&DokanIrpEntryLookasideList, NULL, NULL, 0, sizeof(IRP_ENTRY), TAG, 0);
#if _WIN32_WINNT < 0x0501
RtlInitUnicodeString(&functionName, L"FsRtlTeardownPerStreamContexts");
DokanFsRtlTeardownPerStreamContexts = MmGetSystemRoutineAddress(&functionName);
#endif
RtlZeroMemory(&filterCallbacks, sizeof(FS_FILTER_CALLBACKS));
// only be used by filter driver?
filterCallbacks.SizeOfFsFilterCallbacks = sizeof(FS_FILTER_CALLBACKS);
filterCallbacks.PreAcquireForSectionSynchronization = DokanFilterCallbackAcquireForCreateSection;
status = FsRtlRegisterFileSystemFilterCallbacks(DriverObject, &filterCallbacks);
if (!NT_SUCCESS(status)) {
IoDeleteDevice(dokanGlobal->DeviceObject);
DDbgPrint(" FsRtlRegisterFileSystemFilterCallbacks returned 0x%x\n", status);
return status;
}
DDbgPrint("<== DriverEntry\n");
return( status );
}
