wmisample.c

WMI implementation in a iSCSI miniport can be tested using the iscsicli.exe application, device ma

    //
    // Initialize discovery config
    //
    AdapterExtension->DiscoveryConfigFlags = (DISCOVERY_CONFIG_DO_DISCOVERY |
                                              DISCOVERY_CONFIG_FIND_SNS_AUTOMATICALLY);
    AdapterExtension->SNSServer[0] = 0;


    //
    // Initialize the wmilib context for the PDO
    //
    wmiLibContext = &(AdapterExtension->PDOWmiLibContext);

    wmiLibContext->GuidList = iScsiPDOWmiGuidList;
    wmiLibContext->GuidCount = iScsiPDOWmiGuidCount;

    //
    // Set pointers to WMI callback routines
    //
    wmiLibContext->QueryWmiRegInfo = iScsiQueryWmiRegInfo;
    wmiLibContext->QueryWmiDataBlock = iScsiPDOQueryWmiDataBlock;
    wmiLibContext->ExecuteWmiMethod = NULL;
    wmiLibContext->WmiFunctionControl = NULL;
    wmiLibContext->SetWmiDataItem = NULL;
    wmiLibContext->SetWmiDataBlock = NULL;
        
    return;
}

BOOLEAN
iScsiWmiSrb(
    IN     PISCSI_ADAPTER_EXTENSION    AdapterExtension,
    IN OUT PSCSI_WMI_REQUEST_BLOCK     Srb
    )
/*++

Routine Description:

   Called from StartIo routine to process an SRB_FUNCTION_WMI request.
   Main entry point for all WMI routines.

Arguments:

   AdapterExtension - ISCSI miniport driver's Adapter extension.

   Srb              - IO request packet.

Return Value:

   Always TRUE.

--*/
{
   PSCSIWMI_REQUEST_CONTEXT requestContext;
   PISCSI_SRB_EXTENSION srbExtension;
   BOOLEAN pending;
   BOOLEAN completeRequest = TRUE;
   BOOLEAN adapterRequest;


   //
   // Validate our assumptions.
   //
   ASSERT(Srb->Function == SRB_FUNCTION_WMI);
   ASSERT(Srb->Length == sizeof(SCSI_WMI_REQUEST_BLOCK));

   srbExtension = (PISCSI_SRB_EXTENSION) Srb->SrbExtension;

   requestContext = &(srbExtension->WmiRequestContext);

   //
   // Save the pointer to the SRB in UserContext
   // of SCSIWMI_REQUEST_CONTEXT
   //
   requestContext->UserContext = Srb;

   //
   // Check if the WMI SRB is targetted for 
   // the iScsi adapter or one of the devices
   //
   adapterRequest = (Srb->WMIFlags & SRB_WMI_FLAGS_ADAPTER_REQUEST) == SRB_WMI_FLAGS_ADAPTER_REQUEST;

   //
   // Process the incoming WMI request.
   //
   DebugPrint((iScsiPrtDebugTrace, "Adapter iscsiWMI SRB section\n"));

   pending = ScsiPortWmiDispatchFunction(adapterRequest ? 
                                            &AdapterExtension->WmiLibContext :
                                            &AdapterExtension->PDOWmiLibContext,
                                         Srb->WMISubFunction,
                                         AdapterExtension,
                                         requestContext,
                                         Srb->DataPath,
                                         Srb->DataTransferLength,
                                         Srb->DataBuffer);
   if (pending == FALSE) {

       //
       // We can do this since we assume it is done synchronously
       //
       Srb->DataTransferLength = ScsiPortWmiGetReturnSize(requestContext);;

       //
       // Adapter ready for next request.
       //
       Srb->SrbStatus = ScsiPortWmiGetReturnStatus(requestContext);

   }  else {
       completeRequest = FALSE;
   }

   if (completeRequest == TRUE) {
       ScsiPortNotification(RequestComplete, AdapterExtension, Srb);
   } 

   return TRUE;
}

UCHAR
iScsiQueryWmiRegInfo(
    IN PVOID Context,
    IN PSCSIWMI_REQUEST_CONTEXT RequestContext,
    __out PWCHAR *MofResourceName
    )
/*+++

Routine Description:
    
    This routine returns MofResourceName for this driver.
    
--*/
{
    *MofResourceName = iScsiWmi_MofResourceName;

    return SRB_STATUS_SUCCESS;
}

BOOLEAN
iScsiQueryWmiDataBlock(
    IN PVOID Context,
    IN PSCSIWMI_REQUEST_CONTEXT DispatchContext,
    IN ULONG GuidIndex,
    IN ULONG InstanceIndex,
    IN ULONG InstanceCount,
    IN OUT PULONG InstanceLengthArray,
    IN ULONG BufferAvail,
    OUT PUCHAR Buffer
    )
/*+++

Routine Description :

    Called to query WMI Data blocks
     
--*/
{
    PISCSI_ADAPTER_EXTENSION adapterExtension;
    PSCSI_WMI_REQUEST_BLOCK  srb;
    UCHAR status;
    ULONG sizeNeeded = 0;


    adapterExtension = (PISCSI_ADAPTER_EXTENSION) Context;
    srb = (PSCSI_WMI_REQUEST_BLOCK) DispatchContext->UserContext;
    
    switch (GuidIndex) {
        case iSCSI_Operations_GUID_Index: 
        case iScsi_LB_Operations_GUID_Index: {

            //
            // Even though this class only has methods, we need to
            // respond to any queries for it since WMI expects that
            // there is an actual instance of the class on which to
            // execute the method
            //

            sizeNeeded = sizeof(ULONG);
            if (BufferAvail >= sizeNeeded) {
                *InstanceLengthArray = sizeNeeded;
                status = SRB_STATUS_SUCCESS;
            } else {
                status = SRB_STATUS_DATA_OVERRUN;
            }

            break;
        }

        case iSCSI_HBAInformation_GUID_Index: {

            PMSiSCSI_HBAInformation iScsiHBAInformation;

            sizeNeeded = sizeof(MSiSCSI_HBAInformation);
            if (BufferAvail >= sizeNeeded) {

                *InstanceLengthArray = sizeNeeded;

                iScsiHBAInformation = (PMSiSCSI_HBAInformation) Buffer;

                iSpBuildHBAInformationBuffer(adapterExtension, iScsiHBAInformation);

                status = SRB_STATUS_SUCCESS;

            } else {

                status = SRB_STATUS_DATA_OVERRUN;
            }

            break;
        }

        case iScsi_InitiatorInstanceStatistics_GUID_INDEX: {
        
            sizeNeeded = sizeof(MSiSCSI_InitiatorInstanceStatistics);

            if (BufferAvail >= sizeNeeded) {

                status =  iSpReadInitiatorInstanceStatistics(adapterExtension, 
                                                             Buffer);

                if (status != SRB_STATUS_ERROR) {
                    *InstanceLengthArray = sizeNeeded;

                    status = SRB_STATUS_SUCCESS;
                }
            } else {
                status = SRB_STATUS_DATA_OVERRUN;
            }

            break;
        }

        case iScsi_ConnectStatistics_GUID_INDEX: {

            status = iSpBuildConnectionStatistics(adapterExtension,
                                                  DispatchContext,
                                                  GuidIndex,
                                                  InstanceIndex,
                                                  InstanceCount,
                                                  InstanceLengthArray,
                                                  BufferAvail,
                                                  Buffer,
                                                  &sizeNeeded);        

            break;
        }

        case iScsi_RequestProcessingTime_GUID_Index: {

            status = iSpBuildRequestTimeStatistics(adapterExtension,
                                                   DispatchContext,
                                                   GuidIndex,
                                                   InstanceIndex,
                                                   InstanceCount,
                                                   InstanceLengthArray,
                                                   BufferAvail,
                                                   Buffer,
                                                   &sizeNeeded);        

            break;
        }

        case iScsi_SessionStatistics_GUID_INDEX: {


            status = iSpBuildSessionStatistics(adapterExtension,
                                               DispatchContext,
                                               GuidIndex,
                                               InstanceIndex,
                                               InstanceCount,
                                               InstanceLengthArray,
                                               BufferAvail,
                                               Buffer,
                                               &sizeNeeded);        
            break;
        }

        case iScsi_InitiatorLoginStatistics_GUID_INDEX: {
            PWMI_CONNECTION_LIST connectionList;
            ULONG numberOfSessions;
            ULONG numberOfConnections;          
                                                            
            sizeNeeded = sizeof(MSiSCSI_InitiatorLoginStatistics);
            if (BufferAvail >= sizeNeeded)
            {
                RtlZeroMemory(Buffer, sizeNeeded);

                connectionList = iSpGetConnectionList(adapterExtension, 
                                                      &numberOfSessions,
                                                      &numberOfConnections);

                if (connectionList != NULL)
                {
                    status = iSpReadInitiatorLoginStatistics(adapterExtension,
                                                            connectionList,
                                                            numberOfSessions,
                                                            Buffer);
                    
                    *InstanceLengthArray = sizeNeeded;
                    
                    iSpReleaseConnectionReferences(connectionList,
                                                   numberOfSessions);

                } else {
                    status = SRB_STATUS_ERROR;
                }
                                                        
                
            } else {
                status = SRB_STATUS_DATA_OVERRUN;
            }
            break;
        }
                                                        
        case iScsi_InitiatorSessionInfo_GUID_INDEX: {

            status = iSpBuildInitiatorSessionInfo(adapterExtension,
                                                 DispatchContext,
                                                 BufferAvail,
                                                 Buffer,
                                                 &sizeNeeded);    

            *InstanceLengthArray = sizeNeeded;

            break;
                    
        }

        case iScsi_PortalInfoClass_GUID_Index: {
            status = iSpBuildPortalInfo(adapterExtension,
                                        InstanceLengthArray,
                                        BufferAvail,
                                        Buffer,
                                        &sizeNeeded);  
            break;
        }

        case iScsi_TargetMapping_GUID_Index: {

            status = iSpBuildTargetMapping(adapterExtension,
                                           InstanceLengthArray,
                                           BufferAvail,
                                           Buffer,
                                           &sizeNeeded);

            break;
        }

        case iScsi_PersistentLogin_GUID_Index: {

            status = iSpBuildPersistentLoginInfo(adapterExtension,
                                                 InstanceLengthArray,
                                                 BufferAvail,
                                                 Buffer,
                                                 &sizeNeeded);
            *InstanceLengthArray = sizeNeeded;

            break;
        }

        case iScsi_Query_LB_Policy_GUID_Index: {

            status = iSpQueryLBPolicy(adapterExtension,
                                      InstanceLengthArray,
                                      BufferAvail,
                                      Buffer,
                                      &sizeNeeded);
            
            *InstanceLengthArray = sizeNeeded;

            break;
        }

        case iScsi_Redirect_Portal_GUID_Index: {

            status = iSpBuildRedirectTargetInfo(adapterExtension,
                                                InstanceLengthArray,
                                                BufferAvail,
                                                Buffer,
                                                &sizeNeeded);
            
            *InstanceLengthArray = sizeNeeded;

            break;
        }



        case iSCSI_SecurityCapabilitiesGuid_INDEX:
        {
            status = iScsiQuerySecurityCapabilities(adapterExtension,
                                              BufferAvail,
                                              Buffer,
                                              InstanceLengthArray,
                                              &sizeNeeded);
            break;
        }

        case iScsiDiscoveryConfigGuid_INDEX:
        {
            status = iScsiQueryDiscoveryConfig(adapterExtension,
                                               BufferAvail,
                                               Buffer,
                                               InstanceLengthArray,
                                               &sizeNeeded);
            break;
        }

        case iSCSI_SecurityConfigOperationsGuid_INDEX:
        case iSCSI_DiscoveryOperationsGuid_INDEX:
        case iScsi_ManagementOperation_GUID_Index:
        {
            //
            // Operations only has methods, but we need to support the
            // query since WMI needs to be able to query before
            // executing a method
            //
            sizeNeeded = sizeof(ULONG);
            if (BufferAvail >= sizeNeeded)
            {
                *InstanceLengthArray = sizeNeeded;