swenum.c File Reference

#include "precomp.h"
#include <stdio.h>
#include <swenum.h>
#include <debug.h>

Include dependency graph for swenum.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Typedefs
typedef NTSTATUS(NTAPI *	PKSP_BUS_ENUM_CALLBACK) (IN PHANDLE hKey, IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DummyEntry, IN LPWSTR RootName, IN LPWSTR DirectoryName)

Functions
NTSTATUS	KspCreatePDO (IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DeviceEntry, OUT PDEVICE_OBJECT *OutDeviceObject)
NTSTATUS	KspRegisterDeviceAssociation (IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DeviceEntry, IN OUT PBUS_INSTANCE_ENTRY BusInstanceEntry)
VOID	KspRemoveDeviceAssociations (IN PBUS_DEVICE_ENTRY DeviceEntry)
NTSTATUS	KspEnumerateBusRegistryKeys (IN HANDLE hKey, IN LPWSTR ReferenceString, IN PKSP_BUS_ENUM_CALLBACK Callback, IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DeviceEntry)
NTSTATUS NTAPI	KspCreateDeviceAssociation (IN PHANDLE hKey, IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DeviceEntry, IN LPWSTR InterfaceString, IN LPWSTR ReferenceString)
NTSTATUS NTAPI	KspCreateDeviceReference (IN PHANDLE hKey, IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DummyEntry, IN LPWSTR InterfaceId, IN LPWSTR DeviceId)
NTSTATUS NTAPI	KspCreateDeviceReferenceTrampoline (IN PHANDLE hKey, IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DummyEntry, IN LPWSTR DeviceCategory, IN LPWSTR ReferenceString)
NTSTATUS	KspOpenBusRegistryKey (IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, OUT PHANDLE hKey)
NTSTATUS	KspScanBus (IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension)
NTSTATUS NTAPI	KspBusQueryReferenceString (IN PVOID Context, IN OUT PWCHAR *String)
VOID NTAPI	KspBusDeviceReference (IN PVOID Context)
VOID NTAPI	KspBusDeviceDereference (IN PVOID Context)
VOID NTAPI	KspBusReferenceDeviceObject (IN PVOID Context)
VOID NTAPI	KspBusDereferenceDeviceObject (IN PVOID Context)
NTSTATUS	KspQueryBusDeviceInterface (IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension, IN PIRP Irp)
NTSTATUS	KspEnableBusDeviceInterface (PBUS_DEVICE_ENTRY DeviceEntry, BOOLEAN bEnable)
NTSTATUS	KspDoReparseForIrp (PIRP Irp, PBUS_DEVICE_ENTRY DeviceEntry)
VOID	KspCompletePendingIrps (IN PBUS_DEVICE_ENTRY DeviceEntry, IN OUT NTSTATUS ResultCode)
NTSTATUS	KspStartBusDevice (IN PDEVICE_OBJECT DeviceObject, IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension, IN PIRP Irp)
NTSTATUS	KspQueryBusDeviceCapabilities (IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension, IN PIRP Irp)
NTSTATUS	KspQueryBusInformation (IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension, IN PIRP Irp)
NTSTATUS	KspQueryBusDevicePnpState (IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension, IN PIRP Irp)
NTSTATUS	KspQueryId (IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension, IN PIRP Irp)
NTSTATUS	KspInstallInterface (IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PSWENUM_INSTALL_INTERFACE InstallInterface)
VOID NTAPI	KspInstallBusEnumInterface (IN PVOID Ctx)
VOID NTAPI	KspBusWorkerRoutine (IN PVOID Parameter)
VOID NTAPI	KspBusDpcRoutine (IN PKDPC Dpc, IN PVOID DeferredContext OPTIONAL, IN PVOID SystemArgument1 OPTIONAL, IN PVOID SystemArgument2 OPTIONAL)
VOID NTAPI	KspRemoveBusInterface (PVOID Ctx)
NTSTATUS	KspQueryBusRelations (IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PIRP Irp)
KSDDKAPI NTSTATUS NTAPI	KsGetBusEnumIdentifier (IN PIRP Irp)
KSDDKAPI NTSTATUS NTAPI	KsGetBusEnumParentFDOFromChildPDO (IN PDEVICE_OBJECT DeviceObject, OUT PDEVICE_OBJECT *FunctionalDeviceObject)
KSDDKAPI NTSTATUS NTAPI	KsCreateBusEnumObject (IN PWCHAR BusIdentifier, IN PDEVICE_OBJECT BusDeviceObject, IN PDEVICE_OBJECT PhysicalDeviceObject, IN PDEVICE_OBJECT PnpDeviceObject OPTIONAL, IN REFGUID InterfaceGuid OPTIONAL, IN PWCHAR ServiceRelativePath OPTIONAL)
KSDDKAPI NTSTATUS NTAPI	KsGetBusEnumPnpDeviceObject (IN PDEVICE_OBJECT DeviceObject, IN PDEVICE_OBJECT *PnpDeviceObject)
KSDDKAPI NTSTATUS NTAPI	KsInstallBusEnumInterface (PIRP Irp)
KSDDKAPI NTSTATUS NTAPI	KsIsBusEnumChildDevice (IN PDEVICE_OBJECT DeviceObject, OUT PBOOLEAN ChildDevice)
KSDDKAPI NTSTATUS NTAPI	KsServiceBusEnumCreateRequest (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
KSDDKAPI NTSTATUS NTAPI	KsServiceBusEnumPnpRequest (IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
KSDDKAPI NTSTATUS NTAPI	KsRemoveBusEnumInterface (IN PIRP Irp)

Variables
LONG	KsDeviceCount = 0

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 14 of file swenum.c.

Typedef Documentation

PKSP_BUS_ENUM_CALLBACK

typedef NTSTATUS(NTAPI * PKSP_BUS_ENUM_CALLBACK) (IN PHANDLE hKey, IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DummyEntry, IN LPWSTR RootName, IN LPWSTR DirectoryName)

Definition at line 19 of file swenum.c.

Function Documentation

KsCreateBusEnumObject()

KSDDKAPI NTSTATUS NTAPI KsCreateBusEnumObject	(	IN PWCHAR	BusIdentifier,
		IN PDEVICE_OBJECT	BusDeviceObject,
		IN PDEVICE_OBJECT	PhysicalDeviceObject,
		IN PDEVICE_OBJECT PnpDeviceObject	OPTIONAL,
		IN REFGUID InterfaceGuid	OPTIONAL,
		IN PWCHAR ServiceRelativePath	OPTIONAL
	)

Definition at line 1521 of file swenum.c.

{
    SIZE_T Length;
    NTSTATUS Status = STATUS_SUCCESS;
    UNICODE_STRING ServiceKeyPath = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Services\\");
    PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
    PDEV_EXTENSION DeviceExtension;
    PBUS_DEVICE_ENTRY DeviceEntry;
    PLIST_ENTRY Entry;
    KIRQL OldLevel;
 
    DPRINT1("KsCreateBusEnumObject %S BusDeviceObject %p\n", ServiceRelativePath, BusDeviceObject);
 
    /* calculate sizeof bus enum device extension */
    Length = wcslen(BusIdentifier) * sizeof(WCHAR);
    Length += sizeof(BUS_ENUM_DEVICE_EXTENSION);
 
    BusDeviceExtension = AllocateItem(NonPagedPool, Length);
    if (!BusDeviceExtension)
    {
        /* not enough memory */
 
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* get device extension */
    DeviceExtension = (PDEV_EXTENSION)BusDeviceObject->DeviceExtension;
 
    /* store bus device extension */
    DeviceExtension->Ext = (PCOMMON_DEVICE_EXTENSION)BusDeviceExtension;
 
    DPRINT("DeviceExtension %p BusDeviceExtension %p\n", DeviceExtension, DeviceExtension->Ext);
 
 
    /* zero device extension */
    RtlZeroMemory(BusDeviceExtension, sizeof(BUS_ENUM_DEVICE_EXTENSION));
 
    /* initialize bus device extension */
    wcscpy(BusDeviceExtension->BusIdentifier, BusIdentifier);
 
    /* allocate service path string */
    Length = ServiceKeyPath.MaximumLength;
    Length += BusDeviceObject->DriverObject->DriverExtension->ServiceKeyName.MaximumLength;
 
    if (ServiceRelativePath)
    {
        /* relative path for devices */
        Length += (wcslen(ServiceRelativePath) + 2) * sizeof(WCHAR);
    }
 
    BusDeviceExtension->ServicePath.Length = 0;
    BusDeviceExtension->ServicePath.MaximumLength = (USHORT)Length;
    BusDeviceExtension->ServicePath.Buffer = AllocateItem(NonPagedPool, Length);
 
    if (!BusDeviceExtension->ServicePath.Buffer)
    {
        /* not enough memory */
        FreeItem(BusDeviceExtension);
 
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlAppendUnicodeStringToString(&BusDeviceExtension->ServicePath, &ServiceKeyPath);
    RtlAppendUnicodeStringToString(&BusDeviceExtension->ServicePath, &BusDeviceObject->DriverObject->DriverExtension->ServiceKeyName);
 
    if (ServiceRelativePath)
    {
        RtlAppendUnicodeToString(&BusDeviceExtension->ServicePath, L"\\");
        RtlAppendUnicodeToString(&BusDeviceExtension->ServicePath, ServiceRelativePath);
    }
 
    if (InterfaceGuid)
    {
        /* register an device interface */
        Status = IoRegisterDeviceInterface(PhysicalDeviceObject, InterfaceGuid, NULL, &BusDeviceExtension->DeviceInterfaceLink);
 
        /* check for success */
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("IoRegisterDeviceInterface failed Status %lx\n", Status);
            FreeItem(BusDeviceExtension->ServicePath.Buffer);
            FreeItem(BusDeviceExtension);
            return Status;
        }
 
        /* now enable device interface */
        Status = IoSetDeviceInterfaceState(&BusDeviceExtension->DeviceInterfaceLink, TRUE);
 
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("IoSetDeviceInterfaceState failed Status %lx\n", Status);
            FreeItem(BusDeviceExtension->ServicePath.Buffer);
            FreeItem(BusDeviceExtension);
            return Status;
        }
    }
 
    /* initialize common device extension */
    BusDeviceExtension->Common.BusDeviceExtension = NULL;
    BusDeviceExtension->Common.DeviceObjectReferenceCount = 1;
    BusDeviceExtension->Common.DeviceReferenceCount = 1;
    BusDeviceExtension->Common.IsBus = TRUE;
    InitializeListHead(&BusDeviceExtension->Common.Entry);
 
    /* store device objects */
    BusDeviceExtension->BusDeviceObject = BusDeviceObject;
    BusDeviceExtension->PhysicalDeviceObject = PhysicalDeviceObject;
 
    /* initialize lock */
    KeInitializeSpinLock(&BusDeviceExtension->Lock);
 
    /* initialize timer */
    KeInitializeTimer(&BusDeviceExtension->Timer);
 
    /* initialize dpc */
    KeInitializeDpc(&BusDeviceExtension->Dpc, KspBusDpcRoutine, (PVOID)BusDeviceExtension);
 
    /* initialize event */
    KeInitializeEvent(&BusDeviceExtension->Event, SynchronizationEvent, FALSE);
 
    /* initialize work item */
    ExInitializeWorkItem(&BusDeviceExtension->WorkItem, KspBusWorkerRoutine, (PVOID)BusDeviceExtension);
 
    if (!PnpDeviceObject)
    {
        /* attach device */
        BusDeviceExtension->PnpDeviceObject = IoAttachDeviceToDeviceStack(BusDeviceObject, PhysicalDeviceObject);
 
        if (!BusDeviceExtension->PnpDeviceObject)
        {
            /* failed to attach device */
            DPRINT1("IoAttachDeviceToDeviceStack failed with %x\n", Status);
            if (BusDeviceExtension->DeviceInterfaceLink.Buffer)
            {
                IoSetDeviceInterfaceState(&BusDeviceExtension->DeviceInterfaceLink, FALSE);
                RtlFreeUnicodeString(&BusDeviceExtension->DeviceInterfaceLink);
            }
 
            /* free device extension */
            FreeItem(BusDeviceExtension->ServicePath.Buffer);
            FreeItem(BusDeviceExtension);
 
            return STATUS_DEVICE_REMOVED;
        }
 
        /* mark device as attached */
        BusDeviceExtension->DeviceAttached = TRUE;
    }
    else
    {
        /* directly attach */
        BusDeviceExtension->PnpDeviceObject = PnpDeviceObject;
    }
 
    /* now scan the bus */
    Status = KspScanBus(BusDeviceExtension);
 
    /* check for success */
    if (!NT_SUCCESS(Status))
    {
        /* failed to scan bus */
        if (BusDeviceExtension->DeviceInterfaceLink.Buffer)
        {
            IoSetDeviceInterfaceState(&BusDeviceExtension->DeviceInterfaceLink, FALSE);
            RtlFreeUnicodeString(&BusDeviceExtension->DeviceInterfaceLink);
        }
 
        if (BusDeviceExtension->DeviceAttached)
        {
            /* detach device */
            IoDetachDevice(BusDeviceExtension->PnpDeviceObject);
        }
 
        /* free device extension */
        FreeItem(BusDeviceExtension->ServicePath.Buffer);
        FreeItem(BusDeviceExtension);
 
        return Status;
    }
 
    /* acquire device entry lock */
    KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
 
    /* now iterate all device entries */
    Entry = BusDeviceExtension->Common.Entry.Flink;
    while(Entry != &BusDeviceExtension->Common.Entry)
    {
        /* get device entry */
        DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
        if (!DeviceEntry->PDO)
        {
            /* release device entry lock */
            KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
 
            /* create pdo */
            Status = KspCreatePDO(BusDeviceExtension, DeviceEntry, &DeviceEntry->PDO);
 
            /* acquire device entry lock */
            KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
 
            /* done */
            break;
        }
        /* move to next entry */
        Entry = Entry->Flink;
    }
 
    /* release device entry lock */
    KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
 
 
    /* invalidate device relations */
    IoInvalidateDeviceRelations(BusDeviceExtension->PhysicalDeviceObject, BusRelations);
    DPRINT("KsCreateBusEnumObject Status %x\n", Status);
    /* done */
    return Status;
}

Referenced by SwAddDevice().

KsGetBusEnumIdentifier()

KSDDKAPI NTSTATUS NTAPI KsGetBusEnumIdentifier

(

IN PIRP

Irp

)

Definition at line 1403 of file swenum.c.

{
    PDEV_EXTENSION DeviceExtension;
    PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
    PIO_STACK_LOCATION IoStack;
    SIZE_T Length;
    NTSTATUS Status;
    LPWSTR Buffer;
 
    DPRINT("KsGetBusEnumIdentifier\n");
 
    /* get stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* sanity checks */
    ASSERT(IoStack->DeviceObject);
    ASSERT(IoStack->DeviceObject->DeviceExtension);
 
    /* get device extension */
    DeviceExtension = (PDEV_EXTENSION)IoStack->DeviceObject->DeviceExtension;
 
    /* get bus device extension */
    BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
 
    /* sanity checks */
    ASSERT(BusDeviceExtension);
    ASSERT(BusDeviceExtension->Common.IsBus);
 
    if (!BusDeviceExtension)
    {
        /* invalid parameter */
        return STATUS_INVALID_PARAMETER;
    }
 
    /* get length */
    Length = (wcslen(BusDeviceExtension->BusIdentifier)+1) * sizeof(WCHAR);
 
    /* is there an output buffer provided */
    if (IoStack->Parameters.DeviceIoControl.InputBufferLength)
    {
        if (Length > IoStack->Parameters.DeviceIoControl.InputBufferLength)
        {
            /* buffer is too small */
            return STATUS_BUFFER_TOO_SMALL;
        }
 
        /* now allocate buffer */
        Buffer = AllocateItem(NonPagedPool, Length);
        if (!Buffer)
        {
            /* no memory */
            Status = STATUS_INSUFFICIENT_RESOURCES;
        }
        else
        {
            /* copy bus identifier */
            wcscpy(Buffer, BusDeviceExtension->BusIdentifier);
 
            /* store buffer */
            Irp->AssociatedIrp.SystemBuffer = Buffer;
 
            /* set flag that buffer gets copied back */
            Irp->Flags |= IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER | IRP_INPUT_OPERATION;
 
            /* done */
            Status = STATUS_SUCCESS;
        }
    }
    else
    {
        /* no buffer provided */
        Status = STATUS_BUFFER_OVERFLOW;
    }
 
    /* done */
    Irp->IoStatus.Status = Status;
    return Status;
}

Referenced by SwDispatchDeviceControl().

KsGetBusEnumParentFDOFromChildPDO()

KSDDKAPI NTSTATUS NTAPI KsGetBusEnumParentFDOFromChildPDO	(	IN PDEVICE_OBJECT	DeviceObject,
		OUT PDEVICE_OBJECT *	FunctionalDeviceObject
	)

Definition at line 1489 of file swenum.c.

{
    PDEV_EXTENSION DeviceExtension;
 
    DPRINT("KsGetBusEnumParentFDOFromChildPDO\n");
 
    /* get device extension */
    DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
 
    /* check if this is child pdo */
    if (DeviceExtension->Ext->IsBus == FALSE)
    {
        /* return bus device object */
        *FunctionalDeviceObject = DeviceExtension->Ext->BusDeviceExtension->BusDeviceObject;
 
        /* done */
        return STATUS_SUCCESS;
    }
 
    /* invalid parameter */
    return STATUS_INVALID_PARAMETER;
}

KsGetBusEnumPnpDeviceObject()

KSDDKAPI NTSTATUS NTAPI KsGetBusEnumPnpDeviceObject	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PDEVICE_OBJECT *	PnpDeviceObject
	)

Definition at line 1751 of file swenum.c.

{
    PDEV_EXTENSION DeviceExtension;
    PCOMMON_DEVICE_EXTENSION CommonDeviceExtension;
    PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
 
    DPRINT("KsGetBusEnumPnpDeviceObject\n");
 
    if (!DeviceObject->DeviceExtension)
    {
        /* invalid parameter */
        return STATUS_INVALID_PARAMETER;
    }
 
    /* get device extension */
    DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
 
    /* get common device extension */
    CommonDeviceExtension = DeviceExtension->Ext;
 
    if (!CommonDeviceExtension)
    {
        /* invalid parameter */
        return STATUS_INVALID_PARAMETER;
    }
 
    if (!CommonDeviceExtension->IsBus)
    {
        /* getting pnp device object is only supported for software bus device object */
       return STATUS_INVALID_PARAMETER;
    }
 
    /* sanity checks */
    ASSERT(CommonDeviceExtension);
    ASSERT(CommonDeviceExtension->IsBus);
 
    /* cast to bus device extension */
    BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)CommonDeviceExtension;
 
    /* store result */
    *PnpDeviceObject = BusDeviceExtension->PnpDeviceObject;
 
    /* done */
    return STATUS_SUCCESS;
}

Referenced by SwDispatchPnp(), SwDispatchPower(), and SwDispatchSystemControl().

KsInstallBusEnumInterface()

KSDDKAPI NTSTATUS NTAPI KsInstallBusEnumInterface

(

PIRP

Irp

)

Definition at line 1805 of file swenum.c.

{
    BUS_INSTALL_ENUM_CONTEXT Context;
    KPROCESSOR_MODE Mode;
    LUID luid;
    PIO_STACK_LOCATION IoStack;
    PDEV_EXTENSION DeviceExtension;
    PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
 
    DPRINT("KsInstallBusEnumInterface\n");
 
    /* get current irp stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* get previous mode */
    Mode = ExGetPreviousMode();
 
    /* convert to luid */
    luid = RtlConvertUlongToLuid(SE_LOAD_DRIVER_PRIVILEGE);
 
    /* perform access check */
    if (!SeSinglePrivilegeCheck(luid, Mode))
    {
        /* FIXME insufficient privileges */
        //return STATUS_PRIVILEGE_NOT_HELD;
    }
 
    /* get device extension */
    DeviceExtension = (PDEV_EXTENSION)IoStack->DeviceObject->DeviceExtension;
 
    /* get bus device extension */
    BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
 
 
    /* initialize context */
    Context.Irp = Irp;
    KeInitializeEvent(&Context.Event, NotificationEvent, FALSE);
    Context.BusDeviceExtension = BusDeviceExtension;
    ExInitializeWorkItem(&Context.WorkItem, KspInstallBusEnumInterface, (PVOID)&Context);
 
    /* queue the work item */
    ExQueueWorkItem(&Context.WorkItem, DelayedWorkQueue);
    /* wait for completion */
    KeWaitForSingleObject(&Context.Event, Executive, KernelMode, FALSE, NULL);
 
    /* store result */
    Irp->IoStatus.Status = Context.Status;
 
    /* done */
    return Context.Status;
}

Referenced by SwDispatchDeviceControl().

KsIsBusEnumChildDevice()

KSDDKAPI NTSTATUS NTAPI KsIsBusEnumChildDevice	(	IN PDEVICE_OBJECT	DeviceObject,
		OUT PBOOLEAN	ChildDevice
	)

Definition at line 1864 of file swenum.c.

{
    PDEV_EXTENSION DeviceExtension;
    PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
 
    DPRINT("KsIsBusEnumChildDevice %p\n", DeviceObject);
 
    /* get device extension */
    DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
 
    /* get bus device extension */
    BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
 
    if (!BusDeviceExtension)
    {
        /* not a bus device */
        return STATUS_INVALID_PARAMETER;
    }
 
    /* store result */
    *ChildDevice = (BusDeviceExtension->Common.IsBus == FALSE);
 
    return STATUS_SUCCESS;
}

Referenced by SwDispatchCreate(), SwDispatchPnp(), SwDispatchPower(), and SwDispatchSystemControl().

KspBusDereferenceDeviceObject()

VOID NTAPI KspBusDereferenceDeviceObject

(

IN PVOID

Context

)

Definition at line 598 of file swenum.c.

{
    PCOMMON_DEVICE_EXTENSION ChildDeviceExtension = (PCOMMON_DEVICE_EXTENSION)Context;
 
    /* reference count */
    InterlockedDecrement((PLONG)&ChildDeviceExtension->DeviceObjectReferenceCount);
}

Referenced by KspQueryBusDeviceInterface().

KspBusDeviceDereference()

VOID NTAPI KspBusDeviceDereference

(

IN PVOID

Context

)

Definition at line 576 of file swenum.c.

{
    PCOMMON_DEVICE_EXTENSION ChildDeviceExtension = (PCOMMON_DEVICE_EXTENSION)Context;
 
    /* reference count */
    InterlockedDecrement((PLONG)&ChildDeviceExtension->DeviceReferenceCount);
}

Referenced by KspQueryBusDeviceInterface().

KspBusDeviceReference()

VOID NTAPI KspBusDeviceReference

(

IN PVOID

Context

)

Definition at line 565 of file swenum.c.

{
    PCOMMON_DEVICE_EXTENSION ChildDeviceExtension = (PCOMMON_DEVICE_EXTENSION)Context;
 
    /* reference count */
    InterlockedIncrement((PLONG)&ChildDeviceExtension->DeviceReferenceCount);
}

Referenced by KspQueryBusDeviceInterface().

KspBusDpcRoutine()

VOID NTAPI KspBusDpcRoutine	(	IN PKDPC	Dpc,
		IN PVOID DeferredContext	OPTIONAL,
		IN PVOID SystemArgument1	OPTIONAL,
		IN PVOID SystemArgument2	OPTIONAL
	)

Definition at line 1275 of file swenum.c.

{
    /* get device extension */
    PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeferredContext;
 
    /* queue the item */
    ExQueueWorkItem(&BusDeviceExtension->WorkItem, DelayedWorkQueue);
}

Referenced by KsCreateBusEnumObject().

KspBusQueryReferenceString()

NTSTATUS NTAPI KspBusQueryReferenceString	(	IN PVOID	Context,
		IN OUT PWCHAR *	String
	)

Definition at line 529 of file swenum.c.

{
    LPWSTR Name;
    SIZE_T Length;
    PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)Context;
 
    /* sanity checks */
    ASSERT(BusDeviceExtension);
    ASSERT(BusDeviceExtension->BusIdentifier);
 
    /* calculate length */
    Length = wcslen(BusDeviceExtension->BusIdentifier) + 1;
 
    /* allocate buffer */
    Name = AllocateItem(PagedPool, Length * sizeof(WCHAR));
 
    if (!Name)
    {
        /* failed to allocate buffer */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* copy buffer */
    wcscpy(Name, BusDeviceExtension->BusIdentifier);
 
    /* store result */
    *String = Name;
 
    /* done */
    return STATUS_SUCCESS;
}

Referenced by KspQueryBusDeviceInterface().

KspBusReferenceDeviceObject()

VOID NTAPI KspBusReferenceDeviceObject

(

IN PVOID

Context

)

Definition at line 587 of file swenum.c.

{
    PCOMMON_DEVICE_EXTENSION ChildDeviceExtension = (PCOMMON_DEVICE_EXTENSION)Context;
 
    /* reference count */
    InterlockedIncrement((PLONG)&ChildDeviceExtension->DeviceObjectReferenceCount);
}

Referenced by KspQueryBusDeviceInterface().

KspBusWorkerRoutine()

VOID NTAPI KspBusWorkerRoutine

(

IN PVOID

Parameter

)

Definition at line 1179 of file swenum.c.

{
    PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
    PBUS_DEVICE_ENTRY DeviceEntry;
    PLIST_ENTRY Entry;
    LARGE_INTEGER Time, Diff;
    BOOLEAN DoInvalidate = FALSE;
    KIRQL OldLevel;
 
    /* get device extension */
    BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)Parameter;
 
    /* acquire lock */
    KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
 
    /* get current time */
    KeQueryTickCount(&Time);
 
    /* enumerate all device entries */
    Entry = BusDeviceExtension->Common.Entry.Flink;
    while(Entry != &BusDeviceExtension->Common.Entry)
    {
        /* get offset to device entry */
        DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
 
        /* sanity check */
        ASSERT(DeviceEntry);
 
        //DPRINT1("DeviceEntry %p PDO %p State %x\n", DeviceEntry, DeviceEntry->PDO, DeviceEntry->DeviceState);
 
        if (DeviceEntry->PDO)
        {
            if (DeviceEntry->DeviceState == NotStarted)
            {
                Diff.QuadPart = (Time.QuadPart - DeviceEntry->TimeCreated.QuadPart) * KeQueryTimeIncrement();
 
                /* wait for 15 sec */
                if (Diff.QuadPart > Int32x32To64(15000, 10000))
                {
                     /* release spin lock */
                     KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
 
                     DPRINT1("DeviceID %S Instance %S TimeCreated %I64u Now %I64u Diff %I64u hung\n",
                        DeviceEntry->DeviceName,
                        DeviceEntry->Instance,
                        DeviceEntry->TimeCreated.QuadPart * KeQueryTimeIncrement(),
                        Time.QuadPart * KeQueryTimeIncrement(),
                        Diff.QuadPart);
 
                     /* deactivate interfaces */
                     //KspEnableBusDeviceInterface(DeviceEntry, FALSE);
 
                     /* re-acquire lock */
                     KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
 
                     /* pending remove device object */
                     DeviceEntry->DeviceState = StopPending;
 
                     /* perform invalidation */
                     DoInvalidate = TRUE;
                }
            }
            else if (DeviceEntry->DeviceState == Started)
            {
                /* release spin lock */
                KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
 
                /* found pending irps */
                KspCompletePendingIrps(DeviceEntry, STATUS_REPARSE);
 
                /* re-acquire lock */
                KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
            }
        }
 
 
        /* move to next */
        Entry = Entry->Flink;
    }
 
   /* release lock */
    KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
 
    if (DoInvalidate)
    {
        /* invalidate device relations */
        IoInvalidateDeviceRelations(BusDeviceExtension->PhysicalDeviceObject, BusRelations);
    }
 
    Time.QuadPart = Int32x32To64(5000, -10000);
    KeSetTimer(&BusDeviceExtension->Timer, Time, &BusDeviceExtension->Dpc);
}

Referenced by KsCreateBusEnumObject().

KspCompletePendingIrps()

VOID KspCompletePendingIrps	(	IN PBUS_DEVICE_ENTRY	DeviceEntry,
		IN OUT NTSTATUS	ResultCode
	)

Definition at line 718 of file swenum.c.

{
    PLIST_ENTRY Entry;
    PIRP Irp;
    NTSTATUS Status;
 
    /* go through list */
    while(!IsListEmpty(&DeviceEntry->IrpPendingList))
    {
        /* get first entry */
        Entry = RemoveHeadList(&DeviceEntry->IrpPendingList);
 
        /* get irp */
        Irp = (PIRP)CONTAINING_RECORD(Entry, IRP, Tail.Overlay.ListEntry);
 
        if (ResultCode == STATUS_REPARSE)
        {
            /* construct reparse information */
            Status = KspDoReparseForIrp(Irp, DeviceEntry);
        }
        else
        {
            /* use default code */
            Status = ResultCode;
        }
 
        /* store result code */
        Irp->IoStatus.Status = Status;
 
        DPRINT("Completing IRP %p Status %x\n", Irp, Status);
 
        /* complete the request */
        CompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
}

Referenced by KspBusWorkerRoutine(), and KsServiceBusEnumPnpRequest().

KspCreateDeviceAssociation()

NTSTATUS NTAPI KspCreateDeviceAssociation	(	IN PHANDLE	hKey,
		IN PBUS_ENUM_DEVICE_EXTENSION	BusDeviceExtension,
		IN PBUS_DEVICE_ENTRY	DeviceEntry,
		IN LPWSTR	InterfaceString,
		IN LPWSTR	ReferenceString
	)

Definition at line 258 of file swenum.c.

{
    GUID InterfaceGUID;
    NTSTATUS Status;
    PLIST_ENTRY Entry;
    PBUS_INSTANCE_ENTRY CurEntry;
    UNICODE_STRING DeviceName;
 
    /* initialize interface string */
    RtlInitUnicodeString(&DeviceName, InterfaceString);
 
    /* first convert device name to guid */
    RtlGUIDFromString(&DeviceName, &InterfaceGUID);
 
    /* check if the device is already present */
    Entry = DeviceEntry->DeviceInterfaceList.Flink;
    DPRINT("KspCreateDeviceAssociation ReferenceString %S\n", ReferenceString);
    DPRINT("KspCreateDeviceAssociation InterfaceString %S\n", InterfaceString);
 
    while(Entry != &DeviceEntry->DeviceInterfaceList)
    {
         /* get offset */
         CurEntry = (PBUS_INSTANCE_ENTRY)CONTAINING_RECORD(Entry, BUS_INSTANCE_ENTRY, Entry);
 
         if (IsEqualGUIDAligned(&CurEntry->InterfaceGuid, &InterfaceGUID))
         {
             /* entry already exists */
             return STATUS_SUCCESS;
         }
 
         /* move to next entry */
         Entry = Entry->Flink;
    }
 
    /* time to allocate new entry */
    CurEntry = (PBUS_INSTANCE_ENTRY)AllocateItem(NonPagedPool, sizeof(BUS_INSTANCE_ENTRY));
 
    if (!CurEntry)
    {
        /* no memory */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* store guid */
    RtlMoveMemory(&CurEntry->InterfaceGuid, &InterfaceGUID, sizeof(GUID));
 
    /* now register the association */
    Status = KspRegisterDeviceAssociation(BusDeviceExtension, DeviceEntry, CurEntry);
 
    /* check for success */
    if (NT_SUCCESS(Status))
    {
        /* store entry */
        InsertTailList(&DeviceEntry->DeviceInterfaceList, &CurEntry->Entry);
    }
    else
    {
        /* failed to associated device */
        FreeItem(CurEntry);
    }
 
     /* done */
     return Status;
}

Referenced by KspCreateDeviceReference().

KspCreateDeviceReference()

NTSTATUS NTAPI KspCreateDeviceReference	(	IN PHANDLE	hKey,
		IN PBUS_ENUM_DEVICE_EXTENSION	BusDeviceExtension,
		IN PBUS_DEVICE_ENTRY	DummyEntry,
		IN LPWSTR	InterfaceId,
		IN LPWSTR	DeviceId
	)

Definition at line 330 of file swenum.c.

{
    LPWSTR DeviceName;
    SIZE_T Length;
    PLIST_ENTRY Entry;
    PBUS_DEVICE_ENTRY DeviceEntry = NULL; /* GCC warning */
    BOOLEAN ItemExists = FALSE;
    UNICODE_STRING String;
    NTSTATUS Status;
    KIRQL OldLevel;
 
    /* first construct device name & reference guid */
    Length = wcslen(DeviceId) + wcslen(InterfaceId);
 
    /* append '&' and null byte */
    Length += 2;
 
    /* allocate device name */
    DeviceName = AllocateItem(NonPagedPool, Length * sizeof(WCHAR));
 
    if (!DeviceName)
    {
        /* not enough memory */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* construct device name */
    wcscpy(DeviceName, DeviceId);
    wcscat(DeviceName, L"&");
    wcscat(DeviceName, InterfaceId);
 
    /* scan list and check if it is already present */
    Entry = BusDeviceExtension->Common.Entry.Flink;
 
    while(Entry != &BusDeviceExtension->Common.Entry)
    {
        /* get real offset */
        DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
 
        /* check if name matches */
        if (!wcsicmp(DeviceEntry->DeviceName, DeviceName))
        {
            /* item already exists */
            ItemExists = TRUE;
            break;
        }
 
        /* move to next entry */
        Entry = Entry->Flink;
    }
 
    if (!ItemExists)
    {
        /* allocate new device entry */
        DeviceEntry = AllocateItem(NonPagedPool, sizeof(BUS_DEVICE_ENTRY));
        if (!DeviceEntry)
        {
            /* no memory */
            FreeItem(DeviceName);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        /* initialize device entry */
        InitializeListHead(&DeviceEntry->DeviceInterfaceList);
        InitializeListHead(&DeviceEntry->IrpPendingList);
 
        /* copy device guid */
        RtlInitUnicodeString(&String, DeviceId);
        RtlGUIDFromString(&String, &DeviceEntry->DeviceGuid);
 
        /* copy device names */
        DeviceEntry->DeviceName = DeviceName;
        DeviceEntry->Instance = (DeviceName + wcslen(DeviceId) + 1);
 
        /* copy name */
        DeviceEntry->BusId = AllocateItem(NonPagedPool, (wcslen(DeviceId) + 1) * sizeof(WCHAR));
        if (!DeviceEntry->BusId)
        {
            /* no memory */
            FreeItem(DeviceName);
            FreeItem(DeviceEntry);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        wcscpy(DeviceEntry->BusId, DeviceId);
    }
 
    /* now enumerate the interfaces */
    Status = KspEnumerateBusRegistryKeys(hKey, InterfaceId, KspCreateDeviceAssociation, BusDeviceExtension, DeviceEntry);
 
    /* check if list is empty */
    if (IsListEmpty(&DeviceEntry->DeviceInterfaceList))
    {
        /* invalid device settings */
        FreeItem(DeviceEntry->BusId);
        FreeItem(DeviceEntry->DeviceName);
        FreeItem(DeviceEntry);
 
        ASSERT(ItemExists == FALSE);
 
        return STATUS_INVALID_DEVICE_STATE;
    }
 
    /* check if enumeration failed */
    if (!NT_SUCCESS(Status))
    {
        /* failed */
        KspRemoveDeviceAssociations(DeviceEntry);
        FreeItem(DeviceEntry->BusId);
        FreeItem(DeviceEntry->DeviceName);
        FreeItem(DeviceEntry);
 
        ASSERT(ItemExists == FALSE);
 
        /* done */
        return Status;
    }
 
    if (!ItemExists)
    {
        /* acquire lock */
        KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
 
        /* successfully initialized entry */
        InsertTailList(&BusDeviceExtension->Common.Entry, &DeviceEntry->Entry);
 
        /* release lock */
        KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
    }
 
    /* done */
    return Status;
}

Referenced by KspCreateDeviceReferenceTrampoline().

KspCreateDeviceReferenceTrampoline()

NTSTATUS NTAPI KspCreateDeviceReferenceTrampoline	(	IN PHANDLE	hKey,
		IN PBUS_ENUM_DEVICE_EXTENSION	BusDeviceExtension,
		IN PBUS_DEVICE_ENTRY	DummyEntry,
		IN LPWSTR	DeviceCategory,
		IN LPWSTR	ReferenceString
	)

Definition at line 470 of file swenum.c.

{
    return KspEnumerateBusRegistryKeys(hKey, DeviceCategory, KspCreateDeviceReference, BusDeviceExtension, DummyEntry);
}

Referenced by KspScanBus().

KspCreatePDO()

NTSTATUS KspCreatePDO	(	IN PBUS_ENUM_DEVICE_EXTENSION	BusDeviceExtension,
		IN PBUS_DEVICE_ENTRY	DeviceEntry,
		OUT PDEVICE_OBJECT *	OutDeviceObject
	)

Definition at line 27 of file swenum.c.

{
    PDEVICE_OBJECT DeviceObject;
    WCHAR Buffer[50];
    ULONG CurDeviceId;
    UNICODE_STRING DeviceName;
    NTSTATUS Status;
    PCOMMON_DEVICE_EXTENSION DeviceExtension;
 
    /* increment device count */
    CurDeviceId = InterlockedIncrement(&KsDeviceCount);
 
    /* generate new device id */
    swprintf(Buffer, L"\\Device\\KSENUM%08x", CurDeviceId);
 
    /* initialize new device name */
    RtlInitUnicodeString(&DeviceName, Buffer);
 
    /* create new device object */
    Status = IoCreateDevice(BusDeviceExtension->BusDeviceObject->DriverObject, sizeof(PVOID), &DeviceName, FILE_DEVICE_UNKNOWN, 0, FALSE, &DeviceObject);
 
    /* check for success */
    if (!NT_SUCCESS(Status))
    {
        /* failed to create pdo */
        return Status;
    }
 
    /* now allocate device extension */
    DeviceExtension = (PCOMMON_DEVICE_EXTENSION)AllocateItem(NonPagedPool, sizeof(COMMON_DEVICE_EXTENSION));
    if (!DeviceExtension)
    {
        /* no memory */
        IoDeleteDevice(DeviceObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* store device extension */
    *((PVOID*)DeviceObject->DeviceExtension) = DeviceExtension;
 
    /* initialize device extension */
    DeviceExtension->IsBus = FALSE;
    DeviceExtension->DeviceObject = DeviceObject;
    DeviceExtension->DeviceEntry = DeviceEntry;
    DeviceExtension->BusDeviceExtension = BusDeviceExtension;
 
    /* not started yet*/
    DeviceEntry->DeviceState = NotStarted;
 
    /* get current time */
    KeQueryTickCount(&DeviceEntry->TimeCreated);
 
    /* setup flags */
    DeviceObject->Flags |= DO_POWER_PAGABLE;
    DeviceObject->Flags &= ~ DO_DEVICE_INITIALIZING;
    /* TODO: fire time when expired */
 
    *OutDeviceObject = DeviceObject;
 
    return STATUS_SUCCESS;
}

Referenced by KsCreateBusEnumObject(), KspInstallBusEnumInterface(), and KsServiceBusEnumCreateRequest().

KspDoReparseForIrp()

NTSTATUS KspDoReparseForIrp	(	PIRP	Irp,
		PBUS_DEVICE_ENTRY	DeviceEntry
	)

Definition at line 672 of file swenum.c.

{
    SIZE_T Length;
    LPWSTR Buffer;
    PIO_STACK_LOCATION IoStack;
 
    /* get stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* sanity checks */
    ASSERT(DeviceEntry->PDODeviceName);
    ASSERT(DeviceEntry->Instance);
    ASSERT(IoStack->FileObject);
    ASSERT(IoStack->FileObject->FileName.Buffer);
 
    /* calculate length */
    Length = wcslen(DeviceEntry->PDODeviceName);
    Length += wcslen(DeviceEntry->Instance);
 
    /* zero byte and '\\' */
    Length += 2;
 
    /* allocate buffer */
    Buffer = ExAllocatePoolWithTag(NonPagedPool, Length * sizeof(WCHAR), 'mNoI');
    if (!Buffer)
    {
        /* no resources */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* construct buffer */
    swprintf(Buffer, L"%s\\%s", DeviceEntry->PDODeviceName, DeviceEntry->Instance);
 
    /* free old buffer*/
    ExFreePoolWithTag(IoStack->FileObject->FileName.Buffer, 'mNoI');
 
    /* store new file name */
    RtlInitUnicodeString(&IoStack->FileObject->FileName, Buffer);
 
    /* done */
    return STATUS_REPARSE;
}

Referenced by KspCompletePendingIrps(), and KsServiceBusEnumCreateRequest().

KspEnableBusDeviceInterface()

NTSTATUS KspEnableBusDeviceInterface	(	PBUS_DEVICE_ENTRY	DeviceEntry,
		BOOLEAN	bEnable
	)

Definition at line 637 of file swenum.c.

{
    PLIST_ENTRY Entry;
    PBUS_INSTANCE_ENTRY InstanceEntry;
    NTSTATUS Status = STATUS_SUCCESS;
 
    /* enable now all interfaces */
    Entry = DeviceEntry->DeviceInterfaceList.Flink;
 
    while(Entry != &DeviceEntry->DeviceInterfaceList)
    {
        /* get bus instance entry */
        InstanceEntry = (PBUS_INSTANCE_ENTRY)CONTAINING_RECORD(Entry, BUS_INSTANCE_ENTRY, Entry);
        DPRINT("Enabling %u %wZ Irql %u\n", bEnable, &InstanceEntry->SymbolicLink, KeGetCurrentIrql());
 
        /* set interface state */
        Status = IoSetDeviceInterfaceState(&InstanceEntry->SymbolicLink, bEnable);
 
        if (!NT_SUCCESS(Status))
        {
            /* failed to set interface */
            break;
        }
 
        /* move to next entry */
        Entry = Entry->Flink;
    }
 
    /* done */
    return Status;
}

KspEnumerateBusRegistryKeys()

NTSTATUS KspEnumerateBusRegistryKeys	(	IN HANDLE	hKey,
		IN LPWSTR	ReferenceString,
		IN PKSP_BUS_ENUM_CALLBACK	Callback,
		IN PBUS_ENUM_DEVICE_EXTENSION	BusDeviceExtension,
		IN PBUS_DEVICE_ENTRY	DeviceEntry
	)

Definition at line 168 of file swenum.c.

{
    UNICODE_STRING String;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE hNewKey;
    NTSTATUS Status;
    ULONG ResultLength, Index, KeyInfoLength;
    KEY_FULL_INFORMATION KeyInformation;
    PKEY_BASIC_INFORMATION KeyInfo;
 
    /* initialize key name */
    RtlInitUnicodeString(&String, ReferenceString);
 
    /* initialize object attributes */
    InitializeObjectAttributes(&ObjectAttributes, &String, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hKey, NULL);
 
    /* open new key */
    Status = ZwOpenKey(&hNewKey, GENERIC_READ, &ObjectAttributes);
 
    /* check for success */
    if (!NT_SUCCESS(Status))
    {
        /* failed to open key */
 
        return Status;
    }
 
    /* query key stats */
    Status = ZwQueryKey(hNewKey, KeyFullInformation, &KeyInformation, sizeof(KeyInformation), &ResultLength);
 
    if (!NT_SUCCESS(Status))
    {
        /* close key */
        ZwClose(hNewKey);
 
        /* done */
        return Status;
    }
 
    /* calculate key info length */
    KeyInfoLength = KeyInformation.MaxNameLen + sizeof(KEY_BASIC_INFORMATION) + 1 * sizeof(WCHAR);
 
    /* allocate buffer */
    KeyInfo = (PKEY_BASIC_INFORMATION)AllocateItem(NonPagedPool, KeyInfoLength);
    if (!KeyInfo)
    {
 
        /* no memory */
        ZwClose(hNewKey);
 
        /* done */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* enumerate all keys */
    for(Index = 0; Index < KeyInformation.SubKeys; Index++)
    {
 
        /* query sub key */
        Status = ZwEnumerateKey(hNewKey, Index, KeyBasicInformation, (PVOID)KeyInfo, KeyInfoLength, &ResultLength);
 
        /* check for success */
        if (NT_SUCCESS(Status))
        {
            /* perform callback */
            Status = Callback(hNewKey, BusDeviceExtension, DeviceEntry, KeyInfo->Name, ReferenceString);
 
            /* should enumeration stop */
            if (!NT_SUCCESS(Status))
                break;
        }
    }
 
    /* free info buffer */
    FreeItem(KeyInfo);
 
    /* close key */
    ZwClose(hNewKey);
 
    /* done */
    return Status;
}

Referenced by KspCreateDeviceReference(), KspCreateDeviceReferenceTrampoline(), and KspScanBus().

KspInstallBusEnumInterface()

VOID NTAPI KspInstallBusEnumInterface

(

IN PVOID

Ctx

)

Definition at line 1077 of file swenum.c.

{
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
    PLIST_ENTRY Entry;
    PBUS_DEVICE_ENTRY DeviceEntry;
    PSWENUM_INSTALL_INTERFACE InstallInterface;
    KIRQL OldLevel;
    PBUS_INSTALL_ENUM_CONTEXT Context = (PBUS_INSTALL_ENUM_CONTEXT)Ctx;
 
    /* get current irp stack location */
    IoStack = IoGetCurrentIrpStackLocation(Context->Irp);
 
    /* get install request */
    InstallInterface = (PSWENUM_INSTALL_INTERFACE)Context->Irp->AssociatedIrp.SystemBuffer;
 
    /* sanity check */
    ASSERT(InstallInterface);
    ASSERT(Context->BusDeviceExtension);
 
    if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(SWENUM_INSTALL_INTERFACE))
    {
        /* buffer too small */
        Context->Status = STATUS_INVALID_PARAMETER;
 
        /* signal completion */
        KeSetEvent(&Context->Event, 0, FALSE);
 
        /* done */
        return;
    }
 
    /* FIXME locks */
 
    /* now install the interface */
    Status = KspInstallInterface(Context->BusDeviceExtension, InstallInterface);
    if (!NT_SUCCESS(Status))
    {
        /* failed to install interface */
        Context->Status = Status;
 
        /* signal completion */
        KeSetEvent(&Context->Event, 0, FALSE);
 
        /* done */
        return;
    }
 
    /* now scan the bus */
    Status = KspScanBus(Context->BusDeviceExtension);
    // FIXME: We may need to check for success here, and properly fail...
    ASSERT(NT_SUCCESS(Status));
 
    /* acquire device entry lock */
    KeAcquireSpinLock(&Context->BusDeviceExtension->Lock, &OldLevel);
 
    /* now iterate all device entries */
    ASSERT(!IsListEmpty(&Context->BusDeviceExtension->Common.Entry));
    Entry = Context->BusDeviceExtension->Common.Entry.Flink;
    while(Entry != &Context->BusDeviceExtension->Common.Entry)
    {
        /* get device entry */
        DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
        if (IsEqualGUIDAligned(&DeviceEntry->DeviceGuid, &InstallInterface->DeviceId))
        {
            if (!DeviceEntry->PDO)
            {
                /* release device entry lock */
                KeReleaseSpinLock(&Context->BusDeviceExtension->Lock, OldLevel);
 
                /* create pdo */
                Status = KspCreatePDO(Context->BusDeviceExtension, DeviceEntry, &DeviceEntry->PDO);
 
                /* acquire device entry lock */
                KeAcquireSpinLock(&Context->BusDeviceExtension->Lock, &OldLevel);
 
                /* done */
                break;
            }
        }
 
        /* move to next entry */
        Entry = Entry->Flink;
    }
 
    /* release device entry lock */
    KeReleaseSpinLock(&Context->BusDeviceExtension->Lock, OldLevel);
 
    /* signal that bus driver relations has changed */
    IoInvalidateDeviceRelations(Context->BusDeviceExtension->PhysicalDeviceObject, BusRelations);
 
    /* update status */
    Context->Status = Status;
 
    /* signal completion */
    KeSetEvent(&Context->Event, 0, FALSE);
}

Referenced by KsInstallBusEnumInterface().

KspInstallInterface()

NTSTATUS KspInstallInterface	(	IN PBUS_ENUM_DEVICE_EXTENSION	BusDeviceExtension,
		IN PSWENUM_INSTALL_INTERFACE	InstallInterface
	)

Definition at line 985 of file swenum.c.

{
    SIZE_T Length, Index;
    UNICODE_STRING DeviceString, InterfaceString, ReferenceString;
    HANDLE hKey, hDeviceKey, hInterfaceKey, hReferenceKey;
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
 
    /* sanity check */
    ASSERT(InstallInterface);
 
    /* calculate length */
    Length = wcslen(InstallInterface->ReferenceString);
 
    /* check for invalid characters */
    for(Index = 0; Index < Length; Index++)
    {
        if (InstallInterface->ReferenceString[Index] <= L' ' ||
            InstallInterface->ReferenceString[Index] > L'~' ||
            InstallInterface->ReferenceString[Index] == L',' ||
            InstallInterface->ReferenceString[Index] == L'\\' ||
            InstallInterface->ReferenceString[Index] == L'/')
        {
            /* invalid character */
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    /* open bus key */
    Status = KspOpenBusRegistryKey(BusDeviceExtension, &hKey);
    if (NT_SUCCESS(Status))
    {
        /* convert device guid to string */
        Status = RtlStringFromGUID(&InstallInterface->DeviceId, &DeviceString);
        if (NT_SUCCESS(Status))
        {
            /* initialize object attributes */
            InitializeObjectAttributes(&ObjectAttributes, &DeviceString, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hKey, NULL);
 
            /* construct device key */
            Status = ZwCreateKey(&hDeviceKey, GENERIC_WRITE, &ObjectAttributes, 0, NULL, 0, NULL);
            if (NT_SUCCESS(Status))
            {
                /* convert interface guid to string */
                Status = RtlStringFromGUID(&InstallInterface->InterfaceId, &InterfaceString);
                if (NT_SUCCESS(Status))
                {
                    /* initialize object attributes */
                    InitializeObjectAttributes(&ObjectAttributes, &InterfaceString, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hDeviceKey, NULL);
 
                    /* construct device key */
                    Status = ZwCreateKey(&hInterfaceKey, GENERIC_WRITE, &ObjectAttributes, 0, NULL, 0, NULL);
                    if (NT_SUCCESS(Status))
                    {
                        /* initialize reference string */
                        RtlInitUnicodeString(&ReferenceString, InstallInterface->ReferenceString);
 
                        /* initialize object attributes */
                        InitializeObjectAttributes(&ObjectAttributes, &ReferenceString, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hInterfaceKey, NULL);
 
                        /* construct device key */
                        Status = ZwCreateKey(&hReferenceKey, GENERIC_WRITE, &ObjectAttributes, 0, NULL, 0, NULL);
                        if (NT_SUCCESS(Status))
                        {
                            /* close key */
                            ZwClose(hReferenceKey);
                        }
                    }
                    /* free interface string */
                    RtlFreeUnicodeString(&InterfaceString);
 
                    /* close reference key */
                    ZwClose(hInterfaceKey);
                }
                /* close device key */
                ZwClose(hDeviceKey);
            }
            /* free device string */
            RtlFreeUnicodeString(&DeviceString);
        }
        /* close bus key */
        ZwClose(hKey);
    }
 
    /* done */
    return Status;
 }

Referenced by KspInstallBusEnumInterface().

KspOpenBusRegistryKey()

NTSTATUS KspOpenBusRegistryKey	(	IN PBUS_ENUM_DEVICE_EXTENSION	BusDeviceExtension,
		OUT PHANDLE	hKey
	)

Definition at line 482 of file swenum.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
 
    /* initialize object attributes */
    InitializeObjectAttributes(&ObjectAttributes, &BusDeviceExtension->ServicePath, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
 
    return ZwCreateKey(hKey, GENERIC_READ | GENERIC_WRITE, &ObjectAttributes, 0, NULL, 0, NULL);
}

Referenced by KspInstallInterface(), and KspScanBus().

KspQueryBusDeviceCapabilities()

NTSTATUS KspQueryBusDeviceCapabilities	(	IN PCOMMON_DEVICE_EXTENSION	ChildDeviceExtension,
		IN PIRP	Irp
	)

Definition at line 822 of file swenum.c.

{
    PDEVICE_CAPABILITIES Capabilities;
    PIO_STACK_LOCATION IoStack;
 
    /* get stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* get capabilities */
    Capabilities = IoStack->Parameters.DeviceCapabilities.Capabilities;
 
    RtlZeroMemory(Capabilities, sizeof(DEVICE_CAPABILITIES));
 
    /* setup capabilities */
    Capabilities->UniqueID = TRUE;
    Capabilities->SilentInstall = TRUE;
    Capabilities->SurpriseRemovalOK = TRUE;
    Capabilities->Address = 0;
    Capabilities->UINumber = 0;
    Capabilities->SystemWake = PowerSystemWorking; /* FIXME common device extension */
    Capabilities->DeviceWake = PowerDeviceD0;
 
    /* done */
    return STATUS_SUCCESS;
}

Referenced by KsServiceBusEnumPnpRequest().

KspQueryBusDeviceInterface()

NTSTATUS KspQueryBusDeviceInterface	(	IN PCOMMON_DEVICE_EXTENSION	ChildDeviceExtension,
		IN PIRP	Irp
	)

Definition at line 608 of file swenum.c.

{
    PBUS_INTERFACE_SWENUM Interface;
    PIO_STACK_LOCATION IoStack;
 
    /* get current irp stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* sanity checks */
    ASSERT(IoStack->Parameters.QueryInterface.Size == sizeof(BUS_INTERFACE_SWENUM));
    ASSERT(IoStack->Parameters.QueryInterface.Interface);
 
    /* fill in interface */
    Interface = (PBUS_INTERFACE_SWENUM)IoStack->Parameters.QueryInterface.Interface;
    Interface->Interface.Size = sizeof(BUS_INTERFACE_SWENUM);
    Interface->Interface.Version = BUS_INTERFACE_SWENUM_VERSION;
    Interface->Interface.Context = ChildDeviceExtension;
    Interface->Interface.InterfaceReference = KspBusDeviceReference;
    Interface->Interface.InterfaceDereference = KspBusDeviceDereference;
    Interface->ReferenceDeviceObject = KspBusReferenceDeviceObject;
    Interface->DereferenceDeviceObject = KspBusDereferenceDeviceObject;
    Interface->QueryReferenceString = KspBusQueryReferenceString;
 
    return STATUS_SUCCESS;
}

Referenced by KsServiceBusEnumPnpRequest().

KspQueryBusDevicePnpState()

NTSTATUS KspQueryBusDevicePnpState	(	IN PCOMMON_DEVICE_EXTENSION	ChildDeviceExtension,
		IN PIRP	Irp
	)

Definition at line 879 of file swenum.c.

{
    /* set device flags */
    Irp->IoStatus.Information = PNP_DEVICE_DONT_DISPLAY_IN_UI | PNP_DEVICE_NOT_DISABLEABLE;
 
    /* done */
    return STATUS_SUCCESS;
}

Referenced by KsServiceBusEnumPnpRequest().

KspQueryBusInformation()

NTSTATUS KspQueryBusInformation	(	IN PCOMMON_DEVICE_EXTENSION	ChildDeviceExtension,
		IN PIRP	Irp
	)

Definition at line 851 of file swenum.c.

{
    PPNP_BUS_INFORMATION BusInformation;
 
    /* allocate bus information */
    BusInformation = (PPNP_BUS_INFORMATION)AllocateItem(PagedPool, sizeof(PNP_BUS_INFORMATION));
 
    if (!BusInformation)
    {
        /* no memory */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* return info */
    BusInformation->BusNumber = 0;
    BusInformation->LegacyBusType = InterfaceTypeUndefined;
    RtlMoveMemory(&BusInformation->BusTypeGuid, &KSMEDIUMSETID_Standard, sizeof(GUID));
 
    /* store result */
    Irp->IoStatus.Information = (ULONG_PTR)BusInformation;
 
    /* done */
    return STATUS_SUCCESS;
}

Referenced by KsServiceBusEnumPnpRequest().

KspQueryBusRelations()

NTSTATUS KspQueryBusRelations	(	IN PBUS_ENUM_DEVICE_EXTENSION	BusDeviceExtension,
		IN PIRP	Irp
	)

Definition at line 1311 of file swenum.c.

{
    PDEVICE_RELATIONS DeviceRelations;
    PLIST_ENTRY Entry;
    PBUS_DEVICE_ENTRY DeviceEntry;
    ULONG Count = 0, Length;
    KIRQL OldLevel;
 
    /* acquire lock */
    KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
 
    /* first scan all device entries */
    Entry = BusDeviceExtension->Common.Entry.Flink;
 
    while(Entry != &BusDeviceExtension->Common.Entry)
    {
        /* get offset to device entry */
        DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
 
        /* is there a pdo yet */
        if (DeviceEntry->PDO && (DeviceEntry->DeviceState == NotStarted || DeviceEntry->DeviceState == Started))
        {
            /* increment count */
            Count++;
        }
 
        /* move to next entry */
        Entry = Entry->Flink;
    }
 
    /* calculate length */
    Length = sizeof(DEVICE_RELATIONS) + (Count > 1 ? sizeof(PDEVICE_OBJECT) * (Count-1) : 0);
 
    /* allocate device relations */
    DeviceRelations = (PDEVICE_RELATIONS)AllocateItem(NonPagedPool, Length);
 
    if (!DeviceRelations)
    {
        /* not enough memory */
        KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* rescan device entries */
    Entry = BusDeviceExtension->Common.Entry.Flink;
 
    while(Entry != &BusDeviceExtension->Common.Entry)
    {
        /* get offset to device entry */
        DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
 
        /* is there a pdo yet */
        if (DeviceEntry->PDO && (DeviceEntry->DeviceState == NotStarted || DeviceEntry->DeviceState == Started))
        {
            /* store pdo */
            DeviceRelations->Objects[DeviceRelations->Count] = DeviceEntry->PDO;
 
            /* reference device object */
            ObReferenceObject(DeviceEntry->PDO);
 
            /* increment pdo count */
            DeviceRelations->Count++;
        }
 
        /* move to next entry */
        Entry = Entry->Flink;
    }
 
    /* release lock */
    KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
 
    /* FIXME handle existing device relations */
    ASSERT(Irp->IoStatus.Information == 0);
 
    /* store device relations */
    Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
 
    /* done */
    return STATUS_SUCCESS;
}

Referenced by KsServiceBusEnumPnpRequest().

KspQueryId()

NTSTATUS KspQueryId	(	IN PCOMMON_DEVICE_EXTENSION	ChildDeviceExtension,
		IN PIRP	Irp
	)

Definition at line 891 of file swenum.c.

{
    PIO_STACK_LOCATION IoStack;
    PBUS_DEVICE_ENTRY DeviceEntry;
    PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
    LPWSTR Name;
    SIZE_T Length;
 
    /* get current irp stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    if (IoStack->Parameters.QueryId.IdType == BusQueryInstanceID)
    {
        /* get device entry */
        DeviceEntry = (PBUS_DEVICE_ENTRY) ChildDeviceExtension->DeviceEntry;
 
        /* sanity check */
        ASSERT(DeviceEntry);
        ASSERT(DeviceEntry->Instance);
 
        /* calculate length */
        Length = wcslen(DeviceEntry->Instance) + 2;
 
        /* allocate buffer */
        Name = AllocateItem(PagedPool, Length * sizeof(WCHAR));
 
        if (!Name)
        {
            /* failed to allocate buffer */
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        /* copy buffer */
        wcscpy(Name, DeviceEntry->Instance);
 
        /* store result */
        Irp->IoStatus.Information = (ULONG_PTR)Name;
 
        /* done */
        return STATUS_SUCCESS;
    }
    else if (IoStack->Parameters.QueryId.IdType == BusQueryDeviceID ||
             IoStack->Parameters.QueryId.IdType == BusQueryHardwareIDs)
    {
        /* get device entry */
        DeviceEntry = (PBUS_DEVICE_ENTRY) ChildDeviceExtension->DeviceEntry;
 
        /* get bus device extension */
        BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION) ChildDeviceExtension->BusDeviceExtension;
 
        /* sanity check */
        ASSERT(DeviceEntry);
        ASSERT(DeviceEntry->BusId);
        ASSERT(BusDeviceExtension);
        ASSERT(BusDeviceExtension->BusIdentifier);
 
        /* calculate length */
        Length = wcslen(BusDeviceExtension->BusIdentifier);
        Length += wcslen(DeviceEntry->BusId);
 
        /* extra length for '\\' and 2 zero bytes */
        Length += 4;
 
        /* allocate buffer */
        Name = AllocateItem(PagedPool, Length * sizeof(WCHAR));
        if (!Name)
        {
            /* failed to allocate buffer */
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        /* construct id */
        wcscpy(Name, BusDeviceExtension->BusIdentifier);
        wcscat(Name, L"\\");
        wcscat(Name, DeviceEntry->BusId);
        //swprintf(Name, L"%s\\%s", BusDeviceExtension->BusIdentifier, DeviceEntry->BusId);
 
        /* store result */
        Irp->IoStatus.Information = (ULONG_PTR)Name;
 
        /* done */
        return STATUS_SUCCESS;
    }
    else
    {
        /* other ids are not supported */
        //DPRINT1("Not Supported ID Type %x\n", IoStack->Parameters.QueryId.IdType);
        return Irp->IoStatus.Status;
    }
}

Referenced by KsServiceBusEnumPnpRequest().

KspRegisterDeviceAssociation()

NTSTATUS KspRegisterDeviceAssociation	(	IN PBUS_ENUM_DEVICE_EXTENSION	BusDeviceExtension,
		IN PBUS_DEVICE_ENTRY	DeviceEntry,
		IN OUT PBUS_INSTANCE_ENTRY	BusInstanceEntry
	)

Definition at line 93 of file swenum.c.

{
    NTSTATUS Status;
    UNICODE_STRING ReferenceString;
 
    /* initialize reference string */
    RtlInitUnicodeString(&ReferenceString, DeviceEntry->DeviceName);
 
    /* register device interface */
    Status = IoRegisterDeviceInterface(BusDeviceExtension->PhysicalDeviceObject, &BusInstanceEntry->InterfaceGuid, &ReferenceString, &BusInstanceEntry->SymbolicLink);
 
    /* check for success */
    if (!NT_SUCCESS(Status))
    {
        /* failed */
        return Status;
    }
 
    /* now enable the interface */
    Status = IoSetDeviceInterfaceState(&BusInstanceEntry->SymbolicLink, TRUE);
 
    /* check for success */
    if (!NT_SUCCESS(Status))
    {
        /* failed, free memory */
        FreeItem(BusInstanceEntry->SymbolicLink.Buffer);
        return Status;
    }
 
    DPRINT("Registered DeviceInterface %wZ\n", &BusInstanceEntry->SymbolicLink);
 
 
    /* done */
    return Status;
}

Referenced by KspCreateDeviceAssociation().

KspRemoveBusInterface()

VOID NTAPI KspRemoveBusInterface

(

PVOID

Ctx

)

Definition at line 1290 of file swenum.c.

{
    PBUS_INSTALL_ENUM_CONTEXT Context =(PBUS_INSTALL_ENUM_CONTEXT)Ctx;
 
    /* TODO
     * get SWENUM_INSTALL_INTERFACE struct
     * open device key and delete the keys
     */
 
    UNIMPLEMENTED;
 
    /* set status */
    Context->Status = STATUS_NOT_IMPLEMENTED;
 
 
    /* signal completion */
    KeSetEvent(&Context->Event, IO_NO_INCREMENT, FALSE);
}

Referenced by KsRemoveBusEnumInterface().

KspRemoveDeviceAssociations()

VOID KspRemoveDeviceAssociations

(

IN PBUS_DEVICE_ENTRY

DeviceEntry

)

Definition at line 133 of file swenum.c.

{
    PLIST_ENTRY Entry;
    PBUS_INSTANCE_ENTRY CurEntry;
 
    /* remove all entries */
    Entry = DeviceEntry->DeviceInterfaceList.Flink;
 
    while(Entry != &DeviceEntry->DeviceInterfaceList)
    {
         /* get offset */
         CurEntry = (PBUS_INSTANCE_ENTRY)CONTAINING_RECORD(Entry, BUS_INSTANCE_ENTRY, Entry);
 
         /* sanity check */
         ASSERT(CurEntry->SymbolicLink.Buffer);
 
         /* de-register interface */
         IoSetDeviceInterfaceState(&CurEntry->SymbolicLink, FALSE);
 
         /* free symbolic link buffer */
         FreeItem(CurEntry->SymbolicLink.Buffer);
 
         /* remove entry from list */
         RemoveEntryList(Entry);
 
         /* move to next entry */
         Entry = Entry->Flink;
 
         /* free entry */
         FreeItem(CurEntry);
    }
}

Referenced by KspCreateDeviceReference().

KspScanBus()

NTSTATUS KspScanBus

(

IN PBUS_ENUM_DEVICE_EXTENSION

BusDeviceExtension

)

Definition at line 495 of file swenum.c.

{
    HANDLE hKey;
    NTSTATUS Status;
 
    /* first open key */
    Status = KspOpenBusRegistryKey(BusDeviceExtension, &hKey);
 
    /* check for success */
    if (!NT_SUCCESS(Status))
    {
        /* no success */
 
        return Status;
    }
 
    /* TODO clear reference marks */
 
    /* construct device entries */
    Status = KspEnumerateBusRegistryKeys(hKey, NULL, KspCreateDeviceReferenceTrampoline, BusDeviceExtension, NULL);
 
    /* TODO: delete unreferenced devices */
 
    /* close handle */
    ZwClose(hKey);
 
    /* done */
    return Status;
}

Referenced by KsCreateBusEnumObject(), and KspInstallBusEnumInterface().

KspStartBusDevice()

NTSTATUS KspStartBusDevice	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PCOMMON_DEVICE_EXTENSION	ChildDeviceExtension,
		IN PIRP	Irp
	)

Definition at line 760 of file swenum.c.

{
    WCHAR PDOName[256];
    NTSTATUS Status;
    ULONG ResultLength;
    LPWSTR Name;
    ULONG NameLength;
    PBUS_DEVICE_ENTRY DeviceEntry;
 
    /* FIXME handle pending remove */
 
    /* get full device name */
    Status = IoGetDeviceProperty(DeviceObject, DevicePropertyPhysicalDeviceObjectName, sizeof(PDOName), PDOName, &ResultLength);
 
    if (!NT_SUCCESS(Status))
    {
        /* failed to get device name */
        return Status;
    }
 
    /* allocate device name buffer */
    NameLength = ResultLength + sizeof(UNICODE_NULL);
    Name = AllocateItem(NonPagedPool, NameLength);
    if (!Name)
    {
        /* no memory */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* copy name */
    NT_VERIFY(NT_SUCCESS(RtlStringCbCopyW(Name, NameLength, PDOName)));
 
    /* TODO: time stamp creation time */
 
    /* get device entry */
    DeviceEntry = (PBUS_DEVICE_ENTRY)ChildDeviceExtension->DeviceEntry;
 
    /* sanity check */
    ASSERT(DeviceEntry);
 
    /* store device name */
    DeviceEntry->PDODeviceName = Name;
 
    /* mark device as started */
    DeviceEntry->DeviceState = Started;
 
    /* reference start time */
    KeQueryTickCount(&DeviceEntry->TimeCreated);
 
    DPRINT1("KspStartBusDevice Name %S DeviceName %S Instance %S Started\n", Name, DeviceEntry->DeviceName, DeviceEntry->Instance);
 
    /* enable device classes */
    //KspEnableBusDeviceInterface(DeviceEntry, TRUE);
 
    /* done */
    return STATUS_SUCCESS;
}

Referenced by KsServiceBusEnumPnpRequest().

KsRemoveBusEnumInterface()

KSDDKAPI NTSTATUS NTAPI KsRemoveBusEnumInterface

(

IN PIRP

Irp

)

Definition at line 2210 of file swenum.c.

{
    KPROCESSOR_MODE Mode;
    LUID luid;
    BUS_INSTALL_ENUM_CONTEXT Ctx;
    PDEV_EXTENSION DeviceExtension;
    PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
    PIO_STACK_LOCATION IoStack;
 
    DPRINT("KsRemoveBusEnumInterface\n");
 
    /* get io stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* get device extension */
    DeviceExtension = (PDEV_EXTENSION)IoStack->DeviceObject->DeviceExtension;
 
    /* get bus device extension */
    BusDeviceExtension = DeviceExtension->Ext->BusDeviceExtension;
 
    /* get previous mode */
    Mode = ExGetPreviousMode();
 
    /* convert to luid */
    luid = RtlConvertUlongToLuid(SE_LOAD_DRIVER_PRIVILEGE);
 
    /* perform access check */
    if (!SeSinglePrivilegeCheck(luid, Mode))
    {
        /* insufficient privileges */
        return STATUS_PRIVILEGE_NOT_HELD;
    }
 
    /* initialize context */
    KeInitializeEvent(&Ctx.Event, NotificationEvent, FALSE);
    Ctx.Irp = Irp;
    Ctx.BusDeviceExtension = BusDeviceExtension;
    ExInitializeWorkItem(&Ctx.WorkItem, KspRemoveBusInterface, (PVOID)&Ctx);
 
    /* now queue the work item */
    ExQueueWorkItem(&Ctx.WorkItem, DelayedWorkQueue);
 
    /* wait for completion */
    KeWaitForSingleObject(&Ctx.Event, Executive, KernelMode, FALSE, NULL);
 
    /* return result */
    return Ctx.Status;
}

Referenced by SwDispatchDeviceControl().

KsServiceBusEnumCreateRequest()

KSDDKAPI NTSTATUS NTAPI KsServiceBusEnumCreateRequest	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 1897 of file swenum.c.

{
    PLIST_ENTRY Entry;
    PBUS_DEVICE_ENTRY DeviceEntry = NULL; /* fix gcc */
    PIO_STACK_LOCATION IoStack;
    BOOLEAN ItemExists = FALSE;
    PDEV_EXTENSION DeviceExtension;
    PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
    //PCOMMON_DEVICE_EXTENSION ChildDeviceExtension;
    NTSTATUS Status;
    LARGE_INTEGER Time;
 
    /* FIXME: locks */
 
    /* get device extension */
    DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
 
    /* get bus device extension */
    BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
 
    /* get current irp stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    /* sanity checks */
    ASSERT(IoStack->FileObject);
    if (IoStack->FileObject->FileName.Buffer == NULL)
    {
         DPRINT("KsServiceBusEnumCreateRequest PNP Hack\n");
         Irp->IoStatus.Status = STATUS_SUCCESS;
         return STATUS_SUCCESS;
    }
 
    ASSERT(IoStack->FileObject->FileName.Buffer);
 
    DPRINT1("KsServiceBusEnumCreateRequest IRP %p Name %wZ\n", Irp, &IoStack->FileObject->FileName);
 
    /* scan list and check if it is already present */
    Entry = BusDeviceExtension->Common.Entry.Flink;
 
    while(Entry != &BusDeviceExtension->Common.Entry)
    {
        /* get real offset */
        DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
 
        /* check if name matches */
        if (!wcsicmp(DeviceEntry->DeviceName, IoStack->FileObject->FileName.Buffer + 1))
        {
            /* item already exists */
            ItemExists = TRUE;
            break;
        }
 
        /* move to next entry */
        Entry = Entry->Flink;
    }
 
    if (!ItemExists)
    {
        /* interface not registered */
        DPRINT1("Interface %wZ not registered\n", &IoStack->FileObject->FileName);
        return STATUS_OBJECT_NAME_NOT_FOUND;
    }
 
    /*  is there a pdo yet */
    if (DeviceEntry->PDO)
    {
        if (DeviceEntry->DeviceState == Started)
        {
            /* issue reparse */
            Status =  KspDoReparseForIrp(Irp, DeviceEntry);
            DPRINT("REPARSE Irp %p '%wZ'\n", Irp, &IoStack->FileObject->FileName);
 
            Irp->IoStatus.Status = Status;
            Irp->IoStatus.Information = IO_REPARSE;
            return Status;
        }
 
        /* delay processing until pnp is finished with enumeration */
        IoMarkIrpPending(Irp);
 
        /* insert into irp pending list */
        InsertTailList(&DeviceEntry->IrpPendingList, &Irp->Tail.Overlay.ListEntry);
 
        Time.QuadPart = Int32x32To64(1500, -10000);
        DbgPrint("PENDING Irp %p %wZ DeviceState %d\n", Irp, &IoStack->FileObject->FileName, DeviceEntry->DeviceState);
 
 
        /* set timer */
        KeSetTimer(&BusDeviceExtension->Timer, Time, &BusDeviceExtension->Dpc);
 
        /* done for now */
        return STATUS_PENDING;
 
    }
    else
    {
        /* time to create PDO */
        Status = KspCreatePDO(BusDeviceExtension, DeviceEntry, &DeviceEntry->PDO);
 
        if (!NT_SUCCESS(Status))
        {
            /* failed to create PDO */
            DPRINT1("KsServiceBusEnumCreateRequest failed to create PDO with %x\n", Status);
            return Status;
        }
        DPRINT("PENDING CREATE Irp %p %wZ\n", Irp, &IoStack->FileObject->FileName);
 
        /* delay processing until pnp is finished with enumeration */
        IoMarkIrpPending(Irp);
 
        /* insert into irp pending list */
        InsertTailList(&DeviceEntry->IrpPendingList, &Irp->Tail.Overlay.ListEntry);
 
        /* invalidate device relations */
        IoInvalidateDeviceRelations(BusDeviceExtension->PhysicalDeviceObject, BusRelations);
 
        /* done for now */
        return STATUS_PENDING;
    }
}

Referenced by SwDispatchCreate().

KsServiceBusEnumPnpRequest()

KSDDKAPI NTSTATUS NTAPI KsServiceBusEnumPnpRequest	(	IN PDEVICE_OBJECT	DeviceObject,
		IN OUT PIRP	Irp
	)

Definition at line 2026 of file swenum.c.

{
    PDEV_EXTENSION DeviceExtension;
    PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
    PCOMMON_DEVICE_EXTENSION ChildDeviceExtension;
    PIO_STACK_LOCATION IoStack;
    NTSTATUS Status;
    LARGE_INTEGER Time;
    PDEVICE_RELATIONS DeviceRelation;
    PBUS_DEVICE_ENTRY DeviceEntry;
 
    /* get device extension */
    DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
 
    /* get bus device extension */
    BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
 
    /* get current irp stack location */
    IoStack = IoGetCurrentIrpStackLocation(Irp);
 
    if (BusDeviceExtension->Common.IsBus)
    {
        if (IoStack->MinorFunction == IRP_MN_START_DEVICE)
        {
            /* no op for bus driver */
            Status = STATUS_SUCCESS;
        }
        else if (IoStack->MinorFunction == IRP_MN_QUERY_DEVICE_RELATIONS)
        {
            /* handle bus device relations */
            ASSERT(IoStack->Parameters.QueryDeviceRelations.Type == BusRelations);
 
            Status = KspQueryBusRelations(BusDeviceExtension, Irp);
        }
        else
        {
            /* get default status */
            Status = Irp->IoStatus.Status;
        }
    }
    else
    {
        /* get child device extension */
        ChildDeviceExtension = DeviceExtension->Ext;
 
        /* get bus device extension */
        BusDeviceExtension = ChildDeviceExtension->BusDeviceExtension;
 
        if (IoStack->MinorFunction == IRP_MN_QUERY_ID)
        {
            /* query id */
            Status = KspQueryId(ChildDeviceExtension, Irp);
        }
        else if (IoStack->MinorFunction == IRP_MN_REMOVE_DEVICE)
        {
            ASSERT(ChildDeviceExtension->DeviceEntry->DeviceState != Started || ChildDeviceExtension->DeviceEntry->DeviceState == NotStarted);
            ASSERT(ChildDeviceExtension->DeviceEntry->PDO == DeviceObject);
 
            /* backup device entry */
            DeviceEntry = ChildDeviceExtension->DeviceEntry;
 
            /* free device extension */
            FreeItem(ChildDeviceExtension);
 
            /* clear PDO reference */
            DeviceEntry->PDO = NULL;
 
            /* delete the device */
            IoDeleteDevice(DeviceObject);
 
            if (DeviceEntry->PDODeviceName)
            {
                /* delete pdo device name */
                FreeItem(DeviceEntry->PDODeviceName);
 
                /* set to null */
                DeviceEntry->PDODeviceName = NULL;
            }
 
            /* set state no notstarted */
            DeviceEntry->DeviceState = NotStarted;
 
            /* complete pending irps */
            KspCompletePendingIrps(DeviceEntry, STATUS_DEVICE_REMOVED);
 
            /* done */
            Status = STATUS_SUCCESS;
        }
        else if (IoStack->MinorFunction == IRP_MN_QUERY_BUS_INFORMATION)
        {
            /* query bus information */
            Status = KspQueryBusInformation(ChildDeviceExtension, Irp);
        }
        else if (IoStack->MinorFunction == IRP_MN_QUERY_RESOURCES)
        {
            /* no op */
            Status = STATUS_SUCCESS;
        }
        else if (IoStack->MinorFunction == IRP_MN_QUERY_RESOURCE_REQUIREMENTS)
        {
            /* no op */
            Status = STATUS_SUCCESS;
        }
        else if (IoStack->MinorFunction == IRP_MN_START_DEVICE)
        {
            /* start bus */
            Status = KspStartBusDevice(DeviceObject, ChildDeviceExtension, Irp);
            if (NT_SUCCESS(Status))
            {
                /* complete pending irps*/
                KspCompletePendingIrps(ChildDeviceExtension->DeviceEntry, STATUS_REPARSE);
            }
 
            /* set time out */
            Time.QuadPart = Int32x32To64(1500, -10000);
 
            /* sanity check */
            ASSERT(BusDeviceExtension);
 
            /* set timer */
            KeSetTimer(&BusDeviceExtension->Timer, Time, &BusDeviceExtension->Dpc);
        }
        else if (IoStack->MinorFunction == IRP_MN_QUERY_CAPABILITIES)
        {
            /* query capabilities */
            Status = KspQueryBusDeviceCapabilities(ChildDeviceExtension, Irp);
        }
        else if (IoStack->MinorFunction == IRP_MN_QUERY_PNP_DEVICE_STATE)
        {
            /* query pnp state */
            Status = KspQueryBusDevicePnpState(ChildDeviceExtension, Irp);
        }
        else if (IoStack->MinorFunction == IRP_MN_QUERY_INTERFACE)
        {
            /* query interface */
            Status = KspQueryBusDeviceInterface(ChildDeviceExtension, Irp);
        }
        else if (IoStack->MinorFunction == IRP_MN_QUERY_DEVICE_RELATIONS && IoStack->Parameters.QueryDeviceRelations.Type == TargetDeviceRelation)
        {
            /* handle target device relations */
            ASSERT(Irp->IoStatus.Information == 0);
 
            /* allocate device relation */
            DeviceRelation = AllocateItem(PagedPool, sizeof(DEVICE_RELATIONS));
            if (DeviceRelation)
            {
                DeviceRelation->Count = 1;
                DeviceRelation->Objects[0] = DeviceObject;
 
                /* reference self */
                ObReferenceObject(DeviceObject);
 
                /* store result */
                Irp->IoStatus.Information = (ULONG_PTR)DeviceRelation;
 
                /* done */
                Status = STATUS_SUCCESS;
            }
            else
            {
                /* no memory */
                Status = STATUS_INSUFFICIENT_RESOURCES;
            }
        }
        else
        {
            /* get default status */
            Status = Irp->IoStatus.Status;
        }
    }
 
    DPRINT("KsServiceBusEnumPnpRequest %p Bus %u Function %x Status %x\n", DeviceObject, BusDeviceExtension->Common.IsBus, IoStack->MinorFunction, Status);
    Irp->IoStatus.Status = Status;
    return Status;
}

Referenced by SwDispatchPnp().

Variable Documentation

KsDeviceCount

LONG KsDeviceCount = 0

Definition at line 17 of file swenum.c.

Referenced by KspCreatePDO().