NTSTATUS
NTAPI
DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
PDEVICE_OBJECT DeviceObject;
UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Device\\Null");
NTSTATUS Status;
PFAST_IO_DISPATCH FastIoDispatch;
PAGED_CODE();
/* Page the driver */
MmPageEntireDriver(DriverEntry);
/* Create null device */
Status = IoCreateDevice(DriverObject,
0,
&DeviceName,
FILE_DEVICE_NULL,
0,
FALSE,
&DeviceObject);
if (!NT_SUCCESS(Status)) return Status;
/* Register driver routines */
DriverObject->MajorFunction[IRP_MJ_CLOSE] = NullDispatch;
DriverObject->MajorFunction[IRP_MJ_CREATE] = NullDispatch;
DriverObject->MajorFunction[IRP_MJ_WRITE] = NullDispatch;
DriverObject->MajorFunction[IRP_MJ_READ] = NullDispatch;
DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = NullDispatch;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = NullDispatch;
/* Allocate the fast I/O dispatch table */
FastIoDispatch = ExAllocatePool(NonPagedPool, sizeof(FAST_IO_DISPATCH));
if (!FastIoDispatch)
{
/* Failed, cleanup */
IoDeleteDevice(DeviceObject);
return STATUS_INSUFFICIENT_RESOURCES;
}
/* Initialize it */
RtlZeroMemory(FastIoDispatch, sizeof(FAST_IO_DISPATCH));
FastIoDispatch->SizeOfFastIoDispatch = sizeof(FAST_IO_DISPATCH);
/* Setup our pointers */
FastIoDispatch->FastIoRead = NullRead;
FastIoDispatch->FastIoWrite = NullWrite;
DriverObject->FastIoDispatch = FastIoDispatch;
/* Return success */
return STATUS_SUCCESS;
}
//
// This is where it all starts...
//
NTSTATUS
DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
NTSTATUS status;
PDEVICE_OBJECT device_object;
UNICODE_STRING ctl_device_name;
UNICODE_STRING sym_link;
AWEAllocDriverObject = DriverObject;
MmPageEntireDriver((PVOID)(ULONG_PTR)DriverEntry);
// Create the control device.
RtlInitUnicodeString(&ctl_device_name, AWEALLOC_DEVICE_NAME);
status = IoCreateDevice(DriverObject,
0,
&ctl_device_name,
FILE_DEVICE_NULL,
0,
FALSE,
&device_object);
if (!NT_SUCCESS(status))
return status;
device_object->Flags |= DO_DIRECT_IO;
RtlInitUnicodeString(&sym_link, AWEALLOC_SYMLINK_NAME);
status = IoCreateUnprotectedSymbolicLink(&sym_link, &ctl_device_name);
if (!NT_SUCCESS(status))
{
IoDeleteDevice(device_object);
return status;
}
DriverObject->MajorFunction[IRP_MJ_CREATE] = AWEAllocCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = AWEAllocClose;
DriverObject->MajorFunction[IRP_MJ_READ] = AWEAllocReadWrite;
DriverObject->MajorFunction[IRP_MJ_WRITE] = AWEAllocReadWrite;
DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = AWEAllocFlushBuffers;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] =
AWEAllocQueryInformation;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = AWEAllocSetInformation;
DriverObject->DriverUnload = AWEAllocUnload;
KdPrint(("AWEAlloc: Initialization done. Leaving DriverEntry().\n"));
return STATUS_SUCCESS;
}
NTSTATUS
NTAPI
DriverEntry(IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
PDEVICE_EXTENSION DeviceExtension;
PDEVICE_OBJECT DeviceObject;
UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Device\\Beep");
NTSTATUS Status;
UNREFERENCED_PARAMETER(RegistryPath);
/* Create the device */
Status = IoCreateDevice(DriverObject,
sizeof(DEVICE_EXTENSION),
&DeviceName,
FILE_DEVICE_BEEP,
0,
FALSE,
&DeviceObject);
if (!NT_SUCCESS(Status)) return Status;
/* Make it use buffered I/O */
DeviceObject->Flags |= DO_BUFFERED_IO;
/* Setup the Driver Object */
DriverObject->MajorFunction[IRP_MJ_CREATE] = BeepCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = BeepClose;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = BeepCleanup;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = BeepDeviceControl;
DriverObject->DriverUnload = BeepUnload;
DriverObject->DriverStartIo = BeepStartIo;
/* Set up device extension */
DeviceExtension = DeviceObject->DeviceExtension;
DeviceExtension->ReferenceCount = 0;
DeviceExtension->TimerActive = FALSE;
IoInitializeDpcRequest(DeviceObject, (PIO_DPC_ROUTINE)BeepDPC);
KeInitializeTimer(&DeviceExtension->Timer);
ExInitializeFastMutex(&DeviceExtension->Mutex);
/* Page the entire driver */
MmPageEntireDriver(DriverEntry);
return STATUS_SUCCESS;
}
VOID
MsDereferenceVcb (
IN PVCB Vcb
)
/*++
Routine Description:
This routine dereferences a VCB block. If the reference count
reaches zero, the block is freed.
Arguments:
Vcb - Supplies the VCB to dereference
Return Value:
None
--*/
{
PAGED_CODE();
DebugTrace(+1, DEBUG_TRACE_REFCOUNT, "MsDereferenceVcb, Vcb = %08lx\n", (ULONG)Vcb);
//
// Acquire the lock that protects the reference count.
//
MsAcquireGlobalLock();
if ( --(Vcb->Header.ReferenceCount) == 0 ) {
//
// This was the last reference to the VCB. Delete it now
//
DebugTrace(0,
DEBUG_TRACE_REFCOUNT,
"Reference count = %lx\n",
Vcb->Header.ReferenceCount );
MsReleaseGlobalLock();
MsDeleteVcb( Vcb );
} else {
DebugTrace(0,
DEBUG_TRACE_REFCOUNT,
"Reference count = %lx\n",
Vcb->Header.ReferenceCount );
if (Vcb->Header.ReferenceCount == 1) {
//
// Set driver to be paged completely out
//
MmPageEntireDriver(MsDereferenceVcb);
}
MsReleaseGlobalLock();
}
DebugTrace(-1, DEBUG_TRACE_REFCOUNT, "MsDereferenceVcb -> VOID\n", 0);
return;
}
NTSTATUS
DriverEntry( DRIVER_OBJECT *DriverObject, UNICODE_STRING *RegistryPath )
{
VOID *processEventHandle = 0;
VOID *threadEventHandle = 0;
VOID *imageEventHandle = 0;
NTSTATUS status;
UNICODE_STRING DeviceNameU;
UNICODE_STRING DeviceLinkU;
UNICODE_STRING processEventName;
UNICODE_STRING threadEventName;
UNICODE_STRING imageEventName;
DbgPrint("[PUSH] => (DriverEntry)\n");
MmPageEntireDriver((PVOID)(ULONG_PTR) DriverEntry);
MaxDevices = IMDISK_DEFAULT_MAX_DEVICES;
lstMapInfo.Next=NULL;
PushDriverObject = DriverObject;
RtlInitUnicodeString(&DeviceNameU, PUSH_DEVICE_BASE_NAME);
RtlInitUnicodeString(&DeviceLinkU, PUSH_SYMLINK_NAME);
RtlInitUnicodeString(&processEventName, L"\\BaseNamedObjects\\" PUSH_PROCESS_EVENT_NAME);
RtlInitUnicodeString(&threadEventName, L"\\BaseNamedObjects\\" PUSH_THREAD_EVENT_NAME);
RtlInitUnicodeString(&imageEventName, L"\\BaseNamedObjects\\" PUSH_IMAGE_EVENT_NAME);
//Create a device object
status = IoCreateDevice(DriverObject, //IN: Driver Object
sizeof(DEVICE_EXTENSION), //IN: Device Extension Size
&DeviceNameU, //IN: Device Name
FILE_DEVICE_PUSH, //IN: Device Type
0, //IN: Device Characteristics
FALSE, //IN: Exclusive
&g_DeviceObject); //OUT:Created Device Object
// The control device gets a device_number of -1 to make it easily
// distinguishable from the actual created devices.
//((PDEVICE_EXTENSION) g_DeviceObject->DeviceExtension)->device_number =
//(ULONG) -1;
//Dispatch functions
DriverObject->MajorFunction[IRP_MJ_CREATE] = DispatchCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = DispatchClose;
DriverObject->MajorFunction[IRP_MJ_READ] = ImDiskReadWrite;
DriverObject->MajorFunction[IRP_MJ_WRITE] = ImDiskReadWrite;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchIoCtl;
DriverObject->MajorFunction[IRP_MJ_PNP] = ImDiskDispatchPnP;
DriverObject->DriverUnload = PushUnload;
//Create a symbolic link
IoCreateSymbolicLink(&DeviceLinkU, &DeviceNameU);
ProcessEvent = IoCreateNotificationEvent(&processEventName, &processEventHandle);
ThreadEvent = IoCreateNotificationEvent(&threadEventName, &threadEventHandle);
ImageEvent = IoCreateNotificationEvent(&imageEventName, &imageEventHandle);
KeClearEvent(ProcessEvent);
KeClearEvent(ThreadEvent);
KeClearEvent(ImageEvent);
DbgPrint("[PUSH] <= (DriverEntry)\n");
return status;
}
NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject,PUNICODE_STRING Registry)
{
int Index = 0;
PDEVICE_OBJECT DeviceObject;
MmPageEntireDriver(DriverEntry);
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = FsRecFsControl;
DriverObject->MajorFunction[IRP_MJ_CREATE] = FsRecCreate;
DriverObject->MajorFunction[IRP_MJ_CLOSE] =
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = FsRecCleanupClose;
DriverObject->DriverUnload = FsRecUnload;
FsRecLoadSync = (PKEVENT)ExAllocatePoolWithTag(sizeof(KEVENT),NonPagedPool,POOL_TAG);
if(FsRecLoadSync == NULL)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
KeInitializeEvent(FsRecLoadSync,SynchronizationEvent,TRUE);
if(NT_SUCCESS(FsRecCreateAndRegisterDO(DriverObject,NULL,NULL,
L"\\Cdfs",
L"\\FileSystem\\CdfsRecognizer",
CDFS_TYPE,
FILE_DEVICE_CD_ROM_FILE_SYSTEM,
TRUE)))
{
Index ++;
}
if (NT_SUCCESS( FsRecCreateAndRegisterDO(
DriverObject,
NULL,
&DeviceObject,
L"\\UdfsCdRom",
L"\\FileSystem\\UdfsCdRomRecognizer",
UDFS_TYPE,
FILE_DEVICE_CD_ROM_FILE_SYSTEM,
FALSE) ))
{
Index++;
}
if (NT_SUCCESS( FsRecCreateAndRegisterDO(
DriverObject,
NULL,
&DeviceObject,
L"\\Fat",
L"\\FileSystem\\FatDiskRecognizer",
FATCD_TYPE,
FILE_DEVICE_DISK_FILE_SYSTEM,
FALSE) ))
{
Index++;
}
if (NT_SUCCESS( FsRecCreateAndRegisterDO(
DriverObject,
DeviceObject,
NULL,
L"\\FatCdrom",
L"\\FileSystem\\FatCdRomRecognizer",
FATCD_TYPE,
FILE_DEVICE_CD_ROM_FILE_SYSTEM,
FALSE) ))
{
Index++;
}
if (NT_SUCCESS( FsRecCreateAndRegisterDO(DriverObject, NULL, NULL,
L"\\Ntfs",
L"\\FileSystem\\NtfsRecognizer",
NTFS_TYPE,
FILE_DEVICE_DISK_FILE_SYSTEM,
FALSE) ))
{
++Index;
}
if (NT_SUCCESS( FsRecCreateAndRegisterDO(DriverObject,
NULL,
NULL,
L"\\ExFat",
L"\\FileSystem\\ExFatRecognizer",
EXFAT_TYPE,
FILE_DEVICE_DISK_FILE_SYSTEM,
FALSE) ))
{
++Index;
}
return Index != 0 ? STATUS_SUCCESS : STATUS_IMAGE_ALREADY_LOADED;
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This is the initialization routine for the mailslot file system
device driver. This routine creates the device object for the mailslot
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 = STATUS_SUCCESS;
UNICODE_STRING nameString;
PDEVICE_OBJECT deviceObject;
PMSFS_DEVICE_OBJECT msfsDeviceObject;
BOOLEAN vcbInitialized;
PAGED_CODE();
//
// Initialize MSFS global data.
//
MsInitializeData();
//
// Set driver to be completely paged out.
//
MmPageEntireDriver(DriverEntry);
//
// Create the MSFS device object.
//
RtlInitUnicodeString( &nameString, L"\\Device\\Mailslot" );
status = IoCreateDevice( DriverObject,
sizeof(MSFS_DEVICE_OBJECT)-sizeof(DEVICE_OBJECT),
&nameString,
FILE_DEVICE_MAILSLOT,
0,
FALSE,
&deviceObject );
if (!NT_SUCCESS( status )) {
return status;
}
//
// Now because we use the irp stack for storing a data entry we need
// to bump up the stack size in the device object we just created.
//
deviceObject->StackSize += 1;
//
// Note that because of the way data copying is done, we set neither
// the Direct I/O or Buffered I/O bit in DeviceObject->Flags. If
// data 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)MsFsdCreate;
DriverObject->MajorFunction[IRP_MJ_CREATE_MAILSLOT] =
(PDRIVER_DISPATCH)MsFsdCreateMailslot;
DriverObject->MajorFunction[IRP_MJ_CLOSE] =
(PDRIVER_DISPATCH)MsFsdClose;
DriverObject->MajorFunction[IRP_MJ_READ] =
(PDRIVER_DISPATCH)MsFsdRead;
DriverObject->MajorFunction[IRP_MJ_WRITE] =
(PDRIVER_DISPATCH)MsFsdWrite;
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] =
(PDRIVER_DISPATCH)MsFsdQueryInformation;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] =
(PDRIVER_DISPATCH)MsFsdSetInformation;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] =
(PDRIVER_DISPATCH)MsFsdQueryVolumeInformation;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] =
(PDRIVER_DISPATCH)MsFsdCleanup;
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] =
(PDRIVER_DISPATCH)MsFsdDirectoryControl;
DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] =
(PDRIVER_DISPATCH)MsFsdFsControl;
DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY] =
(PDRIVER_DISPATCH)MsFsdQuerySecurityInfo;
DriverObject->MajorFunction[IRP_MJ_SET_SECURITY] =
(PDRIVER_DISPATCH)MsFsdSetSecurityInfo;
#ifdef _PNP_POWER_
//
// Mailslots should probably have a SetPower handler to ensure
// that the driver is not powered down while a guarateed
// mailslot delivery is in progress. For now, we'll just
// ignore this and let the machine set power.
//
deviceObject->DeviceObjectExtension->PowerControlNeeded = FALSE;
#endif
vcbInitialized = FALSE;
try {
//
// Initialize stuff
//
msfsDeviceObject = (PMSFS_DEVICE_OBJECT)deviceObject;
//
// Now initialize the Vcb, and create the root dcb
//
MsInitializeVcb( &msfsDeviceObject->Vcb );
(VOID)MsCreateRootDcb( &msfsDeviceObject->Vcb );
vcbInitialized = TRUE;
} finally {
if (AbnormalTermination() ) {
//
// We encountered some unrecoverable error while initializing.
// Cleanup as necessary.
//
if (vcbInitialized) {
MsDeleteVcb( &msfsDeviceObject->Vcb );
}
}
}
//
// Return to the caller.
//
return( status );
}
/*
* This definition doesn't work
*/
INIT_FUNCTION
NTSTATUS
APIENTRY
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
NTSTATUS Status;
BOOLEAN Result;
WIN32_CALLOUTS_FPNS CalloutData = {0};
PVOID GlobalUserHeapBase = NULL;
/*
* Register user mode call interface
* (system service table index = 1)
*/
Result = KeAddSystemServiceTable(Win32kSSDT,
NULL,
Win32kNumberOfSysCalls,
Win32kSSPT,
1);
if (Result == FALSE)
{
DPRINT1("Adding system services failed!\n");
return STATUS_UNSUCCESSFUL;
}
hModuleWin = MmPageEntireDriver(DriverEntry);
DPRINT("Win32k hInstance 0x%p!\n",hModuleWin);
/* Register Object Manager Callbacks */
CalloutData.ProcessCallout = Win32kProcessCallback;
CalloutData.ThreadCallout = Win32kThreadCallback;
CalloutData.WindowStationParseProcedure = IntWinStaObjectParse;
CalloutData.WindowStationDeleteProcedure = IntWinStaObjectDelete;
CalloutData.WindowStationOkToCloseProcedure = IntWinstaOkToClose;
CalloutData.DesktopOkToCloseProcedure = IntDesktopOkToClose;
CalloutData.DesktopDeleteProcedure = IntDesktopObjectDelete;
CalloutData.DesktopCloseProcedure = IntDesktopObjectClose;
CalloutData.DesktopOpenProcedure = IntDesktopObjectOpen;
CalloutData.BatchFlushRoutine = NtGdiFlushUserBatch;
/* Register our per-process and per-thread structures. */
PsEstablishWin32Callouts((PWIN32_CALLOUTS_FPNS)&CalloutData);
/* Register service hook callbacks */
#if DBG
KdSystemDebugControl('CsoR', DbgPreServiceHook, ID_Win32PreServiceHook, 0, 0, 0, 0);
KdSystemDebugControl('CsoR', DbgPostServiceHook, ID_Win32PostServiceHook, 0, 0, 0, 0);
#endif
/* Create the global USER heap */
GlobalUserHeap = UserCreateHeap(&GlobalUserHeapSection,
&GlobalUserHeapBase,
1 * 1024 * 1024); /* FIXME: 1 MB for now... */
if (GlobalUserHeap == NULL)
{
DPRINT1("Failed to initialize the global heap!\n");
return STATUS_UNSUCCESSFUL;
}
/* Allocate global server info structure */
gpsi = UserHeapAlloc(sizeof(SERVERINFO));
if (!gpsi)
{
DPRINT1("Failed allocate server info structure!\n");
return STATUS_UNSUCCESSFUL;
}
RtlZeroMemory(gpsi, sizeof(SERVERINFO));
DPRINT("Global Server Data -> %p\n", gpsi);
NT_ROF(InitGdiHandleTable());
NT_ROF(InitPaletteImpl());
/* Create stock objects, ie. precreated objects commonly
used by win32 applications */
CreateStockObjects();
CreateSysColorObjects();
NT_ROF(InitBrushImpl());
NT_ROF(InitPDEVImpl());
NT_ROF(InitLDEVImpl());
NT_ROF(InitDeviceImpl());
NT_ROF(InitDcImpl());
NT_ROF(InitUserImpl());
NT_ROF(InitWindowStationImpl());
NT_ROF(InitDesktopImpl());
NT_ROF(InitInputImpl());
NT_ROF(InitKeyboardImpl());
NT_ROF(MsqInitializeImpl());
NT_ROF(InitTimerImpl());
NT_ROF(InitDCEImpl());
/* Initialize FreeType library */
if (!InitFontSupport())
{
DPRINT1("Unable to initialize font support\n");
return Status;
}
gusLanguageID = UserGetLanguageID();
return STATUS_SUCCESS;
}
NTSTATUS
DriverEntry (
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This is the initialization routine for the AFD device driver.
Arguments:
DriverObject - Pointer to driver object created by the system.
Return Value:
The function value is the final status from the initialization operation.
--*/
{
NTSTATUS status;
UNICODE_STRING deviceName;
CLONG i;
BOOLEAN success;
PAGED_CODE( );
//
// Create the device object. (IoCreateDevice zeroes the memory
// occupied by the object.)
//
// !!! Apply an ACL to the device object.
//
RtlInitUnicodeString( &deviceName, AFD_DEVICE_NAME );
status = IoCreateDevice(
DriverObject, // DriverObject
0, // DeviceExtension
&deviceName, // DeviceName
FILE_DEVICE_NAMED_PIPE, // DeviceType
0, // DeviceCharacteristics
FALSE, // Exclusive
&AfdDeviceObject // DeviceObject
);
if ( !NT_SUCCESS(status) ) {
KdPrint(( "AFD DriverEntry: unable to create device object: %X\n", status ));
return status;
}
//
// Create the security descriptor used for raw socket access checks.
//
status = AfdCreateRawSecurityDescriptor();
if (!NT_SUCCESS(status)) {
IoDeleteDevice(AfdDeviceObject);
return status;
}
AfdDeviceObject->Flags |= DO_DIRECT_IO;
//
// Initialize the driver object for this file system driver.
//
for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++) {
DriverObject->MajorFunction[i] = AfdDispatch;
}
DriverObject->FastIoDispatch = &AfdFastIoDispatch;
DriverObject->DriverUnload = NULL;
//
// Initialize global data.
//
success = AfdInitializeData( );
if ( !success ) {
IoDeleteDevice(AfdDeviceObject);
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Initialize group ID manager.
//
success = AfdInitializeGroup();
if ( !success ) {
IoDeleteDevice(AfdDeviceObject);
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Read registry information.
//
AfdReadRegistry( );
#if DBG
if( AfdEnableUnload ) {
KdPrint(( "AFD: DriverUnload enabled\n" ));
DriverObject->DriverUnload = AfdUnload;
}
#endif
//
// Initialize the lookaside lists.
//
AfdLookasideLists = AFD_ALLOCATE_POOL(
NonPagedPool,
sizeof(*AfdLookasideLists),
AFD_LOOKASIDE_LISTS_POOL_TAG
);
if( AfdLookasideLists == NULL ) {
IoDeleteDevice(AfdDeviceObject);
return STATUS_INSUFFICIENT_RESOURCES;
}
//
// Initialize the work queue item lookaside list.
//
ExInitializeNPagedLookasideList(
&AfdLookasideLists->WorkQueueList,
#if DBG
AfdAllocateWorkItemPool,
AfdFreeWorkItemPool,
#else
NULL,
NULL,
#endif
NonPagedPoolMustSucceed,
sizeof( AFD_WORK_ITEM ),
AFD_WORK_ITEM_POOL_TAG,
12
);
//
// Initialize the AFD buffer lookaside lists. These must be
// initialized *after* the registry data has been read.
//
ExInitializeNPagedLookasideList(
&AfdLookasideLists->LargeBufferList,
AfdAllocateBuffer,
#if DBG
AfdFreeBufferPool,
#else
NULL,
#endif
0,
AfdLargeBufferSize,
AFD_DATA_BUFFER_POOL_TAG,
(USHORT)AfdLargeBufferListDepth
);
ExInitializeNPagedLookasideList(
&AfdLookasideLists->MediumBufferList,
AfdAllocateBuffer,
#if DBG
AfdFreeBufferPool,
#else
NULL,
#endif
0,
AfdMediumBufferSize,
AFD_DATA_BUFFER_POOL_TAG,
(USHORT)AfdMediumBufferListDepth
);
ExInitializeNPagedLookasideList(
&AfdLookasideLists->SmallBufferList,
AfdAllocateBuffer,
#if DBG
AfdFreeBufferPool,
#else
NULL,
#endif
0,
AfdSmallBufferSize,
AFD_DATA_BUFFER_POOL_TAG,
(USHORT)AfdSmallBufferListDepth
);
//
// Initialize our device object.
//
AfdDeviceObject->StackSize = AfdIrpStackSize;
//
// Remember a pointer to the system process. We'll use this pointer
// for KeAttachProcess() calls so that we can open handles in the
// context of the system process.
//
AfdSystemProcess = (PKPROCESS)IoGetCurrentProcess();
//
// Tell MM that it can page all of AFD it is desires. We will reset
// to normal paging of AFD code as soon as an AFD endpoint is
// opened.
//
AfdLoaded = FALSE;
MmPageEntireDriver( DriverEntry );
return (status);
} // DriverEntry
