#include "ucx01000.h"
#include <debug.h>

Include dependency graph for driver.cpp:

Macros
#define	NDEBUG

#define	UCX_CONTROL_DEVICE_ATTEMPTS 100

Functions
	DECLARE_CONST_UNICODE_STRING (UcxKernelOnlySddl, L"D:P")

	_IRQL_requires_ (PASSIVE_LEVEL) static NTSTATUS NTAPI UcxCreateControlDevice(_In_ WDFDRIVER Driver)
	Sends a synchronous IOCTL to the specified device object.

static VOID NTAPI	UcxEvtDriverUnload (_In_ WDFDRIVER Driver)

	CODE_SEG ("INIT") NTSTATUS NTAPI DriverEntry(_In_ PDRIVER_OBJECT DriverObject

	if (!NT_SUCCESS(Status))

	UcxReadUsbFlags ()

	DPRINT ("UCX loaded, control device %wZ\n", &UcxDriver.ControlDeviceName)

Variables
DRIVER_INITIALIZE	DriverEntry

static EVT_WDF_DRIVER_UNLOAD	UcxEvtDriverUnload

_In_ PUNICODE_STRING	RegistryPath

WDF_DRIVER_CONFIG	Config

LARGE_INTEGER	Ticks

NTSTATUS	Status = WdfDriverCreate(DriverObject, RegistryPath, WDF_NO_OBJECT_ATTRIBUTES, &Config, &UcxDriver.Driver)

UcxDriver	RandomSeed = Ticks.LowPart

InitializeListHead &	UcxDriver

UcxDriver	ControllerCount = 0

Config	DriverInitFlags = WdfDriverInitNonPnpDriver

Config	EvtDriverUnload = UcxEvtDriverUnload

Config	DriverPoolTag = UCX_POOL_TAG

UcxDriver	IoTryQueueWorkItem

return	STATUS_SUCCESS

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 10 of file driver.cpp.

◆ UCX_CONTROL_DEVICE_ATTEMPTS

#define UCX_CONTROL_DEVICE_ATTEMPTS 100

Definition at line 13 of file driver.cpp.

Function Documentation

◆ _IRQL_requires_()

_IRQL_requires_ ( PASSIVE_LEVEL )

Sends a synchronous IOCTL to the specified device object.

Parameters

[in]	IoControlCode	The IOCTL to send to the device.
[in]	DeviceObject	Pointer to the device object that will handle the IOCTL.
[in]	InputBuffer	Optional pointer to a buffer containing input data for the IOCTL. When specified, the buffer should be at least of InputBufferLength size.
[in]	InputBufferLength	Size in bytes, of the buffer pointed by InputBuffer.
[out]	OutputBuffer	Optional pointer to a buffer that will receive output data from the IOCTL. When specified, the buffer should be at least of OutputBufferLength size.
[in]	OutputBufferLength	Size in bytes, of the buffer pointed by OutputBuffer.
[in]	FileObject	Optional pointer to a file object that may be necessary for the IOCTL.

Returns: An NTSTATUS code indicating success or failure of this function.

Note: Must be called at PASSIVE_LEVEL with all APCs enabled.

Definition at line 22 of file driver.cpp.

{
    PWDFDEVICE_INIT DeviceInit;
    WDFDEVICE Device;
    ULONG Index;
    NTSTATUS Status = STATUS_OBJECT_NAME_COLLISION;
 
    PAGED_CODE();
 
    DeviceInit = WdfControlDeviceInitAllocate(Driver, &UcxKernelOnlySddl);
    if (DeviceInit == NULL)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    RtlInitEmptyUnicodeString(&UcxDriver.ControlDeviceName,
                              UcxDriver.ControlDeviceNameBuffer,
                              sizeof(UcxDriver.ControlDeviceNameBuffer));
 
    for (Index = 0; Index < UCX_CONTROL_DEVICE_ATTEMPTS && Status == STATUS_OBJECT_NAME_COLLISION; Index++)
    {
        Status = RtlUnicodeStringPrintf(&UcxDriver.ControlDeviceName, L"\\Device\\UCX%lu", Index);
        if (!NT_SUCCESS(Status))
            break;
 
        Status = WdfDeviceInitAssignName(DeviceInit, &UcxDriver.ControlDeviceName);
        if (!NT_SUCCESS(Status))
            break;
 
        Status = WdfDeviceCreate(&DeviceInit, WDF_NO_OBJECT_ATTRIBUTES, &Device);
    }
 
    /* A successful create took the init block over */
    if (!NT_SUCCESS(Status))
    {
        if (DeviceInit != NULL)
            WdfDeviceInitFree(DeviceInit);
        return Status;
    }
 
    WdfControlFinishInitializing(Device);
    UcxDriver.ControlDevice = Device;
 
    return STATUS_SUCCESS;
}

◆ CODE_SEG()

CODE_SEG ( "INIT" )

Definition at line 246 of file Interface.c.

{
    UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\FileSystem\\Filters\\"DRIVER_NAME);
    PDEVICE_OBJECT RawDeviceObject;
    PDEVICE_OBJECT DeviceObject;
    PFILE_OBJECT RawFileObject;
    UNICODE_STRING ObjectName;
    UNICODE_STRING SymLink;
 
    NTSTATUS Status;
 
    RtlZeroMemory(&DriverData, sizeof(DRIVER_DATA));
    DriverData.DriverObject = DriverObject;
 
    /* Save the registry key for this driver */
    DriverData.ServiceKey.Length = RegistryPath->Length;
    DriverData.ServiceKey.MaximumLength = RegistryPath->MaximumLength;
    DriverData.ServiceKey.Buffer = (PWCHAR)ExAllocatePoolWithTag(NonPagedPool,
                                                                 RegistryPath->MaximumLength,
                                                                 FM_TAG_REGISTRY_DATA);
    if (!DriverData.ServiceKey.Buffer) return STATUS_INSUFFICIENT_RESOURCES;
    RtlCopyUnicodeString(&DriverData.ServiceKey, RegistryPath);
 
    /* Do some initialization */
    ExInitializeFastMutex(&DriverData.FilterAttachLock);
 
    /* Create the main filter manager device object */
    Status = IoCreateDevice(DriverObject,
                            0,
                            &DeviceName,
                            FILE_DEVICE_DISK_FILE_SYSTEM,
                            FILE_DEVICE_SECURE_OPEN,
                            FALSE,
                            &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("fltmgr IoCreateDevice failed.  Status = %X\n", Status);
        goto Cleanup;
    }
 
    /* Store a global reference so we can access from callbacks */
    DriverData.DeviceObject = DeviceObject;
 
    /* Generate the symbolic link name */
    RtlInitUnicodeString(&SymLink, L"\\??\\"DRIVER_NAME);
    Status = IoCreateSymbolicLink(&SymLink, &DeviceName);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Create the callbacks for the dispatch table, FastIo and FS callbacks */
    Status = SetupDispatchAndCallbacksTables(DriverObject);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Initialize the comms objects */
    Status = FltpSetupCommunicationObjects(DriverObject);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Register for notifications when a new file system is loaded. This also enumerates any existing file systems */
    Status = IoRegisterFsRegistrationChange(DriverObject, FltpFsNotification);
    FLT_ASSERT(Status != STATUS_DEVICE_ALREADY_ATTACHED); // Windows checks for this, I'm not sure how it can happen. Needs investigation??
    if (!NT_SUCCESS(Status))  goto Cleanup;
 
    InitializeListHead(&FilterList);
    ExInitializeResourceLite(&FilterListLock);
 
    /* IoRegisterFsRegistrationChange isn't notified about the raw  file systems, so we attach to them manually */
    RtlInitUnicodeString(&ObjectName, L"\\Device\\RawDisk");
    Status = IoGetDeviceObjectPointer(&ObjectName,
                                      FILE_READ_ATTRIBUTES,
                                      &RawFileObject,
                                      &RawDeviceObject);
    if (NT_SUCCESS(Status))
    {
        FltpFsNotification(RawDeviceObject, TRUE);
        ObDereferenceObject(RawFileObject);
    }
 
    RtlInitUnicodeString(&ObjectName, L"\\Device\\RawCdRom");
    Status = IoGetDeviceObjectPointer(&ObjectName,
                                      FILE_READ_ATTRIBUTES,
                                      &RawFileObject,
                                      &RawDeviceObject);
    if (NT_SUCCESS(Status))
    {
        FltpFsNotification(RawDeviceObject, TRUE);
        ObDereferenceObject(RawFileObject);
    }
 
    /* We're done, clear the initializing flag */
    ClearFlag(DeviceObject->Flags, DO_DEVICE_INITIALIZING);
    Status = STATUS_SUCCESS;
 
Cleanup:
 
    if (!NT_SUCCESS(Status))
    {
        if (DriverData.FastIoDispatch)
        {
            DriverObject->FastIoDispatch = NULL;
            ExFreePoolWithTag(DriverData.FastIoDispatch, FM_TAG_DISPATCH_TABLE);
        }
 
        IoDeleteSymbolicLink(&SymLink);
 
        if (DeviceObject)
            IoDeleteDevice(DeviceObject);
 
        if (DriverData.ServiceKey.Buffer)
            ExFreePoolWithTag(DriverData.ServiceKey.Buffer, FM_TAG_REGISTRY_DATA);
    }
 
    return Status;
}

◆ DECLARE_CONST_UNICODE_STRING()

DECLARE_CONST_UNICODE_STRING	(	UcxKernelOnlySddl	,
		L"D:P"
	)

◆ DPRINT()

DPRINT	(	"UCX	loaded,
		control device %wZ\n"	,
		&UcxDriver.	ControlDeviceName
	)

◆ if()

if ( ! NT_SUCCESSStatus )

Definition at line 148 of file driver.cpp.

    {
        DPRINT1("WdfDriverCreate failed 0x%lx\n", Status);
        return Status;
    }

◆ UcxEvtDriverUnload()

static VOID NTAPI UcxEvtDriverUnload ( _In_ WDFDRIVER Driver )

static

Definition at line 108 of file driver.cpp.

{
    UNREFERENCED_PARAMETER(Driver);
 
    PAGED_CODE();
 
    if (UcxDriver.ControlDevice != NULL)
    {
        WdfObjectDelete(UcxDriver.ControlDevice);
        UcxDriver.ControlDevice = NULL;
    }
}

◆ UcxReadUsbFlags()

UcxReadUsbFlags ( )

Variable Documentation

◆ Config

WDF_DRIVER_CONFIG_INIT& Config

Definition at line 131 of file driver.cpp.

◆ ControllerCount

UcxDriver ControllerCount = 0

Definition at line 140 of file driver.cpp.

◆ DriverEntry

DRIVER_INITIALIZE DriverEntry

Definition at line 15 of file driver.cpp.

◆ DriverInitFlags

Config DriverInitFlags = WdfDriverInitNonPnpDriver

Definition at line 143 of file driver.cpp.

◆ DriverPoolTag

Config DriverPoolTag = UCX_POOL_TAG

Definition at line 145 of file driver.cpp.

◆ EvtDriverUnload

Config EvtDriverUnload = UcxEvtDriverUnload

Definition at line 144 of file driver.cpp.

◆ IoTryQueueWorkItem

UcxDriver IoTryQueueWorkItem

Initial value:

=

(PFN_UCX_IO_TRY_QUEUE_WORKITEM)MmGetSystemRoutineAddress((PUNICODE_STRING)&TryQueueName)

MmGetSystemRoutineAddress

PVOID NTAPI MmGetSystemRoutineAddress(IN PUNICODE_STRING SystemRoutineName)

Definition: sysldr.c:3672

PFN_UCX_IO_TRY_QUEUE_WORKITEM

BOOLEAN(NTAPI * PFN_UCX_IO_TRY_QUEUE_WORKITEM)(_Inout_ PIO_WORKITEM IoWorkItem, _In_ PIO_WORKITEM_ROUTINE_EX WorkerRoutine, _In_ WORK_QUEUE_TYPE QueueType, _In_opt_ PVOID Context)

Definition: ucxutil.h:134

Definition at line 170 of file driver.cpp.