windows-server-2003/drivers/storage/redbook/wmi.c

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1998 - 1999
//
//  File:       wmi.c
//
//--------------------------------------------------------------------------


#include "redbook.h"
#include "ntddredb.h"
#include "proto.h"

#ifdef _USE_ETW
#include "wmi.tmh"
#endif // _USE_ETW

#ifdef ALLOC_PRAGMA
    #pragma alloc_text(PAGE,   RedBookThreadWmiHandler)
    #pragma alloc_text(PAGE,   RedBookWmiInit)
    #pragma alloc_text(PAGE,   RedBookWmiQueryDataBlock)
    #pragma alloc_text(PAGE,   RedBookWmiQueryRegInfo)
    #pragma alloc_text(PAGE,   RedBookWmiSetDataBlock)
    #pragma alloc_text(PAGE,   RedBookWmiSetDataItem)
    #pragma alloc_text(PAGE,   RedBookWmiSystemControl)
    #pragma alloc_text(PAGE,   RedBookWmiUninit)
#endif // ALLOC_PRAGMA


#define REDBOOK_STD_INDEX      0   // index into WMIGUIDREGINFO
#define REDBOOK_PERF_INDEX     1   // index into WMIGUIDREGINFO

WMIGUIDREGINFO RedBookWmiGuidList[] =
{
    // GUID,  # of data blocks,  flags
    { &MSRedbook_DriverInformationGuid, 1, 0 },  // RedBook driver info
    { &MSRedbook_PerformanceGuid, 1, 0 }  // some perf stuff also
};
/////////////////////////////////////////////////////////

NTSTATUS
RedBookWmiUninit(
    PREDBOOK_DEVICE_EXTENSION DeviceExtension
    )
{
    NTSTATUS status = STATUS_SUCCESS;
    PAGED_CODE();

    if (DeviceExtension->WmiLibInitialized) {
        status = IoWMIRegistrationControl(DeviceExtension->SelfDeviceObject,
                                          WMIREG_ACTION_DEREGISTER);
        ASSERT(NT_SUCCESS(status)); // can not fail?
        DeviceExtension->WmiLibInitialized = 0;
    }
    return status;

}


NTSTATUS
RedBookWmiInit(
    PREDBOOK_DEVICE_EXTENSION DeviceExtension
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/

{
    NTSTATUS status;

    PAGED_CODE();

    if (DeviceExtension->WmiLibInitialized) {
        return STATUS_SUCCESS;
    }

    DeviceExtension->WmiLibInfo.GuidCount = sizeof(RedBookWmiGuidList) /
                                            sizeof(WMIGUIDREGINFO);

    ASSERT(DeviceExtension->WmiLibInfo.GuidCount > 0);
    DeviceExtension->WmiLibInfo.GuidList           = RedBookWmiGuidList;
    DeviceExtension->WmiLibInfo.QueryWmiDataBlock  = RedBookWmiQueryDataBlock;
    DeviceExtension->WmiLibInfo.QueryWmiRegInfo    = RedBookWmiQueryRegInfo;
    DeviceExtension->WmiLibInfo.SetWmiDataBlock    = RedBookWmiSetDataBlock;
    DeviceExtension->WmiLibInfo.SetWmiDataItem     = RedBookWmiSetDataItem;
    DeviceExtension->WmiLibInfo.ExecuteWmiMethod   = NULL;
    DeviceExtension->WmiLibInfo.WmiFunctionControl = NULL;

    status = IoWMIRegistrationControl(DeviceExtension->SelfDeviceObject,
                                      WMIREG_ACTION_REGISTER);

    if (!NT_SUCCESS(status)) {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWarning, "[redbook] "
                   "WmiInit !! Failed [%#010lx]\n", status));
    } else {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                   "WmiInit => Successfully registered\n"));
        DeviceExtension->WmiLibInitialized = 1;
    }

    return status;

}


NTSTATUS
RedBookWmiQueryDataBlock (
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP           Irp,
    IN ULONG          GuidIndex,
    IN ULONG          InstanceIndex,
    IN ULONG          InstanceCount,
    IN OUT PULONG     InstanceLengthArray,
    IN ULONG          OutBufferSize,
    OUT PUCHAR        Buffer
    )

/*++

Routine Description:

    This routine is a callback into the driver to query for the contents of
    a data block. When the driver has finished filling the data block it
    must call RedBookWmiCompleteRequest to complete the irp. The driver can
    return STATUS_PENDING if the irp cannot be completed immediately.

Arguments:

    DeviceObject is the device whose data block is being queried

    Irp is the Irp that makes this request

    GuidIndex is the index into the list of guids provided when the
        device registered

    InstanceIndex is the instance within the GuidIndex to query

    InstanceCount is ???

    InstanceLengthArray is a pointer to an array of ULONG that returns
        the lengths of each instance of the data block.  If this is NULL
        then there was not enough space in the output buffer to fulfill
        the request so the irp should be completed with the buffer needed.

    OutputBufferSize has the maximum size available to write the data
        block.

    Buffer on return is filled with the returned data block

Return Value:

    status

--*/

{
    PREDBOOK_DEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    NTSTATUS status;
    ULONG size = 0;

    PAGED_CODE();

    //
    // Only one instance per GUID
    //

    ASSERT( InstanceIndex == 0 );
    ASSERT( InstanceCount == 1 );

    switch (GuidIndex) {
    case REDBOOK_STD_INDEX: {

        if (InstanceIndex != 0) {
            status = STATUS_WMI_INSTANCE_NOT_FOUND;
            break;
        }

        //
        // Reject the request if not enough space alloc'd
        //

        if (OutBufferSize < sizeof(REDBOOK_WMI_STD_DATA)) {
            size   = sizeof(REDBOOK_WMI_STD_DATA);
            status = STATUS_BUFFER_TOO_SMALL;
            break;
        }

        //
        // requests for wmi information can occur while
        // the system is playing audio.  just copy the info
        //

        RtlCopyMemory( Buffer,
                       &deviceExtension->WmiData,
                       sizeof(REDBOOK_WMI_STD_DATA)
                       );

        /*
         *  BUT overwrite these two values with the last-set ones.
         *  They apply to the next play, but constitute the current state from WMI's point of view.
         */
        ((PREDBOOK_WMI_STD_DATA)Buffer)->NumberOfBuffers = deviceExtension->NextWmiNumberOfBuffers;
        ((PREDBOOK_WMI_STD_DATA)Buffer)->SectorsPerRead = deviceExtension->NextWmiSectorsPerRead;

        //
        // Set the size for each instance
        //

        InstanceLengthArray[InstanceIndex] = sizeof(REDBOOK_WMI_STD_DATA);
        size += sizeof(REDBOOK_WMI_STD_DATA);

        status = STATUS_SUCCESS;
        break;
    }
    case REDBOOK_PERF_INDEX: {

        if (InstanceIndex != 0) {
            status = STATUS_WMI_INSTANCE_NOT_FOUND;
            break;
        }

        //
        // reject the request if not enough space alloc'd
        //

        if (OutBufferSize < sizeof(REDBOOK_WMI_PERF_DATA)) {
            size = sizeof(REDBOOK_WMI_PERF_DATA);
            status = STATUS_BUFFER_TOO_SMALL;
            break;
        }

        //
        // Requests for wmi information can occur while
        // the system is playing audio. just copy the info
        //

        RedBookWmiCopyPerfInfo(deviceExtension, (PVOID)Buffer);

        //
        // set the size for each instance
        //

        InstanceLengthArray[InstanceIndex] = sizeof(REDBOOK_WMI_PERF_DATA);
        size += sizeof(REDBOOK_WMI_PERF_DATA);
        status = STATUS_SUCCESS;
        break;
    }

    default: {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                   "WmiQueryDataBlock !! Invalid GUID [%#010lx]\n",
                   GuidIndex));
        status = STATUS_WMI_GUID_NOT_FOUND;
        break;
    }
    }

    KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
               "WmiQueryDataBlock => internal status [%#010lx]\n",
               status));

    IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp);
    status = WmiCompleteRequest(DeviceObject,
                                Irp,
                                status,
                                size,
                                IO_CD_ROM_INCREMENT);

    if (!NT_SUCCESS(status)) {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                   "WmiQueryDataBlock => IoWMICompleteRequest failed [%#010lx]\n",
                   status));
    }
    return status;
}


NTSTATUS
RedBookWmiSetDataBlock(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP           Irp,
    IN ULONG          GuidIndex,
    IN ULONG          InstanceIndex,
    IN ULONG          BufferSize,
    IN PUCHAR         Buffer
    )

/*++

Routine Description:

    This routine is a callback into the driver to set the contents of
    a data block.
    When the driver has finished filling the data block it must call
    IoWMICompleteRequest(???) to complete the irp.
    The driver can return STATUS_PENDING if the irp cannot be
    completed immediately.

Arguments:

    DeviceObject - the device whose data block is being queried

    Irp - Irp that makes this request

    GuidIndex - index into the list of guids provided
        when the device registered

    InstanceIndex - the index that denotes which index of the
        data block is being set

    BufferSize - the size of the data block passed

    Buffer - the new values for the data block

Return Value:

    status

--*/
{
    PREDBOOK_DEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    ULONG size = 0;
    NTSTATUS status;

    PAGED_CODE();

    switch( GuidIndex ) {
    case REDBOOK_STD_INDEX: {

        REDBOOK_WMI_STD_DATA wmiData;
        ULONG state;

        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                   "WmiSetDataBlock => Instance: [%#010lx]  BuffSize: [%#010lx]\n",
                   InstanceIndex, BufferSize));

        state = GetCdromState(deviceExtension);

        if (InstanceIndex != 0) {
            status = STATUS_WMI_INSTANCE_NOT_FOUND;
            break;
        }

        if ( BufferSize != sizeof(REDBOOK_WMI_STD_DATA) ) {
            status = STATUS_INFO_LENGTH_MISMATCH;
            break;
        }

        wmiData = *(PREDBOOK_WMI_STD_DATA)Buffer;

        //
        // verify the buffer contains valid information
        //

        if ( wmiData.NumberOfBuffers > REDBOOK_WMI_BUFFERS_MAX ||
             wmiData.NumberOfBuffers < REDBOOK_WMI_BUFFERS_MIN ) {
            KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                       "WmiSetDataBlock !! Invalid number of bufers [%#010lx]\n",
                       wmiData.NumberOfBuffers));
            status = STATUS_WMI_SET_FAILURE;
            break;
        }
        if ( wmiData.SectorsPerRead > REDBOOK_WMI_SECTORS_MAX   ||
             wmiData.SectorsPerRead < REDBOOK_WMI_SECTORS_MIN   ||
             wmiData.SectorsPerRead > wmiData.MaximumSectorsPerRead ) {
            KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                       "WmiSetDataBlock !! Invalid number of sectors per read [%#010lx]\n",
                       wmiData.SectorsPerRead));
            status = STATUS_WMI_SET_FAILURE;
            break;
        }
        if ( wmiData.PlayEnabled != TRUE &&
             wmiData.PlayEnabled != FALSE
             ) {
            KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                       "WmiSetDataBlock !! Invalid setting for play enabled [%#010lx]\n",
                       wmiData.PlayEnabled));
            status = STATUS_WMI_SET_FAILURE;
            break;
        }

        /*
         *  Changing WmiData.SectorsPerRead and WmiData.NumberOfBuffers in the middle of playing
         *  could disrupt our buffers.  So just save these new values and update them at the beginning
         *  of the next play.
         */
        deviceExtension->NextWmiNumberOfBuffers = wmiData.NumberOfBuffers;
        deviceExtension->NextWmiSectorsPerRead  = wmiData.SectorsPerRead;

        deviceExtension->WmiData.PlayEnabled     = wmiData.PlayEnabled;
        RedBookRegistryWrite(deviceExtension);

        status = STATUS_SUCCESS;
        break;
    }
    case REDBOOK_PERF_INDEX: {
        status = STATUS_WMI_READ_ONLY;
        break;
    }
    default: {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                   "WmiSetDataBlock !! Invalid GuidIndex [%#010lx]\n",
                   GuidIndex));
        status = STATUS_WMI_GUID_NOT_FOUND;
        break;
    }
    }

    IoReleaseRemoveLock( &deviceExtension->RemoveLock, Irp );
    status = WmiCompleteRequest( DeviceObject,
                                 Irp,
                                 status,
                                 sizeof(REDBOOK_WMI_STD_DATA),
                                 IO_CD_ROM_INCREMENT);
    return status;

}

NTSTATUS
RedBookWmiSetDataItem(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP           Irp,
    IN ULONG          GuidIndex,
    IN ULONG          InstanceIndex,
    IN ULONG          DataItemId,
    IN ULONG          BufferSize,
    IN PUCHAR         Buffer
    )
/*++

Routine Description:

    This routine is a callback into the driver to set the contents of
    a data block.
    ??? When the driver has finished filling the data block it
        must call ClassWmiCompleteRequest(???) to complete the irp.
    The driver can return STATUS_PENDING if the irp cannot be
    completed immediately.

Arguments:

    DeviceObject - the device whose data block is being queried

    Irp - Irp that makes this request

    GuidIndex - index into the list of guids provided
        when the device registered

    DataItemId - Id of the data item being set

    BufferSize - the size of the data block passed

    Buffer - the new values for the data block

Return Value:

    status

--*/
{
    PREDBOOK_DEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    ULONG size = 0;
    ULONG newVal;
    NTSTATUS status;

    PAGED_CODE();

    switch( GuidIndex ) {
    case REDBOOK_STD_INDEX: {

        ULONG state;

        if (InstanceIndex != 0) {
            status = STATUS_WMI_INSTANCE_NOT_FOUND;
            break;
        }

        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                     "WmiSetDataItem => Id: [%#010lx]  Size: [%#010lx]\n",
                     DataItemId, BufferSize));

        state = GetCdromState(deviceExtension);

        if (!TEST_FLAG(state, CD_STOPPED)) {
            status = STATUS_DEVICE_BUSY;
            break;
        }

        switch (DataItemId) {

            //
            // These are the only four settable items
            //

            case REDBOOK_WMI_NUMBER_OF_BUFFERS_ID:

                KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                           "WmiSetDataItem => Setting NumberOfBuffers\n"));

                if (BufferSize != REDBOOK_WMI_NUMBER_OF_BUFFERS_SIZE) {
                    status = STATUS_WMI_SET_FAILURE;
                    break;
                }

                /*
                 *  Save the new value and update WmiData.NumberOfBuffers at the beginning of the next play.
                 */
                newVal = *(PULONG32)Buffer;
                newVal = max(newVal, REDBOOK_WMI_BUFFERS_MIN);
                newVal = min(newVal, REDBOOK_WMI_BUFFERS_MAX);
                deviceExtension->NextWmiNumberOfBuffers = newVal;

                RedBookRegistryWrite(deviceExtension);
                status = STATUS_SUCCESS;
                break;

            case REDBOOK_WMI_SECTORS_PER_READ_ID:

                KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                           "WmiSetDataItem => Setting SectorsPerRead\n"));
                if (BufferSize != REDBOOK_WMI_SECTORS_PER_READ_SIZE) {
                    status = STATUS_WMI_SET_FAILURE;
                    break;
                }

                if (*(PULONG32)Buffer >
                    deviceExtension->WmiData.MaximumSectorsPerRead) {
                    KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                               "WmiSetDataBlock => Interface Card / "
                               "CDROM combo does not support this size\n"));
                    status = STATUS_DEVICE_BUSY;
                    break;
                }

                /*
                 *  Save the new value and update WmiData.SectorsPerRead at the beginning of the next play.
                 */
                newVal = *(PULONG32)Buffer;
                newVal = max(newVal, REDBOOK_WMI_SECTORS_MIN);
                newVal = min(newVal, REDBOOK_WMI_SECTORS_MAX);
                deviceExtension->NextWmiSectorsPerRead = newVal;

                RedBookRegistryWrite(deviceExtension);
                status = STATUS_SUCCESS;
                break;

            case REDBOOK_WMI_PLAY_ENABLED_ID:

                KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                           "WmiSetDataItem => Setting PlayEnabled\n"));
                if ( BufferSize != REDBOOK_WMI_PLAY_ENABLED_SIZE ) {
                    status = STATUS_WMI_SET_FAILURE;
                    break;
                }

                deviceExtension->WmiData.PlayEnabled = *(PBOOLEAN)Buffer;
                status = STATUS_SUCCESS;
                break;

                //
                // The remaining are invalid sets, as they are Read-Only values
                //
            case REDBOOK_WMI_SECTORS_PER_READ_MASK_ID:
                KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                           "WmiSetDataItem => Cannot set SectorsPerReadMask\n"));
                status = STATUS_WMI_READ_ONLY;
                break;

            case REDBOOK_WMI_CDDA_SUPPORTED_ID:
                KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                           "WmiSetDataItem => Cannot set Supported\n"));
                status = STATUS_WMI_READ_ONLY;
                break;

            case REDBOOK_WMI_CDDA_ACCURATE_ID:
                KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                           "WmiSetDataItem => Cannot set KnownGood\n"));
                status = STATUS_WMI_READ_ONLY;
                break;

            default:
                KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                           "WmiSetDataItem => Cannot set unknown "
                           "id %#010lx\n", DataItemId));
                status = STATUS_WMI_ITEMID_NOT_FOUND;
                break;
        }

        //
        // the status is now correctly set.
        // what should size be?
        //
        size = 0;
        break;
    }

    case REDBOOK_PERF_INDEX: {

        if (InstanceIndex != 0) {
            status = STATUS_WMI_INSTANCE_NOT_FOUND;
            break;
        }

        status = STATUS_WMI_READ_ONLY;
        size = 0;
        break;

    }
    default: {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                   "WmiSetDataItem !! Invalid GuidIndex: %#010lx\n",
                   GuidIndex));
        status = STATUS_WMI_GUID_NOT_FOUND;
        size = 0;
        break;
    }
    }

    IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp);
    status = WmiCompleteRequest( DeviceObject,
                                 Irp,
                                 status,
                                 size,
                                 IO_CD_ROM_INCREMENT
                                 );
    return status;

}


NTSTATUS
RedBookWmiSystemControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP           Irp
    )
/*++

Routine Description:

    System Control Irp
    Presume it is a WMI Irp and call into the WMI system to
    handle this IRP for us.

--*/
{
    PREDBOOK_DEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    PREDBOOK_THREAD_WMI_DATA wmiData;
    PIO_STACK_LOCATION irpStack;
    NTSTATUS status;

    PAGED_CODE();

    irpStack = IoGetCurrentIrpStackLocation(Irp);

    if (irpStack->Parameters.WMI.ProviderId != (ULONG_PTR)DeviceObject) {
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(deviceExtension->TargetDeviceObject, Irp);
    }

    status = IoAcquireRemoveLock(&deviceExtension->RemoveLock, Irp);

    if ( !NT_SUCCESS(status) ) {
        Irp->IoStatus.Information = 0;
        Irp->IoStatus.Status = status;
        IoCompleteRequest( Irp, IO_CD_ROM_INCREMENT );
        return status;
    }

    wmiData = ExAllocatePoolWithTag(NonPagedPool,
                                    sizeof(REDBOOK_THREAD_WMI_DATA),
                                    TAG_T_WMI);
    if (wmiData == NULL) {
        IoReleaseRemoveLock(&deviceExtension->RemoveLock, Irp);
        Irp->IoStatus.Information = 0;
        Irp->IoStatus.Status = STATUS_NO_MEMORY;
        IoCompleteRequest( Irp, IO_CD_ROM_INCREMENT );
        return STATUS_NO_MEMORY;
    }

    wmiData->Irp = Irp;

    KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
               "DispatchWmi => Queueing Irp %p\n", wmiData->Irp));

    //
    // queue them, allow thread to handle the request.
    //

    IoMarkIrpPending(Irp);

    ExInterlockedInsertTailList(&deviceExtension->Thread.WmiList,
                                &wmiData->ListEntry,
                                &deviceExtension->Thread.WmiLock);
    KeSetEvent(deviceExtension->Thread.Events[EVENT_WMI],
               IO_NO_INCREMENT, FALSE);

    return STATUS_PENDING;
}

VOID
RedBookThreadWmiHandler(
    PREDBOOK_DEVICE_EXTENSION DeviceExtension,
    PLIST_ENTRY ListEntry
    )
{
    SYSCTL_IRP_DISPOSITION disposition = {0};
    PREDBOOK_THREAD_WMI_DATA wmiData;
    PIRP irp;
    NTSTATUS status;

    PAGED_CODE();
    VerifyCalledByThread(DeviceExtension);

    wmiData = CONTAINING_RECORD(ListEntry, REDBOOK_THREAD_WMI_DATA, ListEntry);

    irp = wmiData->Irp;
    KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
               "HandleWmi => Processing Irp %p\n", irp));

    ExFreePool(wmiData);
    wmiData = NULL;

    //
    // just process the irp now.
    //

    status = WmiSystemControl( &DeviceExtension->WmiLibInfo,
                               DeviceExtension->SelfDeviceObject,
                               irp,
                               &disposition);

    switch ( disposition ) {
        case IrpProcessed: {
            //
            // this irp has been processed and may be completed or pending
            //
            break;
        }
        case IrpNotCompleted: {
            //
            // this irp has not been completed, but has been fully processed.
            // we will complete it now.
            //
            IoReleaseRemoveLock(&DeviceExtension->RemoveLock, irp);
            IoCompleteRequest(irp, IO_CD_ROM_INCREMENT);
            break;
        }
        case IrpNotWmi:
        case IrpForward: {
            //
            // this irp is either not a wmi irp or is a wmi irp targetted
            // at a device lower in the stack.
            //
            IoReleaseRemoveLock(&DeviceExtension->RemoveLock, irp);
            IoSkipCurrentIrpStackLocation(irp);
            IoCallDriver(DeviceExtension->TargetDeviceObject, irp);
            break;
        }
        default: {
            //
            // we should never really get here, but if we do, just forward...
            //
            ASSERT(!"[redbook] WmiSystemControl (unhandled case)");
            IoReleaseRemoveLock(&DeviceExtension->RemoveLock, irp);
            IoSkipCurrentIrpStackLocation(irp);
            IoCallDriver(DeviceExtension->TargetDeviceObject, irp);
            break;
        }
    }

    return;
}



NTSTATUS
RedBookWmiQueryRegInfo(
    IN PDEVICE_OBJECT   DeviceObject,
    OUT PULONG          RegFlags,
    OUT PUNICODE_STRING InstanceName,
    OUT PUNICODE_STRING *RegistryPath,
    OUT PUNICODE_STRING MofResourceName,
    OUT PDEVICE_OBJECT  *PhysicalDeviceObject
    )

/*++

Routine Description:

    This routine is a callback into the driver to retrieve the
    list of guids or data blocks that the driver wants to register
    with WMI.  This routine may not pend or block.

Arguments:

    DeviceObject - the device whose data block is being queried

    RegFlags - Returns with a set of flags that describe the guids
        registered for this device. If the device wants to enable
        and disable collection callbacks before receiving queries
        for the registered guids then it should return the
        WMIREG_FLAG_EXPENSIVE flag. Also the returned flags may
        specify WMIREG_FLAG_INSTANCE_PDO in which case the instance
        name is determined from the PDO associated with the device
        object. Note that the PDO must have an associated devnode.
        If WMIREG_FLAG_INSTANCE_PDO is not set then Name must return
        a unique name for the device.

    InstanceName - Returns with the instance name for the guids if
        WMIREG_FLAG_INSTANCE_PDO is not set in the returned RegFlags.
        The caller will call ExFreePool with the buffer returned.

    RegistryPath - Returns with the registry path of the driver

    MofResourceName - Returns with the name of the MOF resource attached
        to the binary file.  If the driver does not have a mof resource
        attached then this can be returned as NULL.

    PhysicalDeviceObject - Returns with the device object for the PDO
        associated with this device if the WMI_REG_FLAG_INSTANCE_PDO
        flag is returned in RegFlags

Return Value:

    status

--*/
{
    PREDBOOK_DEVICE_EXTENSION deviceExtension = DeviceObject->DeviceExtension;
    PREDBOOK_DRIVER_EXTENSION driverExtension;
    NTSTATUS status = STATUS_SUCCESS;

    PAGED_CODE();

    UNREFERENCED_PARAMETER(InstanceName);

    driverExtension = IoGetDriverObjectExtension(deviceExtension->DriverObject,
                                                 REDBOOK_DRIVER_EXTENSION_ID);

    if (driverExtension)
    {
        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                   "WmiQueryRegInfo => driverExtension is [%p]\n",
                   driverExtension));

        KdPrintEx((DPFLTR_REDBOOK_ID, RedbookDebugWmi, "[redbook] "
                   "WmiQueryRegInfo => Registry Path = %ws\n",
                   driverExtension->RegistryPath.Buffer));

        *RegFlags             = WMIREG_FLAG_INSTANCE_PDO;
        *RegistryPath         = &(driverExtension->RegistryPath);
        *PhysicalDeviceObject = deviceExtension->TargetPdo;
    }
    else
    {
        status = STATUS_INTERNAL_ERROR;
    }

    return status;
}


VOID
RedBookWmiCopyPerfInfo(
    IN  PREDBOOK_DEVICE_EXTENSION DeviceExtension,
    OUT PREDBOOK_WMI_PERF_DATA Out
    )
{
    KIRQL irql;

    //
    // cannot be paged due to spinlock, which allows copy of
    // the LARGE_INTEGERS without problems.
    //

    KeAcquireSpinLock( &DeviceExtension->WmiPerfLock, &irql );
    RtlCopyMemory( Out,
                   &DeviceExtension->WmiPerf,
                   sizeof(REDBOOK_WMI_PERF_DATA)
                   );
    KeReleaseSpinLock( &DeviceExtension->WmiPerfLock, irql );

    //
    // now add InterlockedXxx() calls to safely get a couple of the items.
    //

    Out->StreamPausedCount =
        InterlockedCompareExchange(&DeviceExtension->WmiPerf.StreamPausedCount,0,0);

    //
    // finished.
    //
    return;
}