|
|
/*++
Copyright (c) 1998-1999 Microsoft Corporation
Module Name:
wmi.c
Abstract: Psched's WMI support.
Author: Rajesh Sundaram (rajeshsu) 01-Aug-1998.
Environment:
Kernel Mode
Revision History:
--*/
#include "psched.h"
#pragma hdrstop
//
// Forward declaration for using in #pragma.
//
NTSTATUSPsQueryGuidDataSize( PADAPTER Adapter, PPS_WAN_LINK WanLink, PGPC_CLIENT_VC Vc, NDIS_OID Oid, PULONG BytesNeeded);
#pragma alloc_text(PAGE, PsQueryGuidDataSize)
#define ALIGN(x) (((x) + 7) & ~7)
NDIS_STRING DefaultProfile = NDIS_STRING_CONST("Default Profile");
#define fPS_GUID_TO_OID 0x00000001 // Normal GUID to OID mapping
#define fPS_GUID_TO_STATUS 0x00000002 // GUID to status mapping
#define fPS_GUID_ANSI_STRING 0x00000004 // ANSI string
#define fPS_GUID_UNICODE_STRING 0x00000008 // Unicode String
#define fPS_GUID_ARRAY 0x00000010 // Array
#define fPS_GUID_EVENT_ENABLED 0x00000020 // Event is enabled
#define fPS_GUID_NOT_SETTABLE 0x00000040 // GUID is read only
#define fPS_GUID_EVENT_PERMANENT 0x00000080
#define PS_GUID_SET_FLAG(m, f) ((m)->Flags |= (f))
#define PS_GUID_CLEAR_FLAG(m, f) ((m)->Flags &= ~(f))
#define PS_GUID_TEST_FLAG(m, f) (((m)->Flags & (f)) != 0)
#define MOF_RESOURCE_NAME L"PschedMofResource"
#if DBG
#define NUMBER_QOS_GUIDS 30
#else
#define NUMBER_QOS_GUIDS 24
#endif
NDIS_GUID gPschedSupportedGuids[NUMBER_QOS_GUIDS] ={#if DBG
//
// GUID_QOS_LOG_LEVEL
//
{{0x9dd7f3aeL,0xf2a8,0x11d2,0xbe,0x1b,0x00,0xa0,0xc9,0x9e,0xe6,0x3b}, OID_QOS_LOG_LEVEL, 4, fPS_GUID_TO_OID },
//
// GUID_QOS_LOG_MASK
//
{{0x9e696320L,0xf2a8,0x11d2,0xbe,0x1b,0x00,0xa0,0xc9,0x9e,0xe6,0x3b}, OID_QOS_LOG_MASK, 4, fPS_GUID_TO_OID },
//
// GUID_QOS_STATUS_LOG_THRESHOLD
//
{{0x357b74d2L,0x6134,0x11d1,0xab,0x5b,0x00,0xa0,0xc9,0x24,0x88,0x37}, QOS_STATUS_LOG_THRESHOLD, 4, fPS_GUID_TO_STATUS },
//
// GUID_QOS_LOG_BUFFER_SIZE
//
{{0x357b74d3L,0x6134,0x11d1,0xab,0x5b,0x00,0xa0,0xc9,0x24,0x88,0x37}, OID_QOS_LOG_BUFFER_SIZE, 4, fPS_GUID_TO_OID },
//
// GUID_QOS_LOG_THRESHOLD
//
{{0x357b74d0L,0x6134,0x11d1,0xab,0x5b,0x00,0xa0,0xc9,0x24,0x88,0x37}, OID_QOS_LOG_THRESHOLD, 4, fPS_GUID_TO_OID },
//
// GUID_QOS_LOG_DATA
//
{{0x357b74d1L,0x6134,0x11d1,0xab,0x5b,0x00,0xa0,0xc9,0x24,0x88,0x37}, OID_QOS_LOG_DATA, (ULONG)-1, fPS_GUID_TO_OID },#endif
//
// GUID_QOS_TC_SUPPORTED
//
{{0xe40056dcL,0x40c8,0x11d1,0x2c,0x91,0x00,0xaa,0x00,0x57,0x59,0x15}, OID_QOS_TC_SUPPORTED, -1, fPS_GUID_TO_OID | fPS_GUID_NOT_SETTABLE },
//
// GUID_QOS_REMAINING_BANDWIDTH
//
{{0xc4c51720L,0x40ec,0x11d1,0x2c,0x91,0x00,0xaa,0x00,0x57,0x49,0x15}, OID_QOS_REMAINING_BANDWIDTH, 4, fPS_GUID_TO_OID | fPS_GUID_TO_STATUS | fPS_GUID_NOT_SETTABLE },
//
// GUID_QOS_BESTEFFORT_BANDWIDTH
//
{{0xed885290L,0x40ec,0x11d1,0x2c,0x91,0x00,0xaa,0x00,0x57,0x49,0x15}, OID_QOS_BESTEFFORT_BANDWIDTH, 4, fPS_GUID_TO_OID },
//
// GUID_QOS_HIERARCHY_CLASS
//
{{0xf2cc20c0,0x70c7,0x11d1,0xab,0x5c,0x0,0xa0,0xc9,0x24,0x88,0x37}, OID_QOS_HIERARCHY_CLASS, 4, fPS_GUID_TO_OID },
//
// GUID_QOS_LATENCY
//
{{0xfc408ef0L,0x40ec,0x11d1,0x2c,0x91,0x00,0xaa,0x00,0x57,0x49,0x15}, OID_QOS_LATENCY, 4, fPS_GUID_TO_OID | fPS_GUID_NOT_SETTABLE },
//
// GUID_QOS_FLOW_COUNT
//
{{0x1147f880L,0x40ed,0x11d1,0x2c,0x91,0x00,0xaa,0x00,0x57,0x49,0x15}, OID_QOS_FLOW_COUNT, 4, fPS_GUID_TO_OID | fPS_GUID_TO_STATUS | fPS_GUID_NOT_SETTABLE },
//
// GUID_QOS_NON_BESTEFFORT_LIMIT
//
{{0x185c44e0L,0x40ed,0x11d1,0x2c,0x91,0x00,0xaa,0x00,0x57,0x49,0x15}, OID_QOS_NON_BESTEFFORT_LIMIT, 4, fPS_GUID_TO_OID },
//
// GUID_QOS_SCHEDULING_PROFILES_SUPPORTED
//
{{0x1ff890f0L,0x40ed,0x11d1,0x2c,0x91,0x00,0xaa,0x00,0x57,0x49,0x15}, OID_QOS_SCHEDULING_PROFILES_SUPPORTED, 8, fPS_GUID_TO_OID },
//
// GUID_QOS_CURRENT_SCHEDULING_PROFILE
//
{{0x2966ed30L,0x40ed,0x11d1,0x2c,0x91,0x00,0xaa,0x00,0x57,0x49,0x15}, OID_QOS_CURRENT_SCHEDULING_PROFILE, -1, fPS_GUID_TO_OID | fPS_GUID_UNICODE_STRING | fPS_GUID_NOT_SETTABLE },
//
// GUID_QOS_MAX_OUTSTANDING_SENDS
//
{{0x161ffa86L,0x6120,0x11d1,0x2c,0x91,0x00,0xaa,0x00,0x57,0x49,0x15}, OID_QOS_MAX_OUTSTANDING_SENDS, 4, fPS_GUID_TO_OID },
//
// GUID_QOS_DISABLE_DRR
//
{{0x1fa6dc7aL,0x6120,0x11d1,0x2c,0x91,0x00,0xaa,0x00,0x57,0x49,0x15}, OID_QOS_DISABLE_DRR, 4, fPS_GUID_TO_OID },
//
// GUID_QOS_STATISTICS_BUFFER
//
{{0xbb2c0980L,0xe900,0x11d1,0xb0,0x7e,0x00,0x80,0xc7,0x13,0x82,0xbf}, OID_QOS_STATISTICS_BUFFER, -1, fPS_GUID_TO_OID },
//
// GUID_QOS_TC_INTERFACE_UP_INDICATION
//
{{0x0ca13af0L,0x46c4,0x11d1,0x78,0xac,0x00,0x80,0x5f,0x68,0x35,0x1e}, NDIS_STATUS_INTERFACE_UP, 8, fPS_GUID_TO_STATUS | fPS_GUID_EVENT_ENABLED | fPS_GUID_EVENT_PERMANENT },
//
// GUID_QOS_TC_INTERFACE_DOWN_INDICATION
//
{{0xaf5315e4L,0xce61,0x11d1,0x7c,0x8a,0x00,0xc0,0x4f,0xc9,0xb5,0x7c}, NDIS_STATUS_INTERFACE_DOWN, 8, fPS_GUID_TO_STATUS | fPS_GUID_EVENT_ENABLED | fPS_GUID_EVENT_PERMANENT },
//
// GUID_QOS_TC_INTERFACE_CHANGE_INDICATION
//
{{0xda76a254L,0xce61,0x11d1,0x7c,0x8a,0x00,0xc0,0x4f,0xc9,0xb5,0x7c}, NDIS_STATUS_INTERFACE_CHANGE, 8, fPS_GUID_TO_STATUS | fPS_GUID_EVENT_ENABLED | fPS_GUID_EVENT_PERMANENT },
//
// GUID_QOS_FLOW_MODE
//
{{0x5c82290aL,0x515a,0x11d2,0x8e,0x58,0x00,0xc0,0x4f,0xc9,0xbf,0xcb}, OID_QOS_FLOW_MODE, 4, fPS_GUID_TO_OID },
//
// GUID_QOS_ISSLOW_FLOW
//
{{0xabf273a4,0xee07,0x11d2,0xbe,0x1b,0x00,0xa0,0xc9,0x9e,0xe6,0x3b}, OID_QOS_ISSLOW_FLOW, 4, fPS_GUID_TO_OID | fPS_GUID_NOT_SETTABLE },
//
// GUID_QOS_TIMER_RESOLUTION
//
{{0xba10cc88,0xf13e,0x11d2,0xbe,0x1b,0x00,0xa0,0xc9,0x9e,0xe6,0x3b}, OID_QOS_TIMER_RESOLUTION, 4, fPS_GUID_TO_OID | fPS_GUID_NOT_SETTABLE },
//
// GUID_QOS_FLOW_IP_CONFORMING
//
{{0x07f99a8b, 0xfcd2, 0x11d2, 0xbe, 0x1e, 0x00, 0xa0, 0xc9, 0x9e, 0xe6, 0x3b}, OID_QOS_FLOW_IP_CONFORMING, 4, fPS_GUID_TO_OID | fPS_GUID_NOT_SETTABLE },
//
// GUID_QOS_FLOW_IP_NONCONFORMING
//
{{0x087a5987, 0xfcd2, 0x11d2, 0xbe, 0x1e, 0x00, 0xa0, 0xc9, 0x9e, 0xe6, 0x3b}, OID_QOS_FLOW_IP_NONCONFORMING, 4, fPS_GUID_TO_OID | fPS_GUID_NOT_SETTABLE },
//
// GUID_QOS_FLOW_8021P_CONFORMING
//
{{0x08c1e013, 0xfcd2, 0x11d2, 0xbe, 0x1e, 0x00, 0xa0, 0xc9, 0x9e, 0xe6, 0x3b}, OID_QOS_FLOW_8021P_CONFORMING, 4, fPS_GUID_TO_OID | fPS_GUID_NOT_SETTABLE },
//
// GUID_QOS_FLOW_8021P_NONCONFORMING
//
{{0x09023f91, 0xfcd2, 0x11d2, 0xbe, 0x1e, 0x00, 0xa0, 0xc9, 0x9e, 0xe6, 0x3b}, OID_QOS_FLOW_8021P_NONCONFORMING, 4, fPS_GUID_TO_OID | fPS_GUID_NOT_SETTABLE },
//
// GUID_QOS_ENABLE_AVG_STATS
//
{{0xbafb6d11, 0x27c4, 0x4801, 0xa4, 0x6f, 0xef, 0x80, 0x80, 0xc1, 0x88, 0xc8}, OID_QOS_ENABLE_AVG_STATS, 4, fPS_GUID_TO_OID },
//
// GUID_QOS_ENABLE_WINDOW_ADJUSTMENT
//
{{0xaa966725, 0xd3e9, 0x4c55, 0xb3, 0x35, 0x2a, 0x0, 0x27, 0x9a, 0x1e, 0x64}, OID_QOS_ENABLE_WINDOW_ADJUSTMENT, 4, fPS_GUID_TO_OID }};
NTSTATUSPsWmiGetGuid( OUT PNDIS_GUID *ppNdisGuid, IN LPGUID guid, IN NDIS_OID Oid )/*++
Routine Description:
Arguments:
Return Value:
--*/{ UINT c; PNDIS_GUID pNdisGuid; NDIS_STATUS RetStatus = STATUS_UNSUCCESSFUL; //
// Search the custom GUIDs
//
for (c = 0, pNdisGuid = gPschedSupportedGuids; (c < NUMBER_QOS_GUIDS); c++, pNdisGuid++) { //
// Make sure that we have a supported GUID and the GUID maps
// to an OID.
//
if (NULL != guid) { //
// We are to look for a guid to oid mapping.
//
if (NdisEqualMemory(&pNdisGuid->Guid, guid, sizeof(GUID))) { //
// We found the GUID, save the OID that we will need to
// send to the miniport.
//
RetStatus = STATUS_SUCCESS; *ppNdisGuid = pNdisGuid; break; } } else { //
// We need to find the quid for the status indication
//
if (PS_GUID_TEST_FLAG(pNdisGuid, fPS_GUID_TO_STATUS) && (pNdisGuid->Oid == Oid)) { RetStatus = STATUS_SUCCESS; *ppNdisGuid = pNdisGuid; break; } } } return(RetStatus);}
NTSTATUSPsWmiRegister( IN ULONG_PTR RegistrationType, IN PWMIREGINFO wmiRegInfo, IN ULONG wmiRegInfoSize, IN PULONG pReturnSize )/*++
Routine Description:
Arguments:
Return Value:
--*/{ PWMIREGINFO pwri; ULONG SizeNeeded = 0; PNDIS_GUID pguid; PWMIREGGUID pwrg; PUCHAR ptmp; NTSTATUS Status; UINT c; //
// Initialize the return size.
//
*pReturnSize = 0; //
// Is this a register request?
//
if (WMIREGISTER == RegistrationType) { //
// Determine the amount of space needed for the GUIDs, the MOF and the
// registry path
//
SizeNeeded = sizeof(WMIREGINFO) + (NUMBER_QOS_GUIDS * sizeof(WMIREGGUID)) + //(sizeof(MOF_RESOURCE_NAME) - sizeof(WCHAR) + sizeof(USHORT)) +
(PsMpName.Length + sizeof(USHORT)); //
// We need to give this above information back to WMI.
//
if (wmiRegInfoSize < SizeNeeded) { PsAssert(wmiRegInfoSize >= 4); *((PULONG)wmiRegInfo) = SizeNeeded ;
*pReturnSize = sizeof(ULONG); Status = STATUS_SUCCESS; PsDbgOut(DBG_TRACE, DBG_WMI, ("[PsWmiRegister]: Insufficient buffer space for WMI registration information.\n")); return Status; } //
// Get a pointer to the buffer passed in.
//
pwri = wmiRegInfo; *pReturnSize = SizeNeeded; NdisZeroMemory(pwri, SizeNeeded); pwri->BufferSize = SizeNeeded;
//
// Copy the GUIDs
//
pwri->GuidCount = NUMBER_QOS_GUIDS; for(c = 0, pwrg = pwri->WmiRegGuid, pguid = gPschedSupportedGuids; c < NUMBER_QOS_GUIDS; c++, pguid++, pwrg++) { RtlCopyMemory(&pwrg->Guid, &pguid->Guid, sizeof(GUID)); } //
// Fill in the registry path
//
ptmp = (PUCHAR)pwrg; pwri->RegistryPath = (ULONG)((ULONG_PTR)ptmp - (ULONG_PTR)pwri); *((PUSHORT)ptmp) = PsMpName.Length; ptmp += sizeof(USHORT); RtlCopyMemory(ptmp, PsMpName.Buffer, PsMpName.Length);
/*
//
// Get a pointer to the destination for the MOF name.
//
ptmp += PsMpName.Length; //
// Save the offset to the mof resource.
//
/*
pwri->MofResourceName = (ULONG)((ULONG_PTR)ptmp - (ULONG_PTR)pwri); *((PUSHORT)ptmp) = sizeof(MOF_RESOURCE_NAME) - sizeof(WCHAR); ptmp += sizeof(USHORT); //
// Copy the mof name into the wri buffer.
//
RtlCopyMemory(ptmp, MOF_RESOURCE_NAME, sizeof(MOF_RESOURCE_NAME) - sizeof(WCHAR)); */ Status = STATUS_SUCCESS; } else { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiRegister]: Unsupported registration type\n")); Status = STATUS_INVALID_PARAMETER; }
return(Status);}
NTSTATUSPsTcNotify(IN PADAPTER Adapter, IN PPS_WAN_LINK WanLink, IN NDIS_OID Oid, IN PVOID StatusBuffer, IN ULONG StatusBufferSize){ KIRQL OldIrql; NTSTATUS NtStatus = STATUS_SUCCESS; do { PWCHAR pInstanceName; USHORT cbInstanceName; PWNODE_SINGLE_INSTANCE wnode; ULONG wnodeSize; ULONG DataBlockSize = 0; ULONG InstanceNameSize = 0; ULONG BufSize; PUCHAR ptmp; PNDIS_GUID pNdisGuid; REFADD(&Adapter->RefCount, 'WMIN'); if(Adapter->MediaType == NdisMediumWan) { if(!WanLink) { REFDEL(&Adapter->RefCount, FALSE, 'WMIN'); return STATUS_UNSUCCESSFUL; } PS_LOCK(&WanLink->Lock); if(WanLink->State != WanStateOpen) { PS_UNLOCK(&WanLink->Lock); REFDEL(&Adapter->RefCount, FALSE, 'WMIN'); return STATUS_UNSUCCESSFUL; } else { REFADD(&WanLink->RefCount, 'WMIN');
PS_UNLOCK(&WanLink->Lock); } pInstanceName = WanLink->InstanceName.Buffer; cbInstanceName = WanLink->InstanceName.Length; } else { //
// Get nice pointers to the instance names.
//
pInstanceName = Adapter->WMIInstanceName.Buffer; cbInstanceName = Adapter->WMIInstanceName.Length; } //
// If there is no instance name then we can't indicate an event.
//
if (NULL == pInstanceName) { NtStatus = STATUS_UNSUCCESSFUL; break; } //
// Check to see if the status is enabled for WMI event indication.
//
NtStatus = PsWmiGetGuid(&pNdisGuid, NULL, Oid); if ((!NT_SUCCESS(NtStatus)) || !PS_GUID_TEST_FLAG(pNdisGuid, fPS_GUID_EVENT_ENABLED)) { NtStatus = STATUS_UNSUCCESSFUL; break; } //
// Determine the amount of wnode information we need.
//
wnodeSize = ALIGN(sizeof(WNODE_SINGLE_INSTANCE));
//
// If the data item is an array then we need to add in the number of
// elements.
//
if (PS_GUID_TEST_FLAG(pNdisGuid, fPS_GUID_ARRAY)) { DataBlockSize = StatusBufferSize + sizeof(ULONG); } else { DataBlockSize = StatusBufferSize; } //
// We have a guid registered and active.
//
//
// The data has to start at a word boundary, so need to align everything before it (the wnode and the
// instance name)
//
InstanceNameSize = ALIGN(cbInstanceName + sizeof(USHORT)); BufSize = wnodeSize + InstanceNameSize + DataBlockSize; wnode = ExAllocatePoolWithTag(NonPagedPool, BufSize, WMITag); if (NULL == wnode) { NtStatus = STATUS_UNSUCCESSFUL; break; } NdisZeroMemory(wnode, BufSize); wnode->WnodeHeader.BufferSize = BufSize; wnode->WnodeHeader.ProviderId = IoWMIDeviceObjectToProviderId(PsDeviceObject); wnode->WnodeHeader.Version = 1; KeQuerySystemTime(&wnode->WnodeHeader.TimeStamp); RtlCopyMemory(&wnode->WnodeHeader.Guid, &pNdisGuid->Guid, sizeof(GUID)); wnode->WnodeHeader.Flags = WNODE_FLAG_EVENT_ITEM | WNODE_FLAG_SINGLE_INSTANCE; wnode->OffsetInstanceName = wnodeSize; wnode->DataBlockOffset = wnodeSize + InstanceNameSize;
wnode->SizeDataBlock = DataBlockSize; //
// Get a pointer to the start of the data block.
//
ptmp = (PUCHAR)wnode + wnodeSize; //
// Copy in the instance name. wnodesize is already aligned to 8 byte boundary, so the instance
// name will begin at a 8 byte boundary.
//
*((PUSHORT)ptmp) = cbInstanceName; NdisMoveMemory(ptmp + sizeof(USHORT), pInstanceName, cbInstanceName); //
// Increment ptmp to the start of the data block.
//
ptmp = (PUCHAR)wnode + wnode->DataBlockOffset; //
// Copy in the data.
//
if (PS_GUID_TEST_FLAG(pNdisGuid, fPS_GUID_ARRAY)) { //
// If the status is an array but there is no data then complete it with no
// data and a 0 length
//
if ((NULL == StatusBuffer) || (0 == StatusBufferSize)) { *((PULONG)ptmp) = 0; } else { //
// Save the number of elements in the first ULONG.
//
*((PULONG)ptmp) = StatusBufferSize / pNdisGuid->Size; //
// Copy the data after the number of elements.
//
NdisMoveMemory(ptmp + sizeof(ULONG), StatusBuffer, StatusBufferSize); } } else { PsAssert(StatusBuffer != NULL); //
// Do we indicate any data up?
//
if (0 != DataBlockSize) { //
// Copy the data into the buffer.
//
NdisMoveMemory(ptmp, StatusBuffer, DataBlockSize); } } //
// Indicate the event to WMI. WMI will take care of freeing
// the WMI struct back to pool.
//
NtStatus = IoWMIWriteEvent(wnode); if (!NT_SUCCESS(NtStatus)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsTcNotify]: Adapter %08X, Unable to indicate the WMI event.\n", Adapter)); ExFreePool(wnode); } } while (FALSE); REFDEL(&Adapter->RefCount, FALSE, 'WMIN'); if(WanLink) { REFDEL(&WanLink->RefCount, FALSE, 'WMIN'); } return NtStatus; }
NTSTATUSFASTCALLPsWmiEnableEvents( IN LPGUID Guid )/*++
Routine Description: Arguments: Return Value: --*/{ NTSTATUS Status; PNDIS_GUID pNdisGuid; do { //
// Get a pointer to the Guid/Status to enable.
//
Status = PsWmiGetGuid(&pNdisGuid, Guid, 0); if (!NT_SUCCESS(Status)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiEnableEvents]: Cannot find the guid to enable an event\n")); Status = STATUS_INVALID_PARAMETER; break; } //
// Is this GUID an event indication?
//
if (!PS_GUID_TEST_FLAG(pNdisGuid, fPS_GUID_TO_STATUS)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiEnableEvents]: Guid is not an event request \n")); Status = STATUS_INVALID_DEVICE_REQUEST; break; } //
// Mark the guid as enabled
//
PS_GUID_SET_FLAG(pNdisGuid, fPS_GUID_EVENT_ENABLED); Status = STATUS_SUCCESS; } while (FALSE); return(Status);}
NTSTATUSFASTCALLPsWmiDisableEvents( IN LPGUID Guid )/*++
Routine Description:
Arguments:
Return Value:
--*/{ NTSTATUS Status; PNDIS_GUID pNdisGuid; do { //
// Get a pointer to the Guid/Status to enable.
//
Status = PsWmiGetGuid(&pNdisGuid, Guid, 0); if (!NT_SUCCESS(Status)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiDisableEvents]: Cannot find the guid to disable an event\n")); Status = STATUS_INVALID_PARAMETER; break; } //
// Is this GUID an event indication?
//
if (!PS_GUID_TEST_FLAG(pNdisGuid, fPS_GUID_TO_STATUS)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiDisableEvents]: Guid is not an event request \n")); Status = STATUS_INVALID_DEVICE_REQUEST; break; } if(!PS_GUID_TEST_FLAG(pNdisGuid, fPS_GUID_EVENT_PERMANENT)) { //
// Mark the guid as disabled
//
PS_GUID_CLEAR_FLAG(pNdisGuid, fPS_GUID_EVENT_ENABLED); } Status = STATUS_SUCCESS; } while (FALSE); return(Status);}
#define WMI_BUFFER_TOO_SMALL(_BufferSize, _Wnode, _WnodeSize, _pStatus, _pRSize) \
{ \ if ((_BufferSize) < sizeof(WNODE_TOO_SMALL)) \ { \ *(_pStatus) = STATUS_BUFFER_TOO_SMALL; \ } \ else \ { \ (_Wnode)->WnodeHeader.BufferSize = sizeof(WNODE_TOO_SMALL); \ (_Wnode)->WnodeHeader.Flags |= WNODE_FLAG_TOO_SMALL; \ ((PWNODE_TOO_SMALL)(_Wnode))->SizeNeeded = (_WnodeSize); \ *(_pRSize) = sizeof(WNODE_TOO_SMALL); \ *(_pStatus) = STATUS_SUCCESS; \ } \}
NTSTATUSPsQueryGuidDataSize( PADAPTER Adapter, PPS_WAN_LINK WanLink, PGPC_CLIENT_VC Vc, NDIS_OID Oid, PULONG BytesNeeded){ ULONG Len; ULONG BytesWritten; NDIS_STATUS Status;
PAGED_CODE();
if(Vc) { switch(Oid) { case OID_QOS_STATISTICS_BUFFER: // If the query comes for a VC, then we return per flow stats
// else we return per adapter stats. The query is also sent through
// the scheduling components, so that they can fill in the per flow
// or per query stats.
//
Len = 0; BytesWritten = 0; Status = NDIS_STATUS_BUFFER_TOO_SHORT; *BytesNeeded = 0; (*Vc->PsComponent->QueryInformation) (Vc->PsPipeContext, Vc->PsFlowContext, Oid, Len, NULL, &BytesWritten, BytesNeeded, &Status); *BytesNeeded += sizeof(PS_FLOW_STATS) + FIELD_OFFSET(PS_COMPONENT_STATS, Stats); return STATUS_SUCCESS;
case OID_QOS_ISSLOW_FLOW: case OID_QOS_FLOW_IP_CONFORMING: case OID_QOS_FLOW_IP_NONCONFORMING: case OID_QOS_FLOW_8021P_CONFORMING: case OID_QOS_FLOW_8021P_NONCONFORMING: *BytesNeeded = sizeof(ULONG); return STATUS_SUCCESS; default: return STATUS_WMI_NOT_SUPPORTED; } }
//
// The following OIDs are similar for both WAN and Adapters
//
switch(Oid) { //
// (12636): The following will be enabled when we do admission control over WAN.
// case OID_QOS_REMAINING_BANDWIDTH:
// case OID_QOS_NON_BESTEFFORT_LIMIT:
//
case OID_QOS_BESTEFFORT_BANDWIDTH: case OID_QOS_LATENCY: case OID_QOS_FLOW_COUNT: case OID_QOS_FLOW_MODE: case OID_QOS_MAX_OUTSTANDING_SENDS: case OID_QOS_DISABLE_DRR: case OID_QOS_TIMER_RESOLUTION: case OID_QOS_ENABLE_AVG_STATS: case OID_QOS_ENABLE_WINDOW_ADJUSTMENT:#if DBG
case OID_QOS_LOG_BUFFER_SIZE: case OID_QOS_LOG_THRESHOLD: case OID_QOS_LOG_LEVEL: case OID_QOS_LOG_MASK:#endif
*BytesNeeded = sizeof(ULONG); return STATUS_SUCCESS; #if DBG
case OID_QOS_LOG_DATA: *BytesNeeded = SchedtGetBytesUnread(); return STATUS_SUCCESS; #endif
case OID_QOS_CURRENT_SCHEDULING_PROFILE: if(!Adapter->ProfileName.Buffer) { *BytesNeeded = sizeof(DefaultProfile); } else { *BytesNeeded = Adapter->ProfileName.Length; } return STATUS_SUCCESS; } //
// OIDs that are WAN link specific
//
if(WanLink) { switch(Oid) { case OID_QOS_HIERARCHY_CLASS: { Len = 0; BytesWritten = 0; Status = NDIS_STATUS_BUFFER_TOO_SHORT; *BytesNeeded = 0; (*WanLink->PsComponent->QueryInformation) (WanLink->PsPipeContext, 0, Oid, Len, NULL, &BytesWritten, BytesNeeded, &Status); return STATUS_SUCCESS; } case OID_QOS_STATISTICS_BUFFER: { Len = 0; BytesWritten = 0; Status = NDIS_STATUS_BUFFER_TOO_SHORT; *BytesNeeded = 0; (*WanLink->PsComponent->QueryInformation) (WanLink->PsPipeContext, NULL, Oid, Len, NULL, &BytesWritten, BytesNeeded, &Status); *BytesNeeded += sizeof(PS_ADAPTER_STATS) + FIELD_OFFSET(PS_COMPONENT_STATS, Stats); return STATUS_SUCCESS; } case OID_QOS_TC_SUPPORTED: *BytesNeeded = 0; CollectWanNetworkAddresses(Adapter, WanLink, BytesNeeded, NULL); return STATUS_SUCCESS;
default:
return STATUS_WMI_NOT_SUPPORTED; } } if(Adapter->MediaType != NdisMediumWan) {
switch(Oid) { case OID_QOS_TC_SUPPORTED: *BytesNeeded = 0; CollectNetworkAddresses(Adapter, BytesNeeded, NULL); return STATUS_SUCCESS; //
// (12636): Take the next 2 case statements away when we turn on admission control over WAN links.
//
case OID_QOS_REMAINING_BANDWIDTH: case OID_QOS_NON_BESTEFFORT_LIMIT:
*BytesNeeded = sizeof(ULONG); return STATUS_SUCCESS;
case OID_QOS_HIERARCHY_CLASS: { Len = 0; BytesWritten = 0; Status = NDIS_STATUS_BUFFER_TOO_SHORT; *BytesNeeded = 0; (*Adapter->PsComponent->QueryInformation) (Adapter->PsPipeContext, 0, Oid, Len, NULL, &BytesWritten, BytesNeeded, &Status); return STATUS_SUCCESS; }
case OID_QOS_STATISTICS_BUFFER: { Len = 0; BytesWritten = 0; Status = NDIS_STATUS_BUFFER_TOO_SHORT; *BytesNeeded = 0; (*Adapter->PsComponent->QueryInformation) (Adapter->PsPipeContext, NULL, Oid, Len, NULL, &BytesWritten, BytesNeeded, &Status); *BytesNeeded += sizeof(PS_ADAPTER_STATS) + FIELD_OFFSET(PS_COMPONENT_STATS, Stats); return STATUS_SUCCESS; } default: return STATUS_WMI_NOT_SUPPORTED; } }
return STATUS_WMI_NOT_SUPPORTED;}
NTSTATUSPsQueryGuidData( PADAPTER Adapter, PPS_WAN_LINK WanLink, PGPC_CLIENT_VC Vc, NDIS_OID Oid, PVOID Buffer, ULONG BufferSize){
PULONG pData = (PULONG) Buffer; ULONG Len; ULONG BytesNeeded; ULONG BytesWritten; PUCHAR Data; NDIS_STATUS Status; PPS_COMPONENT_STATS Cstats;
PsAssert(((ULONGLONG)pData % sizeof(PULONG)) == 0);
if(Vc) { switch(Oid) { case OID_QOS_FLOW_IP_CONFORMING: *pData = (((PCF_INFO_QOS)(Vc->CfInfoQoS))->ToSValue) >> 2; return STATUS_SUCCESS;
case OID_QOS_FLOW_IP_NONCONFORMING: *pData = (Vc->IPPrecedenceNonConforming >> 2); return STATUS_SUCCESS;
case OID_QOS_FLOW_8021P_CONFORMING: *pData = Vc->UserPriorityConforming; return STATUS_SUCCESS;
case OID_QOS_FLOW_8021P_NONCONFORMING: *pData = Vc->UserPriorityNonConforming; return STATUS_SUCCESS; case OID_QOS_ISSLOW_FLOW:
*pData = (Vc->Flags & GPC_ISSLOW_FLOW)?TRUE:FALSE;
return STATUS_SUCCESS;
case OID_QOS_STATISTICS_BUFFER: // If the query comes for a VC, then we return per flow stats
// else we return per adapter stats. The query is also sent through
// the scheduling components, so that they can fill in the per flow
// or per query stats.
//
Len = BufferSize; BytesNeeded = 0; BytesWritten;
BytesWritten = sizeof(PS_FLOW_STATS) + FIELD_OFFSET(PS_COMPONENT_STATS, Stats);
Cstats = (PPS_COMPONENT_STATS) Buffer;
Cstats->Type = PS_COMPONENT_FLOW;
Cstats->Length = sizeof(PS_FLOW_STATS);
NdisMoveMemory(&Cstats->Stats, &Vc->Stats, sizeof(PS_FLOW_STATS)); Status = NDIS_STATUS_SUCCESS; Data = (PVOID)( (PUCHAR) Buffer + BytesWritten);
(*Vc->PsComponent->QueryInformation) (Vc->PsPipeContext, Vc->PsFlowContext, Oid, Len, Data, &BytesWritten, &BytesNeeded, &Status); return Status; default: return STATUS_WMI_NOT_SUPPORTED; } }
//
// The Following OIDs are similar for both WAN and Adapters
//
switch(Oid) { case OID_QOS_CURRENT_SCHEDULING_PROFILE: if(!Adapter->ProfileName.Buffer) { NdisMoveMemory(Buffer, &DefaultProfile, sizeof(DefaultProfile)); } else { NdisMoveMemory(Buffer, &Adapter->ProfileName.Buffer, Adapter->ProfileName.Length); } return STATUS_SUCCESS;
case OID_QOS_DISABLE_DRR: *pData = (Adapter->PipeFlags & PS_DISABLE_DRR)?1:0; return STATUS_SUCCESS;
case OID_QOS_MAX_OUTSTANDING_SENDS: *pData = Adapter->MaxOutstandingSends; return STATUS_SUCCESS;
case OID_QOS_BESTEFFORT_BANDWIDTH: PS_LOCK(&Adapter->Lock); *pData = Adapter->BestEffortLimit; PS_UNLOCK(&Adapter->Lock); return STATUS_SUCCESS; case OID_QOS_TIMER_RESOLUTION:
*pData = gTimerResolutionActualTime/10;
return STATUS_SUCCESS;
case OID_QOS_LATENCY: //
// Don't have a valid measure of latency right now.
//
*pData = -1; return STATUS_SUCCESS;
case OID_QOS_ENABLE_AVG_STATS:
*pData = gEnableAvgStats; return STATUS_SUCCESS;
case OID_QOS_ENABLE_WINDOW_ADJUSTMENT:
*pData = gEnableWindowAdjustment; return STATUS_SUCCESS;
#if DBG
case OID_QOS_LOG_BUFFER_SIZE: *pData = SchedtGetBufferSize(); return STATUS_SUCCESS; // The following is temporary until the status reporting works...
// for a query on log threshold we return the current size of the
// log rather than the threshold value... this is just an easy
// way to allow the app to poll the log size without defining a
// new GUID that would be temporary anyway.
case OID_QOS_LOG_THRESHOLD: *pData = SchedtGetBytesUnread(); return STATUS_SUCCESS;
case OID_QOS_LOG_MASK: *pData = LogTraceMask; return STATUS_SUCCESS;
case OID_QOS_LOG_LEVEL: *pData = LogTraceLevel; return STATUS_SUCCESS; case OID_QOS_LOG_DATA: { ULONG BytesRead; DbugReadTraceBuffer(Buffer, BufferSize, &BytesRead); return STATUS_SUCCESS; } #endif
}
if(WanLink) { switch(Oid) {
case OID_QOS_FLOW_MODE: { *pData = WanLink->AdapterMode;
return STATUS_SUCCESS; }
//
// (12636): This has to be uncommented when we do admission control over WAN links.
//
#if 0
case OID_QOS_REMAINING_BANDWIDTH: PS_LOCK(&WanLink->Lock); *pData = WanLink->RemainingBandWidth; PS_UNLOCK(&WanLink->Lock); return STATUS_SUCCESS;
case OID_QOS_NON_BESTEFFORT_LIMIT: PS_LOCK(&WanLink->Lock); *pData = WanLink->NonBestEffortLimit; PS_UNLOCK(&WanLink->Lock); return STATUS_SUCCESS;#endif
case OID_QOS_HIERARCHY_CLASS: { BytesWritten = 0; BytesNeeded = 0; Status = NDIS_STATUS_BUFFER_TOO_SHORT; (*WanLink->PsComponent->QueryInformation) (WanLink->PsPipeContext, NULL, Oid, BufferSize, Buffer, &BytesWritten, &BufferSize, &Status); return STATUS_SUCCESS; }
case OID_QOS_STATISTICS_BUFFER: // If the query comes for a VC, then we return per flow stats
// else we return per adapter stats. The query is also sent through
// the scheduling components, so that they can fill in the per flow
// or per query stats.
//
Len = BufferSize; BytesNeeded = 0; BytesWritten; BytesWritten = sizeof(PS_ADAPTER_STATS) + FIELD_OFFSET(PS_COMPONENT_STATS, Stats); Cstats = (PPS_COMPONENT_STATS) Buffer; Cstats->Type = PS_COMPONENT_ADAPTER; Cstats->Length = sizeof(PS_ADAPTER_STATS); NdisMoveMemory(&Cstats->Stats, &WanLink->Stats, sizeof(PS_ADAPTER_STATS)); Status = NDIS_STATUS_SUCCESS; Data = (PVOID)( (PUCHAR) Buffer + BytesWritten); (*WanLink->PsComponent->QueryInformation) (WanLink->PsPipeContext, NULL, Oid, Len, Data, &BytesWritten, &BytesNeeded, &Status); return Status; case OID_QOS_TC_SUPPORTED:
CollectWanNetworkAddresses(Adapter, WanLink, &BufferSize, Buffer);
return STATUS_SUCCESS;
case OID_QOS_FLOW_COUNT:
PS_LOCK(&WanLink->Lock);
*pData = WanLink->FlowsInstalled;
PS_UNLOCK(&WanLink->Lock);
PsAssert((LONG)*pData >= 0);
return STATUS_SUCCESS;
default: return STATUS_WMI_NOT_SUPPORTED; } }
if(Adapter->MediaType != NdisMediumWan) {
switch(Oid) { case OID_QOS_FLOW_MODE: { *pData = Adapter->AdapterMode; return STATUS_SUCCESS; }
case OID_QOS_HIERARCHY_CLASS: { BytesWritten = 0; BytesNeeded = 0; Status = NDIS_STATUS_BUFFER_TOO_SHORT; (*Adapter->PsComponent->QueryInformation) (Adapter->PsPipeContext, NULL, Oid, BufferSize, Buffer, &BytesWritten, &BufferSize, &Status); return STATUS_SUCCESS; }
case OID_QOS_STATISTICS_BUFFER: // If the query comes for a VC, then we return per flow stats
// else we return per adapter stats. The query is also sent through
// the scheduling components, so that they can fill in the per flow
// or per query stats.
//
Len = BufferSize; BytesNeeded = 0; BytesWritten; BytesWritten = sizeof(PS_ADAPTER_STATS) + FIELD_OFFSET(PS_COMPONENT_STATS, Stats); Cstats = (PPS_COMPONENT_STATS) Buffer; Cstats->Type = PS_COMPONENT_ADAPTER; Cstats->Length = sizeof(PS_ADAPTER_STATS); NdisMoveMemory(&Cstats->Stats, &Adapter->Stats, sizeof(PS_ADAPTER_STATS)); Status = NDIS_STATUS_SUCCESS; Data = (PVOID)( (PUCHAR) Buffer + BytesWritten); (*Adapter->PsComponent->QueryInformation) (Adapter->PsPipeContext, NULL, Oid, Len, Data, &BytesWritten, &BytesNeeded, &Status); return Status;
case OID_QOS_TC_SUPPORTED: CollectNetworkAddresses(Adapter, &BufferSize, Buffer);
return STATUS_SUCCESS;
case OID_QOS_REMAINING_BANDWIDTH: PS_LOCK(&Adapter->Lock); *pData = Adapter->RemainingBandWidth; PS_UNLOCK(&Adapter->Lock); return STATUS_SUCCESS; case OID_QOS_FLOW_COUNT: PS_LOCK(&Adapter->Lock);
*pData = Adapter->FlowsInstalled;
PS_UNLOCK(&Adapter->Lock); PsAssert((LONG)*pData >= 0); return STATUS_SUCCESS; case OID_QOS_NON_BESTEFFORT_LIMIT: PS_LOCK(&Adapter->Lock); *pData = Adapter->NonBestEffortLimit; PS_UNLOCK(&Adapter->Lock); return STATUS_SUCCESS; default: return STATUS_WMI_NOT_SUPPORTED; } }
return STATUS_WMI_NOT_SUPPORTED;}
NTSTATUSPsWmiQueryAllData( IN LPGUID guid, IN PWNODE_ALL_DATA wnode, IN ULONG BufferSize, OUT PULONG pReturnSize )/*++
Routine Description:
Arguments:
Return Value:
--*/{ NTSTATUS NtStatus; NDIS_STATUS Status; ULONG wnodeSize = ALIGN(sizeof(WNODE_ALL_DATA)); ULONG wnodeTotalSize; PNDIS_GUID pNdisGuid; ULONG BytesNeeded; UINT cRoughInstanceCount; UINT cInstanceCount = 0; PUCHAR pBuffer; ULONG OffsetToInstanceNames; PLIST_ENTRY Link; PPS_WAN_LINK WanLink = NULL; POFFSETINSTANCEDATAANDLENGTH poidl; PULONG pInstanceNameOffsets; ULONG OffsetToInstanceInfo; BOOLEAN OutOfSpace = FALSE; PADAPTER Adapter; PLIST_ENTRY NextAdapter; ULONG InstanceNameSize;
do { *pReturnSize = 0; if (BufferSize < sizeof(WNODE_TOO_SMALL)) { //
// Too small even to hold a WNODE_TOO_SMALL !
//
NtStatus = STATUS_BUFFER_TOO_SMALL; break; } //
// We can maintain a global count when adapters and wanlinks go up and down rather
// than counting it here. However, QueryAllData is not a very frequently used operation to
// justify this extra code.
//
cRoughInstanceCount = 0;
PS_LOCK(&AdapterListLock);
NextAdapter = AdapterList.Flink; while(NextAdapter != &AdapterList) { Adapter = CONTAINING_RECORD(NextAdapter, ADAPTER, Linkage); NextAdapter = NextAdapter->Flink; if(Adapter->MediaType == NdisMediumWan) { PS_LOCK_DPC(&Adapter->Lock); cRoughInstanceCount += Adapter->WanLinkCount; PS_UNLOCK_DPC(&Adapter->Lock); } else { cRoughInstanceCount += 1; } }
PS_UNLOCK(&AdapterListLock); //
// Get the OID and see if we support it.
//
NtStatus = PsWmiGetGuid(&pNdisGuid, guid, 0); if(!NT_SUCCESS(NtStatus)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiQueryAllData]: Unsupported guid \n")); break; } //
// Initialize common wnode information.
//
KeQuerySystemTime(&wnode->WnodeHeader.TimeStamp); //
// Setup the OFFSETINSTANCEDATAANDLENGTH array.
//
poidl = wnode->OffsetInstanceDataAndLength; wnode->OffsetInstanceNameOffsets = wnodeSize + (sizeof(OFFSETINSTANCEDATAANDLENGTH) * cRoughInstanceCount);
//
// Get a pointer to the array of offsets to the instance names.
//
pInstanceNameOffsets = (PULONG)((PUCHAR)wnode + wnode->OffsetInstanceNameOffsets);
//
// Get the offset from the wnode where will will start copying the instance
// data into.
//
OffsetToInstanceInfo = ALIGN(wnode->OffsetInstanceNameOffsets + (sizeof(ULONG) * cRoughInstanceCount));
//
// Get a pointer to start placing the data.
//
pBuffer = (PUCHAR)wnode + OffsetToInstanceInfo;
//
// Check to make sure we have at least this much buffer space in the wnode.
//
wnodeTotalSize = OffsetToInstanceInfo;
PS_LOCK(&AdapterListLock);
NextAdapter = AdapterList.Flink; while(NextAdapter != &AdapterList) { Adapter = CONTAINING_RECORD(NextAdapter, ADAPTER, Linkage);
PS_LOCK_DPC(&Adapter->Lock);
if(Adapter->PsMpState != AdapterStateRunning) { PS_UNLOCK_DPC(&Adapter->Lock);
NextAdapter = NextAdapter->Flink;
continue; }
REFADD(&Adapter->RefCount, 'WMIQ');
PS_UNLOCK_DPC(&Adapter->Lock); PS_UNLOCK(&AdapterListLock); if(Adapter->MediaType != NdisMediumWan) { NtStatus = PsQueryGuidDataSize(Adapter, NULL, NULL, pNdisGuid->Oid, &BytesNeeded); if(NT_SUCCESS(NtStatus)) { // Make sure we have enough buffer space for the instance name and
// the data. If not we still continue since we need to find the total
// size
InstanceNameSize = ALIGN(Adapter->WMIInstanceName.Length + sizeof(WCHAR)); wnodeTotalSize += InstanceNameSize + ALIGN(BytesNeeded); if (BufferSize < wnodeTotalSize) { WMI_BUFFER_TOO_SMALL(BufferSize, wnode, wnodeTotalSize, &NtStatus, pReturnSize);
OutOfSpace = TRUE;
PS_LOCK(&AdapterListLock);
NextAdapter = NextAdapter->Flink;
REFDEL(&Adapter->RefCount, TRUE, 'WMIQ');
continue; }
//
// We only have room for so many Instances.
//
if(cInstanceCount >= cRoughInstanceCount) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiQueryAllData]: Adapter %08X, Received more wanlinks (%d) than we counted " "initially (%d)\n", Adapter, cInstanceCount, cRoughInstanceCount));
PS_LOCK(&AdapterListLock);
REFDEL(&Adapter->RefCount, TRUE, 'WMIQ'); break; }
//
// Add the offset to the instance name to the table.
//
pInstanceNameOffsets[cInstanceCount] = OffsetToInstanceInfo; //
// Copy the instance name into the wnode buffer.
//
*((PUSHORT)pBuffer) = Adapter->WMIInstanceName.Length; NdisMoveMemory(pBuffer + sizeof(USHORT), Adapter->WMIInstanceName.Buffer, Adapter->WMIInstanceName.Length); //
// Keep track of true instance counts.
//
OffsetToInstanceInfo += InstanceNameSize; pBuffer = (PUCHAR)wnode + OffsetToInstanceInfo; //
// Query the data
//
NtStatus = PsQueryGuidData(Adapter, NULL, NULL, pNdisGuid->Oid, pBuffer, BytesNeeded); if(!NT_SUCCESS(NtStatus)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiQueryAllData]: Adapter %08X, Failed to query OID %08X \n", Adapter, pNdisGuid->Oid));
PS_LOCK(&AdapterListLock);
REFDEL(&Adapter->RefCount, TRUE, 'WMIQ');
break; } //
// Save the length of the data item for this instance.
//
poidl[cInstanceCount].OffsetInstanceData = OffsetToInstanceInfo; poidl[cInstanceCount].LengthInstanceData = BytesNeeded; //
// Keep track of true instance count.
//
OffsetToInstanceInfo += ALIGN(BytesNeeded); pBuffer = (PUCHAR)wnode + OffsetToInstanceInfo;
cInstanceCount ++; }
} else { //
// Search the Wan Links
//
PS_LOCK(&Adapter->Lock); Link = Adapter->WanLinkList.Flink; for(Link = Adapter->WanLinkList.Flink; Link != &Adapter->WanLinkList; ) { //
// We only have room for so many Instances.
//
if(cInstanceCount >= cRoughInstanceCount) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiQueryAllData]: Adapter %08X, Received more wanlinks (%d) than we counted " "initially (%d)\n", Adapter, cInstanceCount, cRoughInstanceCount)); break; }
//
// Get a pointer to the WanLink.
//
WanLink = CONTAINING_RECORD(Link, PS_WAN_LINK, Linkage); PS_LOCK_DPC(&WanLink->Lock); //
// Check to see if the WanLink is cleaning up.
//
if(WanLink->State != WanStateOpen) { PS_UNLOCK_DPC(&WanLink->Lock);
PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiQueryAllData]: Adapter %08X, WanLink %08X: Link not ready \n", Adapter, WanLink));
Link = Link->Flink; continue; } REFADD(&WanLink->RefCount, 'WMIQ'); PS_UNLOCK_DPC(&WanLink->Lock);
PS_UNLOCK(&Adapter->Lock);
//
// If there is an instance name associated with the VC then we need to query it.
//
PsAssert(WanLink->InstanceName.Buffer); NtStatus = PsQueryGuidDataSize(Adapter, WanLink, NULL, pNdisGuid->Oid, &BytesNeeded); if(NT_SUCCESS(NtStatus)) { //
// Make sure we have enough buffer space for the instance name and
// the data.
//
InstanceNameSize = ALIGN(WanLink->InstanceName.Length + sizeof(USHORT)); wnodeTotalSize += InstanceNameSize + ALIGN(BytesNeeded); if (BufferSize < wnodeTotalSize) { WMI_BUFFER_TOO_SMALL(BufferSize, wnode, wnodeTotalSize, &NtStatus, pReturnSize); OutOfSpace = TRUE; PS_LOCK(&Adapter->Lock);
Link = Link->Flink; REFDEL(&WanLink->RefCount, TRUE, 'WMIQ'); continue; } //
// The instance info contains the instance name followed by the
// data for the item.
//
//
// Add the offset to the instance name to the table.
//
pInstanceNameOffsets[cInstanceCount] = OffsetToInstanceInfo; //
// Copy the instance name into the wnode buffer.
//
*((PUSHORT)pBuffer) = WanLink->InstanceName.Length; NdisMoveMemory(pBuffer + sizeof(USHORT), WanLink->InstanceName.Buffer, WanLink->InstanceName.Length); //
// Keep track of true instance counts.
//
OffsetToInstanceInfo += InstanceNameSize; pBuffer = (PUCHAR)wnode + OffsetToInstanceInfo; //
//
//
NtStatus = PsQueryGuidData(Adapter, WanLink, NULL, pNdisGuid->Oid, pBuffer, BytesNeeded); if (!NT_SUCCESS(NtStatus)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiQueryAllData]: Adapter %08X, Failed to query GUID data\n", Adapter));
PS_LOCK(&Adapter->Lock);
REFDEL(&WanLink->RefCount, TRUE, 'WMIQ'); break; } //
// Save the length of the data item for this instance.
//
poidl[cInstanceCount].OffsetInstanceData = OffsetToInstanceInfo; poidl[cInstanceCount].LengthInstanceData = BytesNeeded; //
// Keep track of true instance counts.
//
OffsetToInstanceInfo += ALIGN(BytesNeeded); pBuffer = (PUCHAR)wnode + OffsetToInstanceInfo; //
// Increment the current instance count.
//
cInstanceCount++; }
PS_LOCK(&Adapter->Lock);
Link = Link->Flink;
REFDEL(&WanLink->RefCount, TRUE, 'WMIQ'); } PS_UNLOCK(&Adapter->Lock); }
PS_LOCK(&AdapterListLock); NextAdapter = NextAdapter->Flink; REFDEL(&Adapter->RefCount, TRUE, 'WMIQ'); }
PS_UNLOCK(&AdapterListLock);
if (!OutOfSpace) { wnode->WnodeHeader.BufferSize = wnodeTotalSize; wnode->InstanceCount = cInstanceCount; //
// Set the status to success.
//
NtStatus = STATUS_SUCCESS; *pReturnSize = wnode->WnodeHeader.BufferSize; }
} while (FALSE);
return(NtStatus);}
NTSTATUSPsWmiFindInstanceName( IN PPS_WAN_LINK *pWanLink, IN PGPC_CLIENT_VC *pVc, IN PADAPTER Adapter, IN PWSTR pInstanceName, IN USHORT cbInstanceName ){ NTSTATUS Status = STATUS_SUCCESS; PVOID ptmp1; PVOID ptmp2; PLIST_ENTRY Link; UINT cListCount; PLIST_ENTRY pListHead; PPS_WAN_LINK WanLink; PGPC_CLIENT_VC Vc; NDIS_STRING usTemp; *pWanLink = NULL; *pVc = NULL; if ( NdisEqualMemory(pInstanceName, WanPrefix.Buffer, WanPrefix.Length)) { //
// The name belongs to a miniport, check to see if it is for this one.
//
usTemp.Buffer = (PWCHAR)((PCHAR)pInstanceName + WanPrefix.Length + INSTANCE_ID_SIZE); usTemp.Length = usTemp.MaximumLength = cbInstanceName - WanPrefix.Length - INSTANCE_ID_SIZE; //
// Get a ULONGLONG pointer to the wnode's instance name.
//
ptmp1 = (PVOID)&pInstanceName[1];
//
// No point in searching wanlinks on the non wan adapters.
//
if(Adapter->MediaType == NdisMediumWan && RtlEqualUnicodeString(&Adapter->WMIInstanceName, &usTemp, TRUE)) { //
// The request is for some WAN Link. Go through the Miniport's list of WMI enabled VCs.
//
PS_LOCK(&Adapter->Lock); for(Link = Adapter->WanLinkList.Flink; Link != &Adapter->WanLinkList; Link = Link->Flink) { //
// Get a pointer to the VC.
//
WanLink = CONTAINING_RECORD(Link, PS_WAN_LINK, Linkage); PS_LOCK_DPC(&WanLink->Lock); if(WanLink->State == WanStateOpen) { //
// Check the name with the one in the wnode.
//
ptmp2 = (PVOID)&WanLink->InstanceName.Buffer[1]; if (RtlCompareMemory( ptmp1, ptmp2, 48) == 48) { //
// This is our baby. Slap a reference on it and get out.
//
*pWanLink = WanLink; REFADD(&WanLink->RefCount, 'WMII'); PS_UNLOCK_DPC(&WanLink->Lock); break; } } PS_UNLOCK_DPC(&WanLink->Lock); } PS_UNLOCK(&Adapter->Lock); //
// If we didn't find the WanLink then return FAILURE.
//
if (!*pWanLink) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiFindInstanceName: Adapter %08X, Could not verify the instance name passed in\n")); Status = STATUS_WMI_INSTANCE_NOT_FOUND; } } else { Status = STATUS_WMI_INSTANCE_NOT_FOUND; } } else { if ( NdisEqualMemory(pInstanceName, VcPrefix.Buffer, VcPrefix.Length)) { //
// The name belongs to a miniport, check to see if it is for this one.
//
usTemp.Buffer = (PWCHAR)((PCHAR)pInstanceName + VcPrefix.Length + INSTANCE_ID_SIZE); usTemp.Length = usTemp.MaximumLength = cbInstanceName - VcPrefix.Length - INSTANCE_ID_SIZE;
//
// Make sure that the VC is searched on the correct adapter. Otherwise, we could land up
// searching all the VCs on all the adapters.
//
if (!RtlEqualUnicodeString(&Adapter->WMIInstanceName, &usTemp, TRUE)) { Status = STATUS_WMI_INSTANCE_NOT_FOUND; } else { //
// Get a ULONGLONG pointer to the wnode's instance name.
//
ptmp1 = (PVOID)&pInstanceName[1]; //
// The request is for some Vc. Go through the Miniport's list of WMI enabled VCs.
//
PS_LOCK(&Adapter->Lock); for(Link = Adapter->GpcClientVcList.Flink; Link != &Adapter->GpcClientVcList; Link = Link->Flink) { //
// Get a pointer to the VC.
//
Vc = CONTAINING_RECORD(Link, GPC_CLIENT_VC, Linkage); PS_LOCK_DPC(&Vc->Lock); if(Vc->ClVcState == CL_CALL_COMPLETE) { //
// Check the name with the one in the wnode. All we need to do is compare the
// number in the name.
//
ptmp2 = (PVOID)&Vc->InstanceName.Buffer[1]; if(RtlCompareMemory(ptmp1, ptmp2, 48) == 48) { //
// This is our baby. Slap a reference on it and get out.
//
*pVc = Vc; InterlockedIncrement(&Vc->RefCount); PS_UNLOCK_DPC(&Vc->Lock); break; } } PS_UNLOCK_DPC(&Vc->Lock); } PS_UNLOCK(&Adapter->Lock); //
// If we didn't find the VC then return FAILURE.
//
if (!*pVc) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiFindInstanceName: Adapter %08X, Could not verify the instance name passed in\n")); Status = STATUS_WMI_INSTANCE_NOT_FOUND; } } } else { //
// The name belongs to a miniport, check to see if it is for this one.
//
usTemp.Buffer = pInstanceName; usTemp.Length = usTemp.MaximumLength = cbInstanceName;
if (!RtlEqualUnicodeString(&Adapter->WMIInstanceName, &usTemp, TRUE)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiFindInstanceName]: Adapter %08X, Invalid instance name \n", Adapter)); Status = STATUS_WMI_INSTANCE_NOT_FOUND; } } } return(Status);}
NTSTATUSPsQuerySetMiniport(PADAPTER Adapter, PPS_WAN_LINK WanLink, PGPC_CLIENT_VC Vc, NDIS_OID Oid, PVOID Data, ULONG DataSize) {
//
// Fail these no matter what
//
switch(Oid) { case OID_QOS_TC_SUPPORTED: case OID_QOS_REMAINING_BANDWIDTH: case OID_QOS_LATENCY: case OID_QOS_FLOW_COUNT: case OID_QOS_NON_BESTEFFORT_LIMIT: case OID_QOS_SCHEDULING_PROFILES_SUPPORTED: case OID_QOS_CURRENT_SCHEDULING_PROFILE: case OID_QOS_DISABLE_DRR: case OID_QOS_MAX_OUTSTANDING_SENDS: case OID_QOS_TIMER_RESOLUTION: return STATUS_WMI_NOT_SUPPORTED; }
if(Vc) { switch(Oid) { case OID_QOS_STATISTICS_BUFFER: NdisZeroMemory(&Vc->Stats, sizeof(PS_FLOW_STATS));
//
// Send the request down, so that the scheduling components
// can also reset their stats.
//
(*Vc->PsComponent->SetInformation) (Vc->PsPipeContext, Vc->PsFlowContext, Oid, DataSize, Data); return STATUS_SUCCESS;
default: return STATUS_WMI_NOT_SUPPORTED; } }
//
// These work for Wan and LAN
//
switch(Oid) {
case OID_QOS_ENABLE_AVG_STATS:
if(DataSize != sizeof(ULONG)) { return STATUS_BUFFER_TOO_SMALL; }
gEnableAvgStats = *(PULONG)Data; return STATUS_SUCCESS;
case OID_QOS_ENABLE_WINDOW_ADJUSTMENT:
if(DataSize != sizeof(ULONG)) { return STATUS_BUFFER_TOO_SMALL; }
gEnableWindowAdjustment = *(PULONG)Data; return STATUS_SUCCESS;
#if DBG
case OID_QOS_LOG_THRESHOLD:
if(DataSize != sizeof(ULONG)) { return STATUS_BUFFER_TOO_SMALL; } DbugTraceSetThreshold(*(PULONG)Data, Adapter, IndicateLogThreshold); return STATUS_SUCCESS;
case OID_QOS_LOG_MASK: if(DataSize != sizeof(ULONG)) { return STATUS_BUFFER_TOO_SMALL; } LogTraceMask = *(PULONG)Data; return STATUS_SUCCESS;
case OID_QOS_LOG_LEVEL: if(DataSize != sizeof(ULONG)) { return STATUS_BUFFER_TOO_SMALL; } LogTraceLevel = *(PULONG)Data; return STATUS_SUCCESS;
#endif
}
if(WanLink) { switch(Oid) { case OID_QOS_STATISTICS_BUFFER:
NdisZeroMemory(&WanLink->Stats, sizeof(PS_ADAPTER_STATS)); //
// Send it to the scheduling components so that
// they can reset the per pipe stats
//
(*WanLink->PsComponent->SetInformation) (WanLink->PsPipeContext, NULL, Oid, DataSize, Data); return STATUS_SUCCESS;
case OID_QOS_FLOW_MODE:
if(DataSize != sizeof(ULONG)) {
return STATUS_BUFFER_TOO_SMALL; }
if(*(PULONG)Data == ADAPTER_FLOW_MODE_DIFFSERV || *(PULONG)Data == ADAPTER_FLOW_MODE_STANDARD ) { InterlockedExchange((PLONG)&WanLink->AdapterMode, *(PULONG)Data);
return STATUS_SUCCESS; } else { return STATUS_INVALID_PARAMETER; } case OID_QOS_HIERARCHY_CLASS: (*WanLink->PsComponent->SetInformation) (WanLink->PsPipeContext, NULL, Oid, DataSize, Data); return STATUS_SUCCESS; } }
if(Adapter->MediaType != NdisMediumWan) { switch(Oid) { case OID_QOS_STATISTICS_BUFFER:
NdisZeroMemory(&Adapter->Stats, sizeof(PS_ADAPTER_STATS)); //
// Send it to the scheduling components so that
// they can reset the per pipe stats
//
(*Adapter->PsComponent->SetInformation) (Adapter->PsPipeContext, NULL, Oid, DataSize, Data); return STATUS_SUCCESS;
case OID_QOS_FLOW_MODE:
if(DataSize != sizeof(ULONG)) {
return STATUS_BUFFER_TOO_SMALL; }
if(*(PULONG)Data == ADAPTER_FLOW_MODE_DIFFSERV || *(PULONG)Data == ADAPTER_FLOW_MODE_STANDARD ) { InterlockedExchange((PLONG)&Adapter->AdapterMode, *(PULONG)Data);
return STATUS_SUCCESS; } else { return STATUS_INVALID_PARAMETER; } case OID_QOS_HIERARCHY_CLASS: (*Adapter->PsComponent->SetInformation) (Adapter->PsPipeContext, NULL, Oid, DataSize, Data); return STATUS_SUCCESS;
case OID_QOS_BESTEFFORT_BANDWIDTH: if(DataSize != sizeof(ULONG)) { return STATUS_BUFFER_TOO_SMALL; } else { return ModifyBestEffortBandwidth(Adapter, *(PULONG)Data); } } }
return STATUS_WMI_NOT_SUPPORTED; }
NTSTATUS PsWmiHandleSingleInstance(ULONG MinorFunction, PWNODE_SINGLE_INSTANCE wnode, PNDIS_GUID pNdisGuid, ULONG BufferSize, PULONG pReturnSize){ PPS_WAN_LINK WanLink; PGPC_CLIENT_VC Vc; USHORT cbInstanceName; PWSTR pInstanceName; PLIST_ENTRY NextAdapter; PADAPTER Adapter; NTSTATUS Status = STATUS_WMI_INSTANCE_NOT_FOUND;
//
// Send this to all the adapter instances.
//
*pReturnSize = 0;
//
// First, we need to check if this is the window size adjustment guid..
//
if( pNdisGuid->Oid == OID_QOS_ENABLE_WINDOW_ADJUSTMENT) { if( MinorFunction == IRP_MN_CHANGE_SINGLE_INSTANCE) { PUCHAR pGuidData; ULONG GuidDataSize; pGuidData = (PUCHAR)wnode + wnode->DataBlockOffset; GuidDataSize = wnode->SizeDataBlock;
//
// Attempt to set the miniport with the information.
//
Status = PsQuerySetMiniport(NULL, NULL, NULL, pNdisGuid->Oid, pGuidData, GuidDataSize); return Status; } else if( MinorFunction == IRP_MN_QUERY_SINGLE_INSTANCE ) { ULONG BytesNeeded; ULONG wnodeSize; //
// Determine the buffer size needed for the GUID data.
//
Status = PsQueryGuidDataSize(NULL, NULL, NULL, pNdisGuid->Oid, &BytesNeeded);
if (!NT_SUCCESS(Status)) { return Status; } //
// Determine the size of the wnode.
//
wnodeSize = wnode->DataBlockOffset + BytesNeeded; if (BufferSize < wnodeSize) { WMI_BUFFER_TOO_SMALL(BufferSize, wnode, wnodeSize, &Status, pReturnSize); return Status; } //
// Initialize the wnode.
//
KeQuerySystemTime(&wnode->WnodeHeader.TimeStamp); wnode->WnodeHeader.BufferSize = wnodeSize; wnode->SizeDataBlock = BytesNeeded; //
// Validate the guid and get the data for it.
//
Status = PsQueryGuidData(NULL, NULL, NULL, pNdisGuid->Oid, (PUCHAR)wnode + wnode->DataBlockOffset, BytesNeeded); if (!NT_SUCCESS(Status)) { return Status; } else { *pReturnSize = wnodeSize; } } }
//
// If we are here, then it is a "per adapter" guid/oid
//
PS_LOCK(&AdapterListLock);
NextAdapter = AdapterList.Flink; while(NextAdapter != &AdapterList) { Adapter = CONTAINING_RECORD(NextAdapter, ADAPTER, Linkage); PS_LOCK_DPC(&Adapter->Lock); if(Adapter->PsMpState != AdapterStateRunning) { PS_UNLOCK_DPC(&Adapter->Lock); NextAdapter = NextAdapter->Flink; continue; }
REFADD(&Adapter->RefCount, 'WMIQ');
PS_UNLOCK_DPC(&Adapter->Lock);
PS_UNLOCK(&AdapterListLock);
//
// We first see if this instance name is meaningful for this adapter.
//
cbInstanceName = *(PUSHORT)((PUCHAR)wnode + wnode->OffsetInstanceName); pInstanceName = (PWSTR)((PUCHAR)wnode + wnode->OffsetInstanceName + sizeof(USHORT)); //
// This routine will determine if the wnode's instance name is a miniport or VC.
// If it's a VC then it will find which one.
//
Vc = 0; WanLink = 0; Status = PsWmiFindInstanceName(&WanLink, &Vc, Adapter, pInstanceName, cbInstanceName); if(!NT_SUCCESS(Status)) { PS_LOCK(&AdapterListLock);
NextAdapter = NextAdapter->Flink;
REFDEL(&Adapter->RefCount, TRUE, 'WMIQ'); continue; } else { //
// Found the adapter or the Vc or the WanLink. If this fails from this point, we can just return.
//
switch(MinorFunction) { case IRP_MN_QUERY_SINGLE_INSTANCE: { ULONG BytesNeeded; ULONG wnodeSize; //
// Determine the buffer size needed for the GUID data.
//
Status = PsQueryGuidDataSize(Adapter, WanLink, Vc, pNdisGuid->Oid, &BytesNeeded); if (!NT_SUCCESS(Status)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiQuerySingleInstance]: Adpater %08X, Unable to determine OID data size for OID %0x\n", Adapter, pNdisGuid->Oid)); break; } //
// Determine the size of the wnode.
//
wnodeSize = wnode->DataBlockOffset + BytesNeeded; if (BufferSize < wnodeSize) { WMI_BUFFER_TOO_SMALL(BufferSize, wnode, wnodeSize, &Status, pReturnSize); break; } //
// Initialize the wnode.
//
KeQuerySystemTime(&wnode->WnodeHeader.TimeStamp); wnode->WnodeHeader.BufferSize = wnodeSize; wnode->SizeDataBlock = BytesNeeded; //
// Validate the guid and get the data for it.
//
Status = PsQueryGuidData(Adapter, WanLink, Vc, pNdisGuid->Oid, (PUCHAR)wnode + wnode->DataBlockOffset, BytesNeeded); if (!NT_SUCCESS(Status)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("PsWmiQuerySingleInstance: Adapter %08X, Failed to get the OID data for OID %08X.\n", Adapter, pNdisGuid->Oid)); } else { *pReturnSize = wnodeSize; } break; }
case IRP_MN_CHANGE_SINGLE_INSTANCE: { PUCHAR pGuidData; ULONG GuidDataSize;
pGuidData = (PUCHAR)wnode + wnode->DataBlockOffset; GuidDataSize = wnode->SizeDataBlock;
//
// Attempt to set the miniport with the information.
//
Status = PsQuerySetMiniport(Adapter, WanLink, Vc, pNdisGuid->Oid, pGuidData, GuidDataSize); break; }
default: PsAssert(0); }
//
// If this was a VC then we need to dereference it.
//
if (NULL != WanLink) { REFDEL(&WanLink->RefCount, FALSE, 'WMII'); } if (NULL != Vc) { DerefClVc(Vc); } REFDEL(&Adapter->RefCount, FALSE, 'WMIQ');
return Status; } }
PS_UNLOCK(&AdapterListLock);
return Status;}
NTSTATUSWMIDispatch( IN PDEVICE_OBJECT pdo, IN PIRP pirp )/*++
Routine Description:
Arguments:
Return Value:
--*/{ PIO_STACK_LOCATION pirpSp = IoGetCurrentIrpStackLocation(pirp); ULONG_PTR ProviderId = pirpSp->Parameters.WMI.ProviderId; PVOID DataPath = pirpSp->Parameters.WMI.DataPath; ULONG BufferSize = pirpSp->Parameters.WMI.BufferSize; PVOID Buffer = pirpSp->Parameters.WMI.Buffer; NTSTATUS Status; ULONG ReturnSize = 0; KIRQL OldIrql; ULONG MinorFunction;
PsDbgOut(DBG_TRACE, DBG_WMI, ("[WMIDispatch]: Device Object %08X, IRP Device Object %08X, " "Minor function %d \n", pdo, pirpSp->Parameters.WMI.ProviderId, pirpSp->MinorFunction));
#if DBG
OldIrql = KeGetCurrentIrql();#endif
//
// Fail the irp if we don't find an adapter. We also fail the irp if the provider ID is not
// us.
//
// If the ProviderID is not us, then ideally we need to pass it down the irp stack.
//
// (By calling IoSkipCurrentIrpStackLocation(pirp) &
// IocallDriver(Adapter->NextDeviceObject, pirp);
//
// In this case, we are not attached to anything, so we can just fail the request.
//
if((pirpSp->Parameters.WMI.ProviderId != (ULONG_PTR)pdo)) {
PsDbgOut(DBG_FAILURE, DBG_WMI, ("[WMIDispatch]: Could not find the adapter for pdo 0x%x \n", pdo));
pirp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST; pirp->IoStatus.Information = 0; IoCompleteRequest(pirp, IO_NO_INCREMENT);
return STATUS_INVALID_DEVICE_REQUEST; }
MinorFunction = pirpSp->MinorFunction;
switch (pirpSp->MinorFunction) { case IRP_MN_REGINFO: Status = PsWmiRegister((ULONG_PTR)DataPath, Buffer, BufferSize, &ReturnSize); break; case IRP_MN_QUERY_ALL_DATA: Status = PsWmiQueryAllData((LPGUID)DataPath, (PWNODE_ALL_DATA)Buffer, BufferSize, &ReturnSize); break; case IRP_MN_CHANGE_SINGLE_INSTANCE: { PWNODE_SINGLE_INSTANCE wnode = (PWNODE_SINGLE_INSTANCE) Buffer; PPS_WAN_LINK WanLink; PGPC_CLIENT_VC Vc; USHORT cbInstanceName; PWSTR pInstanceName; PNDIS_GUID pNdisGuid; PUCHAR pGuidData; ULONG GuidDataSize;
//
// See if the GUID is ours
//
Status = PsWmiGetGuid(&pNdisGuid, &wnode->WnodeHeader.Guid, 0); if(!NT_SUCCESS(Status)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[WmiDispatch]: Invalid GUID \n")); Status = STATUS_INVALID_PARAMETER; break; }
//
// Is this guid settable?
//
if (PS_GUID_TEST_FLAG(pNdisGuid, fPS_GUID_NOT_SETTABLE)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[WmiDispatch]: Guid is not settable!\n")); Status = STATUS_WMI_NOT_SUPPORTED; break; } //
// Get a pointer to the GUID data and size.
//
GuidDataSize = wnode->SizeDataBlock; pGuidData = (PUCHAR)wnode + wnode->DataBlockOffset; if (GuidDataSize == 0) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiHandleSingleInstance]: Guid has not data to set!\n")); Status = STATUS_INVALID_PARAMETER;
break; } //
// Make sure it's not a stauts indication.
//
if (!PS_GUID_TEST_FLAG(pNdisGuid, fNDIS_GUID_TO_OID)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[PsWmiHandleSingleInstance]: Guid does not translate to an OID\n")); Status = STATUS_INVALID_DEVICE_REQUEST; break; }
Status = PsWmiHandleSingleInstance(IRP_MN_CHANGE_SINGLE_INSTANCE, wnode, pNdisGuid, BufferSize, &ReturnSize);
break; } case IRP_MN_QUERY_SINGLE_INSTANCE: { PWNODE_SINGLE_INSTANCE wnode = (PWNODE_SINGLE_INSTANCE) Buffer; PNDIS_GUID pNdisGuid;
//
// See if the GUID is ours
//
Status = PsWmiGetGuid(&pNdisGuid, &wnode->WnodeHeader.Guid, 0); if(!NT_SUCCESS(Status)) { PsDbgOut(DBG_FAILURE, DBG_WMI, ("[WmiDispatch]: Invalid GUID \n")); Status = STATUS_INVALID_PARAMETER; } else { Status = PsWmiHandleSingleInstance(IRP_MN_QUERY_SINGLE_INSTANCE, wnode, pNdisGuid, BufferSize, &ReturnSize); }
break; } case IRP_MN_ENABLE_EVENTS: Status = PsWmiEnableEvents((LPGUID)DataPath); break; case IRP_MN_DISABLE_EVENTS: Status = PsWmiDisableEvents((LPGUID)DataPath); break; case IRP_MN_ENABLE_COLLECTION: case IRP_MN_DISABLE_COLLECTION: case IRP_MN_CHANGE_SINGLE_ITEM:
Status = STATUS_NOT_SUPPORTED; PsDbgOut(DBG_TRACE, DBG_WMI, ("[WMIDispatch]: Unsupported minor function (0x%x) \n", pirpSp->MinorFunction)); break; default: PsDbgOut(DBG_FAILURE, DBG_WMI, ("[WMIDispatch]: Invalid minor function (0x%x) \n", pirpSp->MinorFunction)); Status = STATUS_INVALID_DEVICE_REQUEST; break; } PsAssert(KeGetCurrentIrql() == OldIrql);
pirp->IoStatus.Status = Status; PsAssert(ReturnSize <= BufferSize); pirp->IoStatus.Information = NT_SUCCESS(Status) ? ReturnSize : 0; IoCompleteRequest(pirp, IO_NO_INCREMENT);
//
// Allow IFC_UP notifications.
//
if(MinorFunction == IRP_MN_REGINFO) { //
// Need to walk all the adapters and send notifications.
//
PLIST_ENTRY NextAdapter; PADAPTER Adapter;
PS_LOCK(&AdapterListLock);
WMIInitialized = TRUE;
NextAdapter = AdapterList.Flink; while(NextAdapter != &AdapterList) { Adapter = CONTAINING_RECORD(NextAdapter, ADAPTER, Linkage); PS_LOCK_DPC(&Adapter->Lock);
if(Adapter->PsMpState == AdapterStateRunning && !Adapter->IfcNotification) {
Adapter->IfcNotification = TRUE;
REFADD(&Adapter->RefCount, 'WMIN');
PS_UNLOCK_DPC(&Adapter->Lock);
PS_UNLOCK(&AdapterListLock);
TcIndicateInterfaceChange(Adapter, 0, NDIS_STATUS_INTERFACE_UP);
PS_LOCK(&AdapterListLock);
NextAdapter = NextAdapter->Flink;
REFDEL(&Adapter->RefCount, TRUE, 'WMIN'); } else { //
// This adapter is not yet ready. The interface will be indicated
// in the mpinitialize handler, when the adapter gets ready.
//
PS_UNLOCK_DPC(&Adapter->Lock);
NextAdapter = NextAdapter->Flink; } }
PS_UNLOCK(&AdapterListLock); } PsDbgOut(DBG_TRACE, DBG_WMI, ("[WMIDispatch] : completing with Status %X \n", Status)); return(Status);}
NTSTATUSGenerateInstanceName( IN PNDIS_STRING Prefix, IN PADAPTER Adapter, IN PLARGE_INTEGER Index, IN PNDIS_STRING pInstanceName){#define CONVERT_MASK 0x000000000000000F
NTSTATUS Status = STATUS_SUCCESS; USHORT cbSize; PUNICODE_STRING uBaseInstanceName = (PUNICODE_STRING)&Adapter->WMIInstanceName; UINT Value; WCHAR wcLookUp[] = {L'0', L'1', L'2', L'3', L'4', L'5', L'6', L'7', L'8', L'9', L'A', L'B', L'C', L'D', L'E', L'F'}; WCHAR tmpBuffer[18] = {0}; UINT c; ULONGLONG tmpIndex; KIRQL OldIrql;
do { //
// Is there already a name associated with this VC?
//
//
// The instance name will be of the format:
// <Prefix>: [YYYYYYYYYYYYYYYY] Base Name
//
cbSize = INSTANCE_ID_SIZE + Prefix->Length; if (NULL != uBaseInstanceName) { cbSize += uBaseInstanceName->Length; }
//
// Initialize a temporary UNICODE_STRING to build the name.
//
NdisZeroMemory(pInstanceName->Buffer, cbSize); pInstanceName->Length = 0; pInstanceName->MaximumLength = cbSize;
//
// Add the prefix
//
RtlCopyUnicodeString(pInstanceName, Prefix);
//
// Add the separator.
//
RtlAppendUnicodeToString(pInstanceName, L" [");
//
// Add the VC index.
//
//tmpIndex = (ULONGLONG)(Index->HighPart << 32) | (ULONGLONG)Index->LowPart;
tmpIndex = Index->QuadPart;
for (c = 16; c > 0; c--) { //
// Get the nibble to convert.
//
Value = (UINT)(tmpIndex & CONVERT_MASK);
tmpBuffer[c - 1] = wcLookUp[Value];
//
// Shift the tmpIndex by a nibble.
//
tmpIndex >>= 4; }
RtlAppendUnicodeToString(pInstanceName, tmpBuffer);
//
// Add closing bracket.
//
RtlAppendUnicodeToString(pInstanceName, L"]");
if (NULL != uBaseInstanceName) { RtlAppendUnicodeToString(pInstanceName, L" ");
//
// Append the base instance name passed into us to the end.
//
RtlAppendUnicodeToString(pInstanceName, uBaseInstanceName->Buffer); }
} while (FALSE); return(Status);}
|
