classwmi.c File Reference

#include "stddef.h"
#include "ntddk.h"
#include "scsi.h"
#include "classpnp.h"
#include "mountdev.h"
#include <stdarg.h>
#include "classp.h"
#include <wmistr.h>
#include <wmidata.h>

Include dependency graph for classwmi.c:

Go to the source code of this file.

Macros
#define	TIME_STRING_LENGTH   25
#define	MOFRESOURCENAME   L"MofResourceName"
#define	MSStorageDriver_ClassErrorLogGuid_Index   0
#define	NUM_CLASS_WMI_GUIDS   (sizeof(wmiClassGuids) / sizeof(GUIDREGINFO))

Functions
BOOLEAN	ClassFindGuid (PGUIDREGINFO GuidList, ULONG GuidCount, LPGUID Guid, PULONG GuidIndex)
NTSTATUS	ClassQueryInternalDataBlock (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN ULONG GuidIndex, IN ULONG BufferAvail, OUT PUCHAR Buffer)
PWCHAR	ConvertTickToDateTime (IN LARGE_INTEGER Tick, _Out_writes_(TIME_STRING_LENGTH) PWCHAR String)
BOOLEAN	ClassFindInternalGuid (LPGUID Guid, PULONG GuidIndex)
NTSTATUS NTAPI	ClassSystemControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
SCSIPORT_API NTSTATUS NTAPI	ClassWmiCompleteRequest (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _In_ NTSTATUS Status, _In_ ULONG BufferUsed, _In_ CCHAR PriorityBoost)
	_IRQL_requires_max_ (DISPATCH_LEVEL)

Variables
GUIDREGINFO	wmiClassGuids []

Macro Definition Documentation

MOFRESOURCENAME

#define MOFRESOURCENAME   L"MofResourceName"

Definition at line 80 of file classwmi.c.

MSStorageDriver_ClassErrorLogGuid_Index

#define MSStorageDriver_ClassErrorLogGuid_Index   0

Definition at line 104 of file classwmi.c.

NUM_CLASS_WMI_GUIDS

#define NUM_CLASS_WMI_GUIDS   (sizeof(wmiClassGuids) / sizeof(GUIDREGINFO))

Definition at line 105 of file classwmi.c.

TIME_STRING_LENGTH

#define TIME_STRING_LENGTH   25

Definition at line 45 of file classwmi.c.

Function Documentation

_IRQL_requires_max_()

_IRQL_requires_max_

(

DISPATCH_LEVEL

)

Definition at line 1168 of file classwmi.c.

{

    ULONG sizeNeeded;
    PWNODE_SINGLE_INSTANCE event;
    NTSTATUS status;

    if (EventData == NULL)
    {
        EventDataSize = 0;
    }

    sizeNeeded = sizeof(WNODE_SINGLE_INSTANCE) + EventDataSize;

    event = ExAllocatePoolWithTag(NonPagedPoolNx, sizeNeeded, CLASS_TAG_WMI);
    if (event != NULL)
    {
        RtlZeroMemory(event, sizeNeeded);
        event->WnodeHeader.Guid = *Guid;
        event->WnodeHeader.ProviderId = IoWMIDeviceObjectToProviderId(DeviceObject);
        event->WnodeHeader.BufferSize = sizeNeeded;
        event->WnodeHeader.Flags =  WNODE_FLAG_SINGLE_INSTANCE |
                                    WNODE_FLAG_EVENT_ITEM |
                                    WNODE_FLAG_STATIC_INSTANCE_NAMES;
        KeQuerySystemTime(&event->WnodeHeader.TimeStamp);

        event->InstanceIndex = InstanceIndex;
        event->SizeDataBlock = EventDataSize;
        event->DataBlockOffset = sizeof(WNODE_SINGLE_INSTANCE);
        if (EventData != NULL)
        {
            RtlCopyMemory( &event->VariableData, EventData, EventDataSize);
        }

        status = IoWMIWriteEvent(event);
        if (! NT_SUCCESS(status))
        {
            FREE_POOL(event);
        }
    } else {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }

    return(status);
} // end ClassWmiFireEvent()

ClassFindGuid()

BOOLEAN ClassFindGuid	(	PGUIDREGINFO	GuidList,
		ULONG	GuidCount,
		LPGUID	Guid,
		PULONG	GuidIndex
	)

Definition at line 133 of file classwmi.c.

{
    ULONG i;

    PAGED_CODE();

    for (i = 0; i < GuidCount; i++)
    {
        if (IsEqualGUID(Guid, &GuidList[i].Guid))
        {
            *GuidIndex = i;
            return(TRUE);
        }
    }
    return(FALSE);
} // end ClassFindGuid()

Referenced by ClassSystemControl().

ClassFindInternalGuid()

BOOLEAN ClassFindInternalGuid	(	LPGUID	Guid,
		PULONG	GuidIndex
	)

Definition at line 176 of file classwmi.c.

{
    ULONG i;

    PAGED_CODE();

    for (i = 0; i < NUM_CLASS_WMI_GUIDS; i++)
    {
        if (IsEqualGUID(Guid, &wmiClassGuids[i].Guid))
        {
            *GuidIndex = i;
            return(TRUE);
        }
    }

    return(FALSE);
} // end ClassFindGuid()

Referenced by ClassSystemControl().

ClassQueryInternalDataBlock()

NTSTATUS ClassQueryInternalDataBlock	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN ULONG	GuidIndex,
		IN ULONG	BufferAvail,
		OUT PUCHAR	Buffer
	)

Definition at line 782 of file classwmi.c.

{
    NTSTATUS status;
#ifndef __REACTOS__ // WMI in not a thing on ReactOS yet
    ULONG sizeNeeded = 0, i;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = DeviceObject->DeviceExtension;
    if (GuidIndex == MSStorageDriver_ClassErrorLogGuid_Index) {

        //
        // NOTE - ClassErrorLog is still using SCSI_REQUEST_BLOCK and will not be
        // updated to support extended SRB until classpnp is updated to send >16
        // byte CDBs. Extended SRBs will be translated to SCSI_REQUEST_BLOCK.
        //
        sizeNeeded = MSStorageDriver_ClassErrorLog_SIZE;
        if (BufferAvail >= sizeNeeded) {
            PMSStorageDriver_ClassErrorLog errorLog = (PMSStorageDriver_ClassErrorLog) Buffer;
            PMSStorageDriver_ClassErrorLogEntry logEntry;
            PMSStorageDriver_ScsiRequestBlock srbBlock;
            PMSStorageDriver_SenseData senseData;
            PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
            PCLASS_ERROR_LOG_DATA fdoLogEntry;
            PSCSI_REQUEST_BLOCK fdoSRBBlock;
            PSENSE_DATA fdoSenseData;
            errorLog->numEntries = NUM_ERROR_LOG_ENTRIES;
            for (i = 0; i < NUM_ERROR_LOG_ENTRIES; i++) {
                fdoLogEntry = &fdoData->ErrorLogs[i];
                fdoSRBBlock = &fdoLogEntry->Srb;
                fdoSenseData = &fdoLogEntry->SenseData;
                logEntry = &errorLog->logEntries[i];
                srbBlock = &logEntry->srb;
                senseData = &logEntry->senseData;
                logEntry->tickCount = fdoLogEntry->TickCount.QuadPart;
                logEntry->portNumber = fdoLogEntry->PortNumber;
                logEntry->errorPaging = (fdoLogEntry->ErrorPaging == 0 ? FALSE : TRUE);
                logEntry->errorRetried = (fdoLogEntry->ErrorRetried == 0 ? FALSE : TRUE);
                logEntry->errorUnhandled = (fdoLogEntry->ErrorUnhandled == 0 ? FALSE : TRUE);
                logEntry->errorReserved = fdoLogEntry->ErrorReserved;
                RtlMoveMemory(logEntry->reserved, fdoLogEntry->Reserved, sizeof(logEntry->reserved));
                ConvertTickToDateTime(fdoLogEntry->TickCount, logEntry->eventTime);

                srbBlock->length = fdoSRBBlock->Length;
                srbBlock->function = fdoSRBBlock->Function;
                srbBlock->srbStatus = fdoSRBBlock->SrbStatus;
                srbBlock->scsiStatus = fdoSRBBlock->ScsiStatus;
                srbBlock->pathID = fdoSRBBlock->PathId;
                srbBlock->targetID = fdoSRBBlock->TargetId;
                srbBlock->lun = fdoSRBBlock->Lun;
                srbBlock->queueTag = fdoSRBBlock->QueueTag;
                srbBlock->queueAction = fdoSRBBlock->QueueAction;
                srbBlock->cdbLength = fdoSRBBlock->CdbLength;
                srbBlock->senseInfoBufferLength = fdoSRBBlock->SenseInfoBufferLength;
                srbBlock->srbFlags = fdoSRBBlock->SrbFlags;
                srbBlock->dataTransferLength = fdoSRBBlock->DataTransferLength;
                srbBlock->timeOutValue = fdoSRBBlock->TimeOutValue;
                srbBlock->dataBuffer = (ULONGLONG) fdoSRBBlock->DataBuffer;
                srbBlock->senseInfoBuffer = (ULONGLONG) fdoSRBBlock->SenseInfoBuffer;
                srbBlock->nextSRB = (ULONGLONG) fdoSRBBlock->NextSrb;
                srbBlock->originalRequest = (ULONGLONG) fdoSRBBlock->OriginalRequest;
                srbBlock->srbExtension = (ULONGLONG) fdoSRBBlock->SrbExtension;
                srbBlock->internalStatus = fdoSRBBlock->InternalStatus;
#if defined(_WIN64)
                srbBlock->reserved = fdoSRBBlock->Reserved;
#else
                srbBlock->reserved = 0;
#endif
                RtlMoveMemory(srbBlock->cdb, fdoSRBBlock->Cdb, sizeof(srbBlock->cdb));

                //
                // Note: Sense data has been converted into Fixed format before it was
                //       put in the log.  Therefore, no conversion is needed here.
                //
                senseData->errorCode = fdoSenseData->ErrorCode;
                senseData->valid = (fdoSenseData->Valid == 0 ? FALSE : TRUE);
                senseData->segmentNumber = fdoSenseData->SegmentNumber;
                senseData->senseKey = fdoSenseData->SenseKey;
                senseData->reserved = (fdoSenseData->Reserved == 0 ? FALSE : TRUE);
                senseData->incorrectLength = (fdoSenseData->IncorrectLength == 0 ? FALSE : TRUE);
                senseData->endOfMedia = (fdoSenseData->EndOfMedia == 0 ? FALSE : TRUE);
                senseData->fileMark = (fdoSenseData->FileMark == 0 ? FALSE : TRUE);
                RtlMoveMemory(senseData->information, fdoSenseData->Information, sizeof(senseData->information));
                senseData->additionalSenseLength = fdoSenseData->AdditionalSenseLength;
                RtlMoveMemory(senseData->commandSpecificInformation, fdoSenseData->CommandSpecificInformation, sizeof(senseData->commandSpecificInformation));
                senseData->additionalSenseCode = fdoSenseData->AdditionalSenseCode;
                senseData->additionalSenseCodeQualifier = fdoSenseData->AdditionalSenseCodeQualifier;
                senseData->fieldReplaceableUnitCode = fdoSenseData->FieldReplaceableUnitCode;
                RtlMoveMemory(senseData->senseKeySpecific, fdoSenseData->SenseKeySpecific, sizeof(senseData->senseKeySpecific));
            }
            status = STATUS_SUCCESS;
        } else {
            status = STATUS_BUFFER_TOO_SMALL;
        }
    } else if (GuidIndex > 0 && GuidIndex < NUM_CLASS_WMI_GUIDS) {
        status = STATUS_WMI_INSTANCE_NOT_FOUND;
    } else {
        status = STATUS_WMI_GUID_NOT_FOUND;
    }
#else
    ULONG sizeNeeded = 0;
    status = STATUS_WMI_GUID_NOT_FOUND;
#endif
    status = ClassWmiCompleteRequest(DeviceObject,
                                    Irp,
                                    status,
                                    sizeNeeded,
                                    IO_NO_INCREMENT);
    return status;
}

Referenced by ClassSystemControl().

ClassSystemControl()

NTSTATUS NTAPI ClassSystemControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 221 of file classwmi.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PCLASS_DRIVER_EXTENSION driverExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    ULONG isRemoved;
    ULONG bufferSize;
    PUCHAR buffer;
    NTSTATUS status;
    UCHAR minorFunction;
    ULONG guidIndex = (ULONG)-1;
    PCLASS_WMI_INFO classWmiInfo;
    BOOLEAN isInternalGuid = FALSE;

    PAGED_CODE();

    //
    // Make sure device has not been removed
    isRemoved = ClassAcquireRemoveLock(DeviceObject, Irp);
    if(isRemoved)
    {
        Irp->IoStatus.Status = STATUS_DEVICE_DOES_NOT_EXIST;
        ClassReleaseRemoveLock(DeviceObject, Irp);
        ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
        return STATUS_DEVICE_DOES_NOT_EXIST;
    }

    //
    // If the irp is not a WMI irp or it is not targetted at this device
    // or this device has not regstered with WMI then just forward it on.
    minorFunction = irpStack->MinorFunction;
    if ((minorFunction > IRP_MN_EXECUTE_METHOD) ||
        (irpStack->Parameters.WMI.ProviderId != (ULONG_PTR)DeviceObject) ||
        ((minorFunction != IRP_MN_REGINFO) &&
         (commonExtension->GuidCount == 0)))
    {
        //
        // CONSIDER: Do I need to hang onto lock until IoCallDriver returns ?
        IoSkipCurrentIrpStackLocation(Irp);
        ClassReleaseRemoveLock(DeviceObject, Irp);
        return(IoCallDriver(commonExtension->LowerDeviceObject, Irp));
    }

    buffer = (PUCHAR)irpStack->Parameters.WMI.Buffer;
    bufferSize = irpStack->Parameters.WMI.BufferSize;

    if (minorFunction != IRP_MN_REGINFO)
    {
        //
        // For all requests other than query registration info we are passed
        // a guid. Determine if the guid is one that is supported by the
        // device.
        if (commonExtension->GuidRegInfo != NULL &&
            ClassFindGuid(commonExtension->GuidRegInfo,
                            commonExtension->GuidCount,
                            (LPGUID)irpStack->Parameters.WMI.DataPath,
                            &guidIndex))
        {
            isInternalGuid = FALSE;
            status = STATUS_SUCCESS;
        } else if (ClassFindInternalGuid((LPGUID)irpStack->Parameters.WMI.DataPath,
                            &guidIndex)) {
            isInternalGuid = TRUE;
            status = STATUS_SUCCESS;
        } else {
            status = STATUS_WMI_GUID_NOT_FOUND;
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_WMI, "WMI GUID not found!"));
        }

        TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_WMI, "WMI Find Guid = %x, isInternalGuid = %x", status, isInternalGuid));
        if (NT_SUCCESS(status) &&
            ((minorFunction == IRP_MN_QUERY_SINGLE_INSTANCE) ||
             (minorFunction == IRP_MN_CHANGE_SINGLE_INSTANCE) ||
             (minorFunction == IRP_MN_CHANGE_SINGLE_ITEM) ||
             (minorFunction == IRP_MN_EXECUTE_METHOD)))
        {
            if ( (((PWNODE_HEADER)buffer)->Flags) &
                                          WNODE_FLAG_STATIC_INSTANCE_NAMES)
            {
                if ( ((PWNODE_SINGLE_INSTANCE)buffer)->InstanceIndex != 0 )
                {
                    status = STATUS_WMI_INSTANCE_NOT_FOUND;
                }
            } else {
                status = STATUS_WMI_INSTANCE_NOT_FOUND;
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_WMI, "WMI Instance not found!"));
            }
        }

        if (! NT_SUCCESS(status))
        {
            Irp->IoStatus.Status = status;
            ClassReleaseRemoveLock(DeviceObject, Irp);
            ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
            return(status);
        }
    }

    driverExtension = commonExtension->DriverExtension;

    classWmiInfo = commonExtension->IsFdo ?
                           &driverExtension->InitData.FdoData.ClassWmiInfo :
                           &driverExtension->InitData.PdoData.ClassWmiInfo;
    switch(minorFunction)
    {
        case IRP_MN_REGINFO:
        {
            ULONG guidCount;
            PGUIDREGINFO guidList;
            PWMIREGINFOW wmiRegInfo;
            PWMIREGGUIDW wmiRegGuid;
            PUNICODE_STRING regPath;
            PWCHAR stringPtr;
            ULONG retSize;
            ULONG registryPathOffset;
            ULONG mofResourceOffset;
            ULONG bufferNeeded;
            ULONG i;
            ULONG_PTR nameInfo;
            ULONG nameSize, nameOffset, nameFlags;
            UNICODE_STRING name, mofName;
            PCLASS_QUERY_WMI_REGINFO_EX ClassQueryWmiRegInfoEx;

            name.Buffer = NULL;
            name.Length = 0;
            name.MaximumLength = 0;
            nameFlags = 0;

            ClassQueryWmiRegInfoEx = commonExtension->IsFdo ?
                               driverExtension->ClassFdoQueryWmiRegInfoEx :
                               driverExtension->ClassPdoQueryWmiRegInfoEx;

            if ((classWmiInfo->GuidRegInfo != NULL) &&
                (classWmiInfo->ClassQueryWmiRegInfo != NULL) &&
                (ClassQueryWmiRegInfoEx == NULL))
            {
                status = classWmiInfo->ClassQueryWmiRegInfo(
                                                        DeviceObject,
                                                        &nameFlags,
                                                        &name);

                RtlInitUnicodeString(&mofName, MOFRESOURCENAME);

            } else if ((classWmiInfo->GuidRegInfo != NULL) && (ClassQueryWmiRegInfoEx != NULL)) {
                RtlInitUnicodeString(&mofName, L"");

                status = (*ClassQueryWmiRegInfoEx)(
                                                    DeviceObject,
                                                    &nameFlags,
                                                    &name,
                                                    &mofName);
            } else {
                RtlInitUnicodeString(&mofName, L"");
                nameFlags = WMIREG_FLAG_INSTANCE_PDO;
                status = STATUS_SUCCESS;
            }

            if (NT_SUCCESS(status) &&
                (! (nameFlags &  WMIREG_FLAG_INSTANCE_PDO) &&
                (name.Buffer == NULL)))
            {
                //
                // if PDO flag not specified then an instance name must be
                status = STATUS_INVALID_DEVICE_REQUEST;
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_WMI, "Invalid Device Request!"));
            }

            if (NT_SUCCESS(status))
            {
                guidList = classWmiInfo->GuidRegInfo;
                guidCount = (classWmiInfo->GuidRegInfo == NULL ? 0 : classWmiInfo->GuidCount) + NUM_CLASS_WMI_GUIDS;

                nameOffset = sizeof(WMIREGINFO) +
                                      guidCount * sizeof(WMIREGGUIDW);

                if (nameFlags & WMIREG_FLAG_INSTANCE_PDO)
                {
                    nameSize = 0;
                    nameInfo = commonExtension->IsFdo ?
                                   (ULONG_PTR)((PFUNCTIONAL_DEVICE_EXTENSION)commonExtension)->LowerPdo :
                                   (ULONG_PTR)DeviceObject;
                } else {
                    nameFlags |= WMIREG_FLAG_INSTANCE_LIST;
                    nameSize = name.Length + sizeof(USHORT);
                    nameInfo = nameOffset;
                }

                mofResourceOffset = nameOffset + nameSize;

                registryPathOffset = mofResourceOffset +
                                  mofName.Length + sizeof(USHORT);

                regPath = &driverExtension->RegistryPath;

                bufferNeeded = registryPathOffset + regPath->Length;
                bufferNeeded += sizeof(USHORT);

                if (bufferNeeded <= bufferSize)
                {
                    retSize = bufferNeeded;

                    commonExtension->GuidCount = guidCount;
                    commonExtension->GuidRegInfo = guidList;

                    wmiRegInfo = (PWMIREGINFO)buffer;
                    wmiRegInfo->BufferSize = bufferNeeded;
                    wmiRegInfo->NextWmiRegInfo = 0;
                    wmiRegInfo->MofResourceName = mofResourceOffset;
                    wmiRegInfo->RegistryPath = registryPathOffset;
                    wmiRegInfo->GuidCount = guidCount;

                    for (i = 0; i < classWmiInfo->GuidCount; i++)
                    {
                        wmiRegGuid = &wmiRegInfo->WmiRegGuid[i];
                        wmiRegGuid->Guid = guidList[i].Guid;
                        wmiRegGuid->Flags = guidList[i].Flags | nameFlags;
                        wmiRegGuid->InstanceInfo = nameInfo;
                        wmiRegGuid->InstanceCount = 1;
                    }
                    for (i = 0; i < NUM_CLASS_WMI_GUIDS; i++)
                    {
                        wmiRegGuid = &wmiRegInfo->WmiRegGuid[i + classWmiInfo->GuidCount];
                        wmiRegGuid->Guid = wmiClassGuids[i].Guid;
                        wmiRegGuid->Flags = wmiClassGuids[i].Flags | nameFlags;
                        wmiRegGuid->InstanceInfo = nameInfo;
                        wmiRegGuid->InstanceCount = 1;
                    }

                    if ( nameFlags &  WMIREG_FLAG_INSTANCE_LIST)
                    {
                        bufferNeeded = nameOffset + sizeof(WCHAR);
                        bufferNeeded += name.Length;

                        if (bufferSize >= bufferNeeded){
                            stringPtr = (PWCHAR)((PUCHAR)buffer + nameOffset);
                            *stringPtr++ = name.Length;
                            RtlCopyMemory(stringPtr, name.Buffer, name.Length);
                        }
                        else {
                            NT_ASSERT(bufferSize >= bufferNeeded);
                            status = STATUS_INVALID_BUFFER_SIZE;
                        }
                    }

                    bufferNeeded = mofResourceOffset + sizeof(WCHAR);
                    bufferNeeded += mofName.Length;

                    if (bufferSize >= bufferNeeded){
                        stringPtr = (PWCHAR)((PUCHAR)buffer + mofResourceOffset);
                        *stringPtr++ = mofName.Length;
                        RtlCopyMemory(stringPtr, mofName.Buffer, mofName.Length);
                    }
                    else {
                        NT_ASSERT(bufferSize >= bufferNeeded);
                        status = STATUS_INVALID_BUFFER_SIZE;
                    }

                    bufferNeeded = registryPathOffset + sizeof(WCHAR);
                    bufferNeeded += regPath->Length;

                    if (bufferSize >= bufferNeeded){
                        stringPtr = (PWCHAR)((PUCHAR)buffer + registryPathOffset);
                        *stringPtr++ = regPath->Length;
                        RtlCopyMemory(stringPtr,
                                  regPath->Buffer,
                                  regPath->Length);
                    }
                    else {

                        NT_ASSERT(bufferSize >= bufferNeeded);
                        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_WMI, "Invalid Buffer Size!"));
                        status = STATUS_INVALID_BUFFER_SIZE;
                    }

                } else {
                    *((PULONG)buffer) = bufferNeeded;
                    retSize = sizeof(ULONG);
                }
            } else {
                retSize = 0;
            }

            FREE_POOL(name.Buffer);

            Irp->IoStatus.Status = status;
            Irp->IoStatus.Information = retSize;
            ClassReleaseRemoveLock(DeviceObject, Irp);
            ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
            return(status);
        }

        case IRP_MN_QUERY_ALL_DATA:
        {
            PWNODE_ALL_DATA wnode;
            ULONG bufferAvail;

            wnode = (PWNODE_ALL_DATA)buffer;

            if (bufferSize < sizeof(WNODE_ALL_DATA))
            {
                bufferAvail = 0;
            } else {
                bufferAvail = bufferSize - sizeof(WNODE_ALL_DATA);
            }

            wnode->DataBlockOffset = sizeof(WNODE_ALL_DATA);

            NT_ASSERT(guidIndex != (ULONG)-1);
            _Analysis_assume_(isInternalGuid);
            if (isInternalGuid)
            {
                status = ClassQueryInternalDataBlock(
                                                DeviceObject,
                                                Irp,
                                                guidIndex,
                                                bufferAvail,
                                                buffer + sizeof(WNODE_ALL_DATA));
            } else {
                status = classWmiInfo->ClassQueryWmiDataBlock(
                                                 DeviceObject,
                                                 Irp,
                                                 guidIndex,
                                                 bufferAvail,
                                                 buffer + sizeof(WNODE_ALL_DATA));
            }
            break;
        }

        case IRP_MN_QUERY_SINGLE_INSTANCE:
        {
            PWNODE_SINGLE_INSTANCE wnode;
            ULONG dataBlockOffset;

            wnode = (PWNODE_SINGLE_INSTANCE)buffer;

            dataBlockOffset = wnode->DataBlockOffset;

            NT_ASSERT(guidIndex != (ULONG)-1);
            _Analysis_assume_(isInternalGuid);
            if (isInternalGuid)
            {
                status = ClassQueryInternalDataBlock(
                                            DeviceObject,
                                            Irp,
                                            guidIndex,
                                            bufferSize - dataBlockOffset,
                                            (PUCHAR)wnode + dataBlockOffset);
            } else {
                status = classWmiInfo->ClassQueryWmiDataBlock(
                                              DeviceObject,
                                              Irp,
                                              guidIndex,
                                              bufferSize - dataBlockOffset,
                                              (PUCHAR)wnode + dataBlockOffset);
            }
            break;
        }

        case IRP_MN_CHANGE_SINGLE_INSTANCE:
        {
            PWNODE_SINGLE_INSTANCE wnode;

            wnode = (PWNODE_SINGLE_INSTANCE)buffer;
            _Analysis_assume_(isInternalGuid);
            if (isInternalGuid)
            {
                status = ClassWmiCompleteRequest(DeviceObject,
                                                Irp,
                                                STATUS_WMI_GUID_NOT_FOUND,
                                                0,
                                                IO_NO_INCREMENT);
            } else {

                NT_ASSERT(guidIndex != (ULONG)-1);

                status = classWmiInfo->ClassSetWmiDataBlock(
                                         DeviceObject,
                                         Irp,
                                         guidIndex,
                                         wnode->SizeDataBlock,
                                         (PUCHAR)wnode + wnode->DataBlockOffset);
            }

            break;
        }

        case IRP_MN_CHANGE_SINGLE_ITEM:
        {
            PWNODE_SINGLE_ITEM wnode;

            wnode = (PWNODE_SINGLE_ITEM)buffer;

            NT_ASSERT(guidIndex != (ULONG)-1);
            _Analysis_assume_(isInternalGuid);
            if (isInternalGuid)
            {
                status = ClassWmiCompleteRequest(DeviceObject,
                                                Irp,
                                                STATUS_WMI_GUID_NOT_FOUND,
                                                0,
                                                IO_NO_INCREMENT);
            } else {

                NT_ASSERT(guidIndex != (ULONG)-1);

                status = classWmiInfo->ClassSetWmiDataItem(
                                         DeviceObject,
                                         Irp,
                                         guidIndex,
                                         wnode->ItemId,
                                         wnode->SizeDataItem,
                                         (PUCHAR)wnode + wnode->DataBlockOffset);

            }

            break;
        }

        case IRP_MN_EXECUTE_METHOD:
        {
            PWNODE_METHOD_ITEM wnode;

            wnode = (PWNODE_METHOD_ITEM)buffer;
            _Analysis_assume_(isInternalGuid);
            if (isInternalGuid)
            {
                status = ClassWmiCompleteRequest(DeviceObject,
                                                Irp,
                                                STATUS_WMI_GUID_NOT_FOUND,
                                                0,
                                                IO_NO_INCREMENT);
            } else {

                NT_ASSERT(guidIndex != (ULONG)-1);

                status = classWmiInfo->ClassExecuteWmiMethod(
                                             DeviceObject,
                                             Irp,
                                             guidIndex,
                                             wnode->MethodId,
                                             wnode->SizeDataBlock,
                                             bufferSize - wnode->DataBlockOffset,
                                             buffer + wnode->DataBlockOffset);
            }

            break;
        }

        case IRP_MN_ENABLE_EVENTS:
        {
            _Analysis_assume_(isInternalGuid);
            if (isInternalGuid)
            {
                status = ClassWmiCompleteRequest(DeviceObject,
                                                Irp,
                                                STATUS_WMI_GUID_NOT_FOUND,
                                                0,
                                                IO_NO_INCREMENT);
            } else {

                NT_ASSERT(guidIndex != (ULONG)-1);

                status = classWmiInfo->ClassWmiFunctionControl(
                                                               DeviceObject,
                                                               Irp,
                                                               guidIndex,
                                                               EventGeneration,
                                                               TRUE);
            }
            break;
        }

        case IRP_MN_DISABLE_EVENTS:
        {
            _Analysis_assume_(isInternalGuid);
            if (isInternalGuid)
            {
                status = ClassWmiCompleteRequest(DeviceObject,
                                                Irp,
                                                STATUS_WMI_GUID_NOT_FOUND,
                                                0,
                                                IO_NO_INCREMENT);
            } else {

                NT_ASSERT(guidIndex != (ULONG)-1);

                status = classWmiInfo->ClassWmiFunctionControl(
                                                               DeviceObject,
                                                               Irp,
                                                               guidIndex,
                                                               EventGeneration,
                                                               FALSE);
            }
            break;
        }

        case IRP_MN_ENABLE_COLLECTION:
        {
            _Analysis_assume_(isInternalGuid);
            if (isInternalGuid)
            {
                status = ClassWmiCompleteRequest(DeviceObject,
                                                Irp,
                                                STATUS_WMI_GUID_NOT_FOUND,
                                                0,
                                                IO_NO_INCREMENT);
            } else {

                NT_ASSERT(guidIndex != (ULONG)-1);

                status = classWmiInfo->ClassWmiFunctionControl(
                                                             DeviceObject,
                                                             Irp,
                                                             guidIndex,
                                                             DataBlockCollection,
                                                             TRUE);
            }
            break;
        }

        case IRP_MN_DISABLE_COLLECTION:
        {
            _Analysis_assume_(isInternalGuid);
            if (isInternalGuid)
            {
                status = ClassWmiCompleteRequest(DeviceObject,
                                                Irp,
                                                STATUS_WMI_GUID_NOT_FOUND,
                                                0,
                                                IO_NO_INCREMENT);
            } else {

                NT_ASSERT(guidIndex != (ULONG)-1);

                status = classWmiInfo->ClassWmiFunctionControl(
                                                             DeviceObject,
                                                             Irp,
                                                             guidIndex,
                                                             DataBlockCollection,
                                                             FALSE);
            }

            break;
        }

        default:
        {
            status = STATUS_INVALID_DEVICE_REQUEST;
            break;
        }

    }

    return(status);
} // end ClassSystemControl()

Referenced by ClassInitializeDispatchTables().

ClassWmiCompleteRequest()

SCSIPORT_API NTSTATUS NTAPI ClassWmiCompleteRequest	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp,
		_In_ NTSTATUS	Status,
		_In_ ULONG	BufferUsed,
		_In_ CCHAR	PriorityBoost
	)

Definition at line 1009 of file classwmi.c.

{
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PUCHAR buffer;
    ULONG retSize;
    UCHAR minorFunction;

    minorFunction = irpStack->MinorFunction;
    buffer = (PUCHAR)irpStack->Parameters.WMI.Buffer;

    switch(minorFunction)
    {
        case IRP_MN_QUERY_ALL_DATA:
        {
            PWNODE_ALL_DATA wnode;
            PWNODE_TOO_SMALL wnodeTooSmall;
            ULONG bufferNeeded;

            wnode = (PWNODE_ALL_DATA)buffer;

            bufferNeeded = sizeof(WNODE_ALL_DATA) + BufferUsed;

            if (NT_SUCCESS(Status))
            {
                retSize = bufferNeeded;
                wnode->WnodeHeader.BufferSize = bufferNeeded;
                KeQuerySystemTime(&wnode->WnodeHeader.TimeStamp);
                wnode->WnodeHeader.Flags |= WNODE_FLAG_FIXED_INSTANCE_SIZE;
                wnode->FixedInstanceSize = BufferUsed;
                wnode->InstanceCount = 1;

            } else if (Status == STATUS_BUFFER_TOO_SMALL) {
                wnodeTooSmall = (PWNODE_TOO_SMALL)wnode;

                wnodeTooSmall->WnodeHeader.BufferSize = sizeof(WNODE_TOO_SMALL);
                wnodeTooSmall->WnodeHeader.Flags = WNODE_FLAG_TOO_SMALL;
                wnodeTooSmall->SizeNeeded = sizeof(WNODE_ALL_DATA) + BufferUsed;
                retSize = sizeof(WNODE_TOO_SMALL);
                Status = STATUS_SUCCESS;
            } else {
                retSize = 0;
            }
            break;
        }

        case IRP_MN_QUERY_SINGLE_INSTANCE:
        {
            PWNODE_SINGLE_INSTANCE wnode;
            PWNODE_TOO_SMALL wnodeTooSmall;
            ULONG bufferNeeded;

            wnode = (PWNODE_SINGLE_INSTANCE)buffer;

            bufferNeeded = wnode->DataBlockOffset + BufferUsed;

            if (NT_SUCCESS(Status))
            {
                retSize = bufferNeeded;
                wnode->WnodeHeader.BufferSize = bufferNeeded;
                KeQuerySystemTime(&wnode->WnodeHeader.TimeStamp);
                wnode->SizeDataBlock = BufferUsed;

            } else if (Status == STATUS_BUFFER_TOO_SMALL) {
                wnodeTooSmall = (PWNODE_TOO_SMALL)wnode;

                wnodeTooSmall->WnodeHeader.BufferSize = sizeof(WNODE_TOO_SMALL);
                wnodeTooSmall->WnodeHeader.Flags = WNODE_FLAG_TOO_SMALL;
                wnodeTooSmall->SizeNeeded = bufferNeeded;
                retSize = sizeof(WNODE_TOO_SMALL);
                Status = STATUS_SUCCESS;
            } else {
                retSize = 0;
            }
            break;
        }

        case IRP_MN_EXECUTE_METHOD:
        {
            PWNODE_METHOD_ITEM wnode;
            PWNODE_TOO_SMALL wnodeTooSmall;
            ULONG bufferNeeded;

            wnode = (PWNODE_METHOD_ITEM)buffer;

            bufferNeeded = wnode->DataBlockOffset + BufferUsed;

            if (NT_SUCCESS(Status))
            {
                retSize = bufferNeeded;
                wnode->WnodeHeader.BufferSize = bufferNeeded;
                KeQuerySystemTime(&wnode->WnodeHeader.TimeStamp);
                wnode->SizeDataBlock = BufferUsed;

            } else if (Status == STATUS_BUFFER_TOO_SMALL) {
                wnodeTooSmall = (PWNODE_TOO_SMALL)wnode;

                wnodeTooSmall->WnodeHeader.BufferSize = sizeof(WNODE_TOO_SMALL);
                wnodeTooSmall->WnodeHeader.Flags = WNODE_FLAG_TOO_SMALL;
                wnodeTooSmall->SizeNeeded = bufferNeeded;
                retSize = sizeof(WNODE_TOO_SMALL);
                Status = STATUS_SUCCESS;
            } else {
                retSize = 0;
            }
            break;
        }

        default:
        {
            //
            // All other requests don't return any data
            retSize = 0;
            break;
        }

    }

    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = retSize;
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, PriorityBoost);
    return(Status);
} // end ClassWmiCompleteRequest()

Referenced by ClassQueryInternalDataBlock(), ClassSystemControl(), DiskFdoExecuteWmiMethod(), DiskFdoQueryWmiDataBlock(), DiskFdoSetWmiDataBlock(), DiskFdoSetWmiDataItem(), and DiskWmiFunctionControl().

ConvertTickToDateTime()

PWCHAR ConvertTickToDateTime	(	IN LARGE_INTEGER	Tick,
		_Out_writes_(TIME_STRING_LENGTH) PWCHAR	String
	)

Definition at line 925 of file classwmi.c.

{
    LARGE_INTEGER nowTick, nowTime, time;
    ULONG maxInc = 0;
    TIME_FIELDS timeFields = {0};
    WCHAR outDateTime[TIME_STRING_LENGTH + 1];

    nowTick.QuadPart = 0;
    nowTime.QuadPart = 0;
    //
    // Translate the tick count to a system time
    //
    KeQueryTickCount(&nowTick);
    maxInc = KeQueryTimeIncrement();
    KeQuerySystemTime(&nowTime);
    time.QuadPart = nowTime.QuadPart - ((nowTick.QuadPart - Tick.QuadPart) * maxInc);

    RtlTimeToTimeFields(&time, &timeFields);

    //
    // The buffer String is of size MAX_PATH. Use that to specify the buffer size.
    //
    //yyyymmddhhmmss.mmmmmmsutc
    RtlStringCbPrintfW(outDateTime, sizeof(outDateTime), L"%04d%02d%02d%02d%02d%02d.%03d***+000", timeFields.Year, timeFields.Month, timeFields.Day, timeFields.Hour, timeFields.Minute, timeFields.Second, timeFields.Milliseconds);
    RtlMoveMemory(String, outDateTime, sizeof(WCHAR) * TIME_STRING_LENGTH);
    return  String;
}

Referenced by ClassQueryInternalDataBlock().

Variable Documentation

wmiClassGuids

GUIDREGINFO wmiClassGuids[]

Initial value:

=
{
    {
        MSStorageDriver_ClassErrorLogGuid, 1, 0
    }
}

Definition at line 97 of file classwmi.c.

Referenced by ClassFindInternalGuid(), and ClassSystemControl().