8009 lines
219 KiB
Plaintext
8009 lines
219 KiB
Plaintext
/*++
|
|
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
wmicore.mof
|
|
|
|
Abstract:
|
|
|
|
This file defines all of the MOF classes "built in" to WMI. Typically
|
|
this will be for all data providers that are shipped by MS. The list
|
|
includes:
|
|
|
|
WMI specific internal classes
|
|
Power Management
|
|
NDIS
|
|
SMBIOS Data
|
|
Keyboard
|
|
Mouse
|
|
Disk
|
|
IDE
|
|
Serial
|
|
Temperature via ACPI
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#pragma namespace("\\\\.\\root\\wmi")
|
|
|
|
#pragma classflags("forceupdate")
|
|
|
|
//
|
|
// Wmi internal classes
|
|
|
|
|
|
class WMIEvent : __ExtrinsicEvent
|
|
{
|
|
};
|
|
|
|
|
|
|
|
[abstract]
|
|
class MS_WmiInternal
|
|
{
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("This class supplies the binary mof information") : amended,
|
|
guid("{05901221-D566-11d1-B2F0-00A0C9062910}")
|
|
]
|
|
class MSWmi_MofData : MS_WmiInternal
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
read
|
|
] uint32 Unused1;
|
|
|
|
[WmiDataId(2),
|
|
read
|
|
] uint32 Unused2;
|
|
|
|
|
|
|
|
[WmiDataId(3),
|
|
read
|
|
] uint32 Size;
|
|
|
|
[WmiDataId(4),
|
|
read
|
|
] uint32 Unused4;
|
|
|
|
|
|
[WmiDataId(5),
|
|
WmiSizeIs("Size"),
|
|
read
|
|
] uint8 BinaryMofData[];
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("This class supplies additional information about a data provider. Querying this class with an instance name returned from another class query will return additional information about the instance") : amended,
|
|
guid("{C7BF35D0-AADB-11d1-BF4A-00A0C9062910}")
|
|
]
|
|
class MSWmi_ProviderInfo : MS_WmiInternal
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
// CM_DRP_FRIENDLY_NAME
|
|
[WmiDataId(1),
|
|
read,
|
|
DisplayName("Friendly Name") : amended
|
|
] string FriendlyName;
|
|
|
|
// CM_DRP_DEVICEDESC
|
|
[WmiDataId(2),
|
|
read,
|
|
DisplayName("Description") : amended
|
|
] string Description;
|
|
|
|
// CM_DRP_LOCATION_INFORMATION
|
|
[WmiDataId(3),
|
|
read,
|
|
DisplayName("Location") : amended
|
|
] string Location;
|
|
|
|
// CM_DRP_MFG
|
|
[WmiDataId(4),
|
|
read,
|
|
DisplayName("Manufacturer") : amended
|
|
] string Manufacturer;
|
|
|
|
// CM_DRP_SERVICE
|
|
[WmiDataId(5),
|
|
read,
|
|
DisplayName("Service") : amended
|
|
] string Service;
|
|
|
|
// CONSIDER: adding device capabilities
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("This class supplies the PnPDeviceId for a specific device") : amended,
|
|
guid("{C7BF35D2-AADB-11d1-BF4A-00A0C9062910}"),
|
|
GuidName1("DATA_PROVIDER_PNPID_GUID")
|
|
]
|
|
class MSWmi_PnPDeviceId : MS_WmiInternal
|
|
{
|
|
//
|
|
// Note to driver developers:
|
|
//
|
|
// Support for this guid is required if properties in the wmi namespace
|
|
// are to be mapped into another namespace via the view provider.
|
|
//
|
|
// This guid is automatically supported by WMI if the following conditions
|
|
// are met:
|
|
//
|
|
// 1. The device registers with PDO instance names for all guids
|
|
// (ie, WMIREG_FLAG_PDO_INSTANCE_NAMES)
|
|
//
|
|
// If the driver cannot follow the rules above and WMI cannot support
|
|
// the guid automatically, then the driver can support it in its own
|
|
// driver code.
|
|
|
|
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
// Pnp device id
|
|
[WmiDataId(1),
|
|
Description("PnP Device Id for the device. This property is useful for mapping from the wmi namespace to the cimv2 namespace classes using the view provider") : amended,
|
|
read,
|
|
DisplayName("PnP Device Id") : amended
|
|
] string PnPDeviceId;
|
|
};
|
|
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("This class supplies the Instance names associated with a PnP Device Instance Id") : amended,
|
|
guid("{C7BF35D3-AADB-11d1-BF4A-00A0C9062910}"),
|
|
GuidName1("DATA_PROVIDER_PNPID_INSTANCE_NAMES_GUID")
|
|
]
|
|
class MSWmi_PnPInstanceNames : MS_WmiInternal
|
|
{
|
|
//
|
|
// Note to driver developers:
|
|
//
|
|
// Support for this guid is required if properties in the wmi namespace
|
|
// are to be mapped into another namespace via the view provider.
|
|
//
|
|
// This guid is automatically supported by WMI if the following conditions
|
|
// are met:
|
|
//
|
|
// 1. The device registers with PDO instance names for all guids
|
|
// (ie, WMIREG_FLAG_PDO_INSTANCE_NAMES)
|
|
//
|
|
// If the driver cannot follow the rules above and WMI cannot support
|
|
// the guid automatically, then the driver can support it in its own
|
|
// driver code.
|
|
|
|
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
// Pnp device id
|
|
[WmiDataId(1),
|
|
Description("Count of instance names associated with this PnPId") : amended,
|
|
read,
|
|
DisplayName("Count") : amended
|
|
] uint32 Count;
|
|
|
|
// Instance names
|
|
[WmiDataId(2),
|
|
WmiSizeIs("Count"),
|
|
Description("Wmi Instance Names for the device. This property is useful for mapping from the wmi namespace to the cimv2 namespace classes using the view provider") : amended,
|
|
read,
|
|
DisplayName("Instance Name List") : amended
|
|
] string InstanceNameList[];
|
|
};
|
|
|
|
[WMI,
|
|
guid("{F8C60AED-EF8D-4f95-9EA8-F04318A00F30}")
|
|
]
|
|
class MSWmi_Guid
|
|
{
|
|
[WmiDataId(1)]
|
|
uint8 Guid[16];
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
guid("{B48D49A1-E777-11d0-A50C-00A0C9062910}"),
|
|
description("This event reports whenever a guid is registered or unregistered") : amended
|
|
]
|
|
class MSWmi_GuidRegistrationInfo : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
Description("Type of operation") : amended,
|
|
Values{"Registration Add", "Registration Remove", "Registration Update"} : amended,
|
|
ValueMap{"1", "2", "4"}
|
|
]
|
|
uint32 Operation;
|
|
|
|
[WmiDataId(2),
|
|
Description("Count of guids being registered, unregistered, or updated") : amended
|
|
]
|
|
uint32 GuidCount;
|
|
|
|
[WmiDataId(3),
|
|
WmiSizeIs("GuidCount"),
|
|
Description("List of guids") : amended
|
|
]
|
|
MSWmi_Guid GuidList[];
|
|
};
|
|
|
|
|
|
//
|
|
// ACPI info classes
|
|
//
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("ACPI Table data") : amended,
|
|
guid("{5DAF38AE-F6F8-4d90-8199-EBDE6800EC3B}")
|
|
]
|
|
class MSAcpiInfo
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
|
|
[WmiDataId(1),
|
|
Description("Boot Architecture") : amended,
|
|
Values{"LEGACY_DEVICES", "I8042" } : amended,
|
|
ValueMap{"1", "2"}
|
|
]
|
|
uint32 BootArchitecture;
|
|
|
|
[WmiDataId(2),
|
|
Description("Systems Preferred Power Profile") : amended
|
|
]
|
|
uint32 PreferredProfile;
|
|
|
|
[WmiDataId(3),
|
|
BitValues{"this one bit flag indicates whether or not the WBINVD instruction works properly,if this bit is not set we can not use S2, S3 states, or C3 on MP machines",
|
|
"this flag indicates if wbinvd works EXCEPT that it does not invalidate the cache",
|
|
"this flag indicates that the C1 state is supported on all processors.",
|
|
"this one bit flag indicates whether support for the C2 state is restricted to uniprocessor machines",
|
|
"this bit indicates whether the PWR button is treated as a fix feature (0) or a generic feature (1)",
|
|
"SLEEP_BUTTON_GENERIC",
|
|
"this bit indicates whether the RTC wakeup status is reported in fix register space (0) or not (1)",
|
|
"RTC_WAKE_FROM_S4",
|
|
"This bit indicates whether the machine implements a 24 or 32 bit timer.",
|
|
"This bit indicates whether the machine supports docking",
|
|
"This bit indicates whether the machine supports reset",
|
|
"This bit indicates whether the machine case can be opened",
|
|
"This bit indicates whether the machine has no video"
|
|
} : amended,
|
|
BitMap{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"},
|
|
Description("Capabilities") : amended
|
|
]
|
|
uint32 Capabilities;
|
|
};
|
|
|
|
//
|
|
// SMBIOS data classes
|
|
//
|
|
[abstract]
|
|
class MS_SmBios
|
|
{
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Raw SMBIOS Tables") : amended,
|
|
guid("{8F680850-A584-11d1-BF38-00A0C9062910}")
|
|
]
|
|
class MSSmBios_RawSMBiosTables : MS_SmBios
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read] boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
read,
|
|
DisplayName("Used 20 Calling Method") : amended
|
|
] boolean Used20CallingMethod;
|
|
|
|
[WmiDataId(2),
|
|
read,
|
|
DisplayName("Smbios Major Version") : amended
|
|
] uint8 SmbiosMajorVersion;
|
|
|
|
[WmiDataId(3),
|
|
read,
|
|
DisplayName("Smbios Minor Version") : amended
|
|
] uint8 SmbiosMinorVersion;
|
|
|
|
[WmiDataId(4),
|
|
read,
|
|
DisplayName("Dmi Revision") : amended
|
|
] uint8 DmiRevision;
|
|
|
|
|
|
[WmiDataId(5),
|
|
read,
|
|
DisplayName("Size") : amended
|
|
] uint32 Size;
|
|
|
|
[WmiDataId(6),
|
|
WmiSizeIs("Size"),
|
|
read,
|
|
DisplayName("SMBios Data") : amended
|
|
] uint8 SMBiosData[];
|
|
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Raw SMBIOS Eventlog") : amended,
|
|
guid("{8F680851-A584-11d1-BF38-00A0C9062910}")
|
|
]
|
|
class MSSmBios_SMBiosEventlog : MS_SmBios
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
read
|
|
] uint16 LogTypeDescLength;
|
|
|
|
[WmiDataId(2),
|
|
read
|
|
] boolean LogHeaderDescExists;
|
|
|
|
[WmiDataId(3),
|
|
read
|
|
] uint8 Reserved;
|
|
|
|
[WmiDataId(4),
|
|
read
|
|
] uint16 LogAreaLength;
|
|
|
|
[WmiDataId(5),
|
|
read
|
|
] uint16 LogHeaderStart;
|
|
|
|
[WmiDataId(6),
|
|
read
|
|
] uint16 LogDataStart;
|
|
|
|
[WmiDataId(7),
|
|
read
|
|
] uint8 AccessMethod;
|
|
|
|
|
|
[WmiDataId(8),
|
|
read
|
|
] uint8 LogStatus;
|
|
|
|
|
|
[WmiDataId(9),
|
|
read
|
|
] uint32 LogChangeToken;
|
|
|
|
[WmiDataId(10),
|
|
read
|
|
] uint32 AccessMethodAddress;
|
|
|
|
//
|
|
// LogHeaderFormat, NumberLogTypeDesc, LengthEachLogTypeDesc and
|
|
// ListLogTypeDesc are only valid if LogHeaderDescExists is TRUE.
|
|
// This means that SMBIOS is revision 2.1
|
|
//
|
|
[WmiDataId(11),
|
|
read
|
|
] uint8 LogHeaderFormat;
|
|
|
|
[WmiDataId(12),
|
|
read
|
|
] uint8 NumberLogTypeDesc;
|
|
|
|
[WmiDataId(13),
|
|
read
|
|
] uint8 LengthEachLogTypeDesc;
|
|
|
|
[WmiDataId(14),
|
|
WmiSizeIs("LogTypeDescLength"),
|
|
read
|
|
] uint8 ListLogTypeDesc[];
|
|
|
|
[WmiDataId(15),
|
|
WmiSizeIs("LogAreaLength"),
|
|
read
|
|
] uint8 LogArea[];
|
|
|
|
};
|
|
|
|
[WMI,
|
|
guid("{8F680852-A584-11d1-BF38-00A0C9062910}"),
|
|
Description("SYSID UUID") : amended,
|
|
HeaderName("SYSID_UUID")
|
|
]
|
|
class MSSmBios_SysidUUID : MS_SmBios
|
|
{
|
|
[WmiDataId(1)]
|
|
uint8 Uuid[16];
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("List of UUID SYSIDS") : amended,
|
|
guid("{8F680853-A584-11d1-BF38-00A0C9062910}"),
|
|
GuidName1("SYSID_UUID_DATA_GUID")
|
|
]
|
|
class MSSmBios_SysidUUIDList : MS_SmBios
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
read
|
|
] uint32 Count;
|
|
|
|
[WmiDataId(2),
|
|
WmiSizeIs("Count"),
|
|
read
|
|
] MSSmBios_SysidUUID List;
|
|
|
|
};
|
|
|
|
[WMI,
|
|
guid("{8F680854-A584-11d1-BF38-00A0C9062910}"),
|
|
Description("SYSID 1394") : amended,
|
|
HeaderName("SYSID_1394")
|
|
]
|
|
class MSSmBios_Sysid1394 : MS_SmBios
|
|
{
|
|
[WmiDataId(1)
|
|
]
|
|
uint8 x1394[8];
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("List of 1394 SYSIDS") : amended,
|
|
guid("{8F680855-A584-11d1-BF38-00A0C9062910}"),
|
|
GuidName1("SYSID_1394_DATA_GUID")
|
|
]
|
|
class MSSmBios_Sysid1394List : MS_SmBios
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
read
|
|
] uint32 Count;
|
|
|
|
[WmiDataId(2),
|
|
WmiSizeIs("Count"),
|
|
read
|
|
] MSSmBios_Sysid1394 List;
|
|
|
|
};
|
|
|
|
[abstract]
|
|
class MSMCAInfo
|
|
{
|
|
};
|
|
|
|
|
|
//
|
|
// NOTE: For all MCA events the first four data items must be identical and
|
|
// match whay is in MSMCAEvent_Header.
|
|
//
|
|
[WMI,
|
|
guid("{6381C27F-C8FA-4da7-8953-B86833736E15}")
|
|
]
|
|
class MSMCAEvent_Header
|
|
{
|
|
[WmiDataId(1),
|
|
Description("Unique Id for the error record containing this error") : amended
|
|
]
|
|
uint64 RecordId;
|
|
|
|
[WmiDataId(2),
|
|
Values{ "0", "1", "2" },
|
|
ValueMap{"Recoverable", "Fatal", "Correctable"},
|
|
Description("Severity of the error record") : amended
|
|
]
|
|
uint8 ErrorSeverity;
|
|
|
|
[WmiDataId(3),
|
|
Values{} : amended,
|
|
ValueMap{},
|
|
Description("Type of eventlog message") : amended
|
|
]
|
|
uint32 Type;
|
|
|
|
[WmiDataId(4),
|
|
Description("CPU that reported the error") : amended
|
|
]
|
|
uint32 Cpu;
|
|
|
|
[WmiDataId(5),
|
|
Description("Number of additional errors in the record") : amended
|
|
]
|
|
uint32 AdditionalErrors;
|
|
|
|
};
|
|
|
|
[WMI,
|
|
Dynamic,
|
|
Provider("WmiProv"),
|
|
guid("{5CE27CDE-D179-4c68-937F-A07B8CC2EA39}"),
|
|
Description("MCA CPU Error Event") : amended
|
|
]
|
|
class MSMCAEvent_CPUError : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
Description("Unique Id for the error record containing this error") : amended
|
|
]
|
|
uint64 RecordId;
|
|
|
|
[WmiDataId(2),
|
|
Values{ "0", "1", "2" },
|
|
ValueMap{"Recoverable", "Fatal", "Correctable"},
|
|
Description("Severity of the error record") : amended
|
|
]
|
|
uint8 ErrorSeverity;
|
|
|
|
[WmiDataId(3),
|
|
Values{} : amended,
|
|
ValueMap{},
|
|
Description("Type of eventlog message") : amended
|
|
]
|
|
uint32 Type;
|
|
|
|
[WmiDataId(4),
|
|
Description("CPU that reported the error") : amended
|
|
]
|
|
uint32 Cpu;
|
|
|
|
[WmiDataId(5),
|
|
Description("Number of additional errors in the record") : amended
|
|
]
|
|
uint32 AdditionalErrors;
|
|
|
|
[WmiDataId(6),
|
|
Description("Cache or TLB level of error") : amended
|
|
]
|
|
uint32 Level;
|
|
|
|
[WmiDataId(7),
|
|
Description("Size of Raw Error Record") : amended
|
|
]
|
|
uint32 Size;
|
|
|
|
[WmiDataId(8),
|
|
WmiSizeIs("Size"),
|
|
Description("Raw Error Record") : amended
|
|
]
|
|
uint8 RawRecord[];
|
|
|
|
};
|
|
|
|
|
|
[WMI,
|
|
Dynamic,
|
|
Provider("WmiProv"),
|
|
guid("{433EEA38-C1A7-48f1-884F-B6875F176CC7}"),
|
|
Description("MCA Memory Error Event") : amended
|
|
]
|
|
class MSMCAEvent_MemoryError : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
Description("Unique Id for the error record containing this error") : amended
|
|
]
|
|
uint64 RecordId;
|
|
|
|
[WmiDataId(2),
|
|
Values{ "0", "1", "2" },
|
|
ValueMap{"Recoverable", "Fatal", "Correctable"},
|
|
Description("Severity of the error record") : amended
|
|
]
|
|
uint8 ErrorSeverity;
|
|
|
|
[WmiDataId(3),
|
|
Values{} : amended,
|
|
ValueMap{},
|
|
Description("Type of eventlog message") : amended
|
|
]
|
|
uint32 Type;
|
|
|
|
[WmiDataId(4),
|
|
Description("CPU that reported the error") : amended
|
|
]
|
|
uint32 Cpu;
|
|
|
|
[WmiDataId(5),
|
|
Description("Number of additional errors in the record") : amended
|
|
]
|
|
uint32 AdditionalErrors;
|
|
|
|
[WmiDataId(6),
|
|
Description("Validation bits to indicate the validity of the subsequent fields") : amended,
|
|
BitMap{"0", "1", "2", "3", "4", "5", "6", "7",
|
|
"8", "9", "10", "11", "12", "13", "14", "15", "16"},
|
|
BitValues{"MEM_ERROR_STATUS is valid",
|
|
"MEM_PHYSICAL_ADDR is valid",
|
|
"MEM_ADDR_MASK is valid",
|
|
"MEM_NODE is valid",
|
|
"MEM_CARD is valid",
|
|
"MEM_MODULE is valid",
|
|
"MEM_BANK is valid",
|
|
"MEM_DEVICE is valid",
|
|
"MEM_ROW is valid",
|
|
"MEM_COLUMN is valid",
|
|
"MEM_BIT_POSITION is valid",
|
|
"MEM_PLATFORM_REQUESTOR_ID is valid",
|
|
"MEM_PLATFORM_RESPONDER_ID is valid",
|
|
"MEM_PLATFORM_TARGET is valid",
|
|
"MEM_PLATFORM_BUS_SPECIFIC_DATA is valid",
|
|
"MEM_PLATFORM_OEM_ID is valid",
|
|
"MEM_PLATFORM_OEM_DATA_STRUCT is valid"} : amended
|
|
]
|
|
uint64 VALIDATION_BITS;
|
|
|
|
[WmiDataId(7),
|
|
Description("Memory Error Status") : amended
|
|
]
|
|
uint64 MEM_ERROR_STATUS;
|
|
|
|
[WmiDataId(8),
|
|
Description("64bit physical address of the memory error") : amended
|
|
]
|
|
uint64 MEM_PHYSICAL_ADDR;
|
|
|
|
[WmiDataId(9),
|
|
Description("Defines the valid address bits in the 64-Bit physical address of the memory error. The mask specifies the granularity of the physical address which is dependent on the hardware implementation factors such as interleaving.") : amended
|
|
]
|
|
uint64 MEM_PHYSICAL_MASK;
|
|
|
|
[WmiDataId(10),
|
|
Description("Hardware address of the responder to the transaction") : amended
|
|
]
|
|
uint64 RESPONDER_ID;
|
|
|
|
[WmiDataId(11),
|
|
Description("Hardware address of intended target of transaction") : amended
|
|
]
|
|
uint64 TARGET_ID;
|
|
|
|
[WmiDataId(12),
|
|
Description("Hardware address of the device or component initiating transaction") : amended
|
|
]
|
|
uint64 REQUESTOR_ID;
|
|
|
|
[WmiDataId(13),
|
|
Description("OEM specific bus dependent data") : amended
|
|
]
|
|
uint64 BUS_SPECIFIC_DATA;
|
|
|
|
[WmiDataId(14),
|
|
Description("In a multi-node system, this value identifies the node containing the memory in error") : amended
|
|
]
|
|
uint16 MEM_NODE;
|
|
|
|
[WmiDataId(15),
|
|
Description("The Card number of the memory error location") : amended
|
|
]
|
|
uint16 MEM_CARD;
|
|
|
|
[WmiDataId(16),
|
|
Description("The Module or RANK number of the memory error location") : amended
|
|
]
|
|
uint16 MEM_BANK;
|
|
|
|
[WmiDataId(17),
|
|
Description("The Device number of the memory error location") : amended
|
|
]
|
|
uint16 xMEM_DEVICE;
|
|
|
|
[WmiDataId(18),
|
|
Description("The module or rank number of the memory error location") : amended
|
|
]
|
|
uint16 MEM_MODULE;
|
|
|
|
[WmiDataId(19),
|
|
Description("The Row number of the memory error location") : amended
|
|
]
|
|
uint16 MEM_ROW;
|
|
|
|
[WmiDataId(20),
|
|
Description("The Column number of the memory error location") : amended
|
|
]
|
|
uint16 MEM_COLUMN;
|
|
|
|
[WmiDataId(21),
|
|
Description("Bit position specifies the bit within the memory word that is in error") : amended
|
|
]
|
|
uint16 MEM_BIT_POSITION;
|
|
|
|
[WmiDataId(22),
|
|
Description("Size of Raw Error Record") : amended
|
|
]
|
|
uint32 Size;
|
|
|
|
[WmiDataId(23),
|
|
WmiSizeIs("Size"),
|
|
Description("Raw Error Record") : amended
|
|
]
|
|
uint8 RawRecord[];
|
|
};
|
|
|
|
|
|
[WMI,
|
|
Dynamic,
|
|
Provider("WmiProv"),
|
|
guid("{A14A5594-25DE-410e-9B92-80F0801AEC07}"),
|
|
Description("MCA PCI Bus Error Event") : amended
|
|
]
|
|
class MSMCAEvent_PCIBusError : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
Description("Unique Id for the error record containing this error") : amended
|
|
]
|
|
uint64 RecordId;
|
|
|
|
[WmiDataId(2),
|
|
Values{ "0", "1", "2" },
|
|
ValueMap{"Recoverable", "Fatal", "Correctable"},
|
|
Description("Severity of the error record") : amended
|
|
]
|
|
uint8 ErrorSeverity;
|
|
|
|
[WmiDataId(3),
|
|
Values{} : amended,
|
|
ValueMap{},
|
|
Description("Type of eventlog message") : amended
|
|
]
|
|
uint32 Type;
|
|
|
|
[WmiDataId(4),
|
|
Description("CPU that reported the error") : amended
|
|
]
|
|
uint32 Cpu;
|
|
|
|
[WmiDataId(5),
|
|
Description("Number of additional errors in the record") : amended
|
|
]
|
|
uint32 AdditionalErrors;
|
|
|
|
[WmiDataId(6),
|
|
Description("Validation bits to indicate the validity of the subsequent fields") : amended,
|
|
BitMap{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10"},
|
|
BitValues{"PCI_BUS_ERROR_STATUS is valid",
|
|
"PCI_BUS_ERROR_TYPE is valid",
|
|
"PCI_BUS_ID is valid",
|
|
"PCI_BUS_ADDRESS is valid",
|
|
"PCI_BUS_DATA is valid",
|
|
"PCI_BUS_CMD is valid",
|
|
"PCI_BUS_REQUESTOR_ID is valid",
|
|
"PCI_BUS_RESPONDER_ID is valid",
|
|
"PCI_BUS_TARGET_ID is valid",
|
|
"PCI_BUS_OEM_ID is valid",
|
|
"PCI_BUS_OEM_DATA_STRUCT is valid"} : amended
|
|
]
|
|
uint64 VALIDATION_BITS;
|
|
|
|
[WmiDataId(7),
|
|
Description("Bus Error Type") : amended
|
|
]
|
|
uint64 PCI_BUS_ERROR_STATUS;
|
|
|
|
[WmiDataId(8),
|
|
Description("Memory or IO address on the PCI bus at the time of the event") : amended
|
|
]
|
|
uint64 PCI_BUS_ADDRESS;
|
|
|
|
[WmiDataId(9),
|
|
Description("Data on the PCI bus at the time of the event") : amended
|
|
]
|
|
uint64 PCI_BUS_DATA;
|
|
|
|
[WmiDataId(10),
|
|
Description("Bus command or operation at the time of the event") : amended
|
|
]
|
|
uint64 PCI_BUS_CMD;
|
|
|
|
[WmiDataId(11),
|
|
Description("PCI Bus Requetor ID at the time of the event") : amended
|
|
]
|
|
uint64 PCI_BUS_REQUESTOR_ID;
|
|
|
|
[WmiDataId(12),
|
|
Description("PCI Bus Responder ID at the time of the event") : amended
|
|
]
|
|
uint64 PCI_BUS_RESPONDER_ID;
|
|
|
|
[WmiDataId(13),
|
|
Description("PCI Bus Intended Target ID at the time of the event") : amended
|
|
]
|
|
uint64 PCI_BUS_TARGET_ID;
|
|
|
|
[WmiDataId(14),
|
|
Description("PCI Bus Error Types") : amended,
|
|
Values{"0", "1", "2", "3", "4", "5", "6", "7"},
|
|
ValueMap{"Unknown or OEM System Specific Error",
|
|
"Data Parity Error",
|
|
"System Error",
|
|
"Master Abort",
|
|
"Bus Time Out or No Device Present (No DEVSEL#)",
|
|
"Master Data Parity Error",
|
|
"Address Parity Error",
|
|
"Command Parity Error" } : amended
|
|
]
|
|
uint16 PCI_BUS_ERROR_TYPE;
|
|
|
|
[WmiDataId(15),
|
|
Description("Designated PCI Bus Identifier encountering error") : amended
|
|
]
|
|
uint8 PCI_BUS_ID_BusNumber;
|
|
|
|
[WmiDataId(16),
|
|
Description("Designated PCI Bus Identifier encountering error") : amended
|
|
]
|
|
uint8 PCI_BUS_ID_SegmentNumber;
|
|
|
|
[WmiDataId(17),
|
|
Description("Size of Raw Error Record") : amended
|
|
]
|
|
uint32 Size;
|
|
|
|
[WmiDataId(18),
|
|
WmiSizeIs("Size"),
|
|
Description("Raw Error Record") : amended
|
|
]
|
|
uint8 RawRecord[];
|
|
};
|
|
|
|
|
|
[WMI,
|
|
Dynamic,
|
|
Provider("WmiProv"),
|
|
guid("{805CAF4E-336C-4eb2-8C0C-02F351CBF13C}"),
|
|
Description("MCA PCI Platform Component Error Event") : amended
|
|
]
|
|
class MSMCAEvent_PCIComponentError : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
Description("Unique Id for the error record containing this error") : amended
|
|
]
|
|
uint64 RecordId;
|
|
|
|
[WmiDataId(2),
|
|
Values{ "0", "1", "2" },
|
|
ValueMap{"Recoverable", "Fatal", "Correctable"},
|
|
Description("Severity of the error record") : amended
|
|
]
|
|
uint8 ErrorSeverity;
|
|
|
|
[WmiDataId(3),
|
|
Description("Type of eventlog message") : amended,
|
|
Values{},
|
|
ValueMap{}
|
|
]
|
|
uint32 Type;
|
|
|
|
[WmiDataId(4),
|
|
Description("CPU that reported the error") : amended
|
|
]
|
|
uint32 Cpu;
|
|
|
|
[WmiDataId(5),
|
|
Description("Number of additional errors in the record") : amended
|
|
]
|
|
uint32 AdditionalErrors;
|
|
|
|
[WmiDataId(6),
|
|
Description("Validation bits to indicate the validity of the subsequent fields") : amended,
|
|
BitMap{"0", "1", "2", "3", "4"},
|
|
BitValues{"PCI_COMP_ERROR_STATUS is valid",
|
|
"PCI_COMP_INFO is valid",
|
|
"PCI_COMP_MEM_NUM is valid",
|
|
"PCI_COMP_IO_NUM is valid",
|
|
"PCI_COMP_REGS_DATA_PAIR is valid"} : amended
|
|
]
|
|
uint64 VALIDATION_BITS;
|
|
|
|
[WmiDataId(7),
|
|
Description("Internal Error Code") : amended
|
|
]
|
|
uint64 PCI_COMP_ERROR_STATUS;
|
|
|
|
[WmiDataId(8),
|
|
Description("PCI Component Information - VendorId") : amended
|
|
]
|
|
uint16 PCI_COMP_INFO_VendorId;
|
|
|
|
[WmiDataId(9),
|
|
Description("PCI Component Information - DeviceId") : amended
|
|
]
|
|
uint16 PCI_COMP_INFO_DeviceId;
|
|
|
|
[WmiDataId(10),
|
|
Description("PCI Component Information - Class Code Interface") : amended
|
|
]
|
|
uint8 PCI_COMP_INFO_ClassCodeInterface;
|
|
|
|
[WmiDataId(11),
|
|
Description("PCI Component Information - Class Code SubClass") : amended
|
|
]
|
|
uint8 PCI_COMP_INFO_ClassCodeSubClass;
|
|
|
|
[WmiDataId(12),
|
|
Description("PCI Component Information - Class Code Base Class") : amended
|
|
]
|
|
uint8 PCI_COMP_INFO_ClassCodeBaseClass;
|
|
|
|
[WmiDataId(13),
|
|
Description("PCI Component Information - Function Number") : amended
|
|
]
|
|
uint8 PCI_COMP_INFO_FunctionNumber;
|
|
|
|
[WmiDataId(14),
|
|
Description("PCI Component Information - Device Number") : amended
|
|
]
|
|
uint8 PCI_COMP_INFO_DeviceNumber;
|
|
|
|
[WmiDataId(15),
|
|
Description("PCI Component Information - Bus Number") : amended
|
|
]
|
|
uint8 PCI_COMP_INFO_BusNumber;
|
|
|
|
[WmiDataId(16),
|
|
Description("PCI Component Information - Segment Number") : amended
|
|
]
|
|
uint8 PCI_COMP_INFO_SegmentNumber;
|
|
|
|
[WmiDataId(17),
|
|
Description("Size of Raw Error Record") : amended
|
|
]
|
|
uint32 Size;
|
|
|
|
[WmiDataId(18),
|
|
WmiSizeIs("Size"),
|
|
Description("Raw Error Record") : amended
|
|
]
|
|
uint8 RawRecord[];
|
|
};
|
|
|
|
|
|
[WMI,
|
|
Dynamic,
|
|
Provider("WmiProv"),
|
|
guid("{BDBA4B12-8D00-4570-B9B2-3FDECF1D5661}"),
|
|
Description("MCA Platform IPMI System Eventlog Error Event") : amended
|
|
]
|
|
class MSMCAEvent_SystemEventError : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
Description("Unique Id for the error record containing this error") : amended
|
|
]
|
|
uint64 RecordId;
|
|
|
|
[WmiDataId(2),
|
|
Values{ "0", "1", "2" },
|
|
ValueMap{"Recoverable", "Fatal", "Correctable"},
|
|
Description("Severity of the error record") : amended
|
|
]
|
|
uint8 ErrorSeverity;
|
|
|
|
[WmiDataId(3),
|
|
Description("Type of eventlog message") : amended,
|
|
Values{},
|
|
ValueMap{}
|
|
]
|
|
uint32 Type;
|
|
|
|
[WmiDataId(4),
|
|
Description("CPU that reported the error") : amended
|
|
]
|
|
uint32 Cpu;
|
|
|
|
[WmiDataId(5),
|
|
Description("Number of additional errors in the record") : amended
|
|
]
|
|
uint32 AdditionalErrors;
|
|
|
|
[WmiDataId(6),
|
|
Description("Validation bits to indicate the validity of the subsequent fields") : amended,
|
|
BitMap{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"},
|
|
BitValues{"SEL_RECORD_ID is valid",
|
|
"SEL_RECORD_TYPE is valid",
|
|
"SEL_GENERATOR_ID is valid",
|
|
"SEL_EVM_REV is valid",
|
|
"SEL_SENSOR_TYPE is valid",
|
|
"SEL_SENSOR_NUM is valid",
|
|
"SEL_EVENT_DIR is valid",
|
|
"SEL_EVENT_DATA1 is valid",
|
|
"SEL_EVENT_DATA2 is valid",
|
|
"SEL_EVENT_DATA3 is valid"} : amended
|
|
]
|
|
uint64 VALIDATION_BITS;
|
|
|
|
[WmiDataId(7),
|
|
Description("Timestamp of the event log") : amended
|
|
]
|
|
uint64 SEL_TIME_STAMP;
|
|
|
|
[WmiDataId(8),
|
|
Description("Record ID used for SEL access") : amended
|
|
]
|
|
uint16 SEL_RECORD_ID;
|
|
|
|
[WmiDataId(9),
|
|
Description("Software ID if event was generated by software") : amended
|
|
]
|
|
uint16 SEL_GENERATOR_ID;
|
|
|
|
[WmiDataId(10),
|
|
Description("Indicates the record type") : amended
|
|
]
|
|
uint8 SEL_RECORD_TYPE;
|
|
|
|
[WmiDataId(11),
|
|
Description("The error message format version") : amended
|
|
]
|
|
uint8 SEL_EVM_REV;
|
|
|
|
[WmiDataId(12),
|
|
Description("Sensor type code of the sensor that generated the event") : amended
|
|
]
|
|
uint8 SEL_SENSOR_TYPE;
|
|
|
|
[WmiDataId(13),
|
|
Description("Number of the sensor that generated the event") : amended
|
|
]
|
|
uint8 SEL_SENSOR_NUM;
|
|
|
|
[WmiDataId(14),
|
|
Description("Event Dir") : amended
|
|
]
|
|
uint8 SEL_EVENT_DIR_TYPE;
|
|
|
|
[WmiDataId(15),
|
|
Description("Event Data Field 1") : amended
|
|
]
|
|
uint8 SEL_DATA1;
|
|
|
|
[WmiDataId(16),
|
|
Description("Event Data Field 2") : amended
|
|
]
|
|
uint8 SEL_DATA2;
|
|
|
|
[WmiDataId(17),
|
|
Description("Event Data Field 3") : amended
|
|
]
|
|
uint8 SEL_DATA3;
|
|
|
|
[WmiDataId(18),
|
|
Description("Size of Raw Error Record") : amended
|
|
]
|
|
uint32 Size;
|
|
|
|
[WmiDataId(19),
|
|
WmiSizeIs("Size"),
|
|
Description("Raw Error Record") : amended
|
|
]
|
|
uint8 RawRecord[];
|
|
};
|
|
|
|
|
|
[WMI,
|
|
Dynamic,
|
|
Provider("WmiProv"),
|
|
guid("{4184DF1B-EDFE-406b-B172-54C91FBD9BAF}"),
|
|
Description("MCA SMBIOS Error Event") : amended
|
|
]
|
|
class MSMCAEvent_SMBIOSError : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
Description("Unique Id for the error record containing this error") : amended
|
|
]
|
|
uint64 RecordId;
|
|
|
|
[WmiDataId(2),
|
|
Values{ "0", "1", "2" },
|
|
ValueMap{"Recoverable", "Fatal", "Correctable"},
|
|
Description("Severity of the error record") : amended
|
|
]
|
|
uint8 ErrorSeverity;
|
|
|
|
[WmiDataId(3),
|
|
Values{} : amended,
|
|
ValueMap{},
|
|
Description("Type of eventlog message") : amended
|
|
]
|
|
uint32 Type;
|
|
|
|
[WmiDataId(4),
|
|
Description("CPU that reported the error") : amended
|
|
]
|
|
uint32 Cpu;
|
|
|
|
[WmiDataId(5),
|
|
Description("Number of additional errors in the record") : amended
|
|
]
|
|
uint32 AdditionalErrors;
|
|
|
|
[WmiDataId(6),
|
|
Description("Validation bits to indicate the validity of the subsequent fields") : amended,
|
|
BitMap{"0"},
|
|
BitValues{"SMBIOS_EVENT_TYPE is valid"} : amended
|
|
]
|
|
uint64 VALIDATION_BITS;
|
|
|
|
[WmiDataId(7),
|
|
Description("Event Type") : amended,
|
|
Values{"0", "1", "2", "3", "4", "5", "6", "7",
|
|
"8", "9", "10", "11", "12", "13", "14", "15",
|
|
"16", "17", "18", "19", "20", "21", "22", "23"},
|
|
ValueMap{"Reserved",
|
|
"Single bit ECC memory error",
|
|
"Multiple bit ECC memory error",
|
|
"Parity Memory error",
|
|
"Bus time-out",
|
|
"I/O Channel Check",
|
|
"Software NMI",
|
|
"POST Memory Resize",
|
|
"POST Error",
|
|
"PCI Parity Error",
|
|
"PCI System Error",
|
|
"CPU Failure",
|
|
"EISA FailSafe Timer timeout",
|
|
"Correctable memory log disabled",
|
|
"Logging disabled for a specific event type. Too many errors of the same type received in a short amount of time",
|
|
"Reserved",
|
|
"System limit exceeded (e.g. voltage or temperature threshold exceeded",
|
|
"Asynchronous hardware timer expired and issued a system reset",
|
|
"System configuration information",
|
|
"Hard disk information",
|
|
"System reconfigured",
|
|
"Uncorrectable CPU-complex error",
|
|
"Log Area Reset/Cleared",
|
|
"System boot. If implemented this log entry is guaranteed to be the first one written on any system boot"
|
|
} : amended
|
|
]
|
|
uint8 SMBIOS_EVENT_TYPE;
|
|
|
|
[WmiDataId(8),
|
|
Description("Size of Raw Error Record") : amended
|
|
]
|
|
uint32 Size;
|
|
|
|
[WmiDataId(9),
|
|
WmiSizeIs("Size"),
|
|
Description("Raw Error Record") : amended
|
|
]
|
|
uint8 RawRecord[];
|
|
};
|
|
|
|
|
|
|
|
[WMI,
|
|
Dynamic,
|
|
Provider("WmiProv"),
|
|
guid("{2D2434AA-EF83-4200-BA24-DE366C415F7B}"),
|
|
Description("MCA Platform Specific Error Event") : amended
|
|
]
|
|
class MSMCAEvent_PlatformSpecificError : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
Description("Unique Id for the error record containing this error") : amended
|
|
]
|
|
uint64 RecordId;
|
|
|
|
[WmiDataId(2),
|
|
Values{ "0", "1", "2" },
|
|
ValueMap{"Recoverable", "Fatal", "Correctable"},
|
|
Description("Severity of the error record") : amended
|
|
]
|
|
uint8 ErrorSeverity;
|
|
|
|
[WmiDataId(3),
|
|
Values{} : amended,
|
|
ValueMap{},
|
|
Description("Type of eventlog message") : amended
|
|
]
|
|
uint32 Type;
|
|
|
|
[WmiDataId(4),
|
|
Description("CPU that reported the error") : amended
|
|
]
|
|
uint32 Cpu;
|
|
|
|
[WmiDataId(5),
|
|
Description("Number of additional errors in the record") : amended
|
|
]
|
|
uint32 AdditionalErrors;
|
|
|
|
[WmiDataId(6),
|
|
Description("Validation bits to indicate the validity of the subsequent fields") : amended,
|
|
BitMap{"0", "1", "2", "3", "4", "5", "6", "7"},
|
|
BitValues{"PLATFORM_ERROR_STATUS is valid",
|
|
"PLATFORM_ERROR_REQUESTOR_ID is valid",
|
|
"PLATFORM_ERROR_RESPONDER_ID is valid",
|
|
"PLATFORM_ERROR_TARGET is valid",
|
|
"PLATFORM_ERROR_SPECIFIC_DATA is valid",
|
|
"PLATFORM_ERROR_OEM_ID is valid",
|
|
"PLATFORM_ERROR_OEM_DATA_STRUCT is valid",
|
|
"PLATFORM_ERROR_OEM_DEVICE_PATH is valid"
|
|
} : amended
|
|
]
|
|
uint64 VALIDATION_BITS;
|
|
|
|
[WmiDataId(7),
|
|
Description("Platform generic error status") : amended
|
|
]
|
|
uint64 PLATFORM_ERROR_STATUS;
|
|
|
|
[WmiDataId(8),
|
|
Description("Requestor ID at time of the event") : amended
|
|
]
|
|
uint64 PLATFORM_REQUESTOR_ID;
|
|
|
|
[WmiDataId(9),
|
|
Description("Responder ID at time of the event") : amended
|
|
]
|
|
uint64 PLATFORM_RESPONDER_ID;
|
|
|
|
[WmiDataId(10),
|
|
Description("Target ID at the time of the event") : amended
|
|
]
|
|
uint64 PLATFORM_TARGET_ID;
|
|
|
|
[WmiDataId(11),
|
|
Description("OEM specific bus dependent data") : amended
|
|
]
|
|
uint64 PLATFORM_BUS_SPECIFIC_DATA;
|
|
|
|
[WmiDataId(12),
|
|
Description("A unique ID of the component reporting the error") : amended
|
|
]
|
|
uint8 OEM_COMPONENT_ID[16];
|
|
|
|
[WmiDataId(13),
|
|
Description("Size of Raw Error Record") : amended
|
|
]
|
|
uint32 Size;
|
|
|
|
[WmiDataId(14),
|
|
WmiSizeIs("Size"),
|
|
Description("Raw Error Record") : amended
|
|
]
|
|
uint8 RawRecord[];
|
|
};
|
|
|
|
|
|
[WMI,
|
|
Dynamic,
|
|
Provider("WmiProv"),
|
|
guid("{477B769B-785C-48dd-A02E-57E051BE7B85}"),
|
|
Description("MCA Unknown Error Event") : amended
|
|
]
|
|
class MSMCAEvent_InvalidError : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
Description("Unique Id for the error record containing this error") : amended
|
|
]
|
|
uint64 RecordId;
|
|
|
|
[WmiDataId(2),
|
|
Values{ "0", "1", "2" },
|
|
ValueMap{"Recoverable", "Fatal", "Correctable"},
|
|
Description("Severity of the error record") : amended
|
|
]
|
|
uint8 ErrorSeverity;
|
|
|
|
[WmiDataId(3),
|
|
Values{} : amended,
|
|
ValueMap{},
|
|
Description("Type of eventlog message") : amended
|
|
]
|
|
uint32 Type;
|
|
|
|
[WmiDataId(4),
|
|
Description("CPU that reported the error") : amended
|
|
]
|
|
uint32 Cpu;
|
|
|
|
[WmiDataId(5),
|
|
Description("Number of additional errors in the record") : amended
|
|
]
|
|
uint32 AdditionalErrors;
|
|
|
|
[WmiDataId(6),
|
|
Description("Size of Raw Error Record") : amended
|
|
]
|
|
uint32 Size;
|
|
|
|
[WmiDataId(7),
|
|
WmiSizeIs("Size"),
|
|
Description("Raw Error Record") : amended
|
|
]
|
|
uint8 RawRecord[];
|
|
};
|
|
|
|
|
|
|
|
[WMI,
|
|
Description("An MCA/CMC/CPE event") : amended,
|
|
guid("{9E77A308-6B82-4fc1-AB41-0A55867C35C2}")
|
|
]
|
|
class MSMCAInfo_Entry : MSMCAInfo
|
|
{
|
|
[WmiDataId(1),
|
|
read]
|
|
uint32 Length;
|
|
|
|
[WmiDataId(2),
|
|
read,
|
|
WmiSizeIs("Length")]
|
|
uint8 Data[];
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("This contains the raw MCA logs") : amended,
|
|
guid("{23602A8A-DADD-462f-9AE5-30FA2C37DD5B}")
|
|
]
|
|
class MSMCAInfo_RawMCAData : MSMCAInfo
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
read]
|
|
uint32 Count;
|
|
|
|
[WmiDataId(2),
|
|
read,
|
|
WmiSizeIs("Count")]
|
|
MSMCAInfo_Entry Records[];
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("This contains a CMC event") : amended,
|
|
guid("{2F1A8A9D-7988-457f-A17A-8979E82043C5}")
|
|
]
|
|
class MSMCAInfo_RawCMCEvent : WmiEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
read]
|
|
uint32 Count;
|
|
|
|
[WmiDataId(2),
|
|
read,
|
|
WmiSizeIs("Count")]
|
|
MSMCAInfo_Entry Records[];
|
|
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("This contains a MCA event") : amended,
|
|
guid("{2F1A8A9F-7988-457f-A17A-8979E82043C5}")
|
|
]
|
|
class MSMCAInfo_RawMCAEvent : WmiEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
read]
|
|
uint32 Count;
|
|
|
|
[WmiDataId(2),
|
|
read,
|
|
WmiSizeIs("Count")]
|
|
MSMCAInfo_Entry Records[];
|
|
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("This contains a Corrected Platform event") : amended,
|
|
guid("{6B629D5E-E63C-48a3-9EBB-974227075265}")
|
|
]
|
|
class MSMCAInfo_RawCorrectedPlatformEvent : WmiEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
read]
|
|
uint32 Count;
|
|
|
|
[WmiDataId(2),
|
|
read,
|
|
WmiSizeIs("Count")]
|
|
MSMCAInfo_Entry Records[];
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("This contains the raw MCA logs") : amended,
|
|
guid("{A648EC0D-7E9B-4e6c-8787-1478151CD04B}")
|
|
]
|
|
class MSMCAInfo_CPEControl : MSMCAInfo
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
read,
|
|
write]
|
|
uint32 CPEPollingInterval;
|
|
|
|
[WmiDataId(2),
|
|
read,
|
|
write]
|
|
boolean CPEGenerationEnabled;
|
|
|
|
};
|
|
|
|
//
|
|
// Power management classes
|
|
|
|
[abstract]
|
|
class MSPower
|
|
{
|
|
};
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("The control sets whether the device should dynamically power on and off while the system is working.") : amended,
|
|
guid("827c0a6f-feb0-11d0-bd26-00aa00b7b32a")
|
|
]
|
|
class MSPower_DeviceEnable : MSPower
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
read,
|
|
write] boolean Enable;
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("This control indicates whether the device should be configured to wake a sleeping system.") : amended,
|
|
guid("a9546a82-feb0-11d0-bd26-00aa00b7b32a")
|
|
]
|
|
class MSPower_DeviceWakeEnable : MSPower
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
read,
|
|
write] boolean Enable;
|
|
};
|
|
|
|
|
|
//
|
|
// NDIS classes
|
|
|
|
[abstract]
|
|
class MSNdis
|
|
{
|
|
};
|
|
|
|
[WMI,
|
|
guid("{B5BD98B7-0201-11d1-A50E-00A0C9062910}")]
|
|
class MSNdis_NetworkAddress : MSNdis
|
|
{
|
|
[read, WmiDataId(1),
|
|
DisplayName("Address") : amended
|
|
]
|
|
uint8 Address[6];
|
|
};
|
|
|
|
[WMI,
|
|
guid("{B5BD98B8-0201-11d1-A50E-00A0C9062910}")]
|
|
class MSNdis_NetworkShortAddress : MSNdis
|
|
{
|
|
[read, WmiDataId(1)
|
|
]
|
|
uint8 Address[2];
|
|
};
|
|
|
|
[WMI,
|
|
guid("{60fc6b57-0f66-11d1-96a7-00c04fc3358c}")]
|
|
class MSNdis_NetworkLinkSpeed : MSNdis
|
|
{
|
|
[read, WmiDataId(1)] uint32 Outbound;
|
|
[
|
|
read, WmiDataId(2)] uint32 Inbound;
|
|
};
|
|
|
|
///
|
|
/// GUIDs that do not translate to OIDs
|
|
///
|
|
///
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"),
|
|
guid("{981f2d7f-b1f3-11d0-8dd7-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Enumerate Adapter") : amended]
|
|
class MSNdis_EnumerateAdapter : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Device name.") : amended,
|
|
WmiDataId(1)] string DeviceName;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"),
|
|
guid("{981f2d80-b1f3-11d0-8dd7-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Notify Adapter Removal") : amended]
|
|
class MSNdis_NotifyAdapterRemoval : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Device name.") : amended,
|
|
WmiDataId(1)] string DeviceName;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"),
|
|
guid("{981f2d81-b1f3-11d0-8dd7-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Notify Adapter Arrival") : amended]
|
|
class MSNdis_NotifyAdapterArrival : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Device name.") : amended,
|
|
WmiDataId(1)] string DeviceName;
|
|
};
|
|
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"),
|
|
guid("{981f2d82-b1f3-11d0-8dd7-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Enumerate VC") : amended]
|
|
class MSNdis_NdisEnumerateVc : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"),
|
|
guid("{981f2d79-b1f3-11d0-8dd7-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Notify VC Removal") : amended]
|
|
class MSNdis_NotifyVcRemoval : WmiEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"),
|
|
guid("{182f9e0c-b1f3-11d0-8dd7-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Notify VC Arrival") : amended]
|
|
class MSNdis_NotifyVcArrival : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
};
|
|
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"),
|
|
guid("{a14f1c97-8839-4f8a-9996-a28996ebbf1d}"),
|
|
WmiExpense(1),
|
|
Description("This control decides whether the network device should wake up the system only on receiving a Magic packet") : amended]
|
|
class MSNdis_DeviceWakeOnMagicPacketOnly : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[read, write,
|
|
WmiDataId(1)] boolean EnableWakeOnMagicPacketOnly;
|
|
};
|
|
|
|
|
|
///
|
|
///
|
|
/// General GUIDs
|
|
///
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"),
|
|
guid("{5ec10354-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Hardware Status") : amended]
|
|
class MSNdis_HardwareStatus : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[read,
|
|
Description("Current hardware status of the underlying NIC.") : amended,
|
|
Values{"NdisHardwareStatusReady",
|
|
"NdisHardwareStatusInitializing",
|
|
"NdisHardwareStatusReset",
|
|
"NdisHardwareStatusClosing",
|
|
"NdisHardwarestatusNotReady"} : amended,
|
|
ValueMap{"0",
|
|
"1",
|
|
"2",
|
|
"3",
|
|
"4"},
|
|
WmiDataId(1)] uint32 NdisHardwareStatus;
|
|
|
|
//
|
|
// This is of the type:
|
|
// typedef enum _NDIS_HARDWARE_STATUS
|
|
// {
|
|
// NdisHardwareStatusReady,
|
|
// NdisHardwareStatusInitializing,
|
|
// NdisHardwareStatusReset,
|
|
// NdisHardwareStatusClosing,
|
|
// NdisHardwarestatusNotReady
|
|
// } NDIS_HARDWARE_STATUS, *PNDIS_HARDWARE_STATUS;
|
|
//
|
|
};
|
|
|
|
[WMI,Dynamic, Provider("WMIProv"),
|
|
guid("{5ec10355-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Media Types Supported") : amended]
|
|
class MSNdis_MediaSupported : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Number of media types supported.") : amended,
|
|
WmiDataId(1)] uint32 NumberElements;
|
|
[read,
|
|
Description("List of media types the NIC supports.") : amended,
|
|
WmiDataId(2),
|
|
WmiSizeIs("NumberElements")] uint32 NdisMediaSupported[];
|
|
};
|
|
|
|
[WMI,Dynamic, Provider("WMIProv"),
|
|
guid("{5ec10356-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Media Types In Use") : amended]
|
|
class MSNdis_MediaInUse : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Number of media types in use.") : amended,
|
|
WmiDataId(1)] uint32 NumberElements;
|
|
[read,
|
|
Description("List of media types the NIC is currently supporting.") : amended,
|
|
WmiDataId(2),
|
|
WmiSizeIs("NumberElements")] uint32 NdisMediaInUse[];
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"),guid("{5ec10357-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Maximum Lookahead Supported") : amended]
|
|
class MSNdis_MaximumLookahead : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The maximum number of bytes the NIC can always provide as lookahead data.") : amended,
|
|
WmiDataId(1)] uint32 NdisMaximumLookahead;
|
|
};
|
|
|
|
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"),guid("{5ec10358-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Maximum Frame Size") : amended]
|
|
class MSNdis_MaximumFrameSize : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The maximum network packet size in bytes the NIC supports, not including a header.") : amended,
|
|
WmiDataId(1)] uint32 NdisMaximumFrameSize;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"),guid("{5ec10359-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Link Speed") : amended]
|
|
class MSNdis_LinkSpeed : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The maximum speed of the NIC (kbps).") : amended,
|
|
WmiDataId(1)] uint32 NdisLinkSpeed;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"),guid("{5ec1035a-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Transmit Buffer Space") : amended]
|
|
|
|
class MSNdis_TransmitBufferSpace : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The amount of memory, in bytes, on the NIC available for buffering transmit data.") : amended,
|
|
WmiDataId(1)] uint32 NdisTransmitBufferSpace;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{5ec1035b-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Receive Buffer Space") : amended]
|
|
class MSNdis_ReceiveBufferSpace : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The amount of memory on the NIC available for buffering receive data.") : amended,
|
|
WmiDataId(1)] uint32 NdisReceiveBufferSpace;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{5ec1035c-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Transmit Block Size") : amended]
|
|
class MSNdis_TransmitBlockSize : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The minimum number of bytes that a single net packet occupies in the transmit buffer space of the NIC.") : amended,
|
|
WmiDataId(1)] uint32 NdisTransmitBlockSize;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{5ec1035d-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
Description("NDIS Receive Block Size") : amended]
|
|
class MSNdis_ReceiveBlockSize : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[ read,
|
|
Description("The amount of storage, in bytes, that a single packet occupies in the receive buffer space of the NIC.") : amended,
|
|
WmiDataId(1)] uint32 NdisReceiveBlockSize;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{5ec1035e-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Vendor ID") : amended]
|
|
class MSNdis_VendorID : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("A three-byte IEEE-registered vendor code, followed by a single byte the vendor assigns to identify a particular NIC.") : amended,
|
|
WmiDataId(1)] uint32 NdisVendorID;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{5ec1035f-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Vendor Description") : amended
|
|
]
|
|
class MSNdis_VendorDescription : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Zero-terminated string describing the NIC.") : amended,
|
|
WmiDataId(1)] string NdisVendorDescription;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{5ec10360-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Current Packet Filter") : amended]
|
|
class MSNdis_CurrentPacketFilter : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Current packet types that will be received and indicated by the NIC.") : amended,
|
|
WmiDataId(1)] uint32 NdisCurrentPacketFilter;
|
|
|
|
//
|
|
// This is an inclusive OR of the following types:
|
|
//
|
|
// NDIS_PACKET_TYPE_DIRECTED 0x00000001
|
|
// NDIS_PACKET_TYPE_MULTICAST 0x00000002
|
|
// NDIS_PACKET_TYPE_ALL_MULTICAST 0x00000004
|
|
// NDIS_PACKET_TYPE_BROADCAST 0x00000008
|
|
// NDIS_PACKET_TYPE_SOURCE_ROUTING 0x00000010
|
|
// NDIS_PACKET_TYPE_PROMISCUOUS 0x00000020
|
|
// NDIS_PACKET_TYPE_SMT 0x00000040
|
|
// NDIS_PACKET_TYPE_ALL_LOCAL 0x00000080
|
|
// NDIS_PACKET_TYPE_GROUP 0x00001000
|
|
// NDIS_PACKET_TYPE_ALL_FUNCTIONAL 0x00002000
|
|
// NDIS_PACKET_TYPE_FUNCTIONAL 0x00004000
|
|
// NDIS_PACKET_TYPE_MAC_FRAME 0x00008000
|
|
//
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{5ec10361-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Current Lookahead") : amended]
|
|
class MSNdis_CurrentLookahead : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of bytes of received packet data, excluding the header, that will be indicated to the protocol driver.") : amended,
|
|
WmiDataId(1)] uint32 NdisCurrentLookahead;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{5ec10362-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Driver Version") : amended]
|
|
class MSNdis_DriverVersion : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The NDIS version in use by the NIC driver.") : amended,
|
|
WmiDataId(1)] uint16 NdisDriverVersion;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{5ec10363-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Maximum Packet Total Size") : amended]
|
|
|
|
class MSNdis_MaximumTotalSize : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The maximum total packet length, in bytes, the NIC supports, including the header.") : amended,
|
|
WmiDataId(1)] uint32 NdisMaximumTotalSize;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{5ec10365-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS MAC Options") : amended]
|
|
class MSNdis_MacOptions : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("A bitmask that defines optional properties of the underlying driver or its NIC.") : amended,
|
|
WmiDataId(1)] uint32 NdisMacOptions;
|
|
|
|
//
|
|
// This is an inclusive OR of the following types:
|
|
//
|
|
// NDIS_MAC_OPTION_COPY_LOOKAHEAD_DATA 0x00000001
|
|
// NDIS_MAC_OPTION_RECEIVE_SERIALIZED 0x00000002
|
|
// NDIS_MAC_OPTION_TRANSFERS_NOT_PEND 0x00000004
|
|
// NDIS_MAC_OPTION_NO_LOOPBACK 0x00000008
|
|
// NDIS_MAC_OPTION_FULL_DUPLEX 0x00000010
|
|
// NDIS_MAC_OPTION_EOTX_INDICATION 0x00000020
|
|
// NDIS_MAC_OPTION_RESERVED 0x80000000
|
|
//
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{5ec10366-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Media Connect Status") : amended]
|
|
class MSNdis_MediaConnectStatus : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The connection status of the NIC on the network.") : amended,
|
|
Values{"NdisMediaStateConnected",
|
|
"NdisMediaStateDisconnected"} : amended,
|
|
ValueMap{"0",
|
|
"1"},
|
|
WmiDataId(1)] uint32 NdisMediaConnectStatus;
|
|
|
|
//
|
|
//
|
|
//
|
|
// Defines the state of the LAN media
|
|
//
|
|
// typedef enum _NDIS_MEDIA_STATE
|
|
// {
|
|
// NdisMediaStateConnected,
|
|
// NdisMediaStateDisconnected
|
|
// } NDIS_MEDIA_STATE, *PNDIS_MEDIA_STATE;
|
|
//
|
|
//
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{5ec10367-a61a-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Maximum Send Packets") : amended]
|
|
class MSNdis_MaximumSendPackets : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The maximum number of send packets the MiniportSendPackets function can accept.") : amended,
|
|
WmiDataId(1)] uint32 NdisMaximumSendPackets;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{447956f9-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Vendor's Driver Version") : amended]
|
|
class MSNdis_VendorDriverVersion : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The vendor-assigned version number of the NIC driver.") : amended,
|
|
WmiDataId(1)] uint32 NdisVendorDriverVersion;
|
|
};
|
|
|
|
///
|
|
/// OID_GEN_VLAN_ID:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{765dc702-c5e8-4b67-843b-3f5a4ff2648b}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS VLAN Identifier") : amended]
|
|
class MSNdis_VlanIdentifier : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
Description("The IEEE 802.1Q VLAN ID assigned to this NIC.") : amended,
|
|
WmiDataId(1)] uint32 NdisVlanId;
|
|
};
|
|
|
|
|
|
//
|
|
// OID_GEN_PHYSICAL_MEDIUM:
|
|
//
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{418ca16d-3937-4208-940a-ec6196278085}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Physical Medium Type") : amended]
|
|
class MSNdis_PhysicalMediumType : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The physical medium type of the NIC.") : amended,
|
|
WmiDataId(1)] uint32 NdisPhysicalMediumType;
|
|
// Defines the physical medium type of the NIC
|
|
//
|
|
// typedef enum _NDIS_PHYSICAL_MEDIUM
|
|
// {
|
|
//
|
|
// NdisPhysicalMediumUnspecified,
|
|
// NdisPhysicalMediumWirelessLan,
|
|
// NdisPhysicalMediumCableModem,
|
|
// NdisPhysicalMediumPhoneLine,
|
|
// NdisPhysicalMediumPowerLine,
|
|
// NdisPhysicalMediumDSL, // includes ADSL and UADSL (G.Lite)
|
|
// NdisPhysicalMediumFibreChannel,
|
|
// NdisPhysicalMedium1394,
|
|
// NdisPhysicalMediumWirelessWan,
|
|
// NdisPhysicalMediumMax // Not a real physical type, defined as an upper-bound
|
|
// } NDIS_PHYSICAL_MEDIUM, *PNDIS_PHYSICAL_MEDIUM;
|
|
//
|
|
};
|
|
|
|
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{447956fa-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Transmits OK") : amended]
|
|
class MSNdis_TransmitsOk : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of frames transmitted without errors.") : amended,
|
|
WmiDataId(1)] uint64 NdisTransmitsOk;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{447956fb-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Receives OK") : amended]
|
|
class MSNdis_ReceivesOk : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of frames the NIC receives without errors and indicates to bound protocols.") : amended,
|
|
WmiDataId(1)] uint64 NdisReceivesOk;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{447956fc-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Transmit Errors") : amended]
|
|
class MSNdis_TransmitsError : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of frames a NIC fails to transmit.") : amended,
|
|
WmiDataId(1)] uint32 NdisTransmitsError;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{447956fd-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Receive Errors") : amended]
|
|
class MSNdis_ReceiveError : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of frames a NIC receives but does not indicate to the protocols due to errors.") : amended,
|
|
WmiDataId(1)] uint32 NdisReceiveError;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{447956fe-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Receive No Buffer") : amended]
|
|
class MSNdis_ReceiveNoBuffer : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[ read,
|
|
Description("The number of frames the NIC cannot receive due to lack of NIC receive buffer space.") : amended,
|
|
WmiDataId(1)] uint32 NdisReceiveNoBuffer;
|
|
};
|
|
|
|
///
|
|
///
|
|
/// CoNDIS general GUIDs
|
|
///
|
|
///
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad192-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS Hardware Status") : amended]
|
|
class MSNdis_CoHardwareStatus : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Current hardware status of the underlying NIC.") : amended,
|
|
WmiDataId(1)] uint32 NdisCoHardwareStatus;
|
|
};
|
|
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad193-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS Media Types Supported") : amended]
|
|
class MSNdis_CoMediaSupported : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Number of media types supported.") : amended,
|
|
WmiDataId(1)] uint32 NumberElements;
|
|
[read,
|
|
Description("List of media types the NIC supports.") : amended,
|
|
WmiDataId(2),
|
|
WmiSizeIs("NumberElements")] uint32 NdisCoMediaSupported[];
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad194-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS Media Types In Use") : amended]
|
|
class MSNdis_CoMediaInUse : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Number of media types in use.") : amended,
|
|
WmiDataId(1)] uint32 NumberElements;
|
|
[read,
|
|
Description("List of media types the NIC is currently supporting.") : amended,
|
|
WmiDataId(2),
|
|
WmiSizeIs("NumberElements")] uint32 NdisCoMediaInUse[];
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad195-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS Link Speed") : amended]
|
|
class MSNdis_CoLinkSpeed : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[DisplayName("NdisCoLinkSpeed") : amended,
|
|
read,
|
|
Description("The maximum inbound and outbound speeds of the NIC (kbps).") : amended,
|
|
WmiDataId(1)] MSNdis_NetworkLinkSpeed NdisCoLinkSpeed;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad196-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS Vendor ID") : amended]
|
|
class MSNdis_CoVendorId : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("A three-byte IEEE-registered vendor code, followed by a single byte the vendor assigns to identify a particular NIC.") : amended,
|
|
WmiDataId(1)] uint32 NdisCoVendorID;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad197-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS Vendor Description") : amended]
|
|
class MSNdis_CoVendorDescription : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Zero-terminated string describing the NIC.") : amended,
|
|
WmiDataId(1)] string NdisCoVendorDescription;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad198-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS Driver Version") : amended]
|
|
class MSNdis_CoDriverVersion : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The NDIS version in use by the NIC driver.") : amended,
|
|
WmiDataId(1)] uint16 NdisCoDriverVersion;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad19a-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS MAC Options") : amended]
|
|
class MSNdis_CoMacOptions : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("A bitmask that defines optional properties of the underlying driver or its NIC.") : amended,
|
|
WmiDataId(1)] uint32 NdisCoMacOptions;
|
|
//
|
|
//
|
|
// NDIS MAC option bits for OID_GEN_CO_MAC_OPTIONS.
|
|
//
|
|
// #define NDIS_CO_MAC_OPTION_DYNAMIC_LINK_SPEED 0x00000001
|
|
//
|
|
//
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad19b-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS Media Connect Status") : amended]
|
|
|
|
class MSNdis_CoMediaConnectStatus : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The connection status of the NIC on the network.") : amended,
|
|
Values{"NdisMediaStateConnected",
|
|
"NdisMediaStateDisconnected"} : amended,
|
|
ValueMap{"0",
|
|
"1"},
|
|
WmiDataId(1)] uint32 NdisCoMediaConnectStatus;
|
|
//
|
|
//
|
|
//
|
|
// Defines the state of the LAN media
|
|
//
|
|
// typedef enum _NDIS_MEDIA_STATE
|
|
// {
|
|
// NdisMediaStateConnected,
|
|
// NdisMediaStateDisconnected
|
|
// } NDIS_MEDIA_STATE, *PNDIS_MEDIA_STATE;
|
|
//
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad19c-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS Vendor's Driver Version") : amended]
|
|
class MSNdis_CoVendorDriverVersion : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[DisplayName("NdisCoVendorDriverVersion") : amended,
|
|
read,
|
|
Description("The vendor-assigned version number of the NIC driver.") : amended,
|
|
WmiDataId(1)] uint32 NdisCoVendorDriverVersion;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad19d-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS Minimum Link Speed") : amended]
|
|
class MSNdis_CoMinimumLinkSpeed : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The maximum inbound and outbound speeds of the NIC (kbps).") : amended,
|
|
WmiDataId(1)] MSNdis_NetworkLinkSpeed NdisCoMinimumLinkSpeed;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{0a214805-e35f-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS Transmits PDUs OK") : amended]
|
|
class MSNdis_CoTransmitPdusOk : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of PDUs transmitted without errors") : amended,
|
|
WmiDataId(1)] uint64 NdisCoTransmitPdusOk;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{0a214806-e35f-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS Receive PDUs OK") : amended]
|
|
class MSNdis_CoReceivePdusOk : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of PDUs the NIC receives without errors and indicates to bound protocols.") : amended,
|
|
WmiDataId(1)] uint64 NdisCoReceivePdusOk;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{0a214807-e35f-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS Transmit PDU Errors") : amended]
|
|
class MSNdis_CoTransmitPduErrors : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of PDUs a NIC fails to transmit.") : amended,
|
|
WmiDataId(1)] uint32 NdisCoTransmitPduErrors;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{0a214808-e35f-11d0-9692-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("CoNDIS Receive PDU Errors") : amended]
|
|
class MSNdis_CoReceivePduErrors : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of PDUs a NIC receives but does not indicate to the protocols due to errors.") : amended,
|
|
WmiDataId(1)] uint32 NdisCoReceivePduErrors;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{0a214809-e35f-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("CoNDIS Receive PDUs No Buffer") : amended]
|
|
class MSNdis_CoReceivePdusNoBuffer : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of PDUs the NIC cannot receive due to lack of NIC receive buffer space.") : amended,
|
|
WmiDataId(1)] uint32 NdisCoReceivePdusNoBuffer;
|
|
};
|
|
|
|
///
|
|
///
|
|
/// ATM media specific GUIDs
|
|
///
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad19e-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS ATM Supported VC Rates") : amended]
|
|
class MSNdis_AtmSupportedVcRates : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Minimum cell rate supported.") : amended,
|
|
WmiDataId(1)] uint32 MinCellRate;
|
|
|
|
[
|
|
read,
|
|
Description("Maximum cell rate supported.") : amended,
|
|
WmiDataId(2)] uint32 MaxCellRate;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad19f-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS ATM Supported Service Category") : amended]
|
|
class MSNdis_AtmSupportedServiceCategory : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Bit mask defining the service categories supported by the hardware.") : amended,
|
|
WmiDataId(1)] uint32 NdisAtmSupportedServiceCategory;
|
|
|
|
//
|
|
// This can be a combination of following defines:
|
|
//
|
|
// #define ATM_SERVICE_CATEGORY_CBR 1 // Constant Bit Rate
|
|
// #define ATM_SERVICE_CATEGORY_VBR 2 // Variable Bit Rate
|
|
// #define ATM_SERVICE_CATEGORY_UBR 4 // Unspecified Bit Rate
|
|
// #define ATM_SERVICE_CATEGORY_ABR 8 // Available Bit Rate
|
|
//
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a0-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS ATM Supported AAL Types") : amended]
|
|
class MSNdis_AtmSupportedAalTypes : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Bit mask defining the AAL types supported by the hardware.") : amended,
|
|
WmiDataId(1)] uint32 NdisAtmSupportedAalTypes;
|
|
//
|
|
// This can be a combination of the following defines:
|
|
//
|
|
// #define AAL_TYPE_AAL0 1
|
|
// #define AAL_TYPE_AAL1 2
|
|
// #define AAL_TYPE_AAL34 4
|
|
// #define AAL_TYPE_AAL5 8
|
|
//
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a1-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS ATM Hardware Current Address") : amended]
|
|
class MSNdis_AtmHardwareCurrentAddress : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The address of the NIC encoded in the hardware.") : amended,
|
|
WmiDataId(1)] MSNdis_NetworkAddress NdisAtmHardwareCurrentAddress;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a2-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS ATM Maximum Active VCs") : amended]
|
|
class MSNdis_AtmMaxActiveVcs : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Maximum number of active VCs the adapter can support.") : amended,
|
|
WmiDataId(1)] uint32 NdisAtmMaxActiveVcs;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a3-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS ATM Maximum Active VCI Bits") : amended]
|
|
class MSNdis_AtmMaxActiveVciBits : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of bits controllable in the VCI field of the cell header.") : amended,
|
|
WmiDataId(1)] uint32 NdisAtmMaxActiveVciBits;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a4-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS ATM Maximum Active VPI Bits") : amended]
|
|
class MSNdis_AtmMaxActiveVpiBits : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of bits controllable in the VPI field of the cell header.") : amended,
|
|
WmiDataId(1)] uint32 NdisAtmMaxActiveVpiBits;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a5-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS ATM Maximum AAL0 Packet Size") : amended]
|
|
class MSNdis_AtmMaxAal0PacketSize : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Maximum supported size for AAL0 packets.") : amended,
|
|
WmiDataId(1)] uint32 NdisAtmMaxAal0PacketSize;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a6-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS ATM Maximum AAL1 Packet Size") : amended]
|
|
class MSNdis_AtmMaxAal1PacketSize : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[ read,
|
|
Description("Maximum supported size for AAL1 packets.") : amended,
|
|
WmiDataId(1)] uint32 NdisAtmMaxAal1PacketSize;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad1a7-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS ATM Maximum AAL3/4 Packet Size") : amended]
|
|
class MSNdis_AtmMaxAal34PacketSize : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[ read,
|
|
Description("Maximum supported size for AAL3/4 packets.") : amended,
|
|
WmiDataId(1)] uint32 NdisAtmMaxAal34PacketSize;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{791ad191-e35c-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS ATM Maximum AAL5 Packet Size") : amended]
|
|
class MSNdis_AtmMaxAal5PacketSize : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Maximum supported size for AAL5 packets.") : amended,
|
|
WmiDataId(1)] uint32 NdisAtmMaxAal5PacketSize;
|
|
};
|
|
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{0a21480a-e35f-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS ATM Receive Cells OK") : amended]
|
|
class MSNdis_AtmReceiveCellsOk : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of cells the NIC has received without errors.") : amended,
|
|
WmiDataId(1)] uint64 NdisAtmReceiveCellsOk;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{0a21480b-e35f-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS ATM Transmit Cells OK") : amended]
|
|
class MSNdis_AtmTransmitCellsOk : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of cells the NIC has transmitted without errors.") : amended,
|
|
WmiDataId(1)] uint64 NdisAtmTransmitCellsOk;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{0a21480c-e35f-11d0-9692-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS ATM Receive Cells Dropped") : amended]
|
|
class MSNdis_AtmReceiveCellsDropped : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of receive cells the NIC has dropped.") : amended,
|
|
WmiDataId(1)] uint64 NdisAtmReceiveCellsDropped;
|
|
};
|
|
|
|
///
|
|
///
|
|
/// Ethernet specific GUIDs
|
|
///
|
|
///
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{447956ff-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Ethernet Permanent Address") : amended]
|
|
class MSNdis_EthernetPermanentAddress : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[ read,
|
|
Description("The address of the NIC encoded in the hardware.") : amended,
|
|
WmiDataId(1)] MSNdis_NetworkAddress NdisPermanentAddress;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{44795700-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Ethernet Current Address") : amended]
|
|
class MSNdis_EthernetCurrentAddress : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[ read,
|
|
Description("The address the NIC is currently using.") : amended,
|
|
WmiDataId(1)] MSNdis_NetworkAddress NdisCurrentAddress;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{44795701-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Ethernet Multicast List") : amended]
|
|
class MSNdis_EthernetMulticastList : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[ read,
|
|
Description("Number of multicast addresses enabled on the NIC.") : amended,
|
|
WmiDataId(1)] uint32 NumberElements;
|
|
|
|
[read,
|
|
Description("The multicast address list on the NIC enabled for packet reception.") : amended,
|
|
WmiDataId(2),
|
|
WmiSizeIs("NumberElements")] MSNdis_NetworkAddress NdisMulticastList[];
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{44795702-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("Adpater Ethernet Maximum Multicast List Size") : amended]
|
|
class MSNdis_EthernetMaximumMulticastListSize : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The maximum number of multicast addresses the NIC driver can manage.") : amended,
|
|
WmiDataId(1)] uint32 NdisEthernetMaximumMulticastListSize;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{44795703-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Ethernet MAC Options") : amended]
|
|
class MSNdis_EthernetMacOptions : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Features supported by the underlying driver, which could be emulating Ethernet.") : amended,
|
|
WmiDataId(1)] uint32 NdisEthernetMacOptions;
|
|
|
|
//
|
|
// Supported values:
|
|
//
|
|
// NDIS_802_3_MAC_OPTION_PRIORITY 0x00000001
|
|
//
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{44795704-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Ethernet Receive Error Alignment") : amended]
|
|
class MSNdis_EthernetReceiveErrorAlignment : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of frames received with alignment errors.") : amended,
|
|
WmiDataId(1)] uint32 NdisEthernetReceiveErrorAlignment;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{44795705-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Ethernet One Transmit collision") : amended]
|
|
class MSNdis_EthernetOneTransmitCollision : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of frames successfully transmitted after exactly one collision.") : amended,
|
|
WmiDataId(1)] uint32 NdisEthernetOneTransmitCollision;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{44795706-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Ethernet More Transmit collisions") : amended]
|
|
class MSNdis_EthernetMoreTransmitCollisions : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of frames successfully transmitted after more than one collision.") : amended,
|
|
WmiDataId(1)] uint32 NdisEthernetMoreTransmitCollisions;
|
|
};
|
|
|
|
///
|
|
///
|
|
/// Token Ring specific GUIDs
|
|
///
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{44795707-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Token Ring Permanent Address") : amended]
|
|
class MSNdis_TokenRingPermanentAddress : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The address of the NIC encoded in the hardware.") : amended,
|
|
WmiDataId(1)] MSNdis_NetworkAddress NdisPermanentAddress;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{44795708-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Token Ring Current Address") : amended]
|
|
class MSNdis_TokenRingCurrentAddress : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The address the NIC is currently using.") : amended,
|
|
WmiDataId(1)] MSNdis_NetworkAddress NdisCurrentAddress;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{44795709-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Token Ring Current Functional Address") : amended]
|
|
class MSNdis_TokenRingCurrentFunctional : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The functional address enabled on the NIC for packet reception.") : amended,
|
|
WmiDataId(1)] uint32 NdisTokenRingCurrentFunctional;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{4479570a-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Token Ring Current Group Address") : amended]
|
|
class MSNdis_TokenRingCurrentGroup : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The group address enabled on the NIC for packet reception.") : amended,
|
|
WmiDataId(1)] uint32 NdisTokenRingCurrentGroup;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{4479570b-a61b-11d0-8dd4-00c04fc3358c}"),
|
|
WmiExpense(1),
|
|
Description("NDIS Token Ring Last Open Status") : amended]
|
|
class MSNdis_TokenRingLastOpenStatus : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The last open error status returned for a protocol's call to NdisOpenAdapter.") : amended,
|
|
WmiDataId(1)] uint32 NdisTokenRingLastOpenStatus;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{890a36ec-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Token Ring Current Ring Status") : amended]
|
|
class MSNdis_TokenRingCurrentRingStatus : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The last ring status indicated with an NDIS_RING_XXX status code.") : amended,
|
|
WmiDataId(1)] uint32 NdisTokenRingCurrentRingStatus;
|
|
|
|
//
|
|
// This can be one of the following values:
|
|
//
|
|
// NDIS_RING_SIGNAL_LOSS 0x00008000
|
|
// NDIS_RING_HARD_ERROR 0x00004000
|
|
// NDIS_RING_SOFT_ERROR 0x00002000
|
|
// NDIS_RING_TRANSMIT_BEACON 0x00001000
|
|
// NDIS_RING_LOBE_WIRE_FAULT 0x00000800
|
|
// NDIS_RING_AUTO_REMOVAL_ERROR 0x00000400
|
|
// NDIS_RING_REMOVE_RECEIVED 0x00000200
|
|
// NDIS_RING_COUNTER_OVERFLOW 0x00000100
|
|
// NDIS_RING_SINGLE_STATION 0x00000080
|
|
// NDIS_RING_RING_RECOVERY 0x00000040
|
|
//
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf14032-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Token Ring Current Ring State.") : amended]
|
|
class MSNdis_TokenRingCurrentRingState : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The state of the NIC driver with repsect to entering the ring.") : amended,
|
|
Values{"NdisRingStateOpened",
|
|
"NdisRingStateClosed",
|
|
"NdisRingStateOpening",
|
|
"NdisRingStateClosing",
|
|
"NdisRingStateOpenFailure",
|
|
"NdisRingStateRingFailure"} : amended,
|
|
ValueMap{"1",
|
|
"2",
|
|
"3",
|
|
"4",
|
|
"5",
|
|
"6"},
|
|
WmiDataId(1)] uint32 NdisTokenRingCurrentRingState;
|
|
|
|
//
|
|
// This is defined as follows:
|
|
//
|
|
// typedef enum _NDIS_802_5_RING_STATE
|
|
// {
|
|
// NdisRingStateOpened = 1,
|
|
// NdisRingStateClosed,
|
|
// NdisRingStateOpening,
|
|
// NdisRingStateClosing,
|
|
// NdisRingStateOpenFailure,
|
|
// NdisRingStateRingFailure
|
|
// } NDIS_802_5_RING_STATE, *PNDIS_802_5_RING_STATE;
|
|
//
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf14033-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Token Ring Line Errors") : amended]
|
|
class MSNdis_TokenRingLineErrors : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Number of frames with an invalid FCS or a code violation.") : amended,
|
|
WmiDataId(1)] uint32 NdisTokenRingLineErrors;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf14034-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Token Ring Lost Frames") : amended]
|
|
class MSNdis_TokenRingLostFrames : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of frames transmitted that have not circled the ring within the maximum ring latency.") : amended,
|
|
WmiDataId(1)] uint32 NdisTokenRingLostFrames;
|
|
};
|
|
|
|
///
|
|
///
|
|
/// FDDI specific GUIDs
|
|
///
|
|
///
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf14035-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI Long Permanent Address") : amended]
|
|
class MSNdis_FddiLongPermanentAddress : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The long address of the NIC encoded in the hardware.") : amended,
|
|
WmiDataId(1)] MSNdis_NetworkAddress NdisPermanentAddress;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf14036-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI Long Current Address") : amended]
|
|
class MSNdis_FddiLongCurrentAddress : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The long address the NIC is currently using.") : amended,
|
|
WmiDataId(1)] MSNdis_NetworkAddress NdisCurrentAddress;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf14037-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI Long Multicast List") : amended]
|
|
class MSNdis_FddiLongMulticastList : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Number of multicast addresses enabled on the NIC.") : amended,
|
|
WmiDataId(1)] uint32 NumberElements;
|
|
[read,
|
|
Description("The multicast long address list on the NIC enabled for packet reception.") : amended,
|
|
WmiDataId(2), WmiSizeIs("NumberElements")]
|
|
MSNdis_NetworkAddress NdisMulticastList[];
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf14038-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI Long Maximum List Size") : amended]
|
|
class MSNdis_FddiLongMaximumListSize : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The maximum number of multicast long addresses the NIC driver can manage.") : amended,
|
|
WmiDataId(1)] uint32 NdisFddiLongMaximumListSize;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf14039-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI Short Permanent Address") : amended]
|
|
class MSNdis_FddiShortPermanentAddress : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The short address of the NIC encoded in the hardware.") : amended,
|
|
WmiDataId(1)] MSNdis_NetworkShortAddress NdisPermanentAddress;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf1403a-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI Short Current Address") : amended]
|
|
class MSNdis_FddiShortCurrentAddress : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The short address the NIC is currently using.") : amended,
|
|
WmiDataId(1)] MSNdis_NetworkShortAddress NdisCurrentAddress;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf1403b-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI Short Multicast List") : amended]
|
|
class MSNdis_FddiShortMulticastList : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Number of multicast short addresses enabled on the NIC.") : amended,
|
|
WmiDataId(1)] uint32 NumberElements;
|
|
[read,
|
|
Description("The multicast short address list on the NIC enabled for packet reception.") : amended,
|
|
WmiDataId(2),
|
|
WmiSizeIs("NumberElements")] MSNdis_NetworkShortAddress NdisMulticastList[];
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf1403c-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI Short Maximum List Size") : amended]
|
|
class MSNdis_FddiShortMaximumListSize : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The maximum number of multicast short addresses the NIC driver can manage.") : amended,
|
|
WmiDataId(1)] uint32 NdisFddiShortMaximumListSize;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf1403d-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI Attachment Type") : amended]
|
|
class MSNdis_FddiAttachmentType : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Defines the attachment of the NIC to the network.") : amended,
|
|
Values{"NdisFddiTypeIsolated",
|
|
"NdisFddiTypeLocalA",
|
|
"NdisFddiTypeLocalB",
|
|
"NdisFddiTypeLocalAB",
|
|
"NdisFddiTypeLocalS",
|
|
"NdisFddiTypeWrapA",
|
|
"NdisFddiTypeWrapB",
|
|
"NdisFddiTypeWrapAB",
|
|
"NdisFddiTypeWrapS",
|
|
"NdisFddiTypeCWrapA",
|
|
"NdisFddiTypeCWrapB",
|
|
"NdisFddiTypeCWrapS",
|
|
"NdisFddiTypeThrough"} : amended,
|
|
ValueMap{"1",
|
|
"2",
|
|
"3",
|
|
"4",
|
|
"5",
|
|
"6",
|
|
"7",
|
|
"8",
|
|
"9",
|
|
"10",
|
|
"11",
|
|
"12",
|
|
"13"},
|
|
WmiDataId(1)] uint32 NdisFddiAttachmentType;
|
|
|
|
//
|
|
// This can be of the following type:
|
|
//
|
|
// typedef enum _NDIS_FDDI_ATTACHMENT_TYPE
|
|
// {
|
|
// NdisFddiTypeIsolated = 1,
|
|
// NdisFddiTypeLocalA,
|
|
// NdisFddiTypeLocalB,
|
|
// NdisFddiTypeLocalAB,
|
|
// NdisFddiTypeLocalS,
|
|
// NdisFddiTypeWrapA,
|
|
// NdisFddiTypeWrapB,
|
|
// NdisFddiTypeWrapAB,
|
|
// NdisFddiTypeWrapS,
|
|
// NdisFddiTypeCWrapA,
|
|
// NdisFddiTypeCWrapB,
|
|
// NdisFddiTypeCWrapS,
|
|
// NdisFddiTypeThrough
|
|
// } NDIS_FDDI_ATTACHMENT_TYPE, *PNDIS_FDDI_ATTACHMENT_TYPE;
|
|
//
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf1403e-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI Upstream Node Long") : amended]
|
|
class MSNdis_FddiUpstreamNodeLong : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The long address of the station above this NIC on the ring or zero if the address is unknown.") : amended,
|
|
WmiDataId(1)] MSNdis_NetworkAddress NdisFddiUpstreamNodeLong;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf1403f-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI Downstream Node Long") : amended]
|
|
class MSNdis_FddiDownstreamNodeLong : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The long address of the station below this NIC on the ring or zero if the address is unknown.") : amended,
|
|
WmiDataId(1)] MSNdis_NetworkAddress NdisFddiDownstreamNodeLong;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf14040-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI Frame Errors") : amended]
|
|
class MSNdis_FddiFrameErrors : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of frames detected in error by this NIC that have not been detected in error by another device on the ring.") : amended,
|
|
WmiDataId(1)] uint32 NdisFddiFrameErrors;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf14041-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI Frames Lost") : amended]
|
|
class MSNdis_FddiFramesLost : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of times this NIC detected a format error during frame reception such that the frame was stripped.") : amended,
|
|
WmiDataId(1)] uint32 NdisFddiFramesLost;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf14042-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI Ring Management State") : amended]
|
|
class MSNdis_FddiRingManagmentState : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Defines the current state of the Ring Management state machine.") : amended,
|
|
Values{"NdisFddiRingIsolated",
|
|
"NdisFddiRingNonOperational",
|
|
"NdisFddiRingOperational",
|
|
"NdisFddiRingDetect",
|
|
"NdisFddiRingNonOperationalDup",
|
|
"NdisFddiRingOperationalDup",
|
|
"NdisFddiRingDirected",
|
|
"NdisFddiRingTrace"} : amended,
|
|
ValueMap{"1",
|
|
"2",
|
|
"3",
|
|
"4",
|
|
"5",
|
|
"6",
|
|
"7",
|
|
"8"},
|
|
WmiDataId(1)] uint32 NdisFddiRingManagmentState;
|
|
|
|
//
|
|
// This can be of the following type:
|
|
//
|
|
// typedef enum _NDIS_FDDI_RING_MGT_STATE
|
|
// {
|
|
// NdisFddiRingIsolated = 1,
|
|
// NdisFddiRingNonOperational,
|
|
// NdisFddiRingOperational,
|
|
// NdisFddiRingDetect,
|
|
// NdisFddiRingNonOperationalDup,
|
|
// NdisFddiRingOperationalDup,
|
|
// NdisFddiRingDirected,
|
|
// NdisFddiRingTrace
|
|
// } NDIS_FDDI_RING_MGT_STATE, *PNDIS_FDDI_RING_MGT_STATE;
|
|
//
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf14043-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI LCT Failures") : amended]
|
|
class MSNdis_FddiLctFailures : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The count of the consecutive times the link confidence test (LCT) has failed during connection management.") : amended,
|
|
WmiDataId(1)] uint32 NdisFddiLctFailures;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf14044-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI LEM Rejects") : amended]
|
|
class MSNdis_FddiLemRejects : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The link error monitor (LEM) count of times that a link was rejected.") : amended,
|
|
WmiDataId(1)] uint32 NdisFddiLemRejects;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{acf14045-a61c-11d0-8dd4-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS FDDI LConnect State") : amended]
|
|
class MSNdis_FddiLConnectionState : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Defines the state of this port's Physical Connection Management (PCM) state machine.") : amended,
|
|
Values{"NdisFddiStateOff",
|
|
"NdisFddiStateBreak",
|
|
"NdisFddiStateTrace",
|
|
"NdisFddiStateConnect",
|
|
"NdisFddiStateNext",
|
|
"NdisFddiStateSignal",
|
|
"NdisFddiStateJoin",
|
|
"NdisFddiStateVerify",
|
|
"NdisFddiStateActive",
|
|
"NdisFddiStateMaintenance"} : amended,
|
|
ValueMap{"1",
|
|
"2",
|
|
"3",
|
|
"4",
|
|
"5",
|
|
"6",
|
|
"7",
|
|
"8",
|
|
"9",
|
|
"10"},
|
|
WmiDataId(1)] uint32 NdisFddiLConnectionState;
|
|
//
|
|
// This can be of the following type:
|
|
//
|
|
// typedef enum _NDIS_FDDI_LCONNECTION_STATE
|
|
// {
|
|
// NdisFddiStateOff = 1,
|
|
// NdisFddiStateBreak,
|
|
// NdisFddiStateTrace,
|
|
// NdisFddiStateConnect,
|
|
// NdisFddiStateNext,
|
|
// NdisFddiStateSignal,
|
|
// NdisFddiStateJoin,
|
|
// NdisFddiStateVerify,
|
|
// NdisFddiStateActive,
|
|
// NdisFddiStateMaintenance
|
|
// } NDIS_FDDI_LCONNECTION_STATE, *PNDIS_FDDI_LCONNECTION_STATE;
|
|
//
|
|
|
|
};
|
|
|
|
|
|
///
|
|
///
|
|
/// Wireless (802.11) specific GUIDs
|
|
///
|
|
|
|
///
|
|
/// OID_802_11_BSSID:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{2504b6c2-1fa5-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 Base Service Set Identifier: the MAC address of the associated access point. Writing this is useful when doing a site survey.") : amended]
|
|
class MSNdis_80211_BaseServiceSetIdentifier : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
Description("The 802.11 access point MAC address.") : amended,
|
|
WmiDataId(1)] uint8 Ndis80211MacAddress[6];
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_SSID:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{7d2a90ea-2041-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 Service Set Identifier string that identifies a set of interconnected basic service sets. This is a NULL terminated ANSI string upto 32 characters long.") : amended]
|
|
class MSNdis_80211_ServiceSetIdentifier : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
Description("SSID string") : amended,
|
|
WmiDataId(1)] uint8 Ndis80211SsId[33];
|
|
};
|
|
|
|
|
|
///
|
|
/// Embedded class definition for _NDIS_802_11_NETWORK_TYPE.
|
|
///
|
|
[WMI, guid("{e779ab61-b9ab-11d4-b675-002048570337}")]
|
|
class MSNdis_80211_NetworkType : MSNdis
|
|
{
|
|
[
|
|
Description("NDIS 802.11 network type") : amended,
|
|
Values{"Ndis802_11FH",
|
|
"Ndis802_11DS"} : amended,
|
|
ValueMap{"0",
|
|
"1"},
|
|
WmiDataId(1)] uint32 Ndis80211NetworkType;
|
|
};
|
|
|
|
///
|
|
/// OID_802_11_NETWORK_TYPES_SUPPORTED:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{8531d6e6-2041-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 supported network types") : amended]
|
|
class MSNdis_80211_NetworkTypesSupported : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Number of items in list of 802.11 network types") : amended,
|
|
WmiDataId(1)] uint32 NumberOfItems;
|
|
[
|
|
read,
|
|
Description("List of NDIS 802.11 network types") : amended,
|
|
WmiDataId(2),
|
|
WmiSizeIs("NumberOfItems")]
|
|
MSNdis_80211_NetworkType Ndis80211NetworkTypes[];
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_NETWORK_TYPE_IN_USE:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{857e2326-2041-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 network type in use determines whether the station uses Frequency Hopping Spread Spectrum or Direct Sequence Spread Spectrum.") : amended]
|
|
class MSNdis_80211_NetworkTypeInUse : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
Description("The 802.11 network type") : amended,
|
|
WmiDataId(1)]
|
|
MSNdis_80211_NetworkType Ndis80211NetworkTypeInUse;
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_POWER_MODE:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{85be837c-2041-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 Power Mode") : amended]
|
|
class MSNdis_80211_PowerMode : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
Description("The current 802.11 power mode") : amended,
|
|
Values{"Ndis802_11PowerModeCAM",
|
|
"Ndis802_11PowerModeMAX_PSP",
|
|
"Ndis802_11PowerModeFast_PSP"} : amended,
|
|
ValueMap{"0",
|
|
"1",
|
|
"2"},
|
|
WmiDataId(1)] uint32 Ndis80211PowerMode;
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_TX_POWER_LEVEL:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{11e6ba76-2053-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 Transmit power level") : amended]
|
|
class MSNdis_80211_TransmitPowerLevel : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
Description("The 802.11 transmit power level in mW") : amended,
|
|
WmiDataId(1)] uint32 Ndis80211TransmitPowerLevel;
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_RSSI:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{1507db16-2053-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 Received Signal Strength Indication") : amended]
|
|
class MSNdis_80211_ReceivedSignalStrength : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The 802.11 received signal strength in dBm") : amended,
|
|
WmiDataId(1)] sint32 Ndis80211ReceivedSignalStrength;
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_RSSI_TRIGGER:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{155689b8-2053-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 Received Signal Strength Indication event trigger. An event of class MSNdis_80211_ReceivedSignalStrengthEvent is generated when the current RSSI goes past the trigger value.") : amended]
|
|
class MSNdis_80211_ReceivedSignalStrengthEventTrigger : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
Description("The 802.11 RSSI trigger value in dBm") : amended,
|
|
WmiDataId(1)] sint32 Ndis80211ReceivedSignalStrengthTrigger;
|
|
};
|
|
|
|
|
|
///
|
|
/// Embedded class definition for _NDIS_802_11_NETWORK_INFRASTRUCTURE.
|
|
///
|
|
[WMI, guid("{34e1fa48-b9b6-11d4-b675-002048570337}")]
|
|
class MSNdis_80211_NetworkInfrastructure : MSNdis
|
|
{
|
|
[
|
|
Description("The 802.11 infrastructure mode") : amended,
|
|
Values{"Ndis802_11IBSS",
|
|
"Ndis802_11Infrastructure",
|
|
"Ndis802_11AutoUnknown"},
|
|
ValueMap{"0",
|
|
"1",
|
|
"2"},
|
|
WmiDataId(1)] uint32 Ndis80211NetworkInfrastructure;
|
|
};
|
|
|
|
|
|
///
|
|
///
|
|
/// Embedded class definition for _NDIS_802_11_CONFIGURATION_FH.
|
|
/// This is used with MSNdis_80211_Configuration (below).
|
|
///
|
|
///
|
|
[WMI, guid("{4a800b8c-2068-11d4-97eb-00c04f79c403}")]
|
|
class MSNdis_80211_ConfigurationFH : MSNdis
|
|
{
|
|
[
|
|
WmiDataId(1)] uint32 FHLength;
|
|
[
|
|
WmiDataId(2)] uint32 HopPattern;
|
|
[
|
|
WmiDataId(3)] uint32 HopSet;
|
|
[
|
|
WmiDataId(4)] uint32 DwellTime;
|
|
};
|
|
|
|
|
|
///
|
|
///
|
|
/// Embedded class definition for _NDIS_802_11_CONFIGURATION. This
|
|
/// is used with OID_802_11_CONFIGURATION and OID_802_11_BSSID_LIST.
|
|
///
|
|
///
|
|
[WMI, guid("{220c16fc-b9a8-11d4-b675-002048570337}")]
|
|
class MSNdis_80211_ConfigurationInfo : MSNdis
|
|
{
|
|
[
|
|
Description("Length of configuration structure") : amended,
|
|
WmiDataId(1)] uint32 ConfigLength;
|
|
[
|
|
Description("Beacon period in Kusec") : amended,
|
|
WmiDataId(2)] uint32 BeaconPeriod;
|
|
[
|
|
Description("Announcement Traffic Indication Message (ATIM) Window in Kusec") : amended,
|
|
WmiDataId(3)] uint32 ATIMWindow;
|
|
[
|
|
Description("Frequency in kHz") : amended,
|
|
WmiDataId(4)] uint32 DSConfig;
|
|
[
|
|
Description("Radio configuration parameters") : amended,
|
|
WmiDataId(5)] MSNdis_80211_ConfigurationFH FHConfig;
|
|
};
|
|
|
|
|
|
///
|
|
///
|
|
/// Embedded class definition for _NDIS_WLAN_BSSID. This is used in
|
|
/// OID_802_11_BSSID_LIST (below).
|
|
///
|
|
///
|
|
[WMI, guid("{6929e718-2062-11d4-97eb-00c04f79c403}")]
|
|
class MSNdis_80211_WLanBssId : MSNdis
|
|
{
|
|
[
|
|
WmiDataId(1)] uint32 Ndis80211WLanBssIdLength;
|
|
[
|
|
WmiDataId(2)] uint8 Ndis80211MacAddress[6];
|
|
[
|
|
WmiDataId(3)] uint16 Reserved;
|
|
[
|
|
WmiDataId(4)] uint32 Ndis80211SsIdLength;
|
|
[
|
|
WmiDataId(5)] uint8 Ndis80211SsId[32];
|
|
[
|
|
WmiDataId(6)] uint32 Ndis80211Privacy;
|
|
[
|
|
WmiDataId(7)] uint32 Ndis80211Rssi;
|
|
[
|
|
WmiDataId(8)] MSNdis_80211_NetworkType Ndis80211NetworkTypeInUse;
|
|
[
|
|
WmiDataId(9)] MSNdis_80211_ConfigurationInfo Ndis80211Configuration;
|
|
[
|
|
WmiDataId(10)] MSNdis_80211_NetworkInfrastructure Ndis80211InfrastructureMode;
|
|
[
|
|
WmiDataId(11)] uint8 Ndis80211SupportedRate[8];
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_BSSID_LIST:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{69526f9a-2062-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 Base Service Set Identifier list. This is a list of all BSSID in range, their SSID and RSSI.") : amended]
|
|
class MSNdis_80211_BSSIList : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Number of items in list of 802.11 BSSI") : amended,
|
|
WmiDataId(1)] uint32 NumberOfItems;
|
|
[
|
|
read,
|
|
Description("The list of in-range BSSIDs and their properties") : amended,
|
|
WmiDataId(2),
|
|
WmiSizeIs("NumberOfItems")]
|
|
MSNdis_80211_WLanBssId Ndis80211BSSIList[];
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_INFRASTRUCTURE_MODE:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{697d5a7e-2062-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 Infrastructure mode - defines how the device connects to the network.") : amended]
|
|
class MSNdis_80211_InfrastructureMode : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
WmiDataId(1)] MSNdis_80211_NetworkInfrastructure Ndis80211InfrastructureMode;
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_FRAGMENTATION_THRESHOLD:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{69aaa7c4-2062-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("The size beyond which the 802.11 device should fragment packets") : amended]
|
|
class MSNdis_80211_FragmentationThreshold : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
Description("The 802.11 fragmentation threshold in bytes") : amended,
|
|
WmiDataId(1)] uint32 Ndis80211FragmentationThreshold;
|
|
};
|
|
|
|
|
|
|
|
///
|
|
/// OID_802_11_RTS_THRESHOLD:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{0134d07e-2064-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("The size beyond which the 802.11 device should invoke the RTS/CTS mechanism") : amended]
|
|
class MSNdis_80211_RTSThreshold : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
Description("The 802.11 RTS threshold, in bytes") : amended,
|
|
WmiDataId(1)] uint32 Ndis80211RTSThreshold;
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_NUMBER_OF_ANTENNAS:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{01779336-2064-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("The number of antennas on the 802.11 radio.") : amended]
|
|
class MSNdis_80211_NumberOfAntennas : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("The number of antennas") : amended,
|
|
WmiDataId(1)] uint32 Ndis80211NumberOfAntennas;
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_RX_ANTENNA_SELECTED:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{01ac07a2-2064-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("The antenna selected for receiving on the radio of the 802.11 device") : amended]
|
|
class MSNdis_80211_ReceiveAntennaSelected : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
Description("The receive antenna number") : amended,
|
|
WmiDataId(1)] uint32 Ndis80211ReceiveAntennaSelected;
|
|
};
|
|
|
|
|
|
|
|
///
|
|
/// OID_802_11_TX_ANTENNA_SELECTED:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{01dbb74a-2064-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("The antenna selected for transmitting on the radio of the 802.11 device") : amended]
|
|
class MSNdis_80211_TransmitAntennaSelected : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
Description("The transmit antenna number") : amended,
|
|
WmiDataId(1)] uint32 Ndis80211TransmitAntennaSelected;
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_SUPPORTED_RATES
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{49db8722-2068-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("A set of supported NDIS 802.11 data rates in the operational rate set that the radio is capable of running at.") : amended]
|
|
class MSNdis_80211_DataRates : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
[
|
|
read,
|
|
Description("The list of data rates, in units of 0.5 Mbps") : amended,
|
|
WmiDataId(1)] uint8 Ndis80211DataRate[8];
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_DESIRED_RATES:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{452ee08e-2536-11d4-97ed-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 data rates that are desirable for the radio to operate in.") : amended]
|
|
class MSNdis_80211_DesiredDataRates : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
[
|
|
read, write,
|
|
Description("The list of desired data rates, in units of 0.5 Mbps") : amended,
|
|
WmiDataId(1)] uint8 Ndis80211DesiredRate[8];
|
|
};
|
|
|
|
///
|
|
/// OID_802_11_CONFIGURATION:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{4a4df982-2068-11d4-97eb-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 device radio configuration parameters") : amended]
|
|
class MSNdis_80211_Configuration : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
WmiDataId(1)] MSNdis_80211_ConfigurationInfo Ndis80211Config;
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_STATISTICS:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{42bb73b0-2129-11d4-97ec-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 device statistics") : amended]
|
|
class MSNdis_80211_Statistics : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Length of the statistics structure") : amended,
|
|
WmiDataId(1)] uint32 StatisticsLength;
|
|
[
|
|
read,
|
|
Description("Number of transmitted fragments") : amended,
|
|
WmiDataId(2)] uint64 TransmittedFragmentCount;
|
|
[
|
|
read,
|
|
Description("Number of transmitted multicast frames") : amended,
|
|
WmiDataId(3)] uint64 MulticastTransmittedFrameCount;
|
|
[
|
|
read,
|
|
Description("Number of failures") : amended,
|
|
WmiDataId(4)] uint64 FailedCount;
|
|
[
|
|
read,
|
|
Description("Number of retries") : amended,
|
|
WmiDataId(5)] uint64 RetryCount;
|
|
[
|
|
read,
|
|
Description("Number of multiple retries") : amended,
|
|
WmiDataId(6)] uint64 MultipleRetryCount;
|
|
[
|
|
read,
|
|
Description("Number of Request To Send success") : amended,
|
|
WmiDataId(7)] uint64 RTSSuccessCount;
|
|
[
|
|
read,
|
|
Description("Number of Request To Send failures") : amended,
|
|
WmiDataId(8)] uint64 RTSFailureCount;
|
|
[
|
|
read,
|
|
Description("Number of Acknowledgement failures") : amended,
|
|
WmiDataId(9)] uint64 ACKFailureCount;
|
|
[
|
|
read,
|
|
Description("Number of duplicate frames") : amended,
|
|
WmiDataId(10)] uint64 FrameDuplicateCount;
|
|
[
|
|
read,
|
|
Description("Number of received fragments") : amended,
|
|
WmiDataId(11)] uint64 ReceivedFragmentCount;
|
|
[
|
|
read,
|
|
Description("Number of received multicast frames") : amended,
|
|
WmiDataId(12)] uint64 MulticastReceivedFrameCount;
|
|
[
|
|
read,
|
|
Description("Number of frame checksum errors") : amended,
|
|
WmiDataId(13)] uint64 FCSErrorCount;
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_ADD_WEP:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{4307bff0-2129-11d4-97ec-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("Set a WEP key to the NDIS 802.11 device") : amended]
|
|
class MSNdis_80211_AddWEP : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
write,
|
|
Description("Length of 802.11 WEP structure") : amended,
|
|
WmiDataId(1)] uint32 Length;
|
|
[
|
|
write,
|
|
Description("WEP key index") : amended,
|
|
WmiDataId(2)] uint32 KeyIndex;
|
|
[
|
|
write,
|
|
Description("WEP key length in bytes") : amended,
|
|
WmiDataId(3)] uint32 KeyLength;
|
|
[
|
|
write,
|
|
Description("WEP key index") : amended,
|
|
WmiDataId(4), WmiSizeIs("KeyLength")]
|
|
uint32 KeyMaterial[];
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_REMOVE_WEP:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{433c345c-2129-11d4-97ec-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("Remove a WEP key on the NDIS 802.11 device") : amended]
|
|
class MSNdis_80211_RemoveWEP : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
write,
|
|
Description("The NDIS 802.11 WEP key index") : amended,
|
|
WmiDataId(1)] uint32 Ndis80211KeyIndex;
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_DISASSOCIATE:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{43671f40-2129-11d4-97ec-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("Disassociate the NDIS 802.11 device with the current SSID") : amended]
|
|
class MSNdis_80211_Disassociate : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
[
|
|
write,
|
|
Description("Unused parameter") : amended,
|
|
WmiDataId(1)] uint32 UnusedParameter;
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_BSSID_LIST_SCAN:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{0d9e01e1-ba70-11d4-b675-002048570337}"),
|
|
|
|
WmiExpense(1),
|
|
Description("Perform a survey to refresh the NDIS 802.11 BSS list") : amended]
|
|
class MSNdis_80211_BssIdListScan : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
[
|
|
write,
|
|
Description("Unused parameter") : amended,
|
|
WmiDataId(1)] uint32 UnusedParameter;
|
|
};
|
|
|
|
|
|
|
|
///
|
|
/// OID_802_11_AUTHENTICATION_MODE:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{43920a24-2129-11d4-97ec-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 Authentication Mode") : amended]
|
|
class MSNdis_80211_AuthenticationMode : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
Description("NDIS 802.11 authentication mode setting") : amended,
|
|
Values{"Ndis802_11AuthModeOpen",
|
|
"Ndis802_11AuthModeShared",
|
|
"Ndis802_11AuthModeAutoSwitch"},
|
|
ValueMap{"0",
|
|
"1",
|
|
"2"},
|
|
WmiDataId(1)] uint32 Ndis80211AuthenticationMode;
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_PRIVACY_FILTER:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{6733c4e9-4792-11d4-97f1-00c04f79c403}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 Privacy Filter") : amended]
|
|
class MSNdis_80211_PrivacyFilter : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
Description("NDIS 802.11 privacy filter setting") : amended,
|
|
Values{"Ndis802_11PrivFilterAcceptAll",
|
|
"Ndis802_11PrivFilter8021xWEP"},
|
|
ValueMap{"0",
|
|
"1"},
|
|
WmiDataId(1)] uint32 Ndis80211PrivacyFilter;
|
|
};
|
|
|
|
|
|
|
|
///
|
|
/// OID_802_11_WEP_STATUS:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{b027a21f-3cfa-4125-800b-3f7a18fddcdc}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 WEP Status") : amended]
|
|
class MSNdis_80211_WEPStatus : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read, write,
|
|
Description("NDIS 802.11 WEP Status setting") : amended,
|
|
Values{"Ndis802_11WEPEnabled",
|
|
"Ndis802_11WEPDisabled",
|
|
"Ndis802_11WEPKeyAbsent",
|
|
"Ndis802_11WEPNotSupported"},
|
|
ValueMap{"0",
|
|
"1",
|
|
"2",
|
|
"3"},
|
|
WmiDataId(1)] uint32 Ndis80211WEPStatus;
|
|
};
|
|
|
|
|
|
///
|
|
/// OID_802_11_RELOAD_DEFAULTS:
|
|
///
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{748b14e8-32ee-4425-b91b-c9848c58b55a}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS 802.11 Reload Default Settings") : amended]
|
|
class MSNdis_80211_ReloadDefaults : MSNdis
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
write,
|
|
Description("The parameter(s) to be reloaded to default settings") : amended,
|
|
Values{"Ndis802_11ReloadWEPKeys"} : amended,
|
|
ValueMap{"0"},
|
|
WmiDataId(1)] uint32 Ndis80211ReloadDefaults;
|
|
};
|
|
|
|
|
|
///
|
|
///
|
|
/// NDIS status specific GUIDs
|
|
///
|
|
///
|
|
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{981f2d76-b1f3-11d0-8dd7-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Status Reset Start") : amended]
|
|
class MSNdis_StatusResetStart : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{981f2d77-b1f3-11d0-8dd7-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Status Reset End") : amended]
|
|
class MSNdis_StatusResetEnd : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{981f2d7d-b1f3-11d0-8dd7-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Status Media Connect") : amended]
|
|
class MSNdis_StatusMediaConnect : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{981f2d7e-b1f3-11d0-8dd7-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Status Media Disconnect") : amended]
|
|
class MSNdis_StatusMediaDisconnect : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{981f2d84-b1f3-11d0-8dd7-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Status Media Specific Indication") : amended]
|
|
class MSNdis_StatusMediaSpecificIndication : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Number of bytes for media specific status indication") : amended,
|
|
WmiDataId(1)] uint32 NumberElements;
|
|
[read,
|
|
Description("Media specific status information.") : amended,
|
|
WmiDataId(2), WmiSizeIs("NumberElements")] uint8 NdisStatusMediaSpecificIndication[];
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"), guid("{981f2d85-b1f3-11d0-8dd7-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Status Link Speed Change") : amended]
|
|
class MSNdis_StatusLinkSpeedChange : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("New inbound and outbound link speeds for the adapter.") : amended,
|
|
WmiDataId(1)] MSNdis_NetworkLinkSpeed NdisStatusLinkSpeedChange;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"),
|
|
guid("{5413531c-b1f3-11d0-d78d-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Protocol Bind Notification") : amended]
|
|
class MSNdis_StatusProtocolBind : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Name of transport bound") : amended,
|
|
WmiDataId(1)] string Transport;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"),
|
|
guid("{6e3ce1ec-b1f3-11d0-d78d-00c04fc3358c}"),
|
|
|
|
WmiExpense(1),
|
|
Description("NDIS Protocol Unbind Notification") : amended]
|
|
class MSNdis_StatusProtocolUnbind : WMIEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[
|
|
read,
|
|
Description("Name of transport unbound") : amended,
|
|
WmiDataId(1)] string Transport;
|
|
};
|
|
|
|
//
|
|
// Keyboard and Mouse
|
|
|
|
[abstract]
|
|
class MSKeyboard
|
|
{
|
|
};
|
|
|
|
class MSMouse
|
|
{
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Keyboard port driver information") : amended,
|
|
guid("{4731F89A-71CB-11d1-A52C-00A0C9062910}"),
|
|
GuidName1("KEYBOARD_PORT_WMI_STD_DATA_GUID"),
|
|
HeaderName("KEYBOARD_PORT_WMI_STD_DATA"),
|
|
DisplayName("Keyboard Port Information") : amended
|
|
]
|
|
class MSKeyboard_PortInformation : MSKeyboard
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Connector Type") : amended,
|
|
WmiDataId(1),
|
|
read,
|
|
Values{"I8042 Connector"
|
|
"Serial Connector",
|
|
"USB Connector" } : amended,
|
|
ValueMap{"0",
|
|
"1",
|
|
"2" },
|
|
DefineValues{"KEYBOARD_PORT_WMI_STD_I8042",
|
|
"KEYBOARD_PORT_WMI_STD_SERIAL",
|
|
"KEYBOARD_PORT_WMI_STD_USB"},
|
|
Description("How the keyboard is connected to the computer") : amended]
|
|
uint32 ConnectorType;
|
|
|
|
[DisplayName("Data Queue Size") : amended,
|
|
WmiDataId(2),
|
|
read,
|
|
Description("The DataQueueSize property indicates the size of the data queue.") : amended]
|
|
uint32 DataQueueSize;
|
|
|
|
[DisplayName("Error Count") : amended,
|
|
WmiDataId(3),
|
|
read,
|
|
Description("Number of errors that occured on this device") : amended]
|
|
uint32 ErrorCount;
|
|
|
|
[DisplayName("Number of Function Keys") : amended,
|
|
WmiDataId(4),
|
|
read,
|
|
Description("The NumberOfFunctionKeys property indicates the number of function keys on the keyboard.") : amended]
|
|
uint32 FunctionKeys;
|
|
|
|
[DisplayName("Number of Indicators") : amended,
|
|
WmiDataId(5),
|
|
read,
|
|
Description("The NumberOfIndicators property indicates the number of indicator leds on the keyboard.") : amended]
|
|
uint32 Indicators;
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Keyboard port extended ID") : amended,
|
|
guid("{6ac4e23d-a950-4518-8b2b-aa4dcd5fe14a}"),
|
|
GuidName1("KEYBOARD_PORT_WMI_EXTENDED_ID"),
|
|
HeaderName("KEYBOARD_ID_EX"),
|
|
DisplayName("Keyboard Extended ID Information") : amended
|
|
]
|
|
class MSKeyboard_ExtendedID : MSKeyboard
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Extended Type") : amended,
|
|
WmiDataId(1),
|
|
read,
|
|
Description("The Extended Type property indicates a 32 bit type identifier for the keyboard.") : amended]
|
|
uint32 Type;
|
|
|
|
[DisplayName("Extended Subtype") : amended,
|
|
WmiDataId(2),
|
|
read,
|
|
Description("The Extended Type property indicates a 32 bit subtype identifier for the keyboard.") : amended]
|
|
uint32 Subtype;
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Mouse port driver information") : amended,
|
|
guid("{4731F89C-71CB-11d1-A52C-00A0C9062910}"),
|
|
GuidName1("POINTER_PORT_WMI_STD_DATA_GUID"),
|
|
HeaderName("POINTER_PORT_WMI_STD_DATA"),
|
|
DisplayName("Mouse Port Information") : amended
|
|
]
|
|
class MSMouse_PortInformation : MSMouse
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Connector Type") : amended,
|
|
WmiDataId(1),
|
|
read,
|
|
Values{"I8042 Connector"
|
|
"Serial Connector",
|
|
"USB Connector" } : amended,
|
|
ValueMap{"0",
|
|
"1",
|
|
"2" },
|
|
DefineValues{"POINTER_PORT_WMI_STD_I8042",
|
|
"POINTER_PORT_WMI_STD_SERIAL",
|
|
"POINTER_PORT_WMI_STD_USB"},
|
|
Description("How the mouse is connected to the computer") : amended]
|
|
uint32 ConnectorType;
|
|
|
|
[DisplayName("Data Queue Size") : amended,
|
|
WmiDataId(2),
|
|
read,
|
|
Description("The DataQueueSize property indicates the size of the data queue.") : amended]
|
|
uint32 DataQueueSize;
|
|
|
|
[DisplayName("Error Count") : amended,
|
|
WmiDataId(3),
|
|
read,
|
|
Description("Number of errors that occured on this device") : amended]
|
|
uint32 ErrorCount;
|
|
|
|
[DisplayName("Number of Buttons") : amended,
|
|
WmiDataId(4),
|
|
read,
|
|
Description("The NumberOfButtons property indicates the number of buttons on the pointing device.") : amended]
|
|
uint32 Buttons;
|
|
|
|
[DisplayName("Hardware Type") : amended,
|
|
WmiDataId(5),
|
|
read,
|
|
Values{"Standard Mouse",
|
|
"Standard Pointer",
|
|
"Standard Absolute Pointer",
|
|
"Tablet",
|
|
"Touch Screen",
|
|
"Pen",
|
|
"Track Ball",
|
|
"Other"} : amended,
|
|
ValueMap{"0",
|
|
"1",
|
|
"2",
|
|
"3",
|
|
"4",
|
|
"5",
|
|
"6",
|
|
"256"},
|
|
DefineValues{"POINTER_PORT_WMI_STD_MOUSE",
|
|
"POINTER_PORT_WMI_STD_POINTER",
|
|
"POINTER_PORT_WMI_ABSOLUTE_POINTER",
|
|
"POINTER_PORT_WMI_TABLET",
|
|
"POINTER_PORT_WMI_TOUCH_SCRENE",
|
|
"POINTER_PORT_WMI_PEN",
|
|
"POINTER_PORT_WMI_TRACK_BALL",
|
|
"POINTER_PORT_WMI_OTHER"},
|
|
Description("The HardwareType property indicates the hardware type of the pointing device.") : amended]
|
|
uint32 HardwareType;
|
|
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Mouse class driver information") : amended,
|
|
guid("{4731F89B-71CB-11d1-A52C-00A0C9062910}")
|
|
]
|
|
class MSMouse_ClassInformation : MSMouse
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[
|
|
WmiDataId(1),
|
|
read,
|
|
Description("An identification number for the device") : amended]
|
|
uint64 DeviceId;
|
|
};
|
|
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Keyboard class driver information") : amended,
|
|
guid("{4731F899-71CB-11d1-A52C-00A0C9062910}")
|
|
]
|
|
class MSKeyboard_ClassInformation : MSKeyboard
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[
|
|
WmiDataId(1),
|
|
read,
|
|
Description("An identification number for the device") : amended]
|
|
uint64 DeviceId;
|
|
};
|
|
|
|
//
|
|
// Thermal information via ACPI
|
|
[abstract]
|
|
class MSAcpi
|
|
{
|
|
};
|
|
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("ThermalZone temperature information") : amended,
|
|
guid("{A1BC18C0-A7C8-11d1-BF3C-00A0C9062910}"),
|
|
DisplayName("Thermal Zone Information") : amended
|
|
]
|
|
class MSAcpi_ThermalZoneTemperature : MSAcpi
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Thermal Stamp") : amended,
|
|
WmiDataId(1),
|
|
Description("Thermal information change stamp") : amended,
|
|
read]
|
|
uint32 ThermalStamp;
|
|
|
|
[DisplayName("Thermal Constant 1") : amended,
|
|
WmiDataId(2),
|
|
Description("First thermal constant") : amended,
|
|
read]
|
|
uint32 ThermalConstant1;
|
|
|
|
[DisplayName("Thermal Constant 2") : amended,
|
|
WmiDataId(3),
|
|
Description("Second thermal constant") : amended,
|
|
read]
|
|
uint32 ThermalConstant2;
|
|
|
|
[DisplayName("Reserved") : amended,
|
|
WmiDataId(4),
|
|
Description("Reserved") : amended,
|
|
read]
|
|
uint32 Reserved;
|
|
|
|
[DisplayName("Sampling Period") : amended,
|
|
WmiDataId(5),
|
|
Description("Sampling period") : amended,
|
|
read]
|
|
uint32 SamplingPeriod;
|
|
|
|
[DisplayName("Current Temperature") : amended,
|
|
WmiDataId(6),
|
|
Description("Temperature at thermal zone in tenths of degrees Kelvin") : amended,
|
|
read]
|
|
uint32 CurrentTemperature;
|
|
|
|
[DisplayName("Passive Trippoint") : amended,
|
|
WmiDataId(7),
|
|
Description("Temperature (in tenths of degrees Kelvin) at which the OS must activate CPU throttling (ie, enable passive cooling)") : amended,
|
|
read]
|
|
uint32 PassiveTripPoint;
|
|
|
|
[DisplayName("Critical Trippoint") : amended,
|
|
WmiDataId(8),
|
|
Description("Temperature (in tenths of degrees Kelvin) at which the OS must shutdown the system (ie, critical temperature)") : amended,
|
|
read]
|
|
uint32 CriticalTripPoint;
|
|
|
|
[DisplayName("Active Trippoint Count") : amended,
|
|
WmiDataId(9),
|
|
Description("Count of active trip points") : amended,
|
|
read]
|
|
uint32 ActiveTripPointCount;
|
|
|
|
[WmiDataId(10),
|
|
Description("Temperature levels (in tenths of degrees Kelvin) at which the OS must activate active cooling") : amended,
|
|
DisplayName("Active Trippoint") : amended,
|
|
MissingValue(0),
|
|
read]
|
|
uint32 ActiveTripPoint[10];
|
|
|
|
};
|
|
|
|
//
|
|
// Disk
|
|
[abstract]
|
|
class MSDiskDriver
|
|
{
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Disk Geometry") : amended,
|
|
guid("{25007F51-57C2-11d1-A528-00A0C9062910}"),
|
|
HeaderName("WMI_DISK_GEOMETRY"),
|
|
DisplayName("Disk Geometry") : amended
|
|
]
|
|
class MSDiskDriver_Geometry : MSDiskDriver
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Cylinders") : amended,
|
|
WmiDataId(1),
|
|
read]
|
|
sint64 Cylinders;
|
|
|
|
[DisplayName("Media Type") : amended,
|
|
WmiDataId(2),
|
|
Values{"Format is unknown",
|
|
"5.25, 1.2MB, 512 bytes/sector",
|
|
"3.5, 1.44MB, 512 bytes/sector",
|
|
"3.5, 2.88MB, 512 bytes/sector",
|
|
"3.5, 20.8MB, 512 bytes/sector",
|
|
"3.5, 720KB, 512 bytes/sector",
|
|
"5.25, 360KB, 512 bytes/sector",
|
|
"5.25, 320KB, 512 bytes/sector",
|
|
"5.25, 320KB, 1024 bytes/sector",
|
|
"5.25, 180KB, 512 bytes/sector",
|
|
"5.25, 160KB, 512 bytes/sector",
|
|
"Removable media other than floppy",
|
|
"Fixed hard disk media",
|
|
"3.5, 120M Floppy",
|
|
"3.5 , 640KB, 512 bytes/sector",
|
|
"5.25, 640KB, 512 bytes/sector",
|
|
"5.25, 720KB, 512 bytes/sector",
|
|
"3.5 , 1.2Mb, 512 bytes/sector",
|
|
"3.5 , 1.23Mb, 1024 bytes/sector",
|
|
"5.25, 1.23MB, 1024 bytes/sector",
|
|
"3.5 MO 128Mb 512 bytes/sector",
|
|
"3.5 MO 230Mb 512 bytes/sector",
|
|
"8, 256KB, 128 bytes/sector"} : amended,
|
|
ValueMap{"0",
|
|
"1",
|
|
"2",
|
|
"3",
|
|
"4",
|
|
"5",
|
|
"6",
|
|
"7",
|
|
"8",
|
|
"9",
|
|
"10",
|
|
"11",
|
|
"12",
|
|
"13",
|
|
"14",
|
|
"15",
|
|
"16",
|
|
"17",
|
|
"18",
|
|
"19",
|
|
"20",
|
|
"21",
|
|
"22"},
|
|
read]
|
|
uint32 MediaType;
|
|
|
|
[DisplayName("Tracks Per Cylinder") : amended,
|
|
WmiDataId(3),
|
|
read]
|
|
uint32 TracksPerCylinder;
|
|
|
|
[DisplayName("Sectors Per Track") : amended,
|
|
WmiDataId(4),
|
|
read]
|
|
uint32 SectorsPerTrack;
|
|
|
|
[DisplayName("Bytes Per Sector") : amended,
|
|
WmiDataId(5),
|
|
read]
|
|
uint32 BytesPerSector;
|
|
|
|
};
|
|
|
|
[
|
|
WMI,
|
|
Description("Disk performance statistics") : amended,
|
|
guid("BDD865D2-D7C1-11d0-A501-00A0C9062910"),
|
|
HeaderName("WMI_DISK_PERFORMANCE"),
|
|
DisplayName("Disk Performance Information") : amended
|
|
]
|
|
class MSDiskDriver_PerformanceData : MSDiskDriver
|
|
{
|
|
[DisplayName("Bytes Read") : amended,
|
|
WmiDataId(1),
|
|
Description("Number of bytes read on disk") : amended,
|
|
read]
|
|
sint64 BytesRead;
|
|
|
|
[DisplayName("Bytes Written") : amended,
|
|
WmiDataId(2),
|
|
Description("Number of bytes written on disk") : amended,
|
|
read]
|
|
sint64 BytesWritten;
|
|
|
|
[DisplayName("Read Time") : amended,
|
|
WmiDataId(3),
|
|
Description("Amount off time spent reading from disk") : amended,
|
|
read]
|
|
sint64 ReadTime;
|
|
|
|
[DisplayName("Write Time") : amended,
|
|
WmiDataId(4),
|
|
Description("Amount off time spent writing to disk") : amended,
|
|
read]
|
|
sint64 WriteTime;
|
|
|
|
[DisplayName("Idle Time") : amended,
|
|
WmiDataId(5),
|
|
Description("Amount off disk idle time") : amended,
|
|
read]
|
|
sint64 IdleTime;
|
|
|
|
[DisplayName("Read Count") : amended,
|
|
WmiDataId(6),
|
|
Description("Number of read operations from disk") : amended,
|
|
read]
|
|
uint32 ReadCount;
|
|
|
|
[DisplayName("Write Count") : amended,
|
|
WmiDataId(7),
|
|
Description("Number of write operations to disk") : amended,
|
|
read]
|
|
uint32 WriteCount;
|
|
|
|
[DisplayName("Queue Depth") : amended,
|
|
WmiDataId(8),
|
|
Description("Number of requests waiting in the disk queue") : amended,
|
|
read]
|
|
uint32 QueueDepth;
|
|
|
|
[DisplayName("Split Count") : amended,
|
|
WmiDataId(9),
|
|
Description("Number of split IO operations") : amended,
|
|
read]
|
|
uint32 SplitCount;
|
|
|
|
[DisplayName("Query Time") : amended,
|
|
WmiDataId(10),
|
|
Description("") : amended,
|
|
read]
|
|
sint64 QueryTime;
|
|
|
|
[DisplayName("Storage Device Number") : amended,
|
|
WmiDataId(11),
|
|
Description("") : amended,
|
|
read]
|
|
uint32 StorageDeviceNumber;
|
|
|
|
[WmiDataId(12),
|
|
DisplayName("Storage Manager Name") : amended,
|
|
Description("") : amended,
|
|
read]
|
|
uint16 StorageManagerName[8];
|
|
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Disk performance statistics") : amended,
|
|
guid("BDD865D1-D7C1-11d0-A501-00A0C9062910"),
|
|
DisplayName("Disk Performance Information") : amended
|
|
]
|
|
class MSDiskDriver_Performance : MSDiskDriver
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Performance Data") : amended,
|
|
WmiDataId(1),
|
|
Description("Performance Data Information") : amended,
|
|
read]
|
|
MSDiskDriver_PerformanceData PerfData;
|
|
|
|
[DisplayName("Device Name") : amended,
|
|
WmiDataId(2),
|
|
Description("Internal device name") : amended,
|
|
read]
|
|
string DeviceName;
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// General storage
|
|
[abstract]
|
|
class MSStorageDriver
|
|
{
|
|
};
|
|
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Storage Device Failure Prediction Status") : amended,
|
|
guid("{78ebc102-4cf9-11d2-ba4a-00a0c9062910}"),
|
|
HeaderName("STORAGE_FAILURE_PREDICT_STATUS"),
|
|
GuidName1("WMI_STORAGE_FAILURE_PREDICT_STATUS_GUID"),
|
|
DisplayName("Failure Predict Status") : amended
|
|
]
|
|
class MSStorageDriver_FailurePredictStatus : MSStorageDriver
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Reason") : amended,
|
|
WmiDataId(1),
|
|
ValueMap{"0", "255"},
|
|
Values{"Unknown", "Test - Not a failure"} : amended,
|
|
read]
|
|
uint32 Reason;
|
|
|
|
|
|
[DisplayName("Predict Failure") : amended,
|
|
WmiDataId(2),
|
|
Description("TRUE if drive is predictiing failure. In this case it is critical that the disk is backed up immediately") : amended,
|
|
read]
|
|
boolean PredictFailure;
|
|
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Storage Device Failure Prediction Data") : amended,
|
|
guid("{78ebc103-4cf9-11d2-ba4a-00a0c9062910}"),
|
|
HeaderName("STORAGE_FAILURE_PREDICT_DATA"),
|
|
GuidName1("WMI_STORAGE_FAILURE_PREDICT_DATA_GUID"),
|
|
DisplayName("Failure Predict Data") : amended
|
|
]
|
|
class MSStorageDriver_FailurePredictData : MSStorageDriver
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Length") : amended,
|
|
WmiDataId(1),
|
|
read]
|
|
uint32 Length;
|
|
|
|
|
|
[DisplayName("Vendor Specific") : amended,
|
|
WmiDataId(2),
|
|
Description("Vendor specific failure prediction data") : amended,
|
|
read]
|
|
uint8 VendorSpecific[512];
|
|
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("ATAPI SMART Data") : amended,
|
|
guid("{78ebc103-4cf9-11d2-ba4a-00a0c9062910}"),
|
|
HeaderName("ATAPI_FAILURE_PREDICT_DATA"),
|
|
GuidName1("WMI_ATAPI_FAILURE_PREDICT_DATA_GUID"),
|
|
read,
|
|
DisplayName("ATAPI Failure Predict Data") : amended
|
|
]
|
|
class MSStorageDriver_ATAPISmartData : MSStorageDriver
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Length") : amended,
|
|
WmiDataId(1),
|
|
read]
|
|
uint32 Length;
|
|
|
|
|
|
[DisplayName("Vendor Specific") : amended,
|
|
WmiDataId(2),
|
|
Description("Vendor specific failure prediction data") : amended,
|
|
read]
|
|
uint8 VendorSpecific[362];
|
|
|
|
[WmiDataId(3),
|
|
Description("Off-line data collection status") : amended,
|
|
read,
|
|
Values{"0", "2", "4", "5", "6", "128", "130", "132", "133", "134"},
|
|
ValueMap{"Off-line data collection activity was never started",
|
|
"Off-line data collection activity was completed without error",
|
|
"Off-line data collection activity was suspended by an interrupting command from host",
|
|
"Off-line data collection activity was aborted by an interrupting command from host",
|
|
"Off-line data collection activity was aborted by the device with a fatal error",
|
|
"Off-line data collection activity was never started",
|
|
"Off-line data collection activity was completed without error",
|
|
"Off-line data collection activity was suspended by an interrupting command from host",
|
|
"Off-line data collection activity was aborted by an interrupting command from host",
|
|
"Off-line data collection activity was aborted by the device with a fatal error"
|
|
} : amended
|
|
]
|
|
uint8 OfflineCollectionStatus;
|
|
|
|
[WmiDataId(4),
|
|
Description("Self-test execution status byte") : amended,
|
|
read,
|
|
Values{"0", "1", "2", "3", "4", "5", "6", "7", "15"},
|
|
ValueMap{
|
|
"The previous self-test routine completed without error or no self-test has ever been run"
|
|
"The self-test routine was aborted by the host",
|
|
"The self-test routine was interrupted by the host with a hardware or software reset",
|
|
"A fatal error or unknown test error occurred while the device was executing its self-test routineand the device was unable to complete the self-test routine.",
|
|
"The previous self-test completed having a test element that failed and the test element that failed is not known.",
|
|
"The previous self-test completed having the electrical element of the test failed.",
|
|
"The previous self-test completed having the servo (and/or seek) test element of the test failed.",
|
|
"The previous self-test completed having the read element of the test failed.",
|
|
"Self-test routine in progress."
|
|
} : amended
|
|
]
|
|
uint8 SelfTestStatus;
|
|
|
|
[WmiDataId(5),
|
|
Description("Total time in seconds to complete off-line data collection activity") : amended,
|
|
read
|
|
]
|
|
uint16 TotalTime;
|
|
|
|
[WmiDataId(6),
|
|
Description("Vendor Specific") : amended,
|
|
read
|
|
]
|
|
uint8 VendorSpecific2;
|
|
|
|
[WmiDataId(7),
|
|
Description("Off-line data collection capability") : amended,
|
|
BitMap{"0", "1", "2", "3", "4"},
|
|
BitValues{
|
|
"(EXECUTE OFF-LINE IMMEDIATE implemented bit) - If this bit is set to one, then the SMART EXECUTE OFF-LINE IMMEDIATE command is implemented by this device. If this bit is cleared to zero, then the SMART EXECUTE OFF-LINE IMMEDIATE command is not implemented by this device.",
|
|
"(vendor specific)",
|
|
"(abort/restart off-line by host bit) - If this bit is set to one, then the device shall abort all off-line data collection activity initiated by an SMART EXECUTE OFF-LINE IMMEDIATE command upon receipt of a new command within 2 seconds of receiving the new command. If this bit is cleared to zero, the device shall suspend off-line data collection activity after an interrupting command and resume off-line data collection activity after some vendor-specified event.",
|
|
"(off-line read scanning implemented bit) - If this bit is cleared to zero, the device does not support off-line read scanning. If this bit is set to one, the device supports off-line read scanning.",
|
|
"(self-test implemented bit) - If this bit is cleared to zero, the device does not implement the Short and Extended self-test routines. If this bit is set to one, the device implements the Short and Extended self-test routines."
|
|
} : amended,
|
|
read
|
|
]
|
|
uint8 OfflineCollectCapability;
|
|
|
|
[WmiDataId(8),
|
|
Description("SMART capability") : amended,
|
|
read,
|
|
BitMap{"0", "1"},
|
|
BitValues{
|
|
"(power mode SMART data saving capability bit) - If this bit is set to one, the device saves SMART data prior to going into a power saving mode (Idle, Standby, or Sleep) or immediately upon return to Active or Idle mode from a Standby mode. If this bit is cleared to zero, the device does not save SMART data prior to going into a power saving mode (Idle, Standby, or Sleep) or immediately upon return to Active or Idle mode from a Standby mode.",
|
|
"(SMART data autosave after event capability bit) - This bit is set to one for devices complying with this standard."
|
|
} : amended
|
|
]
|
|
uint16 SmartCapability;
|
|
|
|
[WmiDataId(9),
|
|
Description("Error logging capability") : amended,
|
|
read,
|
|
BitMap{"0"},
|
|
BitValues{"Device error logging supported"} : amended
|
|
]
|
|
uint8 ErrorLogCapability;
|
|
|
|
[WmiDataId(10),
|
|
Description("Vendor Specific") : amended,
|
|
read
|
|
]
|
|
uint8 VendorSpecific3;
|
|
|
|
[WmiDataId(11),
|
|
Description("Short self-test routine recommended polling time (in minutes)") : amended,
|
|
read
|
|
]
|
|
uint8 ShortPollTimeInMinutes;
|
|
|
|
[WmiDataId(12),
|
|
Description("Extended self-test routine recommended polling time (in minutes)") : amended,
|
|
read
|
|
]
|
|
uint8 ExtendedPollTimeInMinutes;
|
|
|
|
[WmiDataId(13),
|
|
Description("Reserved"),
|
|
read
|
|
]
|
|
uint8 Reserved[12];
|
|
|
|
[WmiDataId(14),
|
|
Description("Vendor Specific") : amended,
|
|
read
|
|
]
|
|
uint8 VendorSpecific4[125];
|
|
|
|
[WmiDataId(15),
|
|
Description("Data structure checksum") : amended,
|
|
read
|
|
]
|
|
uint8 Checksum;
|
|
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Storage Device Failure Prediction Thresholds") : amended,
|
|
guid("{DAE10783-CC31-4d2a-8A0F-861C04077A95}"),
|
|
HeaderName("STORAGE_FAILURE_PREDICT_THRESHOLDS"),
|
|
GuidName1("WMI_STORAGE_FAILURE_PREDICT_THRESHOLDS_GUID"),
|
|
DisplayName("Failure Predict Thresholds") : amended
|
|
]
|
|
class MSStorageDriver_FailurePredictThresholds : MSStorageDriver
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Vendor Specific") : amended,
|
|
WmiDataId(1),
|
|
Description("Vendor specific failure prediction thresholds") : amended,
|
|
read]
|
|
uint8 VendorSpecific[512];
|
|
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Storage Device Failure Prediction Event") : amended,
|
|
guid("{78ebc104-4cf9-11d2-ba4a-00a0c9062910}"),
|
|
HeaderName("STORAGE_FAILURE_PREDICT_EVENT"),
|
|
GuidName1("WMI_STORAGE_PREDICT_FAILURE_EVENT_GUID"),
|
|
DisplayName("Failure Predict Event") : amended
|
|
]
|
|
class MSStorageDriver_FailurePredictEvent : WmiEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Length") : amended,
|
|
WmiDataId(1),
|
|
read]
|
|
uint32 Length;
|
|
|
|
|
|
[DisplayName("Vendor Specific") : amended,
|
|
WmiDataId(2),
|
|
Description("Vendor specific failure prediction data") : amended,
|
|
WmiSizeIs("Length"),
|
|
read]
|
|
uint8 VendorSpecific[];
|
|
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Storage Device Failure Prediction Functions") : amended,
|
|
guid("{78ebc105-4cf9-11d2-ba4a-00a0c9062910}"),
|
|
HeaderName("STORAGE_FAILURE_PREDICT_FUNCTION"),
|
|
GuidName1("WMI_STORAGE_FAILURE_PREDICT_FUNCTION_GUID"),
|
|
DisplayName("Failure Predict Functions") : amended
|
|
]
|
|
class MSStorageDriver_FailurePredictFunction : MSStorageDriver
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[WmiMethodId(1),
|
|
Implemented,
|
|
DisplayName("Allow Performance Degredation") : amended,
|
|
HeaderName("ALLOW_PERFORMANCE_HIT"),
|
|
Description("Configures setting that specifies if additional failure prediction checking can cause a loss of performance") : amended]
|
|
void AllowPerformanceHit([in, DisplayName("Allow") : amended] boolean Allow);
|
|
|
|
[WmiMethodId(2),
|
|
Implemented,
|
|
DisplayName("Enable Or Disable Hardware Failure Prediction") : amended,
|
|
HeaderName("ENABLE_DISABLE_FP"),
|
|
Description("Enables or disables failure prediction checking at the hardware level") : amended]
|
|
void EnableDisableHardwareFailurePrediction([in, DisplayName("Enable") : amended] boolean Enable);
|
|
|
|
[WmiMethodId(3),
|
|
Implemented,
|
|
DisplayName("Enable Or Disable Failure Prediction Polling") : amended,
|
|
HeaderName("ENABLE_DISABLE_FP_POLLING"),
|
|
Description("Enables or disables polling for failure prediction status") : amended]
|
|
void EnableDisableFailurePredictionPolling(
|
|
[in,
|
|
DisplayName("Period") : amended,
|
|
Description("Period in seconds to poll for failure prediction status") : amended]
|
|
uint32 Period,
|
|
[in] boolean Enable);
|
|
[WmiMethodId(4),
|
|
Implemented,
|
|
DisplayName("Get Failure Prediction Capability") : amended,
|
|
HeaderName("GET_FP_CAPABILITY"),
|
|
Description("Returns mechanism used to read failure prediction status ") : amended]
|
|
void GetFailurePredictionCapability([out, ValueMap{"0", "1", "2", "3"},
|
|
Value{"Not Supported",
|
|
"Ioctl Based",
|
|
"IDE SMART",
|
|
"SCSI SMART"} : amended,
|
|
DisplayName("Capability") : amended
|
|
] uint32 Capability);
|
|
|
|
[WmiMethodId(5),
|
|
HeaderName("ENABLE_OFFLINE_DIAGS"),
|
|
Implemented,
|
|
DisplayName("Enable Offline Diags") : amended,
|
|
Description("Enables execution of offline diagnostics") : amended]
|
|
void EnableOfflineDiags([out, DisplayName("Success") : amended] boolean Success);
|
|
|
|
|
|
[WmiMethodId(6),
|
|
Implemented,
|
|
DisplayName("Read Log Sectors") : amended,
|
|
HeaderName("READ_LOG_SECTORS"),
|
|
Description("Read log sectors") : amended
|
|
]
|
|
void ReadLogSectors([in, DisplayName("Log Address") : amended] uint8 LogAddress,
|
|
[in, DisplayName("Sector Count") : amended] uint8 SectorCount,
|
|
[out, DisplayName("Length") : amended] uint32 Length,
|
|
[out, WmiSizeIs("Length"), DisplayName("Log Sectors") : amended] uint8 LogSectors[]
|
|
);
|
|
|
|
[WmiMethodId(7),
|
|
Implemented,
|
|
HeaderName("WRITE_LOG_SECTORS"),
|
|
DisplayName("WriteLogSectors") : amended,
|
|
Description("Write log sectors") : amended
|
|
]
|
|
void WriteLogSectors([in, DisplayName("LogAddress") : amended] uint8 LogAddress,
|
|
[in, DisplayName("SectorCount") : amended] uint8 SectorCount,
|
|
[in, DisplayName("Length") : amended] uint32 Length,
|
|
[in, WmiSizeIs("Length"), DisplayName("LogSectors") : amended] uint8 LogSectors[],
|
|
[out, DisplayName("Success") : amended] boolean Success
|
|
);
|
|
|
|
[WmiMethodId(8),
|
|
Implemented,
|
|
HeaderName("EXECUTE_SELF_TEST"),
|
|
DisplayName("Execute Self Test") : amended,
|
|
Description("Execute Self Test") : amended
|
|
]
|
|
void ExecuteSelfTest([in, DisplayName("Sub Command") : amended] uint8 Subcommand,
|
|
[out,
|
|
DisplayName("Return Code") : amended,
|
|
ValueMap{"0", "1", "2"},
|
|
Value{"Successful Completion",
|
|
"Captive Mode Required",
|
|
"Unsuccessful Completion"} : amended
|
|
]
|
|
uint32 ReturnCode);
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Data for Scsi Info Exceptions Mode Page") : amended,
|
|
guid("{1101D829-167B-4ebf-ACAE-28CAB7C34802}"),
|
|
HeaderName("STORAGE_SCSI_INFO_EXCEPTIONS"),
|
|
GuidName1("WMI_STORAGE_SCSI_INFO_EXCEPTIONS_GUID"),
|
|
DisplayName("Scsi Info Exceptions") : amended
|
|
]
|
|
class MSStorageDriver_ScsiInfoExceptions : MSStorageDriver
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Page Savable") : amended,
|
|
WmiDataId(1),
|
|
Description("The returned Parameter Savable bit of 1 indicates that page parameter data is savable.") : amended,
|
|
read, write]
|
|
boolean PageSavable;
|
|
|
|
[DisplayName("Flags") : amended,
|
|
WmiDataId(2),
|
|
Description("Bit flags: "
|
|
"Perf set to zero indicates that informational exception operations that are the cause of delays are acceptable. "
|
|
"DExcpt set to zero indicates information exception operations shall be enabled. "
|
|
"Test of one instructs the drive to create false drive failures. "
|
|
"LogErr bit of zero indicates that logging of informational exception conditions are vendor specific.") : amended,
|
|
BitValues{"Perf", "DExcpt", "Test", "LogErr"} : amended,
|
|
BitMap{"7", "3", "2", "0"},
|
|
read, write]
|
|
uint8 Flags;
|
|
|
|
[DisplayName("Reporting Method") : amended,
|
|
WmiDataId(3),
|
|
Description("The Method of Reporting Informational Exceptions (MRIE) indicates the methods that shall be used by the target to report information exception conditions.") : amended,
|
|
ValueMap{"0", "1", "2", "3", "4", "5", "6"},
|
|
Values{"No Reporting", "Asynchronous Event Reporting", "Generate Unit Attention", "Conditionally Generate Recovered Error", "Unconditionally Generate Recovered Error", "Generate No Sense", "Report On Request"} : amended,
|
|
read, write]
|
|
uint8 MRIE;
|
|
|
|
[
|
|
WmiDataId(4),
|
|
Description("Buffer padding to 32 bits, do not use") : amended,
|
|
read]
|
|
uint8 Padding;
|
|
|
|
[DisplayName("Interval Timer") : amended,
|
|
WmiDataId(5),
|
|
Description("Period in 100ms increments for reproting that an information exception condition has occurred.") : amended,
|
|
read, write]
|
|
uint32 IntervalTimer;
|
|
|
|
[DisplayName("Report Count") : amended,
|
|
WmiDataId(6),
|
|
Description("Indicates the number of times to report an informational exception condition to the application client. A value of zero indications there is no limit.") : amended,
|
|
read, write]
|
|
uint32 ReportCount;
|
|
};
|
|
|
|
|
|
[abstract]
|
|
class MSIde
|
|
{
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"), WMI,
|
|
Description("Scsi Address") : amended,
|
|
guid("{53f5630f-b6bf-11d0-94f2-00a0c91efb8b}"),
|
|
DisplayName("Ide Port Information") : amended
|
|
]
|
|
class MSIde_PortDeviceInfo : MSIde
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Bus") : amended,
|
|
WmiDataId(1),
|
|
Description("Scsi Bus Number") : amended,
|
|
read]
|
|
uint8 Bus;
|
|
|
|
[DisplayName("Target") : amended,
|
|
WmiDataId(2),
|
|
Description("Scsi Target ID") : amended,
|
|
read]
|
|
uint8 Target;
|
|
|
|
[DisplayName("Lun") : amended,
|
|
WmiDataId(3),
|
|
Description("Scsi Lun") : amended,
|
|
read]
|
|
uint8 Lun;
|
|
};
|
|
|
|
|
|
|
|
// Serial
|
|
[abstract]
|
|
class MSSerial
|
|
{
|
|
};
|
|
|
|
|
|
[WMI, Dynamic, Provider ("WMIProv"),
|
|
guid("{A0EC11A8-B16C-11D1-BD98-00A0C906BE2D}"),
|
|
GuidName1("SERIAL_PORT_WMI_NAME_GUID"),
|
|
Description("Serial Port Name" ) : amended,
|
|
DisplayName("Serial Port Name") : amended
|
|
]
|
|
class MSSerial_PortName : MSSerial
|
|
{
|
|
boolean Active;
|
|
[key]
|
|
string InstanceName;
|
|
|
|
[DisplayName("Port Name") : amended,
|
|
WmiDataId(1),
|
|
Description("Serial Port Name") : amended,
|
|
read]
|
|
string PortName;
|
|
};
|
|
|
|
|
|
[WMI, Dynamic, Provider ("WMIProv"),
|
|
guid("{EDB16A62-B16C-11D1-BD98-00A0C906BE2D}"),
|
|
GuidName1("SERIAL_PORT_WMI_COMM_GUID"),
|
|
HeaderName("SERIAL_WMI_COMM_DATA"),
|
|
Description("Serial Communications Information") : amended,
|
|
DisplayName("Serial Comm Information") : amended
|
|
]
|
|
class MSSerial_CommInfo : MSSerial
|
|
{
|
|
boolean Active;
|
|
[key]
|
|
string InstanceName;
|
|
|
|
[DisplayName("Baud Rate") : amended,
|
|
WmiDataId(1),
|
|
Description("The BaudRate property indicates the baud rate for this serial port") : amended,
|
|
read]
|
|
uint32 BaudRate;
|
|
|
|
[WmiDataId(2),
|
|
DisplayName("Bits Per Byte") : amended,
|
|
Description("The BitsPerByte property indicates the number of bits per byte for the serial port") : amended,
|
|
read]
|
|
uint32 BitsPerByte;
|
|
|
|
[DisplayName("Parity") : amended,
|
|
WmiDataId(3),
|
|
read,
|
|
Description("The Parity property indicates the type of parity used") : amended,
|
|
Values{"None",
|
|
"Odd",
|
|
"Even",
|
|
"Space",
|
|
"Mark"} : amended,
|
|
ValueMap{"0",
|
|
"1",
|
|
"2",
|
|
"3",
|
|
"4"},
|
|
DefineValues{"SERIAL_WMI_PARITY_NONE",
|
|
"SERIAL_WMI_PARITY_ODD",
|
|
"SERIAL_WMI_PARITY_EVEN",
|
|
"SERIAL_WMI_PARITY_SPACE",
|
|
"SERIAL_WMI_PARITY_MARK"}
|
|
]
|
|
uint32 Parity;
|
|
|
|
[DisplayName("Parity Check Enable") : amended,
|
|
WmiDataId(4),
|
|
Description("The ParityCheckEnabled property determines whether parity checking is enabled") : amended,
|
|
read]
|
|
boolean ParityCheckEnable;
|
|
|
|
[DisplayName("Stop Bits") : amended,
|
|
WmiDataId(5),
|
|
read,
|
|
Description("The StopBits property indicates the number of stop bits for the serial port") : amended,
|
|
Values{"1",
|
|
"1.5",
|
|
"2"} : amended,
|
|
ValueMap{"0",
|
|
"1",
|
|
"2"},
|
|
DefineValues{"SERIAL_WMI_STOP_1",
|
|
"SERIAL_WMI_STOP_1_5",
|
|
"SERIAL_WMI_STOP_2"}]
|
|
uint32 StopBits;
|
|
|
|
[DisplayName("Xoff Character") : amended,
|
|
WmiDataId(6),
|
|
Description("The XOffCharacter property indicates the XOff character for the serial port") : amended,
|
|
read]
|
|
uint32 XoffCharacter;
|
|
|
|
[DisplayName("Xoff Xmit Threshold") : amended,
|
|
WmiDataId(7),
|
|
Description("The XOffXmitThreshold property indicates the XOff transmit threshold for the serial port") : amended,
|
|
read]
|
|
uint32 XoffXmitThreshold;
|
|
|
|
[DisplayName("Xon Character") : amended,
|
|
WmiDataId(8),
|
|
Description("The XOnCharacter property indicates the XOn character") : amended,
|
|
read]
|
|
uint32 XonCharacter;
|
|
|
|
[DisplayName("Xon Xmit Threshold") : amended,
|
|
WmiDataId(9),
|
|
Description("The XOnXMitThreshold property indicates the XOn transmit threshold") : amended,
|
|
read]
|
|
uint32 XonXmitThreshold;
|
|
|
|
[DisplayName("Maximum Baud Rate") : amended,
|
|
WmiDataId(10),
|
|
Description("The MaximumBaudRate property indicates the maximum baud rate of the serial port") : amended,
|
|
read]
|
|
uint32 MaximumBaudRate;
|
|
|
|
[DisplayName("Maximum Output Buffer Size") : amended,
|
|
WmiDataId(11),
|
|
Description("The MaximumOutputBufferSize property indicates the maximum output buffer size (in bytes)") : amended,
|
|
read]
|
|
uint32 MaximumOutputBufferSize;
|
|
|
|
[DisplayName("Maximum Input Buffer Size") : amended,
|
|
WmiDataId(12),
|
|
Description("The MaximumInputBufferSize property indicates the maximum input buffer size (in bytes)") : amended,
|
|
read]
|
|
uint32 MaximumInputBufferSize;
|
|
|
|
[DisplayName("Support 16Bit Mode") : amended,
|
|
WmiDataId(13),
|
|
Description("The Support16BitMode property determines whether 16-bit mode is supported on the Win32 serial port") : amended,
|
|
read]
|
|
boolean Support16BitMode;
|
|
|
|
[DisplayName("Support DTRDSR") : amended,
|
|
WmiDataId(14),
|
|
Description("The SupportDTRDSR property determines whether Data Terminal Ready (DTR) and Data Set Ready (DSR) signals are supported on the Win32 serial port.") : amended,
|
|
read]
|
|
boolean SupportDTRDSR;
|
|
|
|
[DisplayName("Support Interval Timeouts") : amended,
|
|
WmiDataId(15),
|
|
Description("The SupportIntervalTimeouts property determines whether interval timeouts are supported on the serial port") : amended,
|
|
read]
|
|
boolean SupportIntervalTimeouts;
|
|
|
|
[DisplayName("Support Parity Check") : amended,
|
|
WmiDataId(16),
|
|
Description("The SupportParityCheck property determines whether parity checking is supported on the Win32 serial port") : amended,
|
|
read]
|
|
boolean SupportParityCheck;
|
|
|
|
[DisplayName("Support RTSCTS") : amended,
|
|
WmiDataId(17),
|
|
Description("The SupportRTSCTS property determines whether Ready To Send (RTS) and Clear To Send (CTS) signals are supported on the serial port") : amended,
|
|
read]
|
|
boolean SupportRTSCTS;
|
|
|
|
[DisplayName("Support Xon Xoff") : amended,
|
|
WmiDataId(18),
|
|
Description("The SupportXOnXOff property determines whether software flow control is supported on the serial port") : amended,
|
|
read]
|
|
boolean SupportXonXoff;
|
|
|
|
[DisplayName("Settable Baud Rate") : amended,
|
|
WmiDataId(19),
|
|
Description("The SettableBaudRate property determines whether the baud rate can be set on the serial port") : amended,
|
|
read]
|
|
boolean SettableBaudRate;
|
|
|
|
[DisplayName("Settable Data Bits") : amended,
|
|
WmiDataId(20),
|
|
Description("The SettableDataBits property determines whether the number of data bits can be set on the Win32 serial port") : amended,
|
|
read]
|
|
boolean SettableDataBits;
|
|
|
|
[DisplayName("Settable Flow Control") : amended,
|
|
WmiDataId(21),
|
|
Description("The SettableFlowControl property determines whether the flow control can be set on the serial port") : amended,
|
|
read]
|
|
boolean SettableFlowControl;
|
|
|
|
[DisplayName("Settable Parity") : amended,
|
|
WmiDataId(22),
|
|
Description("The SettableParity property determines whether the parity can be set on the serial port") : amended,
|
|
read]
|
|
boolean SettableParity;
|
|
|
|
[DisplayName("Settable Parity Check") : amended,
|
|
WmiDataId(23),
|
|
Description("The SettableParityCheck property determines whether parity checking can be set on the serial port") : amended,
|
|
read]
|
|
boolean SettableParityCheck;
|
|
|
|
[DisplayName("Settable Stop Bits") : amended,
|
|
WmiDataId(24),
|
|
Description("The SettableStopBits property determines whether the number of stop bits can be set on the serial port") : amended,
|
|
read]
|
|
boolean SettableStopBits;
|
|
|
|
[DisplayName("Is Busy") : amended,
|
|
WmiDataId(25),
|
|
Description("The IsBusy property determines whether the serial port is busy") : amended,
|
|
read]
|
|
boolean IsBusy;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider ("WMIProv"),
|
|
guid("{270B9B86-B16D-11D1-BD98-00A0C906BE2D}"),
|
|
GuidName1("SERIAL_PORT_WMI_HW_GUID"),
|
|
HeaderName("SERIAL_WMI_HW_DATA"),
|
|
Description("Hardware configuration for serial port") : amended,
|
|
DisplayName("Serial Hardware Configuration") : amended
|
|
]
|
|
class MSSerial_HardwareConfiguration : MSSerial
|
|
{
|
|
boolean Active;
|
|
[key]
|
|
string InstanceName;
|
|
|
|
[DisplayName("Irq Number") : amended,
|
|
WmiDataId(1),
|
|
Description("The IRQNumber property indicates the number of the IRQ resource") : amended,
|
|
read]
|
|
uint32 IrqNumber;
|
|
|
|
[DisplayName("Irq Vector") : amended,
|
|
WmiDataId(2),
|
|
Description("The Vector property indicates the vector of the IRQ resource") : amended,
|
|
read]
|
|
uint32 IrqVector;
|
|
|
|
[DisplayName("Irq Level") : amended,
|
|
WmiDataId(3),
|
|
Description("The IRQLevel property indicates the level of the IRQ resource") : amended,
|
|
read]
|
|
uint32 IrqLevel;
|
|
|
|
[DisplayName("Irq Affinity Mask") : amended,
|
|
WmiDataId(4),
|
|
Description("The AffinityMask property indicates the affinity mask of the IRQ resource") : amended,
|
|
read]
|
|
uint64 IrqAffinityMask;
|
|
|
|
[DisplayName("Interrupt Type") : amended,
|
|
WmiDataId(5),
|
|
Description("The InterruptType property indicates the interrupt type of the IRQ resource") : amended,
|
|
Values{"Latched",
|
|
"Level"} : amended,
|
|
ValueMap{"0",
|
|
"1"},
|
|
DefineValues{"SERIAL_WMI_INTTYPE_LATCHED",
|
|
"SERIAL_WMI_INTTYPE_LEVEL"},
|
|
read]
|
|
uint32 InterruptType;
|
|
|
|
[DisplayName("Base IO Address") : amended,
|
|
WmiDataId(6),
|
|
Description("The BaseIOAddress is the base IO address for the serial port") : amended,
|
|
read]
|
|
uint64 BaseIOAddress;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider ("WMIProv"),
|
|
guid("{56415ACC-B16D-11D1-BD98-00A0C906BE2D}"),
|
|
GuidName1("SERIAL_PORT_WMI_PERF_GUID"),
|
|
HeaderName("SERIAL_WMI_PERF_DATA"),
|
|
Description("Performance information for serial port") : amended,
|
|
DisplayName("Serial Performance Data") : amended
|
|
]
|
|
class MSSerial_PerformanceInformation : MSSerial
|
|
{
|
|
boolean Active;
|
|
[key]
|
|
string InstanceName;
|
|
|
|
[DisplayName("Received Count") : amended,
|
|
WmiDataId(1),
|
|
Description("The ReceivedCount property indicates the number of bytes received in the current session") : amended,
|
|
read]
|
|
uint32 ReceivedCount;
|
|
|
|
[DisplayName("Transmitted Count") : amended,
|
|
WmiDataId(2),
|
|
Description("The TransmittedCount property indicates the number of bytes transmitted in the current session") : amended,
|
|
read]
|
|
uint32 TransmittedCount;
|
|
|
|
[DisplayName("Frame Error Count") : amended,
|
|
WmiDataId(3),
|
|
Description("The FrameErrorCount property indicates the number of framing errors that occurred in the current session") : amended,
|
|
read]
|
|
uint32 FrameErrorCount;
|
|
|
|
[DisplayName("Serial Overrun Error Count") : amended,
|
|
WmiDataId(4),
|
|
Description("The SerialOverrunCount property indicates the number of serial overrun errors that occurred in the current session") : amended,
|
|
read]
|
|
uint32 SerialOverrunErrorCount;
|
|
|
|
[DisplayName("Buffer Overrun Error Count") : amended,
|
|
WmiDataId(5),
|
|
Description("The BufferOverrunCount property indicates the number of buffer overrun errors that occurred in the current session") : amended,
|
|
read]
|
|
uint32 BufferOverrunErrorCount;
|
|
|
|
[DisplayName("Parity Error Count") : amended,
|
|
WmiDataId(6),
|
|
Description("The ParityErrorCount property indicates the number of parity errors that occurred in the current session") : amended,
|
|
read]
|
|
uint32 ParityErrorCount;
|
|
};
|
|
|
|
[WMI, Dynamic, Provider ("WMIProv"),
|
|
guid("{8209EC2A-2D6B-11d2-BA49-00A0C9062910}"),
|
|
GuidName1("SERIAL_PORT_WMI_PROPERTIES_GUID"),
|
|
HeaderName("SERIAL_WMI_COMMPROP"),
|
|
Description("Communication properties for serial port") : amended
|
|
]
|
|
class MSSerial_CommProperties : MSSerial
|
|
{
|
|
boolean Active;
|
|
[key]
|
|
string InstanceName;
|
|
|
|
[
|
|
read, WmiDataId(1),
|
|
Description("Specifies the size, in bytes, of the entire data packet, regardless of the amount of data requested") : amended]
|
|
uint16 wPacketLength; // packet size, in bytes
|
|
|
|
[
|
|
read, WmiDataId(2),
|
|
Description("Specifies the version of the structure") : amended]
|
|
uint16 wPacketVersion; // packet version
|
|
|
|
[read, WmiDataId(3),
|
|
BitValues{"SP_SERIALCOMM"} : amended,
|
|
BitMap{"0"},
|
|
Description("Specifies a bitmask indicating which services are implemented by this provider. The SP_SERIALCOMM value is always specified for communications providers, including modem providers.") : amended]
|
|
uint32 dwServiceMask; // services implemented
|
|
|
|
[read, WmiDataId(4),
|
|
Description("Reserved; do not use.") : amended]
|
|
uint32 dwReserved1; // reserved
|
|
|
|
[read, WmiDataId(5),
|
|
Description("Specifies the maximum size, in bytes, of the driver's internal output buffer. A value of zero indicates that no maximum value is imposed by the serial provider") : amended]
|
|
uint32 dwMaxTxQueue; // max Tx bufsize, in bytes
|
|
|
|
[read, WmiDataId(6),
|
|
Description("Specifies the maximum size, in bytes, of the driver's internal input buffer. A value of zero indicates that no maximum value is imposed by the serial provider") : amended]
|
|
uint32 dwMaxRxQueue; // max Rx bufsize, in bytes
|
|
|
|
[read, WmiDataId(7),
|
|
BitValues{"BAUD_075", "BAUD_110", "BAUD_134_5", "BAUD_150", "BAUD_300",
|
|
"BAUD_600", "BAUD_1200", "BAUD_1800", "BAUD_2400", "BAUD_4800",
|
|
"BAUD_7200", "BAUD_9600", "BAUD_14400", "BAUD_19200", "BAUD_38400",
|
|
"BAUD_56K", "BAUD_128K", "BAUD_115200", "BAUD_57600", "BAUD_USER"} : amended,
|
|
|
|
BitMap{"0", "1", "2", "3", "4",
|
|
"5", "6", "7", "8", "9",
|
|
"10", "11", "12", "13", "14",
|
|
"15", "16", "17", "18", "28" },
|
|
Description("Specifies the maximum allowable baud rate, in bits per second (bps). This member can be one of the following values: Value Meaning") : amended]
|
|
uint32 dwMaxBaud; // max baud rate, in bps
|
|
|
|
[read, WmiDataId(8),
|
|
ValueMap{"0x00000000", "0x00000001", "0x00000002",
|
|
"0x00000003", "0x00000004", "0x00000005", "0x00000006",
|
|
"0x00000021", "0x00000022", "0x00000100",
|
|
"0x00000101", "0x00000102", "0x00000103"},
|
|
|
|
Values{ "Unspecified", "RS-232 serial port", "Parallel port",
|
|
"RS-422 port", "RS-423 port","RS-449 port", "Modem device",
|
|
"FAX device", "Scanner device", "Unspecified network bridge",
|
|
"LAT protocol", "TCP/IP Telnet protocol", "X.25 standards"} : amended,
|
|
|
|
Description("Specifies the specific communications provider type") : amended]
|
|
uint32 dwProvSubType; // specific provider type
|
|
|
|
[read, WmiDataId(9),
|
|
BitValues{ "(data-terminal-ready)/DSR (data-set-ready) supported",
|
|
"(request-to-send)/CTS (clear-to-send) supported",
|
|
"(receive-line-signal-detect) supported",
|
|
"Parity checking supported",
|
|
"XON/XOFF flow control supported",
|
|
"Settable XON/XOFF supported",
|
|
"Total (elapsed) time-outs supported",
|
|
"Interval time-outs supported",
|
|
"Special character support provided",
|
|
"Special 16-bit mode supported"} : amended,
|
|
BitMap{"0", "1", "2", "3", "4",
|
|
"5", "6", "7", "8", "9"},
|
|
Description("Specifies a bitmask indicating the capabilities offered by the provider. This member can be one of the following values") : amended]
|
|
uint32 dwProvCapabilities; // capabilities supported
|
|
|
|
[read, WmiDataId(10),
|
|
BitValues{"Parity checking",
|
|
"Baud rate",
|
|
"Data bits",
|
|
"Stop bits",
|
|
"Handshaking (flow control)",
|
|
"Parity checking",
|
|
"(receive-line-signal-detect)"} : amended,
|
|
BitMap{"0", "1", "2", "3", "4",
|
|
"5", "6"},
|
|
Description("Specifies a bitmask indicating the communications parameter that can be changed") : amended]
|
|
uint32 dwSettableParams; // changable parameters
|
|
|
|
[read, WmiDataId(11),
|
|
BitValues{"BAUD_075", "BAUD_110", "BAUD_134_5", "BAUD_150", "BAUD_300",
|
|
"BAUD_600", "BAUD_1200", "BAUD_1800", "BAUD_2400", "BAUD_4800",
|
|
"BAUD_7200", "BAUD_9600", "BAUD_14400", "BAUD_19200", "BAUD_38400",
|
|
"BAUD_56K", "BAUD_128K", "BAUD_115200", "BAUD_57600", "BAUD_USER"} : amended,
|
|
|
|
BitMap{"0", "1", "2", "3", "4",
|
|
"5", "6", "7", "8", "9",
|
|
"10", "11", "12", "13", "14",
|
|
"15", "16", "17", "18", "28" },
|
|
Description("Specifies a bitmask indicating the baud rates that can be used") : amended]
|
|
uint32 dwSettableBaud; // allowable baud rates
|
|
|
|
[read, WmiDataId(12),
|
|
BitValues{"5 data bits",
|
|
"6 data bits",
|
|
"7 data bits",
|
|
"8 data bits",
|
|
"16 data bits",
|
|
"Special wide path through serial hardware lines"} : amended,
|
|
|
|
BitMap{"0", "1", "2", "3", "4", "5"},
|
|
Description("Specifies a bitmask indicating the number of data bits that can be set") : amended]
|
|
uint16 wSettableData; // allowable byte sizes
|
|
|
|
[read, WmiDataId(13),
|
|
BitValues{"1 stop bit",
|
|
"1.5 stop bits",
|
|
"2 stop bits",
|
|
"No parity",
|
|
"Odd parity",
|
|
"Even parity",
|
|
"Mark parity",
|
|
"Space parity"} : amended,
|
|
|
|
BitMap{"0", "1", "2", "8", "9", "10", "11", "12"},
|
|
Description("Specifies a bitmask indicating the stop bit and parity settings that can be selected.") : amended]
|
|
uint16 wSettableStopParity; // stop bits/parity allowed
|
|
|
|
[read, WmiDataId(14),
|
|
Description("Specifies the size, in bytes, of the driver's internal output buffer. A value of zero indicates that the value is unavailable.") : amended]
|
|
uint32 dwCurrentTxQueue; // Tx buffer size, in bytes
|
|
|
|
[read, WmiDataId(15),
|
|
Description("Specifies the size, in bytes, of the driver's internal input buffer. A value of zero indicates that the value is unavailable.") : amended]
|
|
uint32 dwCurrentRxQueue; // Rx buffer size, in bytes
|
|
|
|
[read, WmiDataId(16),
|
|
Description("Specifies provider-specific data.") : amended]
|
|
uint32 dwProvSpec1; // provider-specific data
|
|
|
|
[read, WmiDataId(17),
|
|
Description("Specifies provider-specific data.") : amended]
|
|
uint32 dwProvSpec2; // provider-specific data
|
|
|
|
[
|
|
read, WmiDataId(18),
|
|
Description("Number of bytes of provider specific data") : amended]
|
|
uint32 dwProvCharSize;
|
|
|
|
[
|
|
read, WmiDataId(19),
|
|
WmiSizeIs("dwProvCharSize"),
|
|
Description("Specifies provider-specific data. Applications should ignore this member unless they have detailed information about the format of the data required by the provider.") : amended]
|
|
uint8 wcProvChar[]; // provider-specific data
|
|
|
|
|
|
};
|
|
|
|
[abstract]
|
|
class MSParallel
|
|
{
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"), WMI,
|
|
Description("The allocate and free counts track the port sharing of the parallel port. If the allocate count equals the free count then the port is idle. If the allocate count is greater than the free count (free count + 1) then some other driver in the system has acquired exclusive access to that port. If the allocate count stays constant at freecount+1 for an arbitrarily long period of time, then some driver may have illegally locked the port preventing other drivers from accessing the port.") : amended
|
|
,
|
|
guid("{4BBB69EA-6853-11d2-8ECE-00C04F8EF481}"),
|
|
HeaderName("PARPORT_WMI_ALLOC_FREE_COUNTS"),
|
|
GuidName1("PARPORT_WMI_ALLOCATE_FREE_COUNTS_GUID"),
|
|
DisplayName("Parallel Port Alloc Free Counts") : amended
|
|
]
|
|
class MSParallel_AllocFreeCounts : MSParallel
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Port Allocates") : amended,
|
|
WmiDataId(1),
|
|
Description("Port allocation count") : amended,
|
|
read]
|
|
uint32 PortAllocates;
|
|
|
|
[DisplayName("Port Frees") : amended,
|
|
WmiDataId(2),
|
|
Description("Port free count") : amended,
|
|
read]
|
|
uint32 PortFrees;
|
|
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"), WMI,
|
|
Description("Bytes transferred for each mode for the device") : amended,
|
|
guid("{89FEF2D6-654B-11d2-9E15-00C04F8EF481}"),
|
|
GuidName1("PARALLEL_WMI_BYTES_TRANSFERRED_GUID"),
|
|
HeaderName("PARALLEL_WMI_LOG_INFO"),
|
|
DisplayName("Parallel Device Bytes Transferred") : amended
|
|
]
|
|
class MSParallel_DeviceBytesTransferred : MSParallel
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Flags 1") : amended,
|
|
WmiDataId(1),
|
|
Description("Reserved") : amended,
|
|
read]
|
|
uint32 Flags1;
|
|
|
|
[DisplayName("Flags 2") : amended,
|
|
WmiDataId(2),
|
|
Description("Reserved") : amended,
|
|
read]
|
|
uint32 Flags2;
|
|
|
|
[DisplayName("spare") : amended,
|
|
WmiDataId(3),
|
|
Description("Reserved") : amended,
|
|
read]
|
|
uint32 spare[2];
|
|
|
|
[DisplayName("Spp Write Count") : amended,
|
|
WmiDataId(4),
|
|
Description("Bytes writtem using SPP mode") : amended,
|
|
read]
|
|
sint64 SppWriteCount;
|
|
|
|
[DisplayName("Nibble Read Count") : amended,
|
|
WmiDataId(5),
|
|
Description("Bytes writtem using nibble mode") : amended,
|
|
read]
|
|
sint64 NibbleReadCount;
|
|
|
|
[DisplayName("Bounded Ecp Write Count") : amended,
|
|
WmiDataId(6),
|
|
Description("Bytes writtem using bounded Ecp mode") : amended,
|
|
read]
|
|
sint64 BoundedEcpWriteCount;
|
|
[DisplayName("BoundedEcpReadCount") : amended,
|
|
WmiDataId(7),
|
|
Description("Bytes read using bounded Ecp mode") : amended,
|
|
read]
|
|
sint64 BoundedEcpReadCount;
|
|
|
|
[DisplayName("Hw Ecp Write Count") : amended,
|
|
WmiDataId(8),
|
|
Description("Bytes writtem using hardware Ecp mode") : amended,
|
|
read]
|
|
sint64 HwEcpWriteCount;
|
|
[DisplayName("Hw Ecp Read Count") : amended,
|
|
WmiDataId(9),
|
|
Description("Bytes read using hardware Ecp mode") : amended,
|
|
read]
|
|
sint64 HwEcpReadCount;
|
|
|
|
[DisplayName("Sw Ecp Write Count") : amended,
|
|
WmiDataId(10),
|
|
Description("Bytes writtem using software Ecp mode") : amended,
|
|
read]
|
|
sint64 SwEcpWriteCount;
|
|
[DisplayName("Sw Ecp Read Count") : amended,
|
|
WmiDataId(11),
|
|
Description("Bytes read using software Ecp mode") : amended,
|
|
read]
|
|
sint64 SwEcpReadCount;
|
|
|
|
[DisplayName("Hw Epp Write Count") : amended,
|
|
WmiDataId(12),
|
|
Description("Bytes writtem using hardware Epp mode") : amended,
|
|
read]
|
|
sint64 HwEppWriteCount;
|
|
[DisplayName("Hw Epp Read Count") : amended,
|
|
WmiDataId(13),
|
|
Description("Bytes read using hardware Epp mode") : amended,
|
|
read]
|
|
sint64 HwEppReadCount;
|
|
|
|
[DisplayName("Sw Epp Write Count") : amended,
|
|
WmiDataId(14),
|
|
Description("Bytes writtem using software Epp mode") : amended,
|
|
read]
|
|
sint64 SwEppWriteCount;
|
|
[DisplayName("Sw Epp Read Count") : amended,
|
|
WmiDataId(15),
|
|
Description("Bytes read using software Epp mode") : amended,
|
|
read]
|
|
sint64 SwEppReadCount;
|
|
|
|
[DisplayName("Byte Read Count") : amended,
|
|
WmiDataId(16),
|
|
Description("Bytes read using byte (bidirectional / PS/2) mode") : amended,
|
|
read]
|
|
sint64 ByteReadCount;
|
|
[DisplayName("Channel Nibble Read Count") : amended,
|
|
WmiDataId(17),
|
|
Description("Bytes read using channelized Nibble mode (IEEE 1284.3)") : amended,
|
|
read]
|
|
sint64 ChannelNibbleReadCount;
|
|
|
|
};
|
|
|
|
|
|
[abstract]
|
|
class MSRedbook
|
|
{
|
|
};
|
|
|
|
|
|
[Dynamic,
|
|
Provider("WMIProv"),
|
|
WMI,
|
|
Description("Digital Audio Filter Driver Information (redbook)") : amended,
|
|
GuidName1("GUID_REDBOOK_WMI_STD_DATA"),
|
|
GuidName2("MSRedbook_DriverInformationGuid"),
|
|
HeaderName("REDBOOK_WMI_STD_DATA"),
|
|
guid("{b90550e7-ae0a-11d1-a571-00c04fa34730}"),
|
|
DisplayName("Redbook Driver Information") : amended
|
|
]
|
|
|
|
class MSRedbook_DriverInformation
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
DefineDataId("REDBOOK_WMI_NUMBER_OF_BUFFERS"),
|
|
read,
|
|
write,
|
|
Description("NumberOfBuffers*SectorsPerRead*2352 is the amount of memory used to reduce skipping." ) : amended,
|
|
DisplayName("Number Of Buffers") : amended
|
|
]
|
|
uint32 NumberOfBuffers;
|
|
|
|
[WmiDataId(2),
|
|
DefineDataId("REDBOOK_WMI_SECTORS_PER_READ"),
|
|
read,
|
|
write,
|
|
Description("Sectors (2352 bytes each) per read.") : amended,
|
|
DisplayName("Sectors Per Read") : amended
|
|
]
|
|
uint32 SectorsPerRead;
|
|
|
|
[WmiDataId(3),
|
|
DefineDataId("REDBOOK_WMI_SECTORS_PER_READ_MASK"),
|
|
read,
|
|
write,
|
|
Description("Bitwise mask of supported sectors per read for this drive. The lowest bit is one sector reads. If all bits are set, there are no restrictions.") : amended,
|
|
DisplayName("Sectors Per Read Mask") : amended
|
|
]
|
|
uint32 SectorsPerReadMask;
|
|
|
|
[WmiDataId(4),
|
|
DefineDataId("REDBOOK_WMI_MAX_SECTORS_PER_READ"),
|
|
read,
|
|
write,
|
|
Description("Maximum sectors per read (depends on both adapter and drive).") : amended,
|
|
DisplayName("Maximum Sectors Per Read") : amended
|
|
]
|
|
uint32 MaximumSectorsPerRead;
|
|
|
|
[WmiDataId(5),
|
|
DefineDataId("REDBOOK_WMI_PLAY_ENABLED"),
|
|
read,
|
|
write,
|
|
Description("PlayEnabled indicates the drive is currently using the RedBook filter.") : amended,
|
|
DisplayName("Play Enabled") : amended
|
|
]
|
|
boolean PlayEnabled;
|
|
|
|
[WmiDataId(6),
|
|
DefineDataId("REDBOOK_WMI_CDDA_SUPPORTED"),
|
|
read,
|
|
write,
|
|
Description("CDDASupported indicates the drive supports digital audio for some sector sizes.") : amended,
|
|
DisplayName("CDDA Supported") : amended
|
|
]
|
|
boolean CDDASupported;
|
|
|
|
[WmiDataId(7),
|
|
DefineDataId("REDBOOK_WMI_CDDA_ACCURATE"),
|
|
read,
|
|
write,
|
|
Description("CDDAAccurate indicates the drive acccurately reads digital audio. This ensures the highest quality audio") : amended,
|
|
DisplayName("CDDA Accurate") : amended
|
|
]
|
|
boolean CDDAAccurate;
|
|
|
|
[WmiDataId(8),
|
|
read,
|
|
Description("Reserved for future use") : amended,
|
|
DisplayName("Reserved 1") : amended
|
|
]
|
|
boolean Reserved1;
|
|
|
|
};
|
|
|
|
|
|
[Dynamic,
|
|
Provider("WMIProv"),
|
|
WMI,
|
|
Description("Digital Audio Filter Driver Performance Data (redbook)") : amended,
|
|
GuidName1("GUID_REDBOOK_WMI_PERF_DATA"),
|
|
GuidName2("MSRedbook_PerformanceGuid"),
|
|
HeaderName("REDBOOK_WMI_PERF_DATA"),
|
|
guid("{b90550e8-ae0a-11d1-a571-00c04fa34730}"),
|
|
DisplayName("Redbook Performance Information") : amended
|
|
]
|
|
|
|
class MSRedbook_Performance
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[WmiDataId(1),
|
|
DefineDataId("REDBOOK_WMI_PERF_TIME_READING_DELAY"),
|
|
read,
|
|
Description("Seconds spent ready to read, but unused. (*1E-7)" ) : amended,
|
|
DisplayName("Time Read Delay") : amended
|
|
]
|
|
sint64 TimeReadDelay;
|
|
|
|
[WmiDataId(2),
|
|
DefineDataId("REDBOOK_WMI_PERF_TIME_READING"),
|
|
read,
|
|
Description("Seconds spent reading data from source. (*1E-7)") : amended,
|
|
DisplayName("Time Reading") : amended
|
|
]
|
|
sint64 TimeReading;
|
|
|
|
[WmiDataId(3),
|
|
DefineDataId("REDBOOK_WMI_PERF_TIME_STREAMING_DELAY"),
|
|
read,
|
|
Description("Seconds spent ready to stream, but unused. (*1E-7)") : amended,
|
|
DisplayName("Time Stream Delay") : amended
|
|
]
|
|
sint64 TimeStreamDelay;
|
|
|
|
[WmiDataId(4),
|
|
DefineDataId("REDBOOK_WMI_PERF_TIME_STREAMING"),
|
|
read,
|
|
Description("Seconds spent streaming data. (*1E-7)") : amended,
|
|
DisplayName("Time Streaming") : amended
|
|
]
|
|
sint64 TimeStreaming;
|
|
|
|
[WmiDataId(5),
|
|
DefineDataId("REDBOOK_WMI_PERF_DATA_PROCESSED"),
|
|
read,
|
|
Description("Number of bytes of data read and streamed.") : amended,
|
|
DisplayName("Data Processed") : amended
|
|
]
|
|
sint64 DataProcessed;
|
|
|
|
[WmiDataId(6),
|
|
DefineDataId("REDBOOK_WMI_PERF_STREAM_PAUSED_COUNT"),
|
|
read,
|
|
Description("Number of times the stream has paused due to insufficient stream buffers.") : amended,
|
|
DisplayName("Stream Paused Count") : amended
|
|
]
|
|
uint32 StreamPausedCount;
|
|
|
|
};
|
|
|
|
|
|
[WMI, Dynamic, Provider("WMIProv"),
|
|
guid("{e3dff7bd-3915-11d2-9103-00c04fb998a2}"),
|
|
|
|
WmiExpense(1),
|
|
Description("Enumerates Guids registered with WMI. The InstanceName is the Guid.") : amended]
|
|
class RegisteredGuids
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
|
|
[read]
|
|
boolean Active;
|
|
|
|
[DisplayName("GuidType") : amended,
|
|
read,
|
|
Description("Type of guid") : amended,
|
|
ValueMap{0, 1, 2, 3},
|
|
Value{"Trace Control Guid", "Trace Guid", "Data Guid", "Event Guid"} : amended,
|
|
WmiDataId(1)] uint32 GuidType;
|
|
|
|
[DisplayName("LoggerId") : amended,
|
|
read,
|
|
Description("If Trace guid and enabled, indicates the LoggerId to which this Guid is currently logging data") : amended,
|
|
WmiDataId(2)] uint32 LoggerId;
|
|
|
|
[DisplayName("EnableLevel") : amended,
|
|
read,
|
|
Description("If trace guid and If enabled, indicates the level of logging") : amended,
|
|
WmiDataId(3)] uint32 EnableLevel;
|
|
|
|
[DisplayName("EnableFlags") : amended,
|
|
read,
|
|
Description("If trace guid and enabled, indicates the flags currently used in logging") : amended,
|
|
WmiDataId(4)] uint32 EnableFlags;
|
|
|
|
[DisplayName("IsEnabled") : amended,
|
|
read,
|
|
Description("Indicates whether this Guid is enabled currently. For data guids this means if collection is enabled, For event guids this means if events are enabled. For Trace control guids this means the trace logging is enabled.") : amended,
|
|
WmiDataId(5)] boolean IsEnabled;
|
|
|
|
};
|
|
|
|
|
|
//*************************************************************
|
|
//*** Creates namespace for TRACE under \root\wmi
|
|
//*** EventTrace - is the root for all Trace Guids
|
|
//*** All Provider Control Guids will derive from EventTrace
|
|
//*** All Trace Data Guids will derive from their ControlGuid
|
|
//*************************************************************
|
|
|
|
[abstract]
|
|
class EventTrace
|
|
{
|
|
[HeaderDataId(1),
|
|
Description("Trace Event Size") : amended,
|
|
read]
|
|
uint16 EventSize;
|
|
|
|
[HeaderDataId(2),
|
|
Description("Reserved") : amended,
|
|
read]
|
|
uint16 ReservedHeaderField;
|
|
|
|
[HeaderDataId(3),
|
|
Description("Event Type") : amended,
|
|
read]
|
|
uint8 EventType;
|
|
|
|
[HeaderDataId(4),
|
|
Description("Trace Level") : amended,
|
|
read]
|
|
uint8 TraceLevel;
|
|
|
|
[HeaderDataId(5),
|
|
Description("Trace Version") : amended,
|
|
read]
|
|
uint16 TraceVersion;
|
|
|
|
[HeaderDataId(6),
|
|
Description("Thread Id") : amended,
|
|
PointerType,
|
|
read]
|
|
uint64 ThreadId;
|
|
|
|
[HeaderDataId(7),
|
|
Description("TimeStamp") : amended,
|
|
read]
|
|
uint64 TimeStamp;
|
|
|
|
[HeaderDataId(8),
|
|
Description("Event Guid") : amended,
|
|
read]
|
|
uint8 EventGuid[16];
|
|
|
|
[HeaderDataId(9),
|
|
Description("Kernel Time") : amended,
|
|
read]
|
|
uint32 KernelTime;
|
|
|
|
[HeaderDataId(10),
|
|
Description("User Time") : amended,
|
|
read]
|
|
uint32 UserTime;
|
|
|
|
[HeaderDataId(11),
|
|
Description("Instance Id") : amended,
|
|
read]
|
|
uint32 InstanceId;
|
|
|
|
[HeaderDataId(12),
|
|
Description("Parent Guid") : amended,
|
|
read]
|
|
uint8 ParentGuid[16];
|
|
|
|
[HeaderDataId(13),
|
|
Description("Parent Instance Id") : amended,
|
|
read]
|
|
uint32 ParentInstanceId;
|
|
|
|
[HeaderDataId(14),
|
|
Description("Pointer to Mof Data") : amended,
|
|
PointerType,
|
|
read]
|
|
uint32 MofData;
|
|
|
|
[HeaderDataId(15),
|
|
Description("Length of Mof Data") : amended,
|
|
read]
|
|
uint32 MofLength;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Windows Kernel Trace"),
|
|
Guid("{9e814aad-3204-11d2-9a82-006008a86939}")
|
|
]
|
|
class MSNT_SystemTrace:EventTrace
|
|
{
|
|
[Description ("Enable Flags") : amended,
|
|
ValueDescriptions{
|
|
"Process creations/deletions",
|
|
"Thread creations/deletions",
|
|
"image description",
|
|
"Disk input/output",
|
|
"File details",
|
|
"Page faults",
|
|
"Hard page faults",
|
|
"Network TCP/IP",
|
|
"Registry details",
|
|
"Debug print" } : amended,
|
|
DefineValues{
|
|
"EVENT_TRACE_FLAG_PROCESS",
|
|
"EVENT_TRACE_FLAG_THREAD",
|
|
"EVENT_TRACE_FLAG_IMAGE_LOAD",
|
|
"EVENT_TRACE_FLAG_DISK_IO",
|
|
"EVENT_TRACE_FLAG_DISK_FILE_IO",
|
|
"EVENT_TRACE_FLAG_MEMORY_PAGE_FAULTS",
|
|
"EVENT_TRACE_FLAG_MEMORY_HARD_FAULTS",
|
|
"EVENT_TRACE_FLAG_NETWORK_TCPIP",
|
|
"EVENT_TRACE_FLAG_REGISTRY",
|
|
"EVENT_TRACE_FLAG_DBGPRINT" },
|
|
Values{
|
|
"process",
|
|
"thread",
|
|
"img",
|
|
"disk",
|
|
"file",
|
|
"pf",
|
|
"hf",
|
|
"net",
|
|
"registry",
|
|
"dbgprint" }: amended,
|
|
ValueMap{
|
|
"0x00000001",
|
|
"0x00000002",
|
|
"0x00000004",
|
|
"0x00000100",
|
|
"0x00000200",
|
|
"0x00001000",
|
|
"0x00002000",
|
|
"0x00010000",
|
|
"0x00020000",
|
|
"0x00040000" }
|
|
]
|
|
uint32 Flags;
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Event Trace Event") : amended,
|
|
Guid("{68fdd900-4a3e-11d1-84f4-0000f80464e3}"),
|
|
DisplayName("EventTrace") : amended
|
|
]
|
|
class EventTraceEvent:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Event Trace Event") : amended,
|
|
EventType(0),
|
|
EventTypeName("Header") :amended
|
|
]
|
|
class EventTrace_Header:EventTraceEvent
|
|
{
|
|
[WmiDataId(1),
|
|
Description("Buffer Size in Bytes") : amended,
|
|
read]
|
|
uint32 BufferSize;
|
|
[WmiDataId(2),
|
|
Description("Event Trace Version") : amended,
|
|
read]
|
|
uint32 Version;
|
|
[WmiDataId(3),
|
|
Description("Windows Build Number") : amended,
|
|
read]
|
|
uint32 ProviderVersion;
|
|
[WmiDataId(4),
|
|
Description("Number Of Processors") : amended,
|
|
read]
|
|
uint32 NumberOfProcessors;
|
|
[WmiDataId(5),
|
|
Description("Collection End Time") : amended,
|
|
read]
|
|
uint64 EndTime;
|
|
[WmiDataId(6),
|
|
Description("Timer Resolution") : amended,
|
|
read]
|
|
uint32 TimerResolution;
|
|
[WmiDataId(7),
|
|
Description("Maximum File Size in MBytes") : amended,
|
|
read]
|
|
uint32 MaxFileSize;
|
|
[WmiDataId(8),
|
|
Description("LogFileMode") : amended,
|
|
format("x"),
|
|
read]
|
|
uint32 LogFileMode;
|
|
[WmiDataId(9),
|
|
Description("Number of Buffers Written") : amended,
|
|
read]
|
|
uint32 BuffersWritten;
|
|
[WmiDataId(10),
|
|
Description("Buffer Number with earliest TimeStamp for a Cicular LogFile") : amended,
|
|
read]
|
|
uint32 StartBuffers;
|
|
[WmiDataId(11),
|
|
Description("Pointer Size in Bytes") : amended,
|
|
read]
|
|
uint32 PointerSize;
|
|
[WmiDataId(12),
|
|
Description("Number of Events Lost during collection") : amended,
|
|
read]
|
|
uint32 EventsLost;
|
|
[WmiDataId(13),
|
|
Description("CPU Speed in MHz") : amended,
|
|
read]
|
|
uint32 CPUSpeed;
|
|
[WmiDataId(14),
|
|
Description("Logger Name") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 LoggerName;
|
|
[WmiDataId(15),
|
|
Description("LogFile Name") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 LogFileName;
|
|
[WmiDataId(16),
|
|
Description("TimeZoneInformation") : amended,
|
|
extension("NoPrint"),
|
|
read]
|
|
uint8 TimeZoneInformation[176];
|
|
[WmiDataId(17),
|
|
Description("BootTime") : amended,
|
|
read]
|
|
uint64 BootTime;
|
|
[WmiDataId(18),
|
|
Description("Performance counter frequency in counts per second") : amended,
|
|
read]
|
|
uint64 PerfFreq;
|
|
[WmiDataId(19),
|
|
Description("StartTime") : amended,
|
|
read]
|
|
uint64 StartTime;
|
|
[WmiDataId(20),
|
|
Description("ReservedFlags") : amended,
|
|
read]
|
|
uint32 ReservedFlags;
|
|
[WmiDataId(21),
|
|
Description("Number of Buffers Lost during collection") : amended,
|
|
read]
|
|
uint32 BuffersLost;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Process Create/Exit Event") : amended,
|
|
Guid("{3d6fa8d0-fe05-11d0-9dda-00c04fd7ba7c}"),
|
|
EventVersion(0),
|
|
DisplayName("Process") : amended
|
|
]
|
|
class Process_V0:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Process Create/Exit Event") : amended,
|
|
EventType{1, 2, 3, 4},
|
|
EventTypeName{"Start", "End", "DCStart", "DCEnd"} : amended
|
|
]
|
|
class Process_V0_TypeGroup1:Process_V0
|
|
{
|
|
[WmiDataId(1),
|
|
Description("Process ID") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 ProcessId;
|
|
[WmiDataId(2),
|
|
Description("Parent Process ID") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 ParentId;
|
|
[WmiDataId(3),
|
|
Description("User SID") : amended,
|
|
extension("Sid"),
|
|
read]
|
|
object UserSID;
|
|
[WmiDataId(4),
|
|
Description("ImageFileName") : amended,
|
|
StringTermination("NullTerminated"),
|
|
read]
|
|
string ImageFileName;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Process Create/Exit Event") : amended,
|
|
Guid("{3d6fa8d0-fe05-11d0-9dda-00c04fd7ba7c}"),
|
|
EventVersion(1),
|
|
DisplayName("Process") : amended
|
|
]
|
|
class Process:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Process Create/Exit Event") : amended,
|
|
EventType{1, 2, 3, 4},
|
|
EventTypeName{"Start", "End", "DCStart", "DCEnd"} : amended
|
|
]
|
|
class Process_TypeGroup1:Process
|
|
{
|
|
[WmiDataId(1),
|
|
Description("PageDirectoryBase") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 PageDirectoryBase;
|
|
[WmiDataId(2),
|
|
Description("ProcessId") : amended,
|
|
read]
|
|
uint32 ProcessId;
|
|
[WmiDataId(3),
|
|
Description("ParentId") : amended,
|
|
read]
|
|
uint32 ParentId;
|
|
[WmiDataId(4),
|
|
Description("SessionId") : amended,
|
|
read]
|
|
uint32 SessionId;
|
|
[WmiDataId(5),
|
|
Description("ExitStatus") : amended,
|
|
read]
|
|
sint32 ExitStatus;
|
|
[WmiDataId(6),
|
|
Description("UserSID") : amended,
|
|
extension("Sid"),
|
|
read]
|
|
object UserSID;
|
|
[WmiDataId(7),
|
|
Description("ImageFileName") : amended,
|
|
StringTermination("NullTerminated"),
|
|
read]
|
|
string ImageFileName;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Thread Create/Exit Event") : amended,
|
|
Guid("{3d6fa8d1-fe05-11d0-9dda-00c04fd7ba7c}"),
|
|
EventVersion(0),
|
|
DisplayName("Thread") : amended
|
|
]
|
|
class Thread_V0:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Thread Create/Exit Event") : amended,
|
|
EventType{1, 2, 3, 4},
|
|
EventTypeName{"Start", "End", "DCStart", "DCEnd"} : amended
|
|
]
|
|
class Thread_V0_TypeGroup1:Thread_V0
|
|
{
|
|
[WmiDataId(1),
|
|
Description("ThreadId") : amended,
|
|
format("x"),
|
|
read]
|
|
uint32 TThreadId;
|
|
[WmiDataId(2),
|
|
Description("ProcessId") : amended,
|
|
format("x"),
|
|
read]
|
|
uint32 ProcessId;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Thread Create/Exit Event") : amended,
|
|
Guid("{3d6fa8d1-fe05-11d0-9dda-00c04fd7ba7c}"),
|
|
EventVersion(1),
|
|
DisplayName("Thread") : amended
|
|
]
|
|
class Thread:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Thread Create/Exit Event") : amended,
|
|
EventType{1, 3},
|
|
EventTypeName{"Start", "DCStart"} : amended
|
|
]
|
|
class Thread_TypeGroup1:Thread
|
|
{
|
|
[WmiDataId(1),
|
|
Description("ProcessId") : amended,
|
|
read]
|
|
uint32 ProcessId;
|
|
[WmiDataId(2),
|
|
Description("ThreadId") : amended,
|
|
read]
|
|
uint32 TThreadId;
|
|
[WmiDataId(3),
|
|
Description("StackBase") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 StackBase;
|
|
[WmiDataId(4),
|
|
Description("StackLimit") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 StackLimit;
|
|
[WmiDataId(5),
|
|
Description("UserStackBase") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 UserStackBase;
|
|
[WmiDataId(6),
|
|
Description("UserStackLimit") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 UserStackLimit;
|
|
[WmiDataId(7),
|
|
Description("StartAddr") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 StartAddr;
|
|
[WmiDataId(8),
|
|
Description("Win32StartAddr") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 Win32StartAddr;
|
|
[WmiDataId(9),
|
|
Description("WaitMode") : amended,
|
|
format("c"),
|
|
read]
|
|
sint8 WaitMode;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Thread Create/Exit Event") : amended,
|
|
EventType{2, 4},
|
|
EventTypeName{"End", "DCEnd"} : amended
|
|
]
|
|
class Thread_TypeGroup2:Thread
|
|
{
|
|
[WmiDataId(1),
|
|
Description("ProcessId") : amended,
|
|
read]
|
|
uint32 ProcessId;
|
|
[WmiDataId(2),
|
|
Description("ThreadId") : amended,
|
|
read]
|
|
uint32 TThreadId;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("I/O Read/Write Event") : amended,
|
|
Guid("{3d6fa8d4-fe05-11d0-9dda-00c04fd7ba7c}"),
|
|
DisplayName("DiskIo") : amended
|
|
]
|
|
class DiskIo:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("I/O Read/Write Event") : amended,
|
|
EventType{10, 11},
|
|
EventTypeName{"Read", "Write"} : amended
|
|
]
|
|
class DiskIo_TypeGroup1:DiskIo
|
|
{
|
|
[WmiDataId(1),
|
|
Description("DiskNumber") : amended,
|
|
read]
|
|
uint32 DiskNumber;
|
|
[WmiDataId(2),
|
|
Description("IrpFlags") : amended,
|
|
format("x"),
|
|
read]
|
|
uint32 IrpFlags;
|
|
[WmiDataId(3),
|
|
Description("TransferSize") : amended,
|
|
read]
|
|
uint32 TransferSize;
|
|
[WmiDataId(4),
|
|
Description("QueueDepth") : amended,
|
|
read]
|
|
uint32 QueueDepth;
|
|
[WmiDataId(5),
|
|
Description("ByteOffset") : amended,
|
|
read]
|
|
sint64 ByteOffset;
|
|
[WmiDataId(6),
|
|
Description("FileObject") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 FileObject;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Registry") : amended,
|
|
Guid("{ae53722e-c863-11d2-8659-00c04fa321a1}"),
|
|
EventVersion(0),
|
|
DisplayName("Registry") : amended
|
|
]
|
|
class Registry_V0:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Registry") : amended,
|
|
EventType{10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21},
|
|
EventTypeName{"Create", "Open", "Delete", "Query", "SetValue", "DeleteValue", "QueryValue", "EnumerateKey", "EnumerateValueKey", "QueryMultipleValue", "SetInformation", "Flush"} : amended
|
|
]
|
|
class Registry_V0_TypeGroup1:Registry_V0
|
|
{
|
|
[WmiDataId(1),
|
|
Description("Status") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 Status;
|
|
[WmiDataId(2),
|
|
Description("KeyHandle") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 KeyHandle;
|
|
[WmiDataId(3),
|
|
Description("ElapsedTime") : amended,
|
|
read]
|
|
sint64 ElapsedTime;
|
|
[WmiDataId(4),
|
|
Description("KeyName") : amended,
|
|
StringTermination("NullTerminated"),
|
|
format("w"),
|
|
read]
|
|
string KeyName;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Registry") : amended,
|
|
Guid("{ae53722e-c863-11d2-8659-00c04fa321a1}"),
|
|
EventVersion(1),
|
|
DisplayName("Registry") : amended
|
|
]
|
|
class Registry:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Registry") : amended,
|
|
EventType{10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22},
|
|
EventTypeName{"Create", "Open", "Delete", "Query", "SetValue", "DeleteValue", "QueryValue", "EnumerateKey", "EnumerateValueKey", "QueryMultipleValue", "SetInformation", "Flush", "RunDown"} : amended
|
|
]
|
|
class Registry_TypeGroup1:Registry
|
|
{
|
|
[WmiDataId(1),
|
|
Description("Status") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 Status;
|
|
[WmiDataId(2),
|
|
Description("KeyHandle") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 KeyHandle;
|
|
[WmiDataId(3),
|
|
Description("ElapsedTime") : amended,
|
|
read]
|
|
sint64 ElapsedTime;
|
|
[WmiDataId(4),
|
|
Description("Index") : amended,
|
|
read]
|
|
uint32 Index;
|
|
[WmiDataId(5),
|
|
Description("KeyName") : amended,
|
|
StringTermination("NullTerminated"),
|
|
format("w"),
|
|
read]
|
|
string KeyName;
|
|
};
|
|
|
|
|
|
[Dynamic,
|
|
Description("File Name") : amended,
|
|
Guid("{90cbdc39-4a3e-11d1-84f4-0000f80464e3}"),
|
|
EventVersion(0),
|
|
DisplayName("FileIo") : amended
|
|
]
|
|
class FileIo_V0:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("File Name") : amended,
|
|
EventType(0),
|
|
EventTypeName("Name") : amended
|
|
]
|
|
class FileIo_V0_Name:FileIo_V0
|
|
{
|
|
[WmiDataId(1),
|
|
Description("FileObject") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 FileObject;
|
|
[WmiDataId(2),
|
|
Description("FileName") : amended,
|
|
StringTermination("NullTerminated"),
|
|
format("w"),
|
|
read]
|
|
string FileName;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("File Name") : amended,
|
|
Guid("{90cbdc39-4a3e-11d1-84f4-0000f80464e3}"),
|
|
EventVersion(1),
|
|
DisplayName("FileIo") : amended
|
|
]
|
|
class FileIo:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("File Name") : amended,
|
|
EventType{0, 32},
|
|
EventTypeName{"Name", "FileCreate"} : amended
|
|
]
|
|
class FileIo_Name:FileIo
|
|
{
|
|
[WmiDataId(1),
|
|
Description("FileObject") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 FileObject;
|
|
[WmiDataId(2),
|
|
Description("FileName") : amended,
|
|
StringTermination("NullTerminated"),
|
|
format("w"),
|
|
read]
|
|
string FileName;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("TcpIp Send/Receive") : amended,
|
|
Guid("{9a280ac0-c8e0-11d1-84e2-00c04fb998a2}"),
|
|
EventVersion(0),
|
|
DisplayName("TcpIp") : amended
|
|
]
|
|
class TcpIp_V0:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("TcpIp Send/Receive") : amended,
|
|
EventType{10, 11, 12, 13, 14, 15},
|
|
EventTypeName{"Send", "Recv", "Connect", "Disconnect", "Retransmit", "Accept"} : amended
|
|
]
|
|
class TcpIp_V0_TypeGroup1:TcpIp_V0
|
|
{
|
|
[WmiDataId(1),
|
|
Description("Remote IP Address") : amended,
|
|
extension("IPAddr"),
|
|
read]
|
|
object daddr;
|
|
[WmiDataId(2),
|
|
Description("Local IP Address") : amended,
|
|
extension("IPAddr"),
|
|
read]
|
|
object saddr;
|
|
[WmiDataId(3),
|
|
Description("Remote Port") : amended,
|
|
extension("Port"),
|
|
read]
|
|
object dport;
|
|
[WmiDataId(4),
|
|
Description("Local Port") : amended,
|
|
extension("Port"),
|
|
read]
|
|
object sport;
|
|
[WmiDataId(5),
|
|
Description("Transfer Size in Bytes") : amended,
|
|
read]
|
|
uint32 size;
|
|
[WmiDataId(6),
|
|
Description("Process ID") : amended,
|
|
read]
|
|
uint32 PID;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("TcpIp Send/Receive") : amended,
|
|
Guid("{9a280ac0-c8e0-11d1-84e2-00c04fb998a2}"),
|
|
DisplayName("TcpIp") : amended
|
|
]
|
|
class TcpIp:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("TcpIp Send/Receive") : amended,
|
|
EventType{10, 11, 12, 13, 14, 15, 16},
|
|
EventTypeName{"Send", "Recv", "Connect", "Disconnect", "Retransmit", "Accept", "Reconnect"} : amended
|
|
]
|
|
class TcpIp_TypeGroup1:TcpIp
|
|
{
|
|
[WmiDataId(1),
|
|
Description("Process ID") : amended,
|
|
read]
|
|
uint32 PID;
|
|
[WmiDataId(2),
|
|
Description("Transfer Size in Bytes") : amended,
|
|
read]
|
|
uint32 size;
|
|
[WmiDataId(3),
|
|
Description("Remote IP Address") : amended,
|
|
extension("IPAddr"),
|
|
read]
|
|
object daddr;
|
|
[WmiDataId(4),
|
|
Description("Local IP Address") : amended,
|
|
extension("IPAddr"),
|
|
read]
|
|
object saddr;
|
|
[WmiDataId(5),
|
|
Description("Remote Port") : amended,
|
|
extension("Port"),
|
|
read]
|
|
object dport;
|
|
[WmiDataId(6),
|
|
Description("Local Port") : amended,
|
|
extension("Port"),
|
|
read]
|
|
object sport;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("UcpIp Send/Receive") : amended,
|
|
Guid("{bf3a50c5-a9c9-4988-a005-2df0b7c80f80}"),
|
|
EventVersion(0),
|
|
DisplayName("UdpIp") : amended
|
|
]
|
|
class UdpIp_V0:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("UcpIp Send/Receive") : amended,
|
|
EventType{10, 11},
|
|
EventTypeName{"Send", "Recv"} : amended
|
|
]
|
|
class UdpIp_V0_TypeGroup1:UdpIp_V0
|
|
{
|
|
[WmiDataId(1),
|
|
Description("Process ID") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 context;
|
|
[WmiDataId(2),
|
|
Description("Local IP Address") : amended,
|
|
extension("IPAddr"),
|
|
read]
|
|
object saddr;
|
|
[WmiDataId(3),
|
|
Description("Local Port") : amended,
|
|
extension("Port"),
|
|
read]
|
|
object sport;
|
|
[WmiDataId(4),
|
|
Description("Transfer Size in Bytes") : amended,
|
|
read]
|
|
uint16 size;
|
|
[WmiDataId(5),
|
|
Description("Remote IP Address") : amended,
|
|
extension("IPAddr"),
|
|
read]
|
|
object daddr;
|
|
[WmiDataId(6),
|
|
Description("Remote Port") : amended,
|
|
extension("Port"),
|
|
read]
|
|
object dport;
|
|
[WmiDataId(7),
|
|
Description("Number of Bytes successfully sent") : amended,
|
|
read]
|
|
uint16 dsize;
|
|
};
|
|
|
|
|
|
[Dynamic,
|
|
Description("UdpIp Send/Receive") : amended,
|
|
Guid("{bf3a50c5-a9c9-4988-a005-2df0b7c80f80}"),
|
|
DisplayName("UdpIp") : amended
|
|
]
|
|
class UdpIp:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("UdpIp Send/Receive") : amended,
|
|
EventType{10, 11},
|
|
EventTypeName{"Send", "Recv"} : amended
|
|
]
|
|
class UdpIp_TypeGroup1:UdpIp
|
|
{
|
|
[WmiDataId(1),
|
|
Description("Process ID") : amended,
|
|
read]
|
|
uint32 PID;
|
|
[WmiDataId(2),
|
|
Description("Transfer Size in Bytes") : amended,
|
|
read]
|
|
uint32 size;
|
|
[WmiDataId(3),
|
|
Description("Remote IP Address") : amended,
|
|
extension("IPAddr"),
|
|
read]
|
|
object daddr;
|
|
[WmiDataId(4),
|
|
Description("Local IP Address") : amended,
|
|
extension("IPAddr"),
|
|
read]
|
|
object saddr;
|
|
[WmiDataId(5),
|
|
Description("Remote Port") : amended,
|
|
extension("Port"),
|
|
read]
|
|
object dport;
|
|
[WmiDataId(6),
|
|
Description("Local Port") : amended,
|
|
extension("Port"),
|
|
read]
|
|
object sport;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Image Load") : amended,
|
|
Guid("{2cb15d1d-5fc1-11d2-abe1-00a0c911f518}"),
|
|
EventVersion(0),
|
|
DisplayName("Image") : amended
|
|
]
|
|
class Image_V0:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Image Load") : amended,
|
|
EventType(10),
|
|
EventTypeName("Load") : amended
|
|
]
|
|
class Image_V0_Load:Image_V0
|
|
{
|
|
[WmiDataId(1),
|
|
Description("BaseAddress") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 BaseAddress;
|
|
[WmiDataId(2),
|
|
Description("ModuleSize") : amended,
|
|
read]
|
|
uint32 ModuleSize;
|
|
[WmiDataId(3),
|
|
Description("ImageFileName") : amended,
|
|
StringTermination("NullTerminated"),
|
|
format("w"),
|
|
read]
|
|
string ImageFileName;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Image Load") : amended,
|
|
Guid("{2cb15d1d-5fc1-11d2-abe1-00a0c911f518}"),
|
|
EventVersion(1),
|
|
DisplayName("Image") : amended
|
|
]
|
|
class Image:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Image Load") : amended,
|
|
EventType(10),
|
|
EventTypeName("Load") : amended
|
|
]
|
|
class Image_Load:Image
|
|
{
|
|
[WmiDataId(1),
|
|
Description("ImageBase") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 ImageBase;
|
|
[WmiDataId(2),
|
|
Description("ImageSize") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 ImageSize;
|
|
[WmiDataId(3),
|
|
Description("ProcessId") : amended,
|
|
read]
|
|
uint32 ProcessId;
|
|
[WmiDataId(4),
|
|
Description("FileName") : amended,
|
|
StringTermination("NullTerminated"),
|
|
format("w"),
|
|
read]
|
|
string FileName;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Page Fault Event") : amended,
|
|
Guid("{3d6fa8d3-fe05-11d0-9dda-00c04fd7ba7c}"),
|
|
DisplayName("PageFault") : amended
|
|
]
|
|
class PageFault:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Page Fault Event") : amended,
|
|
EventType{10, 11, 12, 13, 14},
|
|
EventTypeName{"TransitionFault", "DemandZeroFault", "CopyOnWrite", "GuardPageFault", "HardPageFault"} : amended
|
|
]
|
|
class PageFault_TransitionFault:PageFault
|
|
{
|
|
[WmiDataId(1),
|
|
Description("VirtualAddress") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 VirtualAddress;
|
|
[WmiDataId(2),
|
|
Description("ProgramCounter") : amended,
|
|
pointer,
|
|
read]
|
|
uint32 ProgramCounter;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Hardware Configuration") : amended,
|
|
Guid("{01853a65-418f-4f36-aefc-dc0f1d2fd235}"),
|
|
DisplayName("HWConfig") : amended
|
|
]
|
|
class HWConfig:MSNT_SystemTrace
|
|
{
|
|
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Hardware Configuration") : amended,
|
|
EventType(10),
|
|
EventTypeName("CPU") : amended
|
|
]
|
|
class HWConfig_CPU:HWConfig
|
|
{
|
|
[WmiDataId(1),
|
|
Description("MHz") : amended,
|
|
read]
|
|
uint32 MHz;
|
|
[WmiDataId(2),
|
|
Description("NumberOfProcessors") : amended,
|
|
read]
|
|
uint32 NumberOfProcessors;
|
|
[WmiDataId(3),
|
|
Description("MemSize") : amended,
|
|
read]
|
|
uint32 MemSize;
|
|
[WmiDataId(4),
|
|
Description("PageSize") : amended,
|
|
read]
|
|
uint32 PageSize;
|
|
[WmiDataId(5),
|
|
Description("AllocationGranularity") : amended,
|
|
read]
|
|
uint32 AllocationGranularity;
|
|
[WmiDataId(6),
|
|
Description("ComputerName") : amended,
|
|
StringTermination("NullTerminated"),
|
|
format("w"),
|
|
read]
|
|
string ComputerName;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Hardware Configuration") : amended,
|
|
EventType(11),
|
|
EventTypeName("PhyDisk") : amended
|
|
]
|
|
class HWConfig_PhyDisk:HWConfig
|
|
{
|
|
[WmiDataId(1),
|
|
Description("DiskNumber") : amended,
|
|
read]
|
|
uint32 DiskNumber;
|
|
[WmiDataId(2),
|
|
Description("BytesPerSector") : amended,
|
|
read]
|
|
uint32 BytesPerSector;
|
|
[WmiDataId(3),
|
|
Description("SectorsPerTrack") : amended,
|
|
read]
|
|
uint32 SectorsPerTrack;
|
|
[WmiDataId(4),
|
|
Description("TracksPerCylinder") : amended,
|
|
read]
|
|
uint32 TracksPerCylinder;
|
|
[WmiDataId(5),
|
|
Description("Cylinders") : amended,
|
|
read]
|
|
uint64 Cylinders;
|
|
[WmiDataId(6),
|
|
Description("SCSIPort") : amended,
|
|
read]
|
|
uint32 SCSIPort;
|
|
[WmiDataId(7),
|
|
Description("SCSIPath") : amended,
|
|
read]
|
|
uint32 SCSIPath;
|
|
[WmiDataId(8),
|
|
Description("SCSITarget") : amended,
|
|
read]
|
|
uint32 SCSITarget;
|
|
[WmiDataId(9),
|
|
Description("SCSILun") : amended,
|
|
read]
|
|
uint32 SCSILun;
|
|
[WmiDataId(10),
|
|
Description("Manufacturer") : amended,
|
|
StringTermination("NullTerminated"),
|
|
format("w"),
|
|
read]
|
|
string Manufacturer;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Hardware Configuration") : amended,
|
|
EventType(12),
|
|
EventTypeName("LogDisk") : amended
|
|
]
|
|
class HWConfig_LogDisk:HWConfig
|
|
{
|
|
[WmiDataId(1),
|
|
Description("DiskNumber") : amended,
|
|
read]
|
|
uint32 DiskNumber;
|
|
[WmiDataId(2),
|
|
Description("Pad") : amended,
|
|
read]
|
|
uint32 Pad;
|
|
[WmiDataId(3),
|
|
Description("StartOffset") : amended,
|
|
read]
|
|
uint64 StartOffset;
|
|
[WmiDataId(4),
|
|
Description("PartitionSize") : amended,
|
|
read]
|
|
uint64 PartitionSize;
|
|
};
|
|
|
|
[Dynamic,
|
|
Description("Hardware Configuration") : amended,
|
|
EventType(13),
|
|
EventTypeName("NIC") : amended
|
|
]
|
|
class HWConfig_NIC:HWConfig
|
|
{
|
|
[WmiDataId(1),
|
|
Description("NICName") : amended,
|
|
StringTermination("NullTerminated"),
|
|
format("w"),
|
|
read]
|
|
string NICName;
|
|
};
|
|
|
|
//
|
|
// Tape
|
|
[abstract]
|
|
class MSTapeDriver
|
|
{
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Tape Drive Parameters") : amended,
|
|
guid("{B9A8CFD5-8D72-47a4-AC0E-284A3200F4FB}"),
|
|
HeaderName("WMI_TAPE_DRIVE_PARAMETERS"),
|
|
GuidName1("WMI_TAPE_DRIVE_PARAMETERS_GUID"),
|
|
DisplayName("Tape Drive Parameters") : amended
|
|
]
|
|
class MSTapeDriveParam : MSTapeDriver
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Maximum Block Size") : amended,
|
|
WmiDataId(1),
|
|
Description("Maximum block size supported") : amended,
|
|
read]
|
|
uint32 MaximumBlockSize;
|
|
|
|
[DisplayName("Minimum Block Size") : amended,
|
|
WmiDataId(2),
|
|
Description("Minimum block size supported") : amended,
|
|
read]
|
|
uint32 MinimumBlockSize;
|
|
|
|
[DisplayName("Default Block Size") : amended,
|
|
WmiDataId(3),
|
|
Description("Default block size supported") : amended,
|
|
read]
|
|
uint32 DefaultBlockSize;
|
|
|
|
[DisplayName("Maximum Partition Count") : amended,
|
|
WmiDataId(4),
|
|
Description("Maximum number of partitions allowed.") : amended,
|
|
read]
|
|
uint32 MaximumPartitionCount;
|
|
|
|
[DisplayName("Compression Capable") : amended,
|
|
WmiDataId(5),
|
|
Description("TRUE if drive supports compression.") : amended,
|
|
read]
|
|
boolean CompressionCapable;
|
|
|
|
[WmiDataId(6),
|
|
DisplayName("Compression Enabled") : amended,
|
|
Description("TRUE if compression is enabled.") : amended,
|
|
read]
|
|
boolean CompressionEnabled;
|
|
|
|
[WmiDataId(7),
|
|
DisplayName("Report Setmarks") : amended,
|
|
Description("TRUE if drive reports setmarks") : amended,
|
|
read]
|
|
boolean ReportSetmarks;
|
|
|
|
[WmiDataId(8),
|
|
DisplayName("Hardware Error Correction") : amended,
|
|
Description("TRUE if drive supports hardware error correction") : amended,
|
|
read]
|
|
boolean HardwareErrorCorrection;
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Tape Media Capacity") : amended,
|
|
guid("{8C2147A4-FF29-4336-B8A4-227B54CC0966}"),
|
|
HeaderName("WMI_TAPE_MEDIA_PARAMETERS"),
|
|
GuidName1("WMI_TAPE_MEDIA_PARAMETERS_GUID"),
|
|
DisplayName("Tape Media Capacity") : amended
|
|
]
|
|
class MSTapeMediaCapacity : MSTapeDriver
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Maximum Capacity") : amended,
|
|
WmiDataId(1),
|
|
Description("Maximum capacity of the media") : amended,
|
|
read]
|
|
uint64 MaximumCapacity;
|
|
|
|
[DisplayName("Available Capacity") : amended,
|
|
WmiDataId(2),
|
|
Description("Available capacity of the media") : amended,
|
|
read]
|
|
uint64 AvailableCapacity;
|
|
|
|
[DisplayName("Block Size") : amended,
|
|
WmiDataId(3),
|
|
Description("Current blocksize") : amended,
|
|
read]
|
|
uint32 BlockSize;
|
|
|
|
[DisplayName("Partition Count") : amended,
|
|
WmiDataId(4),
|
|
Description("Current number of partitions") : amended,
|
|
read]
|
|
uint32 PartitionCount;
|
|
|
|
[DisplayName("Media Write Protected") : amended,
|
|
WmiDataId(5),
|
|
Description("TRUE if media is write protected") : amended,
|
|
read]
|
|
boolean MediaWriteProtected;
|
|
};
|
|
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Tape Symbolic Name") : amended,
|
|
guid("{3FB828F7-F119-4066-B1E6-DB407CE9DE91}"),
|
|
HeaderName("WMI_TAPE_SYMBOLIC_NAME"),
|
|
GuidName1("WMI_TAPE_SYMBOLIC_NAME_GUID"),
|
|
DisplayName("Tape Symbolic Name") : amended
|
|
]
|
|
class MSTapeSymbolicName : MSTapeDriver
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
|
|
[DisplayName("Tape symbolic name") : amended,
|
|
WmiDataId(1),
|
|
Description("Symbolic name such as Tape0") : amended,
|
|
read]
|
|
string TapeSymbolicName;
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Tape Drive Problem Warning") : amended,
|
|
guid("{BC4DD36C-FA66-4080-87A0-0C5922EB7887}"),
|
|
HeaderName("WMI_TAPE_PROBLEM_WARNING"),
|
|
GuidName1("WMI_TAPE_PROBLEM_WARNING_GUID"),
|
|
DisplayName("Tape Problem Event") : amended
|
|
]
|
|
class MSTapeDriveProblemEvent : WmiEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Drive Problem Type") : amended,
|
|
WmiDataId(1),
|
|
Description("Tape drive problem warning event") : amended,
|
|
read]
|
|
uint32 DriveProblemType;
|
|
|
|
[WmiDataId(2),
|
|
DisplayName("Tape Data") : amended,
|
|
Description("Tape drive problem data") : amended,
|
|
read]
|
|
uint8 TapeData[512];
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("IO Read Write Errors") : amended,
|
|
guid("{58FD29F9-B516-40fd-871A-7EE76D5BB53E}"),
|
|
HeaderName("WMI_TAPE_PROBLEM_IO_ERROR"),
|
|
GuidName1("WMI_TAPE_PROBLEM_IO_ERROR_GUID"),
|
|
DisplayName("Tape Io Error") : amended
|
|
]
|
|
class MSTapeProblemIoError : MSTapeDriver
|
|
{
|
|
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Read Corrected Without Delay") : amended,
|
|
WmiDataId(1),
|
|
Description("Read errors corrected without much delay") : amended,
|
|
read]
|
|
uint32 ReadCorrectedWithoutDelay;
|
|
|
|
[DisplayName("Read Corrected With Delay") : amended,
|
|
WmiDataId(2),
|
|
Description("Read errors corrected with substantial delay") : amended,
|
|
read]
|
|
uint32 ReadCorrectedWithDelay;
|
|
|
|
[DisplayName("Read Total Errors") : amended,
|
|
WmiDataId(3),
|
|
Description("Total number of Read errors") : amended,
|
|
read]
|
|
uint32 ReadTotalErrors;
|
|
|
|
[DisplayName("Read Total Corrected Errors") : amended,
|
|
WmiDataId(4),
|
|
Description("Total number of read errors that were corrected") : amended,
|
|
read]
|
|
uint32 ReadTotalCorrectedErrors;
|
|
|
|
[DisplayName("Read Total Uncorrected Errors") : amended,
|
|
WmiDataId(5),
|
|
Description("Total number of uncorrected read errors") : amended,
|
|
read]
|
|
uint32 ReadTotalUncorrectedErrors;
|
|
|
|
[DisplayName("Read Correction Algorithm Processed") : amended,
|
|
WmiDataId(6),
|
|
Description("Number of times correction algorithm was processed for read") : amended,
|
|
read]
|
|
uint32 ReadCorrectionAlgorithmProcessed;
|
|
|
|
[DisplayName("Write Corrected Without Delay") : amended,
|
|
WmiDataId(7),
|
|
Description("Write errors corrected without much delay") : amended,
|
|
read]
|
|
uint32 WriteCorrectedWithoutDelay;
|
|
|
|
[DisplayName("Write Corrected With Delay") : amended,
|
|
WmiDataId(8),
|
|
Description("Write errors corrected with substantial delay") : amended,
|
|
read]
|
|
uint32 WriteCorrectedWithDelay;
|
|
|
|
[DisplayName("Write Total Errors") : amended,
|
|
WmiDataId(9),
|
|
Description("Total number of Read errors") : amended,
|
|
read]
|
|
uint32 WriteTotalErrors;
|
|
|
|
[DisplayName("Write Total Corrected Errors") : amended,
|
|
WmiDataId(10),
|
|
Description("Total number of write errors that were corrected") : amended,
|
|
read]
|
|
uint32 WriteTotalCorrectedErrors;
|
|
|
|
[DisplayName("Write Total Uncorrected Errors") : amended,
|
|
WmiDataId(11),
|
|
Description("Total number of uncorrected write errors") : amended,
|
|
read]
|
|
uint32 WriteTotalUncorrectedErrors;
|
|
|
|
[DisplayName("Write Correction Algorithm Processed") : amended,
|
|
WmiDataId(12),
|
|
Description("Number of times correction algorithm was processed for write") : amended,
|
|
read]
|
|
uint32 WriteCorrectionAlgorithmProcessed;
|
|
|
|
[DisplayName("Non Medium Errors") : amended,
|
|
WmiDataId(13),
|
|
Description("Errors not related to medium") : amended,
|
|
read]
|
|
uint32 NonMediumErrors;
|
|
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Device Errors") : amended,
|
|
guid("{43EC6B13-10BB-4bf6-B716-1C1E2F10BB5F}"),
|
|
HeaderName("WMI_TAPE_PROBLEM_DEVICE_ERROR"),
|
|
GuidName1("WMI_TAPE_PROBLEM_DEVICE_ERROR_GUID"),
|
|
DisplayName("Tape Device Error") : amended
|
|
]
|
|
class MSTapeProblemDeviceError : MSTapeDriver
|
|
{
|
|
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Read Warning") : amended,
|
|
WmiDataId(1),
|
|
Description("WARNING : Drive is experiencing read problem.") : amended,
|
|
read]
|
|
boolean ReadWarning;
|
|
|
|
[DisplayName("Write Warning") : amended,
|
|
WmiDataId(2),
|
|
Description("WARNING : Drive is experiencing write problem.") : amended,
|
|
read]
|
|
boolean WriteWarning;
|
|
|
|
[DisplayName("Hard Error") : amended,
|
|
WmiDataId(3),
|
|
Description("Drive hardware problem") : amended,
|
|
read]
|
|
boolean HardError;
|
|
|
|
[DisplayName("Read Failure") : amended,
|
|
WmiDataId(4),
|
|
Description("Critical Error : Too many read errors.") : amended,
|
|
read]
|
|
boolean ReadFailure;
|
|
|
|
[DisplayName("Write Failure") : amended,
|
|
WmiDataId(5),
|
|
Description("Critical Error : Too many write errors.") : amended,
|
|
read]
|
|
boolean WriteFailure;
|
|
|
|
[DisplayName("Unsupported Format") : amended,
|
|
WmiDataId(6),
|
|
Description("Tape format not supported") : amended,
|
|
read]
|
|
boolean UnsupportedFormat;
|
|
|
|
[DisplayName("Tape Snapped") : amended,
|
|
WmiDataId(7),
|
|
Description("Tape is snapped. Replace media") : amended,
|
|
read]
|
|
boolean TapeSnapped;
|
|
|
|
[DisplayName("Drive Requires Cleaning") : amended,
|
|
WmiDataId(8),
|
|
Description("Drive Requires Cleaning") : amended,
|
|
read]
|
|
boolean DriveRequiresCleaning;
|
|
|
|
[DisplayName("Time To Clean Drive") : amended,
|
|
WmiDataId(9),
|
|
Description("It's time to clean the drive") : amended,
|
|
read]
|
|
boolean TimetoCleanDrive;
|
|
|
|
[DisplayName("Drive Hardware Error") : amended,
|
|
WmiDataId(10),
|
|
Description("Hardware error. Check drive") : amended,
|
|
read]
|
|
boolean DriveHardwareError;
|
|
|
|
[DisplayName("Scsi Interface Error") : amended,
|
|
WmiDataId(11),
|
|
Description("Some error in cabling, or connection.") : amended,
|
|
read]
|
|
boolean ScsiInterfaceError;
|
|
|
|
[DisplayName("Media Life") : amended,
|
|
WmiDataId(12),
|
|
Description("Critical error: Media life expired.") : amended,
|
|
read]
|
|
boolean MediaLife;
|
|
};
|
|
|
|
//
|
|
// Medium Changer Libraries
|
|
[abstract]
|
|
class MSChangerDriver
|
|
{
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Changer Parameters") : amended,
|
|
guid("{24EB52AC-7C77-438b-AB61-D024DAB0C03A}"),
|
|
HeaderName("WMI_CHANGER_PARAMETERS"),
|
|
GuidName1("WMI_CHANGER_PARAMETERS_GUID"),
|
|
DisplayName("Changer Parameters") : amended
|
|
]
|
|
class MSChangerParameters : MSChangerDriver
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Number Of Slots") : amended,
|
|
WmiDataId(1),
|
|
Description("Number of slots in the changer") : amended,
|
|
read]
|
|
uint32 NumberOfSlots;
|
|
|
|
[DisplayName("Number Of Drives") : amended,
|
|
WmiDataId(2),
|
|
Description("Number of drives in the changer") : amended,
|
|
read]
|
|
uint32 NumberOfDrives;
|
|
|
|
[DisplayName("Number Of IE Ports") : amended,
|
|
WmiDataId(3),
|
|
Description("Number of IEPorts in the changer") : amended,
|
|
read]
|
|
uint32 NumberOfIEPorts;
|
|
|
|
[DisplayName("Number Of Transports") : amended,
|
|
WmiDataId(4),
|
|
Description("Number of transport in the changer") : amended,
|
|
read]
|
|
uint32 NumberOfTransports;
|
|
|
|
[DisplayName("Number Of Doors") : amended,
|
|
WmiDataId(5),
|
|
Description("Number of doors in the changer") : amended,
|
|
read]
|
|
uint32 NumberOfDoors;
|
|
|
|
[DisplayName("Number Of Cleaner Slots") : amended,
|
|
WmiDataId(6),
|
|
Description("Number of slots for cleaner cartridge in the changer") : amended,
|
|
read]
|
|
uint32 NumberOfCleanerSlots;
|
|
|
|
[
|
|
DisplayName("Magazine Size") : amended,
|
|
WmiDataId(7),
|
|
Description("Magazine size if one exists") : amended,
|
|
read]
|
|
uint32 MagazineSize;
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Changer Problem Warning") : amended,
|
|
guid("{45DB06A5-20D5-4de3-A36C-3AB974600A4C}"),
|
|
HeaderName("WMI_CHANGER_PROBLEM_WARNING"),
|
|
GuidName1("WMI_CHANGER_PROBLEM_WARNING_GUID"),
|
|
DisplayName("Changer Problem Event") : amended
|
|
]
|
|
class MSChangerProblemEvent : WmiEvent
|
|
{
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Changer Problem Type") : amended,
|
|
WmiDataId(1),
|
|
Description("Changer library problem warning type") : amended,
|
|
read]
|
|
uint32 ChangerProblemType;
|
|
|
|
[DisplayName("Changer Data") : amended,
|
|
WmiDataId(2),
|
|
Description("Changer problem data") : amended,
|
|
read]
|
|
uint8 ChangerData[512];
|
|
};
|
|
|
|
[Dynamic, Provider("WMIProv"),
|
|
WMI,
|
|
Description("Changer Errors") : amended,
|
|
guid("{56B396A8-0B95-42fe-BBCE-D36FDA904F8E}"),
|
|
HeaderName("WMI_CHANGER_PROBLEM_DEVICE_ERROR"),
|
|
GuidName1("WMI_CHANGER_PROBLEM_DEVICE_ERROR_GUID"),
|
|
DisplayName("Changer Device Error") : amended
|
|
]
|
|
class MSChangerProblemDeviceError : MSChangerDriver
|
|
{
|
|
|
|
[key, read]
|
|
string InstanceName;
|
|
[read] boolean Active;
|
|
|
|
[DisplayName("Changer Problem Type") : amended,
|
|
WmiDataId(1),
|
|
Description("Changer library problem warning type") : amended,
|
|
read]
|
|
uint32 ChangerProblemType;
|
|
|
|
};
|
|
|
|
[abstract]
|
|
class MSDeviceUI
|
|
{
|
|
};
|
|
|
|
[WMI, Dynamic, Provider ("WMIProv"),
|
|
guid("{4504B1D4-C5EE-4df6-951F-16180E3DD815}"),
|
|
HeaderName("DEVICE_UI_FIRMWARE_REVISION"),
|
|
GuidName1("DEVICE_UI_FIRMWARE_REVISION_GUID"),
|
|
Description("Firmware Revision" ) : amended,
|
|
DisplayName("Device Firmware Revision") : amended
|
|
]
|
|
class MSDeviceUI_FirmwareRevision : MSDeviceUI
|
|
{
|
|
boolean Active;
|
|
[key]
|
|
string InstanceName;
|
|
|
|
[DisplayName("Firmware Revision") : amended,
|
|
WmiDataId(1),
|
|
Description("Firmware Revision") : amended,
|
|
read]
|
|
string FirmwareRevision;
|
|
};
|
|
|