mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
9453 lines
427 KiB
9453 lines
427 KiB
|
|
// (c) 1998-2000 Microsoft Corporation. All rights reserved.
|
|
|
|
#pragma autorecover
|
|
#pragma classflags("forceupdate")
|
|
|
|
Qualifier Description : ToSubClass Amended;
|
|
Qualifier Values : ToSubClass Amended;
|
|
Qualifier DisplayName : Amended;
|
|
Qualifier BitValues:ToSubClass Amended ;
|
|
|
|
Qualifier Aggregate : ToSubClass ;
|
|
Qualifier ValueMap : ToSubClass ;
|
|
Qualifier Aggregation : ToSubClass ;
|
|
Qualifier ArrayType : ToSubClass ;
|
|
Qualifier Association : ToInstance ToSubClass DisableOverride ;
|
|
Qualifier BitMap : ToSubClass ;
|
|
Qualifier CIM_Key : ToSubClass ;
|
|
Qualifier CIMTYPE : ToSubClass ;
|
|
Qualifier Deprecated : ToSubClass ;
|
|
Qualifier Enumeration : ToSubClass ;
|
|
Qualifier EnumPrivileges : ToSubClass ;
|
|
Qualifier Fixed : ToSubclass;
|
|
Qualifier ImplementationSource : ToSubClass ;
|
|
Qualifier Key : ToInstance ToSubClass DisableOverride ;
|
|
Qualifier Locale : ToInstance ;
|
|
Qualifier MappingStrings : ToSubClass ;
|
|
Qualifier Max : ToSubClass ;
|
|
Qualifier MaxLen : ToSubClass ;
|
|
Qualifier Min : ToSubClass ;
|
|
Qualifier ModelCorrespondence : ToSubClass ;
|
|
Qualifier Not_Null : ToSubClass ;
|
|
Qualifier Override : Restricted ;
|
|
Qualifier Privileges : ToSubClass ;
|
|
Qualifier Propagated : ToSubClass ;
|
|
Qualifier provider : ToInstance ;
|
|
Qualifier Range : ToSubClass ;
|
|
Qualifier Read : ToSubClass ;
|
|
Qualifier Schema : ToInstance ;
|
|
Qualifier Singleton : ToSubClass ToInstance ;
|
|
Qualifier SUBTYPE : ToSubClass ;
|
|
Qualifier Units : ToSubClass ;
|
|
Qualifier UUID : ToInstance ;
|
|
Qualifier Volatile : ToSubClass ;
|
|
Qualifier Weak : ToSubClass ;
|
|
Qualifier Write : ToSubClass ;
|
|
Qualifier WritePrivileges : ToSubClass ;
|
|
|
|
|
|
#pragma namespace ("\\\\.\\Root")
|
|
|
|
[Locale(0x409)]
|
|
instance of __Namespace
|
|
{
|
|
Name = "CIMV2";
|
|
};
|
|
|
|
#pragma namespace ("\\\\.\\Root\\CIMV2")
|
|
|
|
|
|
|
|
|
|
instance of __Win32Provider as $P
|
|
{
|
|
Name = "CIMWin32";
|
|
ClsId = "{d63a5850-8f16-11cf-9f47-00aa00bf345c}";
|
|
ImpersonationLevel = 1;
|
|
PerUserInitialization = "FALSE";
|
|
HostingModel = "NetworkServiceHost";
|
|
};
|
|
instance of __InstanceProviderRegistration
|
|
{
|
|
Provider = $P;
|
|
SupportsGet = "TRUE";
|
|
SupportsPut = "TRUE";
|
|
SupportsDelete = "TRUE";
|
|
SupportsEnumeration = "TRUE";
|
|
QuerySupportLevels = {"WQL:UnarySelect"};
|
|
};
|
|
|
|
instance of __MethodProviderRegistration
|
|
{
|
|
Provider = $P;
|
|
};
|
|
|
|
|
|
|
|
|
|
instance of __Win32Provider as $DCRs
|
|
{
|
|
Name = "Cimwin32A";
|
|
ClsId = "{04788120-12C2-498d-83C1-A7D92E677AC6}";
|
|
ImpersonationLevel = 1;
|
|
PerUserInitialization = "FALSE";
|
|
HostingModel = "NetworkServiceHost";
|
|
};
|
|
|
|
instance of __InstanceProviderRegistration
|
|
{
|
|
Provider = $DCRs;
|
|
SupportsGet = "TRUE";
|
|
SupportsPut = "TRUE";
|
|
SupportsDelete = "TRUE";
|
|
SupportsEnumeration = "TRUE";
|
|
QuerySupportLevels = {"WQL:UnarySelect"};
|
|
};
|
|
|
|
instance of __MethodProviderRegistration
|
|
{
|
|
Provider = $DCRs;
|
|
};
|
|
|
|
|
|
[DisplayName("Managed System Elements (CIM)"),
|
|
Abstract, Description (
|
|
"The CIM_ManagedSystemElement class is the base class for the system element "
|
|
"hierarchy. Membership criteria: Any distinguishable component of a "
|
|
"system is a candidate for inclusion in this class.\nExamples: software "
|
|
"components, such as files; and devices, such as disk drives and "
|
|
"controllers, and physical components such as chips and cards."),
|
|
Locale (0x409), UUID ("{8502C517-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_ManagedSystemElement
|
|
{
|
|
[DisplayName("Caption"),
|
|
MaxLen (64) , Description (
|
|
"The Caption property is a short textual description (one-line string) "
|
|
"of the object.") , Read ]
|
|
string Caption ;
|
|
[DisplayName("Description"),
|
|
Description (
|
|
"The Description property provides a textual description of the object. "
|
|
) , Read ]
|
|
string Description ;
|
|
[DisplayName("Install Date"),
|
|
Description (
|
|
"The InstallDate property is datetime value indicating when the object was installed. A lack of a "
|
|
"value does not indicate that the object is not installed.") ,
|
|
MappingStrings {"MIF.DMTF|ComponentID|001.5"} , Read ]
|
|
datetime InstallDate ;
|
|
[DisplayName("Name"),
|
|
Description (
|
|
"The Name property defines the label by which the object is known. When "
|
|
"subclassed, the Name property can be overridden to be a Key property."
|
|
) , Read ]
|
|
string Name ;
|
|
[DisplayName("Status"),
|
|
Read, MaxLen (10) , Description (
|
|
"The Status property is a string indicating the current status of the object. "
|
|
"Various operational and non-operational statuses can be "
|
|
"defined. Operational statuses are \"OK\", \"Degraded\" "
|
|
"and \"Pred Fail\". \"Pred Fail\" indicates that an element "
|
|
"may be functioning properly but predicting a failure in the "
|
|
"near future. An example is a SMART-enabled hard drive. "
|
|
"Non-operational statuses can also be specified. These are "
|
|
"\"Error\", \"Starting\", \"Stopping\" and \"Service\". "
|
|
"The latter, \"Service\", could apply during mirror-"
|
|
"resilvering of a disk, reload of a user permissions list, "
|
|
"or other administrative work. Not all such work is on-line, "
|
|
"yet the managed element is neither \"OK\" nor in one of the "
|
|
"other states.") ,
|
|
ValueMap {"OK", "Error", "Degraded", "Unknown", "Pred Fail",
|
|
"Starting", "Stopping", "Service", "Stressed",
|
|
"NonRecover", "No Contact", "Lost Comm" },
|
|
Values {"OK", "Error", "Degraded", "Unknown", "Pred Fail",
|
|
"Starting", "Stopping", "Service", "Stressed",
|
|
"NonRecover", "No Contact", "Lost Comm" } ]
|
|
string Status;
|
|
};
|
|
|
|
[DisplayName("Logical Elements (CIM)"),
|
|
Abstract, Description (
|
|
"The CIM_LogicalElement class is the base class for all the components "
|
|
"of the system that represent abstract system components.\nExample: "
|
|
"profiles, processes, or system capabilities in the form of logical "
|
|
"devices."),
|
|
Locale (0x409), UUID ("{8502C518-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_LogicalElement:CIM_ManagedSystemElement
|
|
{
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_SystemResource class is an entity managed by BIOS and/or an operating system which is available "
|
|
"for use by software and/or logical devices. Examples of Resources in the "
|
|
"x86 environment are IRQs, DMA channels and memory mapped I/O."),
|
|
Locale (0x409), UUID ("{8502C519-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_SystemResource:CIM_LogicalElement
|
|
{
|
|
};
|
|
|
|
|
|
[Abstract, Description ("The CIM_IRQ class represents an Intel architecture IRQ"),
|
|
Locale (0x409), UUID ("{8502C51A-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_IRQ:CIM_SystemResource
|
|
{
|
|
[read , Propagated ("CIM_ComputerSystem.CreationClassName") , CIM_Key,
|
|
MaxLen (256) , Description (
|
|
"CSCreationClassName contains the scoping computer system's creation class name.") ]
|
|
string CSCreationClassName;
|
|
[read , Propagated ("CIM_ComputerSystem.Name") , CIM_Key , Description (
|
|
"CSName contains the scoping computer system's name."), MaxLen (256) ]
|
|
string CSName ;
|
|
[read , CIM_Key, MaxLen (256) , Description (
|
|
"CreationClassName indicates the name of the class or the subclass used "
|
|
"in the creation of an instance. When used with the other key properties "
|
|
"of this class, this property allows all instances of this class and its "
|
|
"subclasses to be uniquely identified.") ]
|
|
string CreationClassName ;
|
|
[read , Description (
|
|
"A part of the object's key value, IRQ Number.") ,
|
|
MappingStrings {"MIF.DMTF|IRQ|001.1"} , key]
|
|
uint32 IRQNumber ;
|
|
[read , Description (
|
|
"Availability of the IRQ.") ,
|
|
ValueMap {"1", "2", "3", "4", "5"} ,
|
|
Values {"Other", "Unknown", "Available", "In Use/Not Available",
|
|
"In Use and Available/Shareable"} , MappingStrings {"MIF.DMTF|IRQ|001.2"} ]
|
|
uint16 Availability ;
|
|
[read , Description (
|
|
"IRQ trigger type indicating whether edge (value=4) or level triggered ("
|
|
"value=3) interrupts occur. Also, \"Other\" (1) and \"Unknown\" (2) may "
|
|
"be defined.") , ValueMap {"1", "2", "3", "4"} , Values {"Other",
|
|
"Unknown", "Level", "Edge"}, MappingStrings {"MIF.DMTF|IRQ|001.3",
|
|
"MIF.DMTF|System Resource IRQ Info|001.2"} ]
|
|
uint16 TriggerType ;
|
|
[read , Description (
|
|
"IRQ trigger level indicating whether the interrupt is triggered by the "
|
|
"hardware signal going high (value=4) or low (value=3). Also, \"Other\" "
|
|
"(1) and \"Unknown\" (2) may be defined.") ,
|
|
Values {"Other", "Unknown", "Active Low", "Active High"},
|
|
ValueMap {"1", "2", "3", "4"} ,
|
|
MappingStrings {"MIF.DMTF|System Resource IRQ Info|001.3"} ]
|
|
uint16 TriggerLevel ;
|
|
[read , Description ("Boolean indicating whether the IRQ can be shared.")
|
|
, MappingStrings {"MIF.DMTF|IRQ|001.4"} ]
|
|
boolean Shareable ;
|
|
|
|
};
|
|
|
|
[Abstract, Description ("Personal Computer architecture Memory "
|
|
"Mapped I/O. This class addresses both memory and port I/O "
|
|
"resources. The property, MappedResource, defines whether memory "
|
|
"or I/O is mapped (and for I/O whether the mapping is to a "
|
|
"memory or a port space."),
|
|
Locale (0x409), UUID ("{8502C51B-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_MemoryMappedIO:CIM_SystemResource
|
|
{
|
|
[read , Propagated ("CIM_ComputerSystem.CreationClassName") , Description (
|
|
"The scoping computer system's creation class name property.") ,
|
|
CIM_Key, MaxLen (256) ]
|
|
string CSCreationClassName ;
|
|
[read , Propagated ("CIM_ComputerSystem.Name") , MaxLen (256) , Description (
|
|
"The scoping computer system's name.") , CIM_Key]
|
|
string CSName ;
|
|
[read , MaxLen (256) , Description (
|
|
"CreationClassName indicates the name of the class or the subclass used "
|
|
"in the creation of an instance. When used with the other key properties "
|
|
"of this class, this property allows all instances of this class and its "
|
|
"subclasses to be uniquely identified.") , CIM_Key]
|
|
string CreationClassName ;
|
|
[read , Description (
|
|
"The StartingAddress property contains the starting address of memory mapped I/O. The hardware resource identifier "
|
|
"property should be set to this value to construct the mapped I/O "
|
|
"resource key.") , CIM_Key, MappingStrings {"MIF.DMTF|Memory Mapped I/O|001.1"}
|
|
]
|
|
uint64 StartingAddress ;
|
|
[read , Description ("The EndingAddress property contains the ending address of memory mapped I/O") ,
|
|
MappingStrings {"MIF.DMTF|Memory Mapped I/O|001.2"} ]
|
|
uint64 EndingAddress ;
|
|
|
|
};
|
|
|
|
[Abstract, Description ("Personal computer architecture DMA."),
|
|
Locale (0x409), UUID ("{8502C523-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_DMA:CIM_SystemResource
|
|
{
|
|
[read , Propagated ("CIM_ComputerSystem.CreationClassName") , MaxLen (256
|
|
) , Description ("The scoping computer system's creation class name.") ,
|
|
CIM_Key]
|
|
string CSCreationClassName ;
|
|
[read , Propagated ("CIM_ComputerSystem.Name") , Description (
|
|
"The scoping computer system's name.") , CIM_Key, MaxLen (256) ]
|
|
string CSName ;
|
|
[read , MaxLen (256) , Description (
|
|
"CreationClassName indicates the name of the class or the subclass used "
|
|
"in the creation of an instance. When used with the other key properties "
|
|
"of this class, this property allows all instances of this class and its "
|
|
"subclasses to be uniquely identified.") , CIM_Key]
|
|
string CreationClassName ;
|
|
[read , Key, Description (
|
|
"A part of the object's key value, the DMA channel number.") ,
|
|
MappingStrings {"MIF.DMTF|DMA|001.1"} ]
|
|
uint32 DMAChannel ;
|
|
[read , Description (
|
|
"The Availability property indicates the availability of the DMA.") ,
|
|
ValueMap {"1", "2", "3", "4", "5"} ,
|
|
Values {"Other", "Unknown", "Available", "In Use/Not Available",
|
|
"In Use and Available/Shareable"}, MappingStrings {"MIF.DMTF|DMA|001.2"
|
|
} ]
|
|
uint16 Availability ;
|
|
[read , Description (
|
|
"Indicate whether the DMA channel supports burst mode") ,
|
|
MappingStrings {"MIF.DMTF|DMA|001.3"} ]
|
|
boolean BurstMode ;
|
|
[read , Description(
|
|
"An array indicating all the transfer widths (in bits) supported by this "
|
|
"DMA Channel. Permissible values are 8, 16, 32, 64 or 128 bits. "
|
|
"If unknown, enter 0."),
|
|
Units ("Bits") ,
|
|
MappingStrings {"MIF.DMTF|System Resource DMA Info|001.2"},
|
|
ValueMap{ "0", "8", "16", "32", "64", "128"} ]
|
|
uint16 TransferWidths[] ;
|
|
[read , Description (
|
|
"An integer indicating the DMA channel address size in bits. Permissible "
|
|
"values are 8, 16, 32 or 64 bits. If unknown, enter 0.") , Units ("Bits"
|
|
) , ValueMap {"0", "8", "16", "32", "64"} , MappingStrings {
|
|
"MIF.DMTF|System Resource DMA Info|001.3"} ]
|
|
uint16 AddressSize ;
|
|
[read , Description (
|
|
"The maximum number of bytes that can be transferred by this DMA channel."
|
|
" If unknown, enter 0.") , Units ("Bytes") , MappingStrings {
|
|
"MIF.DMTF|System Resource DMA Info|001.4"} ]
|
|
uint32 MaxTransferSize ;
|
|
[read , Description (
|
|
"Indicates whether DMA may execute in 'count by byte' mode (value=4) or "
|
|
"not (value=3). Also, \"Other\" (1) and \"Unknown\" (2) may be defined."
|
|
) , ValueMap {"1", "2", "3", "4"} , Values {"Other", "Unknown",
|
|
"Not execute in 'count by byte' mode", "Execute in 'count by byte' mode"
|
|
}, MappingStrings {"MIF.DMTF|System Resource DMA Info|001.7"} ]
|
|
uint16 ByteMode ;
|
|
[read , Description (
|
|
"Indicates whether DMA may execute in 'count by word' mode (value=4) or "
|
|
"not (value=3). Also, \"Other\" (1) and \"Unknown\" (2) may be defined."
|
|
) , ValueMap {"1", "2", "3", "4"} , Values {"Other", "Unknown",
|
|
"Not execute in 'count by word' mode", "Execute in 'count by word' mode"
|
|
}, MappingStrings {"MIF.DMTF|System Resource DMA Info|001.8"} ]
|
|
uint16 WordMode ;
|
|
[read , Description (
|
|
"DMA channel timing. For example, \"Type A\" (value =4) or \"Type F\" "
|
|
"(6) could be specified.") ,
|
|
ValueMap {"1", "2", "3", "4", "5", "6"} ,
|
|
Values {"Other", "Unknown",
|
|
"ISA Compatible", "Type A", "Type B", "Type F"}, MappingStrings {
|
|
"MIF.DMTF|System Resource DMA Info|001.9"} ]
|
|
uint16 ChannelTiming ;
|
|
[read , Description (
|
|
"Indicates whether C type (burst) timing is supported (value=5) or not ("
|
|
"value=4). Also, \"Other\" (1), \"Unknown\" (2) and \"ISA Compatible\" ("
|
|
"3) are defined.") , ValueMap {"1", "2", "3", "4", "5"} , Values {
|
|
"Other", "Unknown", "ISA Compatible", "Not Supported", "Supported"} ,
|
|
MappingStrings {"MIF.DMTF|System Resource DMA Info|001.10"} ]
|
|
uint16 TypeCTiming ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"A CIM_System is a LogicalElement that aggregates an enumerable set of "
|
|
"Managed System Elements. The aggregation operates as a functional "
|
|
"whole. Within any particular subclass of System, there is a "
|
|
"well-defined list of Managed System Element classes whose instances "
|
|
"must be aggregated."),
|
|
Locale (0x409), UUID ("{8502C524-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_System: CIM_LogicalElement
|
|
{
|
|
[CIM_Key, Read,
|
|
Description ("The CreationClassName property indicates the name "
|
|
"of the class or the subclass used in the creation of an instance. "
|
|
"When used with the other key properties of this class, this "
|
|
"property allows all instances of this class and its subclasses to "
|
|
"be uniquely identified.")]
|
|
string CreationClassName ;
|
|
|
|
[Override ("Name") , Description (
|
|
"The Name property defines the label by which the object is known. "
|
|
"When subclassed, the Name property can be overridden to be a Key "
|
|
"property.") , Key, Read]
|
|
string Name ;
|
|
[Description (
|
|
"The CIM_System object and its derivatives are top level objects of CIM. "
|
|
"They provide the scope for numerous components. Having unique system "
|
|
"keys is required. A heuristic can be defined in individual system "
|
|
"subclasses to attempt to always generate the same system name key. The "
|
|
"NameFormat property identifies how the system name was generated, using "
|
|
"the subclass' heuristic.") , Read ]
|
|
string NameFormat ;
|
|
[Description (
|
|
"A string that provides information on how the primary system owner can "
|
|
"be reached (e.g. phone number, email address, ...).") , Read ]
|
|
string PrimaryOwnerContact ;
|
|
[MaxLen(64),
|
|
Description ("The name of the primary system owner.") , Read ]
|
|
string PrimaryOwnerName ;
|
|
[Description (
|
|
"An array (bag) of strings that specify the roles this System "
|
|
"plays in the IT-environment. Subclasses of System may "
|
|
"override this property to define explicit Roles values. "
|
|
"Alternately, a Working Group may describe the heuristics, "
|
|
"conventions and guidelines for specifying Roles. For "
|
|
"example, for an instance of a networking system, the Roles "
|
|
"property might contain the string, 'Switch' or 'Bridge'.") , Read, Write ]
|
|
string Roles[] ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"A class derived from CIM_System that is a special collection of "
|
|
"CIM_ManagedSystemElement instances. This collection provides compute "
|
|
"capabilities and serves as aggregation point to associate one or more "
|
|
"of the following elements: file system, operating system, processor and "
|
|
"memory (volatile and/or non-volatile storage)."),
|
|
Locale (0x409), UUID ("{8502C525-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_ComputerSystem:CIM_System
|
|
{
|
|
[Override ("NameFormat") , Description (
|
|
"The CIM_ComputerSystem object and its derivatives are Top Level Objects of "
|
|
"CIM. They provide the scope for numerous components. Having unique "
|
|
"CIM_System keys is required. A heuristic is defined to create the "
|
|
"CIM_ComputerSystem name to attempt to always generate the same name, "
|
|
"independent of discovery protocol. This prevents inventory and "
|
|
"management problems where the same asset or entity is discovered "
|
|
"multiple times, but can not be resolved to a single object. Use of the "
|
|
"heuristic is optional, but recommended. \n\n The NameFormat property "
|
|
"identifies how the computer system name is generated, using a heuristic. "
|
|
"The heuristic is outlined, in detail, in the CIM V2 Common Model "
|
|
"specification. It assumes that the documented rules are traversed in "
|
|
"order, to determine and assign a name. The NameFormat values list "
|
|
"defines the precedence order for assigning the computer system name. "
|
|
"Several rules do map to the same Value. \n\n Note that the "
|
|
"CIM_ComputerSystem Name calculated using the heuristic is the system's key "
|
|
"value. Other names can be assigned and used for the CIM_ComputerSystem "
|
|
"that better suit the business, using Aliases.") , ValueMap {"IP", "Dial"
|
|
, "HID", "NWA", "HWA", "X25", "ISDN", "IPX", "DCC", "ICD", "E.164",
|
|
"SNA", "OID/OSI", "Other"} ,
|
|
Values {"IP", "Dial"
|
|
, "HID", "NWA", "HWA", "X25", "ISDN", "IPX", "DCC", "ICD", "E.164",
|
|
"SNA", "OID/OSI", "Other"},
|
|
Read ]
|
|
string NameFormat ;
|
|
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"A class derived from CIM_ComputerSystem that represents a desktop, mobile, "
|
|
"network PC, server or other type of a single node computer system."),
|
|
Locale (0x409), UUID ("{8502C526-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_UnitaryComputerSystem:CIM_ComputerSystem
|
|
{
|
|
[Description (
|
|
"This object contains the data needed to find either the "
|
|
"initial load device (its key) or the boot service to "
|
|
"request the operating system to start up. In addition, "
|
|
"the load parameters (ie, a pathname and parameters) "
|
|
"may also be specified.") , Read ]
|
|
string InitialLoadInfo[] ;
|
|
[Description (
|
|
"This object contains the data identifying either the "
|
|
"initial load device (its key) or the boot service that "
|
|
"requested the last operating system load. In addition, "
|
|
"the load parameters (ie, a pathname and parameters) "
|
|
"may also be specified.") , Read
|
|
]
|
|
string LastLoadInfo ;
|
|
[Description (
|
|
"Boolean indicating that the ComputerSystem, with its "
|
|
"running OperatingSystem, supports power management. This "
|
|
"boolean does not indicate that power management features are "
|
|
"currently enabled, or if enabled, what features are "
|
|
"supported. Refer to the PowerManagementCapabilities array "
|
|
"for this information. If this boolean is false, the integer "
|
|
"value 1 for the string, \"Not Supported\", should be the "
|
|
"only entry in the PowerManagementCapabilities array.") , Read ]
|
|
boolean PowerManagementSupported ;
|
|
[read , Description (
|
|
"Indicates the specific power-related capabilities of a computer system "
|
|
"and its associated running operating system. The values, 0=\"Unknown\", "
|
|
"1=\"Not Supported\", and 2=\"Disabled\" are self-explanatory. The value,"
|
|
" 3=\"Enabled\" indicates that the power management features are "
|
|
"currently enabled but the exact feature set is unknown or the "
|
|
"information is unavailable. \"Power Saving Modes Entered "
|
|
"Automatically\" (4) describes that a system can change its power state "
|
|
"based on usage or other criteria. \"Power State Settable\" (5) "
|
|
"indicates that the SetPowerState method is supported. \"Power Cycling "
|
|
"Supported\" (6) indicates that the SetPowerState method can be invoked "
|
|
"with the PowerState parameter set to 5 (\"Power Cycle\"). \"Timed "
|
|
"Power On Supported\" (7) indicates that the SetPowerState method can be "
|
|
"invoked with the PowerState parameter set to 5 (\"Power Cycle\") "
|
|
"and the Time parameter set to a specific date and time, or interval, "
|
|
"for power-on.") , Values {"Unknown", "Not Supported", "Disabled",
|
|
"Enabled", "Power Saving Modes Entered Automatically",
|
|
"Power State Settable", "Power Cycling Supported",
|
|
"Timed Power On Supported"} , MappingStrings {
|
|
"MIF.DMTF|System Power Controls|001.2"} ]
|
|
uint16 PowerManagementCapabilities[] ;
|
|
[Read , Description(
|
|
"Indicates the current power state of the computer system and "
|
|
"its associated operating system. Regarding the power saving "
|
|
"states, these are defined as follows: Value 4 (Unknown) "
|
|
"indicates that the system is known to be in a power save mode, but its exact status in this mode is "
|
|
"unknown; 2 (Low Power Mode) indicates that "
|
|
"the system is in a power save state but still functioning, "
|
|
"and may exhibit degraded performance; 3 ("
|
|
"Standby) describes that the system is not functioning but "
|
|
"could be brought to full power 'quickly'; and value 7 "
|
|
"(Warning) indicates that the computer"
|
|
"System is in a warning state, though also in a power save "
|
|
"mode."),
|
|
Values {"Unknown", "Full Power",
|
|
"Power Save - Low Power Mode", "Power Save - Standby",
|
|
"Power Save - Unknown", "Power Cycle", "Power Off",
|
|
"Power Save - Warning",
|
|
"Power Save - Hibernate", "Power Save - Soft Off"} ]
|
|
uint16 PowerState ;
|
|
[read , Description (
|
|
"If enabled (value = 4), the unitary computer system can be reset via "
|
|
"hardware (e.g. the power and reset buttons). If disabled (value = 3), "
|
|
"hardware reset is not allowed. In addition to Enabled and Disabled, "
|
|
"other values for the property are also defined - \"Not Implemented\" (5)"
|
|
", \"Other\" (1) and \"Unknown\" (2).") , ValueMap {"1", "2", "3", "4",
|
|
"5"} , Values {"Other", "Unknown", "Disabled", "Enabled",
|
|
"Not Implemented"} , MappingStrings {
|
|
"MIF.DMTF|System Hardware Security|001.4"} ]
|
|
uint16 ResetCapability ;
|
|
|
|
[Description (
|
|
"SetPowerState method defines the desired power state of a computer system and "
|
|
"its running operating system, and when the system should be put into "
|
|
"that state. The PowerState parameter is specified as one of the valid "
|
|
"integer values defined for the property, PowerState. The Time parameter "
|
|
"(for all state changes but 5, \"Power Cycle\") indicates when the power "
|
|
"state should be set, either as a regular date-time value or as an "
|
|
"interval value (where the interval begins when the method invocation is "
|
|
"received). When the PowerState parameter is equal to 5, \"Power Cycle\","
|
|
" the Time parameter indicates when the system should power on again. "
|
|
"power off is immediate. SetPowerState should return 0 if successful, 1 "
|
|
"if the specified power state and time requests are not supported, and some "
|
|
"other value if any other error occurred.") ]
|
|
uint32 SetPowerState([IN, ValueMap {"1", "2", "3", "4", "5", "6", "7", "8"},
|
|
Values {"Full Power", "Power Save - Low Power Mode",
|
|
"Power Save - Standby", "Power Save - Other",
|
|
"Power Cycle", "Power Off", "Hibernate", "Soft Off"}] uint16 PowerState,
|
|
[IN] datetime Time) ;
|
|
};
|
|
|
|
[DisplayName("Services (CIM)"),
|
|
Abstract, Description (
|
|
"A CIM_Service is a Logical Element that contains the information "
|
|
"necessary to represent and manage the functionality provided by "
|
|
"a Device and/or SoftwareFeature. A Service is a general-purpose "
|
|
"object to configure and manage the implementation of "
|
|
"functionality. It is not the functionality itself."),
|
|
Locale (0x409), UUID ("{8502C527-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Service:CIM_LogicalElement
|
|
{
|
|
[DisplayName("Class Name"),
|
|
CIM_Key, Read,
|
|
Description ("CreationClassName indicates the name of the class or the "
|
|
"subclass used in the creation of an instance. When used with the other "
|
|
"key properties of this class, this property allows all instances of this "
|
|
"class and its subclasses to be uniquely identified.") ]
|
|
string CreationClassName ;
|
|
[Override ("Name") , Key, Description (
|
|
"The Name property uniquely identifies the service and provides an "
|
|
"indication of the functionality that is managed. This functionality is "
|
|
"described in more detail in the object's Description property. ") ,
|
|
Read ]
|
|
string Name ;
|
|
[DisplayName("Start Mode"),
|
|
Description (
|
|
"StartMode is a string value indicating whether the Service "
|
|
"is automatically started by a System, Operating System, etc. "
|
|
"or only started upon request.") , ValueMap {"Automatic", "Manual"} , Values {"Automatic", "Manual"} , Read ]
|
|
string StartMode ;
|
|
[DisplayName("Started"),
|
|
Description (
|
|
"Started is a boolean indicating whether the service has been "
|
|
"started (TRUE), or stopped (FALSE).") , Read ]
|
|
boolean Started ;
|
|
[DisplayName("System Class Name"),
|
|
Propagated ("CIM_System.CreationClassName") , CIM_Key, Description (
|
|
"The scoping System's CreationClassName. ") , Read ]
|
|
string SystemCreationClassName ;
|
|
[DisplayName("System Name"),
|
|
Propagated ("CIM_System.Name") , CIM_Key, Description (
|
|
"The name of the system that hosts this service") , Read ]
|
|
string SystemName ;
|
|
[Description (
|
|
"The StartService method places the Service in the started "
|
|
"state. It returns an integer value of 0 if the Service was "
|
|
"successfully started, 1 if the request is not supported and "
|
|
"any other number to indicate an error. In a subclass, the "
|
|
"set of possible return codes could be specified, using a "
|
|
"ValueMap qualifier on the method. The strings to which the "
|
|
"ValueMap contents are 'translated' may also be specified in "
|
|
"the subclass as a Values array qualifier.") ]
|
|
uint32 StartService() ;
|
|
[Description (
|
|
"The StopService method places the service in the stopped state. It "
|
|
"returns an integer value of 0 if the service was successfully stopped, "
|
|
"1 if the request is not supported and any other number to indicate an "
|
|
"error.") ]
|
|
uint32 StopService() ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_ClusteringService class represents the functionality "
|
|
"provided by a cluster. For example, failover functionality may "
|
|
"be modeled as a service of a failover cluster."),
|
|
Locale (0x409), UUID ("{debac832-6b54-4add-8a62-8d3861b97b1d}")
|
|
]
|
|
class CIM_ClusteringService : CIM_Service
|
|
{
|
|
[Description (
|
|
"AddNode brings a new computer system into a cluster. "
|
|
"The node to be added is specified as a parameter to the "
|
|
"method. The return value should be 0 if the computer "
|
|
"system is successfully added, 1 if the method is not "
|
|
"supported and any other number if an error occurred.")
|
|
]
|
|
uint32 AddNode ([IN] CIM_ComputerSystem ref CS);
|
|
[Description (
|
|
"EvictNode removes a computer system from a cluster. "
|
|
"The node to be evicted is specified as a parameter to the "
|
|
"method. The return value should be 0 if the computer system "
|
|
"is successfully evicted, 1 if the method is not supported "
|
|
"and any other number if an error occurred.")
|
|
]
|
|
uint32 EvictNode ([IN] CIM_ComputerSystem ref CS);
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{F126ACC2-E3D4-11d2-8601-0000F8102E5F}" ),
|
|
Abstract, Description (
|
|
"CIM_ServiceAccessPoint represents the ability to utilize or invoke a "
|
|
"service. Access points represent that a service is made available to "
|
|
"other entities for use.") ]
|
|
class CIM_ServiceAccessPoint:CIM_LogicalElement
|
|
{
|
|
[CIM_Key, MaxLen (256) , Description (
|
|
"CreationClassName indicates the name of the class or the subclass used "
|
|
"in the creation of an instance. When used with the other key properties "
|
|
"of this class, this property allows all instances of this class and its "
|
|
"subclasses to be uniquely identified."), Read ]
|
|
string CreationClassName;
|
|
[Override ("Name") , Key, MaxLen (256) , Description (
|
|
"The Name property uniquely identifies the service access point and "
|
|
"provides an indication of the functionality that is managed. This "
|
|
"functionality is described in more detail in the object's Description "
|
|
"property."), Read ]
|
|
string Name;
|
|
[Propagated ("CIM_System.CreationClassName") , CIM_Key, MaxLen (256) ,
|
|
Description ("The scoping system's creation class name."), Read ]
|
|
string SystemCreationClassName;
|
|
[Propagated ("CIM_System.Name") , CIM_Key, MaxLen (256) , Description (
|
|
"The scoping system's name."), Read ]
|
|
string SystemName;
|
|
[Read: ToSubClass, Description ("The Type property indicates the type "
|
|
"of SAP such as 'attached' or 'Redirected'."): ToSubClass,
|
|
Schema ("Win32"): ToSubClass,
|
|
BitValues {"Write", "Read", "Redirected", "Net_Attached",
|
|
"unknown"}: ToSubClass ]
|
|
uint32 Type;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"A representation of the access points of a clustering service."),
|
|
Locale (0x409), UUID ("{2bb2b772-ffed-4aa6-b1b3-3d0cb74fc613}")]
|
|
class CIM_ClusteringSAP : CIM_ServiceAccessPoint
|
|
{
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"An abstraction or emulation of a hardware entity, that may or may not "
|
|
"be realized in physical hardware. Any characteristics of "
|
|
"logical devices that are used to manage its operation or configuration "
|
|
"are contained in, or associated with, the CIM_LogicalDevice object. "
|
|
"Examples of the operational properties for a printer would be paper "
|
|
"sizes supported, or detected errors. Examples of the configuration "
|
|
"properties of a sensor device would be threshold settings. Various "
|
|
"configurations could exist for a logical device. These configurations "
|
|
"could be contained in CIM_Setting objects and associated with the "
|
|
"logical device."),
|
|
Locale (0x409), UUID ("{8502C529-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_LogicalDevice:CIM_LogicalElement
|
|
{
|
|
[Read , Description (
|
|
"The availability and status of the device. For example, the "
|
|
"Availability property indicates that the device is running "
|
|
"and has full power (value=3), or is in a warning (4), test "
|
|
"(5), degraded (10) or power save state (values 13-15 and "
|
|
"17). Regarding the power saving states, these are defined "
|
|
"as follows: Value 13 (\"Power Save - Unknown\") indicates "
|
|
"that the device is known to be in a power save mode, but its "
|
|
"exact status in this mode is unknown; 14 (\"Power Save - Low "
|
|
"Power Mode\") indicates that the device is in a power save "
|
|
"state but still functioning, and may exhibit degraded "
|
|
"performance; 15 (\"Power Save - Standby\") describes that "
|
|
"the device is not functioning but could be brought to full "
|
|
"power 'quickly'; and value 17 (\"Power Save - Warning\") "
|
|
"indicates that the device is in a warning state, though also "
|
|
"in a power save mode."),
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9",
|
|
"10", "11", "12", "13", "14", "15", "16", "17", "18", "19",
|
|
"20", "21"},
|
|
Values {"Other", "Unknown", "Running/Full Power", "Warning",
|
|
"In Test", "Not Applicable", "Power Off", "Off Line",
|
|
"Off Duty", "Degraded", "Not Installed", "Install Error",
|
|
"Power Save - Unknown", "Power Save - Low Power Mode",
|
|
"Power Save - Standby", "Power Cycle",
|
|
"Power Save - Warning",
|
|
"Paused", "Not Ready", "Not Configured", "Quiesced"},
|
|
MappingStrings {"MIF.DMTF|Operational State|003.5",
|
|
"MIB.IETF|HOST-RESOURCES-MIB.hrDeviceStatus"} ]
|
|
uint16 Availability ;
|
|
[CIM_Key, Read, Description (
|
|
"CreationClassName indicates the name of the class or the subclass used "
|
|
"in the creation of an instance. When used with the other key properties "
|
|
"of this class, this property allows all instances of this class and its "
|
|
"subclasses to be uniquely identified.") ]
|
|
string CreationClassName ;
|
|
[Read , Schema ("Win32") , Description (
|
|
"Indicates the Win32 Configuration Manager error code. The following "
|
|
"values may be returned: \n"
|
|
"0 This device is working properly. \n"
|
|
"1 This device is not configured correctly. \n"
|
|
"2 Windows cannot load the driver for this device. \n"
|
|
"3 The driver for this device might be corrupted, or your system may be running low on memory or other resources. \n"
|
|
"4 This device is not working properly. One of its drivers or your registry might be corrupted. \n"
|
|
"5 The driver for this device needs a resource that Windows cannot manage. \n"
|
|
"6 The boot configuration for this device conflicts with other devices. \n"
|
|
"7 Cannot filter. \n"
|
|
"8 The driver loader for the device is missing. \n"
|
|
"9 This device is not working properly because the controlling firmware is reporting the resources for the device incorrectly. \n"
|
|
"10 This device cannot start. \n"
|
|
"11 This device failed. \n"
|
|
"12 This device cannot find enough free resources that it can use. \n"
|
|
"13 Windows cannot verify this device's resources. \n"
|
|
"14 This device cannot work properly until you restart your computer. \n"
|
|
"15 This device is not working properly because there is probably a re-enumeration problem. \n"
|
|
"16 Windows cannot identify all the resources this device uses. \n"
|
|
"17 This device is asking for an unknown resource type. \n"
|
|
"18 Reinstall the drivers for this device. \n"
|
|
"19 Your registry might be corrupted. \n"
|
|
"20 Failure using the VxD loader. \n"
|
|
"21 System failure: Try changing the driver for this device. If that does not work, see your hardware documentation. Windows is removing this device. \n"
|
|
"22 This device is disabled. \n"
|
|
"23 System failure: Try changing the driver for this device. If that doesn't work, see your hardware documentation. \n"
|
|
"24 This device is not present, is not working properly, or does not have all its drivers installed. \n"
|
|
"25 Windows is still setting up this device. \n"
|
|
"26 Windows is still setting up this device. \n"
|
|
"27 This device does not have valid log configuration. \n"
|
|
"28 The drivers for this device are not installed. \n"
|
|
"29 This device is disabled because the firmware of the device did not give it the required resources. \n"
|
|
"30 This device is using an Interrupt Request (IRQ) resource that another device is using. \n"
|
|
"31 This device is not working properly because Windows cannot load the drivers required for this device."),
|
|
ValueMap {"0", "1","2", "3","4", "5","6", "7","8", "9","10", "11","12",
|
|
"13","14", "15","16", "17","18", "19","20", "21","22", "23","24","25",
|
|
"26","27", "28","29", "30","31"},
|
|
Values {
|
|
"This device is working properly.",
|
|
"This device is not configured correctly.",
|
|
"Windows cannot load the driver for this device.",
|
|
"The driver for this device might be corrupted, or your system may be running low on memory or other resources.",
|
|
"This device is not working properly. One of its drivers or your registry might be corrupted.",
|
|
"The driver for this device needs a resource that Windows cannot manage.",
|
|
"The boot configuration for this device conflicts with other devices.",
|
|
"Cannot filter.",
|
|
"The driver loader for the device is missing.",
|
|
"This device is not working properly because the controlling firmware is reporting the resources for the device incorrectly.",
|
|
"This device cannot start.",
|
|
"This device failed.",
|
|
"This device cannot find enough free resources that it can use.",
|
|
"Windows cannot verify this device's resources.",
|
|
"This device cannot work properly until you restart your computer.",
|
|
"This device is not working properly because there is probably a re-enumeration problem.",
|
|
"Windows cannot identify all the resources this device uses.",
|
|
"This device is asking for an unknown resource type.",
|
|
"Reinstall the drivers for this device.",
|
|
"Failure using the VxD loader.",
|
|
"Your registry might be corrupted.",
|
|
"System failure: Try changing the driver for this device. If that does not work, see your hardware documentation. Windows is removing this device.",
|
|
"This device is disabled.",
|
|
"System failure: Try changing the driver for this device. If that doesn't work, see your hardware documentation.",
|
|
"This device is not present, is not working properly, or does not have all its drivers installed.",
|
|
"Windows is still setting up this device.",
|
|
"Windows is still setting up this device.",
|
|
"This device does not have valid log configuration.",
|
|
"The drivers for this device are not installed.",
|
|
"This device is disabled because the firmware of the device did not give it the required resources.",
|
|
"This device is using an Interrupt Request (IRQ) resource that another device is using.",
|
|
"This device is not working properly because Windows cannot load the drivers required for this device."
|
|
} ]
|
|
uint32 ConfigManagerErrorCode ;
|
|
[read , Schema ("Win32") , Description (
|
|
"Indicates whether the device is using a user-defined configuration.")
|
|
]
|
|
boolean ConfigManagerUserConfig ;
|
|
[read, Description (
|
|
"DeviceID is an address or other identifying information to uniquely name "
|
|
"the logical device.") , CIM_Key ]
|
|
string DeviceID ;
|
|
[read , Description (
|
|
"Indicates the specific power-related capabilities of the logical device. "
|
|
"The array values, 0=\"Unknown\", 1=\"Not Supported\" and 2=\"Disabled\" "
|
|
"are self-explanatory. The value, 3=\"Enabled\" indicates that the power "
|
|
"management features are currently enabled but the exact feature set is "
|
|
"unknown or the information is unavailable. \"Power Saving Modes Entered "
|
|
"Automatically\" (4) describes that a device can change its power state "
|
|
"based on usage or other criteria. \"Power State Settable\" (5) "
|
|
"indicates that the SetPowerState method is supported. \"Power Cycling "
|
|
"Supported\" (6) indicates that the SetPowerState method can be invoked "
|
|
"with the PowerState input variable set to 5 (\"Power Cycle\"). \"Timed "
|
|
"Power On Supported\" (7) indicates that the SetPowerState method can be "
|
|
"invoked with the PowerState input variable set to 5 (\"Power Cycle\") "
|
|
"and the Time parameter set to a specific date and time, or interval, "
|
|
"for power-on.") , Values {"Unknown", "Not Supported", "Disabled",
|
|
"Enabled", "Power Saving Modes Entered Automatically",
|
|
"Power State Settable", "Power Cycling Supported",
|
|
"Timed Power On Supported"} ]
|
|
uint16 PowerManagementCapabilities[] ;
|
|
[read , Schema ("Win32") , Description (
|
|
"Indicates the Win32 Plug and Play device ID of the logical device. "
|
|
"Example: *PNP030b") ]
|
|
string PNPDeviceID ;
|
|
[read , Description (
|
|
"Boolean indicating that the Device can be power managed "
|
|
"- ie, put into a power save state. This boolean does not "
|
|
"indicate that power management features are currently "
|
|
"enabled, or if enabled, what features are supported. "
|
|
"Refer to the PowerManagementCapabilities array for this "
|
|
"information. If this boolean is false, the integer value "
|
|
"1, for the string, \"Not Supported\", should be the only "
|
|
"entry in the PowerManagementCapabilities array.") ]
|
|
boolean PowerManagementSupported ;
|
|
[read , Description (
|
|
"StatusInfo is a string indicating whether the logical device is in an "
|
|
"enabled (value = 3), disabled (value = 4) or some other (1) or unknown ("
|
|
"2) state. If this property does not apply to the logical device, the "
|
|
"value, 5 (\"Not Applicable\"), should be used.") , ValueMap {"1", "2",
|
|
"3", "4", "5"} , Values {"Other", "Unknown", "Enabled", "Disabled",
|
|
"Not Applicable"} , MappingStrings {"MIF.DMTF|Operational State|003.3"}
|
|
]
|
|
uint16 StatusInfo ;
|
|
[Propagated ("CIM_System.CreationClassName"), CIM_Key, Read,
|
|
Description ("The scoping System's CreationClassName.") ]
|
|
string SystemCreationClassName ;
|
|
[Propagated ("CIM_System.Name") , CIM_Key, Read,
|
|
Description ("The scoping System's Name.")]
|
|
string SystemName ;
|
|
[Description(
|
|
"SetPowerState defines the desired power state for a "
|
|
"logical device and when a device should be put into that "
|
|
"state. The desired power state is specified by setting "
|
|
"the PowerState parameter to one of the "
|
|
"following integer values: 1=\"Full Power\", 2=\"Power Save "
|
|
"- Low Power Mode\", 3=\"Power Save - Standby\", 4=\"Power "
|
|
"Save - Other\", 5=\"Power Cycle\" or 6=\"Power Off\". "
|
|
"The Time parameter (for all state changes, except 5, "
|
|
"\"Power Cycle\") indicates when the power state should be "
|
|
"set, either as a regular date-time value or as an interval "
|
|
"value (where the interval begins when the method "
|
|
"invocation is received). When the PowerState parameter is "
|
|
"equal to 5, \"Power Cycle\", the Time parameter indicates "
|
|
"when the device should power on again. Power off is "
|
|
"immediate. SetPowerState should return 0 if successful, 1 "
|
|
"if the specified PowerState and Time request is not "
|
|
"supported, and some other value if any other error "
|
|
"occurred. In a subclass, the set of possible return codes "
|
|
"could be specified, using a ValueMap qualifier on the method. "
|
|
"The strings to which the ValueMap contents are 'translated' "
|
|
"may also be specified in the subclass as a Values array "
|
|
"qualifier.") ]
|
|
uint32 SetPowerState([IN, ValueMap {"1", "2", "3", "4", "5", "6"},
|
|
Values {"Full Power", "Power Save - Low Power Mode",
|
|
"Power Save - Standby", "Power Save - Other", "Power Cycle",
|
|
"Power Off"}] uint16 PowerState, [IN] datetime Time) ;
|
|
[Description (
|
|
"Requests a reset of the logical device. The return value should be 0 if "
|
|
"the request was successfully executed, 1 if the request is not "
|
|
"supported and some other value if an error occurred.") ]
|
|
uint32 Reset() ;
|
|
[Read , Description (
|
|
"LastErrorCode captures the last error code reported by the "
|
|
"logical device.") ]
|
|
uint32 LastErrorCode;
|
|
[Read , Description (
|
|
"ErrorDescription is a free-form string supplying more "
|
|
"information about the error recorded in LastErrorCode property, and information "
|
|
"on any corrective actions that may be taken.") ]
|
|
string ErrorDescription;
|
|
[Read , Description (
|
|
"ErrorCleared is a boolean property indicating that the "
|
|
"error reported in LastErrorCode property is now cleared.") ]
|
|
boolean ErrorCleared;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"CIM_MediaAccessDevice represents the ability to access one or more media "
|
|
"and use this media to store and retrieve data."),
|
|
Locale (0x409), UUID ("{8502C52A-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_MediaAccessDevice:CIM_LogicalDevice
|
|
{
|
|
[read , Description (
|
|
"Capabilities of the media access device. For example, the "
|
|
"device may support \"Random Access\", removable media and \"Automatic "
|
|
"Cleaning\". In this case, the values 3, 7 and 9 would be written to "
|
|
"the array. \n"
|
|
"Several of the enumerated values require some explanation: "
|
|
"1) Value 11, Supports Dual Sided Media, distinguishes a "
|
|
"Device that can access both sides of dual sided Media, from "
|
|
"a Device that reads only a single side and requires the "
|
|
"Media to be flipped; and, 2) Value 12, Predismount Eject "
|
|
"Not Required, indicates that Media does not have to be "
|
|
"explicitly ejected from the Device before being accessed "
|
|
"by a PickerElement.") , ArrayType ("Indexed") , Values {"Unknown",
|
|
"Other", "Sequential Access", "Random Access", "Supports Writing",
|
|
"Encryption", "Compression", "Supports Removeable Media", "Manual Cleaning", "Automatic Cleaning",
|
|
"SMART Notification", "Supports Dual Sided Media",
|
|
"Predismount Eject Not Required" } ,
|
|
MappingStrings {"MIF.DMTF|Storage Devices|001.9",
|
|
"MIF.DMTF|Storage Devices|001.11", "MIF.DMTF|Storage Devices|001.12",
|
|
"MIF.DMTF|Disks|003.7"} ,
|
|
ModelCorrespondence {"CIM_MediaAccessDevice.CapabilityDescriptions"} ]
|
|
uint16 Capabilities[] ;
|
|
[read , Description (
|
|
"An array of free-form strings providing more detailed explanations for "
|
|
"any of the access device features indicated in the Capabilities array. "
|
|
"Note, each entry of this array is related to the entry in the "
|
|
"Capabilities array that is located at the same index.") , ArrayType (
|
|
"Indexed") ,
|
|
ModelCorrespondence {"CIM_MediaAccessDevice.Capabilities"} ]
|
|
string CapabilityDescriptions[] ;
|
|
[read , Description (
|
|
"A free form string indicating the algorithm or tool used by the device "
|
|
"to support compression. If it is not possible or not desired to "
|
|
"describe the compression scheme (perhaps because it is not known), "
|
|
"recommend using the following words: \"Unknown\" to represent that it "
|
|
"is not known whether the device supports compression capabilities or "
|
|
"not, \"Compressed\" to represent that the device supports compression "
|
|
"capabilities but either its compression scheme is not known or not "
|
|
"disclosed, and \"Not Compressed\" to represent that the devices does "
|
|
"not support compression capabilities.") ]
|
|
string CompressionMethod ;
|
|
[read , Description (
|
|
"ErrorMethodology is a free-form string describing the type(s) of error "
|
|
"detection and correction supported by this device.") ]
|
|
string ErrorMethodology ;
|
|
[read , Description (
|
|
"Maximum size, in Kbytes, of media supported by this device. "
|
|
"KBytes is interpreted as the number of bytes multiplied by "
|
|
"1000 (NOT the number of bytes multiplied by 1024).") , Units (
|
|
"Kilobytes") , MappingStrings {
|
|
"MIF.DMTF|Sequential Access Devices|001.2"} ]
|
|
uint64 MaxMediaSize ;
|
|
[read , Description ("Default block size, in bytes, for this device.") ,
|
|
Units ("Bytes") ]
|
|
uint64 DefaultBlockSize ;
|
|
[read , Description (
|
|
"Maximum block size, in bytes, for media accessed by this device.") ,
|
|
Units ("Bytes") ]
|
|
uint64 MaxBlockSize ;
|
|
[read , Description (
|
|
"Minimum block size, in bytes, for media accessed by this device.") ,
|
|
Units ("Bytes") ]
|
|
uint64 MinBlockSize ;
|
|
[read , Description (
|
|
"When the media access device supports multiple individual media, this "
|
|
"property defines the maximum number which can be supported or inserted."
|
|
) ]
|
|
uint32 NumberOfMediaSupported ;
|
|
[Read, Description (
|
|
"Boolean indicating that the media access device needs cleaning. "
|
|
"Whether manual or automatic cleaning is possible is indicated in the "
|
|
"Capabilities array property. ") ]
|
|
boolean NeedsCleaning;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of a diskette drive, a subtype of "
|
|
"CIM_MediaAccessDevice."),Locale (0x409), UUID ("{F27851CD-BBAC-11d2-85E5-0000F8102E5F}") ]
|
|
class CIM_DisketteDrive:CIM_MediaAccessDevice
|
|
{
|
|
};
|
|
|
|
[Abstract, Description ("Capabilities and management of cooling devices."),
|
|
Locale (0x409), UUID ("{9565979A-7D80-11D2-AAD3-006008C78BC7}")]
|
|
class CIM_CoolingDevice : CIM_LogicalDevice
|
|
{
|
|
[Description (
|
|
"ActiveCooling is a boolean indicating that the cooling "
|
|
"device provides active (as opposed to passive) cooling."),
|
|
read
|
|
]
|
|
boolean ActiveCooling;
|
|
};
|
|
|
|
[Locale (0x409), UUID ("{F3A5233A-E3D3-11d2-8601-0000F8102E5F}"),
|
|
Abstract,
|
|
Description (
|
|
"Capabilities and management of a refrigeration cooling device.")]
|
|
class CIM_Refrigeration : CIM_CoolingDevice
|
|
{
|
|
};
|
|
|
|
[Locale (0x409), UUID ("{FE5D55E0-E3D3-11d2-8601-0000F8102E5F}"),
|
|
Abstract,
|
|
Description (
|
|
"Capabilities and management of a heat pipe cooling device.")
|
|
]
|
|
class CIM_HeatPipe : CIM_CoolingDevice
|
|
{
|
|
};
|
|
|
|
[Locale (0x409), UUID ("{0A59C856-E3D4-11d2-8601-0000F8102E5F}"),
|
|
Abstract,
|
|
Description (
|
|
"Capabilities and management of a fan cooling device.")
|
|
]
|
|
class CIM_Fan : CIM_CoolingDevice
|
|
{
|
|
[Description (
|
|
"Indication of whether the fan supports variable speeds."), read ]
|
|
boolean VariableSpeed;
|
|
[Description (
|
|
"DesiredSpeed is the currently requested fan speed, "
|
|
"defined in revolutions per minute, when a variable speed fan "
|
|
"is supported (VariableSpeed boolean = TRUE). The current "
|
|
"speed is determined via a sensor (CIM_Tachometer) that is "
|
|
"associated with the fan using the CIM_AssociatedSensor "
|
|
"relationship."),
|
|
Units ("Revolutions per Minute") , read
|
|
]
|
|
uint64 DesiredSpeed;
|
|
[Description (
|
|
"Requests that the fan speed be set to the "
|
|
"value specified in the method's input parameter. The return "
|
|
"value should be 0 if the request was successfully executed, "
|
|
"1 if the request is not supported and some other value if an "
|
|
"error occurred. ") ]
|
|
uint32 SetSpeed ([IN] uint64 DesiredSpeed);
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_Sensor class represents a hardware device capable of measuring the "
|
|
"characteristics of some physical property - for example, the "
|
|
"temperature or voltage characteristics of a unitary computer"
|
|
"system.") ,
|
|
Locale (0x409), UUID ("{9565979B-7D80-11D2-AAD3-006008C78BC7}") ]
|
|
class CIM_Sensor : CIM_LogicalDevice
|
|
{
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"A numeric sensor is capable of returning numeric readings "
|
|
"and optionally supports thresholds settings.") ,
|
|
Locale (0x409), UUID ("{9565979C-7D80-11D2-AAD3-006008C78BC7}") ]
|
|
class CIM_NumericSensor : CIM_Sensor
|
|
{
|
|
[Description ("The current value indicated by the sensor."), read ]
|
|
sint32 CurrentReading;
|
|
[Description (
|
|
"NominalReading indicates the 'normal' or expected value "
|
|
"for the numeric sensor."), read
|
|
]
|
|
sint32 NominalReading;
|
|
[Description (
|
|
"NormalMax provides guidance for the user as to the "
|
|
"normal maximum range for the numeric sensor."), read
|
|
]
|
|
sint32 NormalMax;
|
|
[Description (
|
|
"NormalMin provides guidance for the user as to the "
|
|
"normal minimum range for the numeric sensor."), read
|
|
]
|
|
sint32 NormalMin;
|
|
[Description (
|
|
"MaxReadable indicates the largest value of the measured "
|
|
"property that can be read by the numeric sensor."), read
|
|
]
|
|
sint32 MaxReadable;
|
|
[Description (
|
|
"MinReadable indicates the smallest value of the measured "
|
|
"property that can be read by the numeric sensor."), read
|
|
]
|
|
sint32 MinReadable;
|
|
[Description (
|
|
"Resolution indicates the ability of the sensor to resolve "
|
|
"differences in the measured property. This value may vary "
|
|
"depending on whether the device is linear over its dynamic "
|
|
"range."), read
|
|
]
|
|
uint32 Resolution;
|
|
[Description (
|
|
"Indicates the tolerance of the sensor for the measured "
|
|
"property. Tolerance, along with resolution and accuracy, "
|
|
"is used to calculate the actual value of the measured "
|
|
"physical property. Tolerance may vary depending on "
|
|
"whether the device is linear over its dynamic range."), read
|
|
]
|
|
sint32 Tolerance;
|
|
[Description (
|
|
"Indicates the accuracy of the sensor for the measured "
|
|
"property. Its value is recorded as plus/minus hundredths "
|
|
"of a percent. Accuracy, along with resolution and tolerance, "
|
|
"is used to calculate the actual value of the measured "
|
|
"physical property. Accuracy may vary depending on whether "
|
|
"the device is linear over its dynamic range."),
|
|
Units ("Hundredths of Percent"), read
|
|
]
|
|
sint32 Accuracy;
|
|
[Description (
|
|
"Indicates that the sensor is linear over its dynamic range."),
|
|
read ]
|
|
boolean IsLinear;
|
|
[Description (
|
|
"The sensor's threshold values specify the ranges (min and max "
|
|
"values) for determining whether the Sensor is operating under "
|
|
"Normal, NonCritical, Critical or Fatal conditions. If Current"
|
|
"Reading is between LowerThresholdNonCritical and UpperThreshold"
|
|
"NonCritical, then the Sensor is reporting a normal value. "
|
|
"If CurrentReading is between LowerThresholdNonCritical and Lower"
|
|
"ThresholdCritical, then the CurrentState is NonCritical."),
|
|
read ]
|
|
sint32 LowerThresholdNonCritical;
|
|
[Description (
|
|
"The sensor's threshold values specify the ranges (min and max "
|
|
"values) for determining whether the Sensor is operating under "
|
|
"Normal, NonCritical, Critical or Fatal conditions. If the Current"
|
|
"Reading is between LowerThresholdNonCritical and UpperThreshold"
|
|
"NonCritical, then the Sensor is reporting a normal value. "
|
|
"If the CurrentReading is between UpperThresholdNonCritical and "
|
|
"UpperThresholdCritical, then the CurrentState is NonCritical."),
|
|
read ]
|
|
sint32 UpperThresholdNonCritical;
|
|
[Description (
|
|
"The Sensor's threshold values specify the ranges (min and max "
|
|
"values) for determining whether the Sensor is operating under "
|
|
"Normal, NonCritical, Critical or Fatal conditions. If the Current"
|
|
"Reading is between LowerThresholdCritical and LowerThreshold"
|
|
"Fatal, then the CurrentState is Critical."),
|
|
read ]
|
|
sint32 LowerThresholdCritical;
|
|
[Description (
|
|
"The sensor's threshold values specify the ranges (min and max "
|
|
"values) for determining whether the Sensor is operating under "
|
|
"Normal, NonCritical, Critical or Fatal conditions. If the Current"
|
|
"Reading is between UpperThresholdCritical and UpperThreshold"
|
|
"Fatal, then the CurrentState is Critical."),
|
|
read ]
|
|
sint32 UpperThresholdCritical;
|
|
[Description (
|
|
"The sensor's threshold values specify the ranges (min and max "
|
|
"values) for determining whether the Sensor is operating under "
|
|
"Normal, NonCritical, Critical or Fatal conditions. If the Current"
|
|
"Reading is below LowerThresholdFatal, then the CurrentState is "
|
|
"Fatal."),
|
|
read ]
|
|
sint32 LowerThresholdFatal;
|
|
[Description (
|
|
"The sensor's threshold values specify the ranges (min and max "
|
|
"values) for determining whether the Sensor is operating under "
|
|
"Normal, NonCritical, Critical or Fatal conditions. If the Current"
|
|
"Reading is above UpperThresholdFatal, then the CurrentState is "
|
|
"Fatal."),
|
|
read ]
|
|
sint32 UpperThresholdFatal;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"This class exists for backward compatibility to earlier "
|
|
"CIM Schema definitions. With additions to Sensor and Numeric"
|
|
"Sensor in V2.2, it is no longer necessary. A TempertatureSensor "
|
|
"can be defined by setting the SensorType property, inherited "
|
|
"from Sensor, to 2 (\"Temperature\"). Other properties of this "
|
|
"class are hard-coded to constant values to correspond to "
|
|
"definitions in the sensor hierarchy."),
|
|
Locale (0x409), UUID ("{9565979D-7D80-11D2-AAD3-006008C78BC7}") ]
|
|
class CIM_TemperatureSensor:CIM_NumericSensor
|
|
{
|
|
[Override ("CurrentReading") ,
|
|
Units ("Tenths of degrees Centigrade"),
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.5"},
|
|
read ]
|
|
sint32 CurrentReading;
|
|
[Override ("NominalReading") ,
|
|
Units ("Tenths of degrees Centigrade"),
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.6"},
|
|
read ]
|
|
sint32 NominalReading;
|
|
[Override ("NormalMax") ,
|
|
Units ("Tenths of degrees Centigrade"),
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.7"},
|
|
read ]
|
|
sint32 NormalMax;
|
|
[Override ("NormalMin") ,
|
|
Units ("Tenths of degrees Centigrade"),
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.8"},
|
|
read ]
|
|
sint32 NormalMin;
|
|
[Override ("MaxReadable") ,
|
|
Units ("Tenths of degrees Centigrade"),
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.9"},
|
|
read ]
|
|
sint32 MaxReadable;
|
|
[Override ("MinReadable") ,
|
|
Units ("Tenths of degrees Centigrade"),
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.10"},
|
|
read ]
|
|
sint32 MinReadable;
|
|
[Override ("Resolution") ,
|
|
Units ("Hundredths of degrees Centigrade"),
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.17"},
|
|
read ]
|
|
uint32 Resolution;
|
|
[Override ("Tolerance") ,
|
|
Units ("Tenths of degrees Centigrade"),
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.18"},
|
|
read ]
|
|
sint32 Tolerance;
|
|
[Override ("Accuracy") ,
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.19"},
|
|
read ]
|
|
sint32 Accuracy;
|
|
[Override ("LowerThresholdNonCritical") ,
|
|
Units ("Tenths of degrees Centigrade"),
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.11"},
|
|
read ]
|
|
sint32 LowerThresholdNonCritical;
|
|
[Override ("UpperThresholdNonCritical") ,
|
|
Units ("Tenths of degrees Centigrade"),
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.12"},
|
|
read ]
|
|
sint32 UpperThresholdNonCritical;
|
|
[Override ("LowerThresholdCritical") ,
|
|
Units ("Tenths of degrees Centigrade"),
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.13"},
|
|
read ]
|
|
sint32 LowerThresholdCritical;
|
|
[Override ("UpperThresholdCritical") ,
|
|
Units ("Tenths of degrees Centigrade"),
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.14"},
|
|
read ]
|
|
sint32 UpperThresholdCritical;
|
|
[Override ("LowerThresholdFatal") ,
|
|
Units ("Tenths of degrees Centigrade"),
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.15"},
|
|
read ]
|
|
sint32 LowerThresholdFatal;
|
|
[Override ("UpperThresholdFatal") ,
|
|
Units ("Tenths of degrees Centigrade"),
|
|
MappingStrings {"MIF.DMTF|Temperature Probe|001.16"},
|
|
read ]
|
|
sint32 UpperThresholdFatal;
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{DCA1D084-E3D3-11d2-8601-0000F8102E5F}" ),
|
|
Abstract, Description (
|
|
"This class exists for backward compatibility to earlier "
|
|
"CIM Schema definitions. With additions to Sensor and Numeric"
|
|
"Sensor in V2.2, it is no longer necessary. A CurrentSensor can "
|
|
"be defined by setting the SensorType property, inherited from "
|
|
"Sensor, to 4 (\"Current\"). Other properties of this class are "
|
|
"hard-coded to constant values to correspond to definitions in "
|
|
"the sensor hierarchy.")
|
|
]
|
|
class CIM_CurrentSensor : CIM_NumericSensor
|
|
{
|
|
[Override ("CurrentReading") ,
|
|
Units ("Milliamps"),
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.5"},
|
|
read ]
|
|
sint32 CurrentReading;
|
|
[Override ("NominalReading") ,
|
|
Units ("Milliamps"),
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.6"},
|
|
read ]
|
|
sint32 NominalReading;
|
|
[Override ("NormalMax") ,
|
|
Units ("Milliamps"),
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.7"},
|
|
read ]
|
|
sint32 NormalMax;
|
|
[Override ("NormalMin") ,
|
|
Units ("Milliamps"),
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.8"},
|
|
read ]
|
|
sint32 NormalMin;
|
|
[Override ("MaxReadable") ,
|
|
Units ("Milliamps"),
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.9"},
|
|
read ]
|
|
sint32 MaxReadable;
|
|
[Override ("MinReadable") ,
|
|
Units ("Milliamps"),
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.10"},
|
|
read ]
|
|
sint32 MinReadable;
|
|
[Override ("Resolution") ,
|
|
Units ("Tenths of Milliamps"),
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.17"},
|
|
read ]
|
|
uint32 Resolution;
|
|
[Override ("Tolerance") ,
|
|
Units ("Milliamps"),
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.18"},
|
|
read ]
|
|
sint32 Tolerance;
|
|
[Override ("Accuracy") ,
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.19"},
|
|
read ]
|
|
sint32 Accuracy;
|
|
[Override ("LowerThresholdNonCritical") ,
|
|
Units ("Milliamps"),
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.11"},
|
|
read ]
|
|
sint32 LowerThresholdNonCritical;
|
|
[Override ("UpperThresholdNonCritical") ,
|
|
Units ("Milliamps"),
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.12"},
|
|
read ]
|
|
sint32 UpperThresholdNonCritical;
|
|
[Override ("LowerThresholdCritical") ,
|
|
Units ("Milliamps"),
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.13"},
|
|
read ]
|
|
sint32 LowerThresholdCritical;
|
|
[Override ("UpperThresholdCritical") ,
|
|
Units ("Milliamps"),
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.14"},
|
|
read ]
|
|
sint32 UpperThresholdCritical;
|
|
[Override ("LowerThresholdFatal") ,
|
|
Units ("Milliamps"),
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.15"},
|
|
read ]
|
|
sint32 LowerThresholdFatal;
|
|
[Override ("UpperThresholdFatal") ,
|
|
Units ("Milliamps"),
|
|
MappingStrings {"MIF.DMTF|Electrical Current Probe|001.16"},
|
|
read ]
|
|
sint32 UpperThresholdFatal;
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{A998F9B4-E3D4-11d2-8601-0000F8102E5F}" ),
|
|
Abstract,
|
|
Description (
|
|
"This class exists for backward compatibility to earlier "
|
|
"CIM Schema definitions. With additions to Sensor and Numeric"
|
|
"Sensor in V2.2, it is no longer necessary. A VoltageSensor can "
|
|
"be defined by setting the SensorType property, inherited from "
|
|
"Sensor, to 3 (\"Voltage\"). Other properties of this class are "
|
|
"hard-coded to constant values to correspond to definitions in "
|
|
"the sensor hierarchy.")
|
|
]
|
|
class CIM_VoltageSensor : CIM_NumericSensor
|
|
{
|
|
[Override ("CurrentReading") ,
|
|
Units ("Millivolts"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.5"},
|
|
read ]
|
|
sint32 CurrentReading;
|
|
[Override ("NominalReading") ,
|
|
Units ("Millivolts"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.6"},
|
|
read ]
|
|
sint32 NominalReading;
|
|
[Override ("NormalMax") ,
|
|
Units ("Millivolts"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.7"},
|
|
read ]
|
|
sint32 NormalMax;
|
|
[Override ("NormalMin") ,
|
|
Units ("Millivolts"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.8"},
|
|
read ]
|
|
sint32 NormalMin;
|
|
[Override ("MaxReadable") ,
|
|
Units ("Millivolts"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.9"},
|
|
read ]
|
|
sint32 MaxReadable;
|
|
[Override ("MinReadable") ,
|
|
Units ("Millivolts"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.10"},
|
|
read ]
|
|
sint32 MinReadable;
|
|
[Override ("Resolution") ,
|
|
Units ("Tenths of Millivolts"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.17"},
|
|
read ]
|
|
uint32 Resolution;
|
|
[Override ("Tolerance") ,
|
|
Units ("Millivolts"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.18"},
|
|
read ]
|
|
sint32 Tolerance;
|
|
[Override ("Accuracy"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.19"},
|
|
read ]
|
|
sint32 Accuracy;
|
|
[Override ("LowerThresholdNonCritical") ,
|
|
Units ("Millivolts"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.11"},
|
|
read ]
|
|
sint32 LowerThresholdNonCritical;
|
|
[Override ("UpperThresholdNonCritical") ,
|
|
Units ("Millivolts"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.12"},
|
|
read ]
|
|
sint32 UpperThresholdNonCritical;
|
|
[Override ("LowerThresholdCritical") ,
|
|
Units ("Millivolts"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.13"},
|
|
read ]
|
|
sint32 LowerThresholdCritical;
|
|
[Override ("UpperThresholdCritical") ,
|
|
Units ("Millivolts"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.14"},
|
|
read ]
|
|
sint32 UpperThresholdCritical;
|
|
[Override ("LowerThresholdFatal") ,
|
|
Units ("Millivolts"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.15"},
|
|
read ]
|
|
sint32 LowerThresholdFatal;
|
|
[Override ("UpperThresholdFatal") ,
|
|
Units ("Millivolts"),
|
|
MappingStrings {"MIF.DMTF|Voltage Probe|001.16"},
|
|
read ]
|
|
sint32 UpperThresholdFatal;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_CDROMDrive class represents a CD-ROM drive on the system."
|
|
"\n<B>Note:</B> The name of the drive does not correspond to the "
|
|
"logical drive letter assigned to device, which is the name of the "
|
|
"logical storage device dependent on this drive."),
|
|
Locale (0x409), UUID ("{8502C52B-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_CDROMDrive:CIM_MediaAccessDevice
|
|
{
|
|
};
|
|
|
|
|
|
|
|
[Abstract, Description (
|
|
"The CIM_DiskDrive class represents a physical disk drive as seen by the "
|
|
"operating system. The features of the drive seen through this object "
|
|
"correspond to the logical and management characteristics of the drive "
|
|
"and, in some cases may not reflect the actual physical characteristics "
|
|
"of the device. Any interface to a physical drive is a member of this "
|
|
"class. Any object based on another logical device would not be a member "
|
|
"of this class.\nExample: IDE Fixed Disk."),
|
|
Locale (0x409), UUID ("{8502C52C-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_DiskDrive:CIM_MediaAccessDevice
|
|
{
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_TapeDrive class represents a tape drive on the system. Tape "
|
|
"drives are primarily distinguished by the fact that they can only be "
|
|
"accessed sequentially."),
|
|
Locale (0x409), UUID ("{8502C52D-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_TapeDrive:CIM_MediaAccessDevice
|
|
{
|
|
[read , Description (
|
|
"EOTWarningZoneSize indicates the size, in bytes, of the "
|
|
"area designated as 'end of tape'. Access in this area "
|
|
"generates an 'end of tape' warning."),
|
|
Units ("Bytes") ]
|
|
uint32 EOTWarningZoneSize ;
|
|
[read , Description (
|
|
"The MaxPartitionCount property indicates the maximum part count for the "
|
|
"tape drive.") ]
|
|
uint32 MaxPartitionCount ;
|
|
[read, Description (
|
|
"Padding indicates the number of bytes inserted between "
|
|
"blocks on a tape Media."),
|
|
Units ("Bytes") ]
|
|
uint32 Padding ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Controller is a superclass for grouping the miscellaneous "
|
|
"control-related Devices that exist. Examples of Controllers "
|
|
"are SCSIControllers, USBControllers, SerialControllers, ... "
|
|
"The Controller class is an abstraction for Devices with a "
|
|
"single protocol stack, which exist primarily for communication "
|
|
"to, and control or reset of downstream (ControlledBy) Devices."),
|
|
Locale (0x409), UUID ("{8502C531-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Controller:CIM_LogicalDevice
|
|
{
|
|
[Description (
|
|
"Maximum number of directly addressable entities supported "
|
|
"by this Controller. A value of 0 should be used if the "
|
|
"number is unknown or unlimited.")
|
|
, MappingStrings {"MIF.DMTF|Bus Port|001.9"} , Read ]
|
|
uint32 MaxNumberControlled ;
|
|
[read , Description (
|
|
"The protocol used by the controller to access 'controlled' devices.") ,
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
|
|
"11", "12", "13", "14", "15", "16", "17", "18", "19",
|
|
"20", "21", "22", "23", "24", "25", "26", "27", "28",
|
|
"29", "30", "31", "32", "33", "34", "35", "36", "37",
|
|
"38", "39", "40", "41", "42", "43", "44", "45", "46",
|
|
"47"},
|
|
Values {"Other", "Unknown", "EISA", "ISA", "PCI", "ATA/ATAPI",
|
|
"Flexible Diskette", "1496", "SCSI Parallel Interface",
|
|
"SCSI Fibre Channel Protocol", "SCSI Serial Bus Protocol",
|
|
"SCSI Serial Bus Protocol-2 (1394)",
|
|
"SCSI Serial Storage Architecture", "VESA", "PCMCIA",
|
|
"Universal Serial Bus", "Parallel Protocol", "ESCON",
|
|
"Diagnostic", "I2C", "Power", "HIPPI", "MultiBus", "VME",
|
|
"IPI", "IEEE-488", "RS232", "IEEE 802.3 10BASE5",
|
|
"IEEE 802.3 10BASE2", "IEEE 802.3 1BASE5",
|
|
"IEEE 802.3 10BROAD36", "IEEE 802.3 100BASEVG",
|
|
"IEEE 802.5 Token-Ring", "ANSI X3T9.5 FDDI", "MCA",
|
|
"ESDI", "IDE", "CMD", "ST506", "DSSI", "QIC2",
|
|
"Enhanced ATA/IDE", "AGP", "TWIRP (two-way infrared)",
|
|
"FIR (fast infrared)", "SIR (serial infrared)",
|
|
"IrBus"},
|
|
MappingStrings {"MIF.DMTF|Bus Port|001.2", "MIF.DMTF|Disks|003.3"} ]
|
|
uint16 ProtocolSupported ;
|
|
[Read, Description ("The TimeOfLastReset property indicates the "
|
|
"date and time this controller was last reset. This could mean "
|
|
"the controller was powered down, or reinitialized.") ]
|
|
datetime TimeOfLastReset ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of the video controller."),
|
|
Locale (0x409), UUID ("{1008CCE5-7BFF-11D2-AAD2-006008C78BC7}") ]
|
|
class CIM_VideoController : CIM_Controller
|
|
{
|
|
[Read, Description (
|
|
"A free-form string describing the video processor/Controller.") ]
|
|
string VideoProcessor;
|
|
[Read, Description (
|
|
"An integer enumeration indicating the type of video "
|
|
"memory."),
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
|
|
"11", "12", "13"},
|
|
Values {"Other", "Unknown", "VRAM", "DRAM", "SRAM", "WRAM",
|
|
"EDO RAM", "Burst Synchronous DRAM",
|
|
"Pipelined Burst SRAM", "CDRAM", "3DRAM", "SDRAM",
|
|
"SGRAM"},
|
|
MappingStrings {"MIF.DMTF|Video|003.6"} ]
|
|
uint16 VideoMemoryType;
|
|
[Read, Description (
|
|
"Number of video pages supported given the current resolutions "
|
|
"and available memory.") ]
|
|
uint32 NumberOfVideoPages;
|
|
[Read, Description (
|
|
"Maximum amount of memory supported in bytes."),
|
|
Units ("Bytes") ]
|
|
uint32 MaxMemorySupported;
|
|
[Read, Description (
|
|
"An array of integers indicating the graphics and 3D "
|
|
"capabilities of the video controller."),
|
|
Values {"Unknown", "Other", "Graphics Accelerator",
|
|
"3D Accelerator"},
|
|
ModelCorrespondence {"CIM_VideoController.CapabilityDescriptions"} ]
|
|
uint16 AcceleratorCapabilities[];
|
|
[Read, Description (
|
|
"An array of free-form strings providing more detailed "
|
|
"explanations for any of the video accelerator features "
|
|
"indicated in the Capabilities array. Note, each entry "
|
|
"of this array is related to the entry in the Capabilities "
|
|
"array that is located at the same index."),
|
|
ArrayType ("Indexed"),
|
|
ModelCorrespondence {"CIM_VideoController.AcceleratorCapabilities"} ]
|
|
string CapabilityDescriptions[];
|
|
[Read, Description (
|
|
"The number of bits used to display each pixel."),
|
|
Units ("Bits"),
|
|
MappingStrings {"MIF.DMTF|Video|003.12"} ]
|
|
uint32 CurrentBitsPerPixel;
|
|
[Read, Description (
|
|
"Current number of horizontal pixels."),
|
|
Units ("Pixels"),
|
|
MappingStrings {"MIF.DMTF|Video|003.11"} ]
|
|
uint32 CurrentHorizontalResolution;
|
|
[Read, Description (
|
|
"Current number of vertical pixels."),
|
|
Units ("Pixels"),
|
|
MappingStrings {"MIF.DMTF|Video|003.10"} ]
|
|
uint32 CurrentVerticalResolution;
|
|
[Read, Description ( "Maximum refresh rate of the video "
|
|
"controller in Hertz."),
|
|
Units ("Hertz"),
|
|
MappingStrings {"MIF.DMTF|Video|003.5"} ]
|
|
uint32 MaxRefreshRate;
|
|
[Read, Description ("Minimum refresh rate of the video "
|
|
"controller in Hertz."),
|
|
Units ("Hertz"),
|
|
MappingStrings {"MIF.DMTF|Video|003.4"} ]
|
|
uint32 MinRefreshRate;
|
|
[Read, Description (
|
|
"Current refresh rate in Hertz."),
|
|
Units ("Hertz"),
|
|
MappingStrings {"MIF.DMTF|Video|003.15"} ]
|
|
uint32 CurrentRefreshRate;
|
|
[Read, Description (
|
|
"Current scan mode. \"Interlaced\" (value=3) or "
|
|
"\"Non Interlaced\" (4) can be defined using this "
|
|
"property."),
|
|
ValueMap {"1", "2", "3", "4"},
|
|
Values {"Other", "Unknown", "Interlaced", "Non Interlaced"},
|
|
MappingStrings {"MIF.DMTF|Video|003.8"} ]
|
|
uint16 CurrentScanMode;
|
|
[Read, Description ("Number of colors supported "
|
|
"at the current resolutions.") ]
|
|
uint64 CurrentNumberOfColors;
|
|
[Read, Description (
|
|
"If in character mode, number of rows for this video "
|
|
"controller. Otherwise, enter 0."),
|
|
MappingStrings {"MIF.DMTF|Video|003.13"} ]
|
|
uint32 CurrentNumberOfRows;
|
|
[Read, Description (
|
|
"If in character mode, number of columns for this "
|
|
"video controller. Otherwise, enter 0."),
|
|
MappingStrings {"MIF.DMTF|Video|003.14"} ]
|
|
uint32 CurrentNumberOfColumns;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of a PC video controller, a subtype "
|
|
"of video controller."),
|
|
Locale (0x409), UUID ("{1008CCE6-7BFF-11D2-AAD2-006008C78BC7}") ]
|
|
class CIM_PCVideoController : CIM_VideoController
|
|
{
|
|
[Read, Description (
|
|
"The video architecture. For example, VGA (value=5) or "
|
|
"PC-98 (160) may be specified."),
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
|
|
"11", "12", "160"},
|
|
Values {"Other", "Unknown", "CGA", "EGA", "VGA", "SVGA", "MDA",
|
|
"HGC", "MCGA", "8514A", "XGA", "Linear Frame Buffer",
|
|
"PC-98"},
|
|
MappingStrings {"MIF.DMTF|Video|003.2"} ]
|
|
uint16 VideoArchitecture;
|
|
[Read, Description ("Current video mode."),
|
|
MappingStrings {"MIF.DMTF|Video|003.3"} ]
|
|
uint16 VideoMode;
|
|
[Read, Description (
|
|
"Current number of color planes. If this value is not "
|
|
"applicable for the current video configuration, enter "
|
|
"0.") ]
|
|
uint16 NumberOfColorPlanes;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of a PCMCIA controller."),
|
|
Locale (0x409), UUID ("{FAF76B5A-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PCMCIAController: cim_controller
|
|
{
|
|
[read , Schema ("Win32") ,
|
|
Description ("The Manufacturer property indicates the name of the "
|
|
"PCMCIA controller manufacturer.\nExample: Acme") ]
|
|
string Manufacturer ;
|
|
};
|
|
|
|
[Abstract, Description ("Capabilities and management of a USB controller."),
|
|
Locale (0x409), UUID ("{FAF76B5B-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_USBController : CIM_Controller
|
|
{
|
|
[read , Schema ("Win32") , Description (
|
|
"The Manufacturer property indicates the name of the USB controller "
|
|
"manufacturer.\nExample: Acme") ]
|
|
string Manufacturer ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"NetworkAdapter is an Abstract class defining general "
|
|
"networking hardware concepts (for example, PermanentAddress or "
|
|
"Speed of operation). NetworkAdapters are Devices with the "
|
|
"ability to support multiple, higher level protocols and provide "
|
|
"the implementation behind the Network Model's ProtocolEndpoint "
|
|
"class. (This information is conveyed using the DeviceSAP"
|
|
"Implementation association, defined in the Core Model.) "
|
|
"NetworkAdapters and their Endpoints represent the potential for "
|
|
"connectivity among peers.\n"
|
|
"The 'potential for connectivity' is very different than the "
|
|
"master-slave/controller-controlled by relationships of CIM_"
|
|
"Controller. Sometimes, however, a single Device is both a kind "
|
|
"of NetworkAdapter and a Controller - for example, when a Fibre"
|
|
"ChannelAdapater is operating as a ComputerSystem's SCSIController. "
|
|
"In this case, there are aspects of the Device that are network "
|
|
"oriented and others that are Controller oriented - and, both the "
|
|
"Controller and Adapter classes should be instantiated. A Device"
|
|
"Identity relationship would also be created to tie together these "
|
|
"differing aspects/abstractions of the Device."),
|
|
Locale (0x409), UUID ("{8502C532-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_NetworkAdapter:CIM_LogicalDevice
|
|
{
|
|
[read , MaxLen (64) , Description (
|
|
"PermanentAddress defines the network address hard coded into an adapter. "
|
|
" This 'hard coded' address may be changed via firmware upgrade or "
|
|
"software configuration. If so, this field should be updated when the "
|
|
"change is made. PermanentAddress should be left blank if no 'hard coded'"
|
|
" address exists for the network adapter.") , MappingStrings {
|
|
"MIF.DMTF|Network Adapter 802 Port|001.2"} ]
|
|
string PermanentAddress ;
|
|
[read , MaxLen (64) , Description (
|
|
"An array of strings indicating the network addresses for an adapter.")
|
|
, MappingStrings {"MIF.DMTF|Network Adapter 802 Port|001.3"} ]
|
|
string NetworkAddresses[] ;
|
|
[read , Description (
|
|
"An estimate of the current bandwidth in bits per second. For endpoints "
|
|
"which vary in bandwidth or for those where no accurate estimation can "
|
|
"be made, this property should contain the nominal bandwidth.") ,
|
|
Units ("Bits per Second") , MappingStrings {
|
|
"MIB.IETF|RFC1213-MIB.ifSpeed",
|
|
"MIF.DMTF|Network Adapter 802 Port|001.5"} ]
|
|
uint64 Speed ;
|
|
[read , Description (
|
|
"The maximum speed, in bits per second, for the network adapter.") ,
|
|
Units ("Bits per Second") ]
|
|
uint64 MaxSpeed;
|
|
[Read , Description (
|
|
"A boolean indicating whether the NetworkAdapter is capable "
|
|
"of automatically determining the speed or other communications "
|
|
"characteristics of the attached network media.") ]
|
|
boolean AutoSense;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"User devices are logical devices that allow a computer system's users to "
|
|
"input, view or hear data. The CIM_UserDevice class is a superclass from which other classes, "
|
|
"such as CIM_Keyboard or CIM_DesktopMonitor, descend."),
|
|
Locale (0x409), UUID ("{8502C533-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_UserDevice:CIM_LogicalDevice
|
|
{
|
|
[read , Description (
|
|
"An indication of whether the device is locked, preventing user input or "
|
|
"output.") ]
|
|
boolean IsLocked ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_Display class is a superclass for grouping the miscellaneous display "
|
|
"devices that exist."),
|
|
Locale (0x409), UUID ("{1008CCE7-7BFF-11D2-AAD2-006008C78BC7}") ]
|
|
class CIM_Display : CIM_UserDevice
|
|
{
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of the desktop monitor (CRT) "
|
|
"logical device."),
|
|
Locale (0x409), UUID ("{1008CCE8-7BFF-11D2-AAD2-006008C78BC7}") ]
|
|
class CIM_DesktopMonitor : CIM_Display
|
|
{
|
|
[Read, Description (
|
|
"The type of desktop monitor or CRT. For example, "
|
|
"multiscan color or monochrome monitors (values 2 or 3, "
|
|
"respectively) can be indicated in this property."),
|
|
Values {"Unknown", "Other", "Multiscan Color",
|
|
"Multiscan Monochrome", "Fixed Frequency Color",
|
|
"Fixed Frequency Monochrome"}]
|
|
uint16 DisplayType;
|
|
[Read, Description (
|
|
"Monitor's bandwidth in MegaHertz. If unknown, enter 0."),
|
|
Units ("MegaHertz") ]
|
|
uint32 Bandwidth;
|
|
[Read, Description (
|
|
"The logical height of the display in screen coordinates.")]
|
|
uint32 ScreenHeight;
|
|
[Read, Description (
|
|
"The logical width of the display in screen coordinates.")]
|
|
uint32 ScreenWidth;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of the flat panel logical "
|
|
"device."),
|
|
Locale (0x409), UUID ("{1008CCE9-7BFF-11D2-AAD2-006008C78BC7}") ]
|
|
class CIM_FlatPanel : CIM_Display
|
|
{
|
|
[Read, Description (
|
|
"Flat panel's horizontal resolution in Pixels."),
|
|
Units ("Pixels") ]
|
|
uint32 HorizontalResolution;
|
|
[Read, Description (
|
|
"Flat panel's vertical resolution in Pixels."),
|
|
Units ("Pixels") ]
|
|
uint32 VerticalResolution;
|
|
[Read, Description (
|
|
"A Flat panel's scan mode indicating either single "
|
|
"(value=2) or dual scan (3)."),
|
|
Values {"Unknown", "Other", "Single Scan", "Dual Scan"} ]
|
|
uint16 ScanMode;
|
|
[Read, Description (
|
|
"An integer enumeration describing the type of flat panel "
|
|
"display."),
|
|
Values {"Unknown", "Other", "Passive Matrix LCD",
|
|
"Active Matrix LCD", "Cholesteric LCD",
|
|
"Field Emission Display",
|
|
"Electro Luminescent Display", "Gas Plasma", "LED"} ]
|
|
uint16 DisplayType;
|
|
[Read, Description (
|
|
"A description of the display illumination type. For example, "
|
|
"backlit (value=2) or reflective (4) can be specified."),
|
|
Values {"Unknown", "Other", "Backlit", "Edgelit", "Reflective"} ]
|
|
uint16 LightSource;
|
|
[Read, Description (
|
|
"Boolean indicating whether the flat panel supports color "
|
|
"display.") ]
|
|
boolean SupportsColor;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of the keyboard logical device."),
|
|
Locale (0x409), UUID ("{8502C534-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Keyboard:CIM_UserDevice
|
|
{
|
|
[Description (
|
|
"A free-form string indicating the format and layout of the "
|
|
"Keyboard."
|
|
) , Read ]
|
|
string Layout ;
|
|
[Read, Description ("Number of function keys on the Keyboard.")]
|
|
uint16 NumberOfFunctionKeys ;
|
|
[read , Description (
|
|
"An integer indicating whether a hardware-level password is enabled at "
|
|
"the keyboard (value=4), preventing local input. Other values are: "
|
|
"\"Disabled\" (3), \"Not Implemented\" (5), \"Other\" (1) and "
|
|
"\"Unknown\" (2).") , ValueMap {"1", "2", "3", "4", "5"} , Values {
|
|
"Other", "Unknown", "Disabled", "Enabled", "Not Implemented"} ,
|
|
MappingStrings {"MIF.DMTF|System Hardware Security|001.2"} ]
|
|
uint16 Password ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_PointingDevice class represents a device used to point to "
|
|
"regions on the display. Membership criteria: Any device used to "
|
|
"manipulate a pointer or point to regions on a visual display is a "
|
|
"member of this class. Example: A mouse, stylus, touch pad, or tablet."
|
|
),
|
|
Locale (0x409), UUID ("{8502C535-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_PointingDevice:CIM_UserDevice
|
|
{
|
|
[read , Description (
|
|
"Integer indicating whether the pointing device is configured for right ("
|
|
"value=2) or left handed operation (value=3). Also, the values, "
|
|
"\"Unknown\" (0) and \"Not Applicable\" (1), can be defined.") ,
|
|
Values {"Unknown", "Not Applicable", "Right Handed Operation",
|
|
"Left Handed Operation"} ]
|
|
uint16 Handedness ;
|
|
[read , Description (
|
|
"The NumberOfButtons property indicates the number of buttons on the "
|
|
"pointing device.\nExample: 2") ]
|
|
uint8 NumberOfButtons ;
|
|
[read , Description (
|
|
"The type of the pointing device.") ,
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9"} ,
|
|
Values {"Other", "Unknown", "Mouse",
|
|
"Track Ball", "Track Point", "Glide Point", "Touch Pad", "Touch Screen",
|
|
"Mouse - Optical Sensor"} , MappingStrings {"MIF.DMTF|Pointing Device|001.1"} ]
|
|
uint16 PointingType ;
|
|
[read , Description (
|
|
"The Resolution property indicates the tracking resolution.\nExample: 0"
|
|
),
|
|
Units ("Counts per Inch") ]
|
|
uint32 Resolution ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"StorageExtent describes the capabilities and management of "
|
|
"the various media that exist to store data and allow data "
|
|
"retrieval. This superclass could be used to represent the "
|
|
"various components of RAID (Hardware or Software) or as a "
|
|
"raw logical extent on top of physical media."),
|
|
Locale (0x409), UUID ("{8502C538-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_StorageExtent:CIM_LogicalDevice
|
|
{
|
|
[read, Description (
|
|
"Access describes whether the media is readable (value=1), "
|
|
"writeable (value=2), or both (value=3). \"Unknown\" (0) "
|
|
"and \"Write Once\" (4) can also be defined.") ,
|
|
Values {"Unknown", "Readable", "Writeable", "Read/Write Supported"
|
|
, "Write Once"} ]
|
|
uint16 Access ;
|
|
|
|
[read, Description (
|
|
"Size in bytes of the blocks which form this StorageExtent. "
|
|
"If variable block size, then the maximum block size in bytes "
|
|
"should be specified. If the block size is unknown or if a "
|
|
"block concept is not valid (for example, for Aggregate Extents, "
|
|
"Memory or LogicalDisks), enter a 1."),
|
|
Units ("Bytes"),
|
|
MappingStrings {"MIB.IETF|HOST-RESOURCES-MIB.hrStorageAllocationUnits"} ]
|
|
uint64 BlockSize;
|
|
|
|
[Description (
|
|
"ErrorMethodology is a free-form string describing the type of error "
|
|
"detection and correction supported by this storage extent.") , Read ]
|
|
string ErrorMethodology ;
|
|
|
|
[Description (
|
|
"Total number of consecutive blocks, each block the size of the "
|
|
"value contained in the BlockSize property, which "
|
|
"form this storage extent. Total size of the storage extent can "
|
|
"be calculated by multiplying the value of the BlockSize property "
|
|
"by the value of this property. If "
|
|
"the value of BlockSize is 1, this property is the total size of the "
|
|
"storage extent."),
|
|
MappingStrings { "MIB.IETF|HOST-RESOURCES-MIB.hrStorageSize"} ]
|
|
uint64 NumberOfBlocks;
|
|
|
|
[Description ("A free form string describing the media and/or its use."
|
|
) , Read ]
|
|
string Purpose ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"A PhysicalExtent is used to model an SCC RAID "
|
|
"implementation. It defines the consecutive addressable "
|
|
"block addresses on a single storage device, that are "
|
|
"treated as a single StorageExtent and that are in the "
|
|
"same StorageRedundancyGroup. An alternate possibility, "
|
|
"if automatic configuration is used, is to instantiate or "
|
|
"extend the AggregatePExtent class.") ,
|
|
Locale (0x409), UUID ("{9565979E-7D80-11D2-AAD3-006008C78BC7}") ]
|
|
class CIM_PhysicalExtent : CIM_StorageExtent
|
|
{
|
|
[read, Override ("BlockSize") ,
|
|
MappingStrings {"MIF.DMTF|Physical Extent|001.4"}
|
|
]
|
|
uint64 BlockSize;
|
|
[read, Override ("NumberOfBlocks") ,
|
|
MappingStrings {"MIF.DMTF|Physical Extent|001.3"}
|
|
]
|
|
uint64 NumberOfBlocks;
|
|
[read, Description (
|
|
"Number of bytes of user data to skip before "
|
|
"starting the check data interleave."),
|
|
Units ("Bytes") ,
|
|
MappingStrings {"MIF.DMTF|Physical Extent|001.6"}
|
|
]
|
|
uint64 UnitsBeforeCheckDataInterleave;
|
|
[read, Description (
|
|
"Number of bytes to be reserved for check data."),
|
|
Units ("Bytes") ,
|
|
MappingStrings {"MIF.DMTF|Physical Extent|001.7"}
|
|
]
|
|
uint64 UnitsOfCheckData;
|
|
[read, Description (
|
|
"Number of bytes to be reserved for user data."),
|
|
Units ("Bytes") ,
|
|
MappingStrings {"MIF.DMTF|Physical Extent|001.8"}
|
|
]
|
|
uint64 UnitsOfUserData;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_AggregatePExtent class provides summary information about "
|
|
"the addressable logical blocks which are in the same "
|
|
"storage redundancy group and reside on the same physical media. "
|
|
"This is an alternative grouping for physical extents, when "
|
|
"only summary information is needed or when automatic "
|
|
"configuration is used. Automatic configuration can result in "
|
|
"thousands of physical extents being defined. There is no value "
|
|
"in modeling the individual extents. So, the CIM_AggregatePExtent "
|
|
"object was defined.") ,
|
|
Locale (0x409), UUID ("{9565979F-7D80-11D2-AAD3-006008C78BC7}") ]
|
|
class CIM_AggregatePExtent : CIM_StorageExtent
|
|
{
|
|
[read, Override ("NumberOfBlocks") , Description (
|
|
"Total number of blocks (including the check data blocks) "
|
|
"contained in this aggregate physical extent. The block size (an "
|
|
"inherited property) should be set to the same value as for "
|
|
"the media access device associated with this extent."),
|
|
MappingStrings {"MIF.DMTF|Aggregate Physical Extent|001.2"}
|
|
]
|
|
uint64 NumberOfBlocks;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"A LogicalDisk is a presentation of a contiguous range of "
|
|
"logical blocks that is identifiable by a FileSystem via the "
|
|
"Disk's DeviceId (key) field. For example in a Windows "
|
|
"environment, the DeviceID field would contain a drive letter. "
|
|
"In a Unix environment, it would contain the access path; and in "
|
|
"a NetWare environment, DeviceID would contain the volume name. "
|
|
"LogicalDisks are typically built on a DiskPartition or Storage"
|
|
"Volume (for example, exposed by a software volume manager) "
|
|
"using the LogicalDiskBasedOnPartition or LogicalDiskBasedOn"
|
|
"Volume associations. However, it can be based on other "
|
|
"StorageExtents, like CIM_Memory, in the case of a RAM disk. "
|
|
"The latter is described using the LogicalDiskBasedOnExtent "
|
|
"relationship. (Indeed, the BasedOnExtent association is the "
|
|
"superclass for the BasedOnPartition and BasedOnVolume "
|
|
"relationships.)"),
|
|
Locale (0x409), UUID ("{8502C539-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_LogicalDisk:CIM_StorageExtent
|
|
{
|
|
[read , units ("Bytes"), Description (
|
|
"The FreeSpace property indicates in bytes how much free space is "
|
|
"available on the logical disk.")]
|
|
uint64 FreeSpace ;
|
|
[read , units ("Bytes"), Description (
|
|
"The Size property indicates in bytes, the size of the logical disk.")]
|
|
uint64 Size ;
|
|
};
|
|
|
|
[Association,
|
|
Abstract, Description (
|
|
"A generic association to establish dependency relationships between "
|
|
"objects."),
|
|
Locale (0x409), UUID ("{8502C53A-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Dependency
|
|
{
|
|
[Description (
|
|
"Antecedent represents the independent object in this association.") ,
|
|
Read ]
|
|
CIM_ManagedSystemElement REF Antecedent;
|
|
[Description (
|
|
"Dependent represents the object dependent on the Antecedent.") ,
|
|
Read ]
|
|
CIM_ManagedSystemElement REF Dependent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"CIM_ServiceServiceDependency is an association between a "
|
|
"service and another service, indicating that the latter is "
|
|
"required to be present, required to have completed, or must "
|
|
"be absent for the former service to provide its "
|
|
"functionality. For example, boot services may be dependent "
|
|
"upon underlying BIOS Disk and initialization services. "
|
|
"In the case of the initialization services, the boot service "
|
|
"is simply dependent on the init services completing. For "
|
|
"the disk services, boot services may actually utilize the "
|
|
"SAPs of this service. This usage dependency is modeled via "
|
|
"the CIM_ServiceSAPDependency association."),
|
|
Locale (0x409), UUID ("{8502C53B-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_ServiceServiceDependency:CIM_Dependency
|
|
{
|
|
[read, Override ("Antecedent") , Description (
|
|
"The required service.") ]
|
|
CIM_Service REF Antecedent;
|
|
[read, Override ("Dependent") , Description (
|
|
"The service that is dependent on an underlying service.") ]
|
|
CIM_Service REF Dependent;
|
|
[read, Description (
|
|
"The nature of the service to service dependency. This "
|
|
"property describes that the associated service must have "
|
|
"completed (value=2), must be started (3) or must not be "
|
|
"started (4) in order for the service to function."),
|
|
Values {"Unknown", "Other", "Service Must Have Completed",
|
|
"Service Must Be Started",
|
|
"Service Must Not Be Started"} ]
|
|
uint16 TypeOfDependency;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_DeviceConnection relationship indicates that two or more device are "
|
|
"connected together."),
|
|
Locale (0x409), UUID ("{8502C53C-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_DeviceConnection:CIM_Dependency
|
|
{
|
|
[read, Override ("Antecedent") , Description ("A logical device.")]
|
|
CIM_LogicalDevice REF Antecedent;
|
|
[read, Override ("Dependent") , Description (
|
|
"A second logical device connected to the Antecedent device.") ]
|
|
CIM_LogicalDevice REF Dependent;
|
|
[read, Description (
|
|
"When several bus and/or connection speeds are possible, the "
|
|
"NegotiatedSpeed property defines the one in use between the devices. "
|
|
"Speed is specified in bits per second. If connection or bus speeds are "
|
|
"not negotiated, or if this information is not available/important to "
|
|
"device management, the property should be set to 0.") , Units (
|
|
"Bits per Second") ]
|
|
uint64 NegotiatedSpeed ;
|
|
[read, Description (
|
|
"When several bus and/or connection data widths are possible, the "
|
|
"NegotiatedDataWidth property defines the one in use between the devices."
|
|
" Data width is specified in bits. If data width is not negotiated, or "
|
|
"if this information is not available/important to device management, "
|
|
"the property should be set to 0.") , Units ("Bits") ]
|
|
uint32 NegotiatedDataWidth ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Many devices include sensors or have sensors installed "
|
|
"nearby, in order to measure critical input and output "
|
|
"properties. This association indicates that relationship."),
|
|
Locale (0x409), UUID ("{956597A0-7D80-11D2-AAD3-006008C78BC7}") ]
|
|
class CIM_AssociatedSensor : CIM_Dependency
|
|
{
|
|
[read, Override ("Antecedent") , Description ("The sensor.")
|
|
]
|
|
CIM_Sensor REF Antecedent;
|
|
[read, Override ("Dependent") , Description (
|
|
"The logical device for which information is measured by "
|
|
"the sensor.")
|
|
]
|
|
CIM_LogicalDevice REF Dependent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_ControlledBy relationship indicates which devices are commanded by "
|
|
"or accessed through the controller logical device."),
|
|
Locale (0x409), UUID ("{8502C53D-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_ControlledBy:CIM_DeviceConnection
|
|
{
|
|
[read, Override ("Antecedent") , Description ("The controller.") ]
|
|
CIM_Controller REF Antecedent;
|
|
[read, Override ("Dependent") , Description ("The controlled device.") ]
|
|
CIM_LogicalDevice REF Dependent;
|
|
[read, Description (
|
|
"The AccessState property indicates whether the controller is actively "
|
|
"commanding or accessing the device (value=1) or not (value=2). Also, "
|
|
"the value, \"Unknown\" (0), can be defined. This information is "
|
|
"necessary when a logical device can be commanded by, or accessed through,"
|
|
" multiple controllers.") , Values {"Unknown", "Active", "Inactive"} ]
|
|
uint16 AccessState ;
|
|
[read, Description ( "Number of hard resets issued by the controller. A hard reset "
|
|
"returns the device to its initialization or 'boot-up' state. "
|
|
"All internal device state information and data are lost.") ]
|
|
uint32 NumberOfHardResets ;
|
|
[read, Description ( "Number of soft resets issued by the controller. A soft "
|
|
"reset does not completely clear current device state and/or "
|
|
"data. Exact semantics are dependent on the device, and on "
|
|
"the protocols and mechanisms used to communicate to it.") ]
|
|
uint32 NumberOfSoftResets ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"CIM_BasedOn is an association describing how storage extents can be "
|
|
"assembled from lower level extents. For example, protected space extents "
|
|
"are parts of physical extents, while volume sets are assembled from one "
|
|
"or more physical or protected space extents. As another example, "
|
|
"cache memory can be defined independently and realized in a "
|
|
"physical element or can be 'based on' volatile or "
|
|
"non-volatile storage extents."),
|
|
Locale (0x409), UUID ("{8502C53E-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_BasedOn:CIM_Dependency
|
|
{
|
|
[read, Override ("Antecedent") , Description ("The lower level storage extent."
|
|
) ]
|
|
CIM_StorageExtent REF Antecedent;
|
|
[read, Override ("Dependent") , Description ("The higher level storage extent."
|
|
) ]
|
|
CIM_StorageExtent REF Dependent;
|
|
[read, Description (
|
|
"StartingAddress indicates where in lower level storage, the higher "
|
|
"level extent begins.") ]
|
|
uint64 StartingAddress ;
|
|
[read, Description (
|
|
"EndingAddress indicates where in lower level storage, the higher level "
|
|
"extent ends. This property is useful when mapping non-contiguous "
|
|
"extents into a higher level grouping.") ]
|
|
uint64 EndingAddress ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Where a storage extent must be accessed through a media access device, "
|
|
"this relationship is described by the CIM_MediaPresent association."),
|
|
Locale (0x409), UUID ("{8502C540-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_MediaPresent:CIM_Dependency
|
|
{
|
|
[read, Override ("Antecedent") , Description (
|
|
"The media access device.") ]
|
|
CIM_MediaAccessDevice REF Antecedent;
|
|
[read, Override ("Dependent") , Description (
|
|
"The storage extent accessed using the media access device.") ]
|
|
CIM_StorageExtent REF Dependent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"A DiskPartition is a presentation of a contiguous range "
|
|
"of logical blocks that is identifiable by the Operating"
|
|
"System via the Partition's type and subtype fields. Disk"
|
|
"Partitions should be directly realized by PhysicalMedia "
|
|
"(indicated by the RealizesDiskPartition association) or built "
|
|
"on StorageVolumes (indicated by the PartitionBasedOnVolume "
|
|
"association."),
|
|
Locale (0x409), UUID ("{8502C541-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_DiskPartition:CIM_StorageExtent
|
|
{
|
|
[Read, Description (
|
|
"Boolean indicating that the DiskPartition is labelled as "
|
|
"bootable. This does not mean that an OperatingSystem is "
|
|
"actually loaded on the partition.")
|
|
]
|
|
boolean Bootable ;
|
|
|
|
[Read, Description (
|
|
"Boolean indicating that the DiskPartition is labelled as "
|
|
"the primary partition for a ComputerSystem.")
|
|
]
|
|
boolean PrimaryPartition ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"LogicalDisks can be BasedOn a DiskPartition. For example, a "
|
|
"personal computer's C: drive may be located on a Partition on "
|
|
"local PhysicalMedia. In this association of LogicalDisks to "
|
|
"Partitions, note that the cardinality of the Antecedent, Disk"
|
|
"Partition, is Max(1). This dictates that a LogicalDisk can not "
|
|
"span more than one Partition. However, there are cases where "
|
|
"this is true. When it occurs, the LogicalDisk is really based "
|
|
"on some kind of RAID configuration (for example, a mirror or "
|
|
"stripe set). In these scenarios, the LogicalDisk is more "
|
|
"correctly BasedOn a StorageVolume. To prevent incorrectly using "
|
|
"the LogicalDiskBasedOnPartition association, the Max(1) "
|
|
"qualifier was put on the Antecedent reference to the "
|
|
"DiskPartition."),
|
|
Locale (0x409), UUID ("{8502C53F-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_LogicalDiskBasedOnPartition : CIM_BasedOn
|
|
{
|
|
[read, Override ("Antecedent") , Max(1), Description ("The disk partition.") ]
|
|
CIM_DiskPartition REF Antecedent;
|
|
[read, Override ("Dependent") , Description (
|
|
"The logical disk which is built on the partition.") ]
|
|
CIM_LogicalDisk REF Dependent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The POTSModem class represents a Device that translates "
|
|
"binary data into wave modulations for sound based "
|
|
"transmission. It connects to the POTS (Plain Old Telephone "
|
|
"System) network."),
|
|
Locale (0x409), UUID ("{8502C546-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_PotsModem:CIM_LogicalDevice
|
|
{
|
|
[read , Description (
|
|
"Answer mode defines the current auto-answer/call-back setting for the modem.") ,
|
|
Values {"Unknown", "Other", "Disabled", "Manual Answer", "Auto Answer",
|
|
"Auto Answer with Call-Back"} ]
|
|
uint16 AnswerMode ;
|
|
[read , Description (
|
|
"Describes the data compression characteristics of the modem.") ,
|
|
Values {"Unknown", "Other", "No Compression", "MNP 5", "V.42bis"} ]
|
|
uint16 CompressionInfo ;
|
|
[Description (
|
|
"CountriesSupported is an array (bag) that contains a set of strings "
|
|
"defining the countries/regions in which the modem can operate.") , Read ]
|
|
string CountriesSupported[] ;
|
|
[Description (
|
|
"CountrySelected is a string value defining the country/region for which the "
|
|
"modem is currently programmed. When multiple countries/regions are supported, "
|
|
"this property defines which one is currently selected for use.") , Read
|
|
]
|
|
string CountrySelected ;
|
|
[Description (
|
|
"CurrentPasswords is an array (bag) containing the currently defined "
|
|
"passwords for the modem. This array may be left blank for security "
|
|
"reasons.") , Read ]
|
|
string CurrentPasswords[] ;
|
|
[read , Description (
|
|
"DialType is an integer indicating whether tone (value=1) or pulse "
|
|
"dialing (value=2) is used. \"Unknown\" (0) can also be defined.") ,
|
|
Values {"Unknown", "Tone", "Pulse"} ]
|
|
uint16 DialType ;
|
|
[read , Description (
|
|
"Describes the error correction characteristics of the modem.") ,
|
|
Values {"Unknown", "Other", "No Error Correction", "MNP 4", "LAPM"} ]
|
|
uint16 ErrorControlInfo ;
|
|
[read , Description (
|
|
"InactivityTimeout defines the time limit (in seconds) for automatic "
|
|
"disconnection of the phone line, if no data is exchanged. A value of 0 "
|
|
"indicates that this feature is present but not enabled.") , Units (
|
|
"Seconds") ]
|
|
uint32 InactivityTimeout ;
|
|
[Description (
|
|
"Defines the maximum settable communication speed for accessing the "
|
|
"phone system.") , Units ("Bits per second") , Read ]
|
|
uint32 MaxBaudRateToPhone ;
|
|
[Description (
|
|
"Defines the maximum settable communication speed to the COM port for an "
|
|
"external modem. Enter 0 if not applicable.") , Units ("Bits per second"
|
|
) , Read ]
|
|
uint32 MaxBaudRateToSerialPort ;
|
|
[Description (
|
|
"MaxNumberOfPasswords specifies the number of passwords definable in the "
|
|
"modem itself. If this feature is not supported, enter 0.") , Read ]
|
|
uint16 MaxNumberOfPasswords ;
|
|
[read , Description (
|
|
"Describes the modulation scheme of the modem.") ,
|
|
Values {"Unknown", "Other",
|
|
"Not Supported", "Bell 103", "Bell 212A", "V.22bis", "V.32", "V.32bis",
|
|
"V.turbo", "V.FC", "V.34", "V.34bis"} ]
|
|
uint16 ModulationScheme ;
|
|
[read , Description (
|
|
"Number of rings before the modem answers an incoming call.") ]
|
|
uint8 RingsBeforeAnswer ;
|
|
[read ,Description (
|
|
"Describes the volume level of the audible tones from the "
|
|
"modem. For example, high, medium or low volume can be "
|
|
"reported (values 3, 4 or 5, respectively).") ,
|
|
Values {"Unknown", "Other", "Not Supported", "High", "Medium", "Low",
|
|
"Off", "Auto"} ]
|
|
uint16 SpeakerVolumeInfo ;
|
|
[Description ("Indication of whether the modem supports call-back") ,
|
|
Read ]
|
|
boolean SupportsCallback ;
|
|
[Description (
|
|
"Boolean indicating that synchronous, as well as asynchronous, "
|
|
"communication is supported.") , Read ]
|
|
boolean SupportsSynchronousConnect ;
|
|
[Read, Description ("The TimeOfLastReset property indicates the "
|
|
"date and time this controller was last reset. This could mean "
|
|
"the controller was powered down, or reinitialized.") ]
|
|
datetime TimeOfLastReset ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of the power supply logical device."),
|
|
Locale (0x409), UUID ("{8502C547-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_PowerSupply:CIM_LogicalDevice
|
|
{
|
|
[read , Description (
|
|
"ActiveInputVoltage indicates which input voltage range is "
|
|
"currently in use. Range 1, 2 or both can be specified "
|
|
"using the values 3, 4 or 5, respectively. If the Supply "
|
|
"is not currently drawing power, the value 6 (\"Neither\") "
|
|
"can be specified. This information is necessary in the "
|
|
"case of a UPS, a subclass of PowerSupply.") ,
|
|
ValueMap {"1", "2", "3", "4", "5", "6"} ,
|
|
Values {"Other", "Unknown", "Range 1", "Range 2", "Both",
|
|
"Neither"} ,
|
|
MappingStrings {"MIF.DMTF|Power Supply|002.15"} ]
|
|
uint16 ActiveInputVoltage ;
|
|
[read , Description (
|
|
"Boolean indicating that the power supply is a switching (vs. linear) "
|
|
"supply.") ]
|
|
boolean IsSwitchingSupply ;
|
|
[Description (
|
|
"The frequency (in Hertz) at the high end of this power"
|
|
"supply's input frequency range 1. A value of zero "
|
|
"implies DC."),
|
|
Units ("Hertz"),
|
|
Read ]
|
|
uint32 Range1InputFrequencyHigh ;
|
|
[Description (
|
|
"The frequency (in Hertz) at the low end of this power"
|
|
"supply's input frequency range 1. A value of zero "
|
|
"implies DC."
|
|
) , Units ("Hertz") , MappingStrings {"MIF.DMTF|Power Supply|002.17"} ,
|
|
Read ]
|
|
uint32 Range1InputFrequencyLow ;
|
|
[Description (
|
|
"The high voltage of input voltage range 1 for this power supply, in "
|
|
"Millivolts. A value of 0 denotes 'unknown'.") , Units ("Millivolts") ,
|
|
MappingStrings {"MIF.DMTF|Power Supply|002.8"} , Read ]
|
|
uint32 Range1InputVoltageHigh ;
|
|
[Description (
|
|
"The low voltage of input voltage range 1 for this power supply, in "
|
|
"Millivolts. A value of 0 denotes 'unknown'.") , Units ("Millivolts") ,
|
|
MappingStrings {"MIF.DMTF|Power Supply|002.7"} , Read ]
|
|
uint32 Range1InputVoltageLow ;
|
|
[Description (
|
|
"The frequency (in Hertz) at the high end of this power"
|
|
"supply's input frequency range 2. A value of zero "
|
|
"implies DC."
|
|
) , Units ("Hertz") , MappingStrings {"MIF.DMTF|Power Supply|002.20"} ,
|
|
Read ]
|
|
uint32 Range2InputFrequencyHigh ;
|
|
[Description (
|
|
"The frequency (in Hertz) at the low end of this power"
|
|
"supply's input frequency range 2. A value of zero "
|
|
"implies DC."
|
|
) , Units ("Hertz") , MappingStrings {"MIF.DMTF|Power Supply|002.19"} ,
|
|
Read ]
|
|
uint32 Range2InputFrequencyLow ;
|
|
[Description (
|
|
"The high voltage of input voltage range 2 for this power supply, in "
|
|
"Millivolts. A value of 0 denotes 'unknown'.") , Units ("Millivolts") ,
|
|
MappingStrings {"MIF.DMTF|Power Supply|002.12"} , Read ]
|
|
uint32 Range2InputVoltageHigh ;
|
|
[Description (
|
|
"The low voltage of input voltage range 2 for this power supply, in "
|
|
"Millivolts. A value of 0 denotes 'unknown'.") , Units ("Millivolts") ,
|
|
MappingStrings {"MIF.DMTF|Power Supply|002.11"} , Read ]
|
|
uint32 Range2InputVoltageLow ;
|
|
[Description (
|
|
"Represents the total output power of the power supply in Milliwatts. 0 "
|
|
"denotes 'unknown'.") , Units ("Milliwatts") , MappingStrings {
|
|
"MIF.DMTF|Power Supply|002.21"} , Read ]
|
|
uint32 TotalOutputPower ;
|
|
[read , Description (
|
|
"TypeOfRangeSwitching describes the kind of input voltage "
|
|
"range switching implemented in this power supply. For "
|
|
"example, Autoswitch can be specified (value=4).") ,
|
|
ValueMap {"1", "2", "3", "4", "5", "6"} ,
|
|
Values {"Other", "Unknown", "Manual", "Autoswitch", "Wide Range", "Not Applicable"} ,
|
|
MappingStrings {"MIF.DMTF|Power Supply|002.16"} ]
|
|
uint16 TypeOfRangeSwitching ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of the battery logical device. This class "
|
|
"applies to both batteries in laptop systems and other internal/external "
|
|
"batteries, such as used in, or as UPSs."),
|
|
Locale (0x409), UUID ("{8502C548-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Battery:CIM_LogicalDevice
|
|
{
|
|
[read , Description (
|
|
"Description of the battery's charge status. Values such "
|
|
"as \"Fully Charged\" (value=3) or \"Partially Charged\" "
|
|
"(11) can be specified. The value, 10, is "
|
|
"not valid in the CIM Schema since in DMI it represents "
|
|
"that no battery is installed. In this case, this object "
|
|
"should not be instantiated.") ,
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"} ,
|
|
Values {"Other", "Unknown", "Fully Charged", "Low",
|
|
"Critical", "Charging", "Charging and High", "Charging and Low",
|
|
"Charging and Critical", "Undefined", "Partially Charged"} ,
|
|
MappingStrings {"MIF.DMTF|Portable Battery|002.14"} ]
|
|
uint16 BatteryStatus ;
|
|
[read , Description (
|
|
"TimeOnBattery indicates the elapsed time in seconds since the "
|
|
"computer system's UPS last switched to battery power, or the time "
|
|
"since the system or UPS was last restarted, whichever is less. Zero "
|
|
"shall be returned if the battery is 'on line'.") , Units ("Seconds") ]
|
|
uint32 TimeOnBattery ;
|
|
[read , Description (
|
|
"EstimatedRunTime is an estimate in minutes of the time to battery "
|
|
"charge depletion under the present load conditions if the utility power "
|
|
"is off, or lost and remains off, or a Laptop is disconnected from a "
|
|
"power source.") , Units ("Minutes") , MappingStrings {
|
|
"MIF.DMTF|Portable Battery|002.15"} ]
|
|
uint32 EstimatedRunTime ;
|
|
[read , Description (
|
|
"An estimate of the percentage of full charge remaining.") , Units (
|
|
"Percent") ]
|
|
uint16 EstimatedChargeRemaining ;
|
|
[read , Description (
|
|
"An enumeration that describes the battery's chemistry.") ,
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8"} ,
|
|
Values {"Other", "Unknown", "Lead Acid", "Nickel Cadmium", "Nickel Metal Hydride",
|
|
"Lithium-ion", "Zinc air", "Lithium Polymer"} , MappingStrings {
|
|
"MIF.DMTF|Portable Battery|002.7"} ]
|
|
uint16 Chemistry ;
|
|
[read , Description (
|
|
"The design capacity of the battery in Milliwatt-Hours. If this property is "
|
|
"not supported, enter 0.") , Units ("Milliwatt-Hours") , MappingStrings {
|
|
"MIF.DMTF|Portable Battery|002.8"} ]
|
|
uint32 DesignCapacity ;
|
|
[read , Description (
|
|
"The full charge capacity of the battery in Milliwatt-Hours. Comparison of "
|
|
"this value to the DesignCapacity property determines when the battery "
|
|
"requires replacement. A battery's end of life is typically when the "
|
|
"FullChargeCapacity property falls below 80% of the DesignCapacity property. If this "
|
|
"property is not supported, enter 0.") , Units ("Milliwatt-Hours") ,
|
|
MappingStrings {"MIF.DMTF|Portable Battery|002.11"} ]
|
|
uint32 FullChargeCapacity ;
|
|
[read , Description (
|
|
"The design voltage of the battery in Millivolts. If this attribute is not "
|
|
"supported, enter 0.") , Units ("Millivolts") , MappingStrings {
|
|
"MIF.DMTF|Portable Battery|002.9"} ]
|
|
uint64 DesignVoltage ;
|
|
[read , MaxLen (64) , Description (
|
|
"The Smart Battery Data Specification version number supported by this "
|
|
"battery. If the battery does not support this function, the value "
|
|
"should be left blank.") , MappingStrings {
|
|
"MIF.DMTF|Portable Battery|002.10"} ]
|
|
string SmartBatteryVersion ;
|
|
[read , Description (
|
|
"The remaining time to charge the battery fully in minutes at the "
|
|
"current charging rate and usage.") , Units ("Minutes") ,
|
|
MappingStrings {"MIF.DMTF|Portable Battery|002.16"} ]
|
|
uint32 TimeToFullCharge ;
|
|
[Read , Description ("Indicates the battery's expected lifetime in minutes, "
|
|
"assuming that the battery is fully charged. This property represents "
|
|
"the total expected life of the battery, not its current remaining life, "
|
|
"which is indicated by the EstimatedRunTime property. "), Units ("Minutes") ]
|
|
uint32 ExpectedLife;
|
|
[Read , Description ("MaxRechargeTime indicates the maximum time, in minutes, "
|
|
"to fully charge the battery. This property represents the time to recharge "
|
|
"a fully depleted battery, not the current remaining charging time, which is "
|
|
"indicated in the TimeToFullCharge property. "), Units ("Minutes") ]
|
|
uint32 MaxRechargeTime;
|
|
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of the Printer LogicalDevice."),
|
|
Locale (0x409), UUID ("{8502C54A-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Printer : CIM_LogicalDevice
|
|
{
|
|
[read, Description (
|
|
"Status information for a Printer, beyond that specified "
|
|
"in the LogicalDevice Availability property. Values include "
|
|
"\"Idle\" (3) and an indication that the Device is currently "
|
|
"printing (4)."),
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7"},
|
|
Values {"Other", "Unknown", "Idle", "Printing", "Warmup",
|
|
"Stopped Printing", "Offline"},
|
|
MappingStrings {"MIB.IETF|Printer-MIB.hrPrinterStatus"}
|
|
]
|
|
uint16 PrinterStatus;
|
|
[read, Description ("Printer error information."),
|
|
Values {"Unknown", "Other", "No Error", "Low Paper",
|
|
"No Paper", "Low Toner",
|
|
"No Toner", "Door Open", "Jammed", "Offline",
|
|
"Service Requested", "Output Bin Full"},
|
|
ModelCorrespondence {"CIM_Printer.ErrorInformation"},
|
|
MappingStrings {
|
|
"MIB.IETF|Printer-MIB.hrPrinterDetectedErrorState"}
|
|
]
|
|
uint16 DetectedErrorState;
|
|
[read, write, Description (
|
|
"An array providing supplemental information for the "
|
|
"current error state, indicated in DetectedErrorState."),
|
|
ModelCorrespondence {"CIM_Printer.DetectedErrorState"}
|
|
]
|
|
string ErrorInformation[];
|
|
[read, Description (
|
|
"An integer array indicating the types of paper supported."),
|
|
Values {"Unknown", "Other", "A", "B", "C", "D", "E",
|
|
"Letter", "Legal", "NA-10x13-Envelope", "NA-9x12-Envelope",
|
|
"NA-Number-10-Envelope", "NA-7x9-Envelope",
|
|
"NA-9x11-Envelope", "NA-10x14-Envelope",
|
|
"NA-Number-9-Envelope", "NA-6x9-Envelope",
|
|
"NA-10x15-Envelope", "A0", "A1", "A2", "A3", "A4", "A5",
|
|
"A6", "A7", "A8", "A9" "A10", "B0", "B1", "B2", "B3", "B4",
|
|
"B5", "B6", "B7", "B8", "B9", "B10", "C0", "C1", "C2" "C3",
|
|
"C4", "C5", "C6", "C7", "C8", "ISO-Designated", "JIS B0",
|
|
"JIS B1", "JIS B2", "JIS B3", "JIS B4", "JIS B5", "JIS B6",
|
|
"JIS B7", "JIS B8", "JIS B9", "JIS B10",
|
|
"NA-Letter", "NA-Legal", "B4-Envelope", "B5-Envelope",
|
|
"C3-Envelope", "C4-Envelope", "C5-Envelope", "C6-Envelope",
|
|
"Designated-Long-Envelope", "Monarch-Envelope",
|
|
"Executive", "Folio", "Invoice", "Ledger", "Quarto"}
|
|
]
|
|
uint16 PaperSizesSupported[];
|
|
[read, Description (
|
|
"An array of free-form strings specifying the types of "
|
|
"paper that are currently available on the Printer. Each "
|
|
"string should be expressed in the form specified by "
|
|
"ISO/IEC 10175 Document Printing Application (DPA) which "
|
|
"is also summarized in Appendix C of RFC 1759 (Printer MIB). "
|
|
"Examples of valid strings are \"iso-a4-colored\" and "
|
|
"\"na-10x14-envelope\". By definition a paper size that "
|
|
"is available and listed in PaperTypesAvailable should "
|
|
"also appear in the PaperSizesSupported property."),
|
|
ArrayType ("Indexed"),
|
|
ModelCorrespondence {"CIM_PrintJob.RequiredPaperType",
|
|
"CIM_PrintService.PaperTypesAvailable"},
|
|
MappingStrings {"MIB.IETF|Printer-MIB.prtInputMediaName"}
|
|
]
|
|
string PaperTypesAvailable[];
|
|
[read, Description (
|
|
"Specifies the paper type that the Printer will use if a "
|
|
"PrintJob does not specify a particular type. The string "
|
|
"should be expressed in the form specified by ISO/IEC "
|
|
"10175 Document Printing Application (DPA) which is also "
|
|
"summarized in Appendix C of RFC 1759 (Printer MIB)."),
|
|
ModelCorrespondence {"CIM_Printer.PaperTypesAvailable"}
|
|
]
|
|
string DefaultPaperType;
|
|
[read, Description (
|
|
"Specifies the paper type that the Printer is currently "
|
|
"using. The string should be expressed in the form specified "
|
|
"by ISO/IEC 10175 Document Printing Application (DPA) which "
|
|
"is also summarized in Appendix C of RFC 1759 (Printer MIB)."),
|
|
ModelCorrespondence {"CIM_Printer.PaperTypesAvailable"}
|
|
]
|
|
string CurrentPaperType;
|
|
[read, Description (
|
|
"An array indicating the print languages natively supported."),
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
|
|
"11", "12", "13", "14", "15", "16", "17", "18", "19",
|
|
"20", "21", "22", "23", "24", "25", "26", "27", "28",
|
|
"29", "30", "31", "32", "33", "34", "35", "36", "37",
|
|
"38", "39", "40", "41", "42", "43", "44", "45", "46", "47"},
|
|
Values {"Other", "Unknown", "PCL", "HPGL", "PJL", "PS",
|
|
"PSPrinter", "IPDS", "PPDS", "EscapeP", "Epson", "DDIF",
|
|
"Interpress", "ISO6429", "Line Data", "MODCA", "REGIS",
|
|
"SCS", "SPDL", "TEK4014", "PDS", "IGP", "CodeV", "DSCDSE",
|
|
"WPS", "LN03", "CCITT", "QUIC", "CPAP", "DecPPL",
|
|
"Simple Text", "NPAP", "DOC", "imPress", "Pinwriter",
|
|
"NPDL", "NEC201PL", "Automatic", "Pages", "LIPS", "TIFF",
|
|
"Diagnostic", "CaPSL", "EXCL", "LCDS", "XES", "MIME"},
|
|
MappingStrings {"MIB.IETF|Printer-MIB.prtInterpreterLangFamily"},
|
|
ModelCorrespondence {"CIM_Printer.MimeTypesSupported",
|
|
"CIM_PrintJob.Language",
|
|
"CIM_PrintService.LanguagesSupported"}
|
|
]
|
|
uint16 LanguagesSupported[];
|
|
[read, Description (
|
|
"An array of free-form strings providing more detailed "
|
|
"explanations of any mime types that are supported by "
|
|
"the Printer. If data is provided for this property, then "
|
|
"the value 47, \"Mime\", should be included in the Languages"
|
|
"Supported property."),
|
|
ModelCorrespondence {"CIM_Printer.LanguagesSupported",
|
|
"CIM_PrintJob.MimeTypes",
|
|
"CIM_PrintService.MimeTypesSupported"}
|
|
]
|
|
string MimeTypesSupported[];
|
|
[read, Description (
|
|
"Indicates the current printer language being used. A "
|
|
"language that is being used by the Printer should also be "
|
|
"listed in LanguagesSupported."),
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
|
|
"11", "12", "13", "14", "15", "16", "17", "18", "19",
|
|
"20", "21", "22", "23", "24", "25", "26", "27", "28",
|
|
"29", "30", "31", "32", "33", "34", "35", "36", "37",
|
|
"38", "39", "40", "41", "42", "43", "44", "45", "46", "47"},
|
|
Values {"Other", "Unknown", "PCL", "HPGL", "PJL", "PS",
|
|
"PSPrinter", "IPDS", "PPDS", "EscapeP", "Epson", "DDIF",
|
|
"Interpress", "ISO6429", "Line Data", "MODCA", "REGIS",
|
|
"SCS", "SPDL", "TEK4014", "PDS", "IGP", "CodeV", "DSCDSE",
|
|
"WPS", "LN03", "CCITT", "QUIC", "CPAP", "DecPPL",
|
|
"Simple Text", "NPAP", "DOC", "imPress", "Pinwriter",
|
|
"NPDL", "NEC201PL", "Automatic", "Pages", "LIPS", "TIFF",
|
|
"Diagnostic", "CaPSL", "EXCL", "LCDS", "XES", "MIME"},
|
|
ModelCorrespondence {"CIM_Printer.LanguagesSupported",
|
|
"CIM_Printer.CurrentMimeType"}
|
|
]
|
|
uint16 CurrentLanguage;
|
|
[read, Description (
|
|
"Specifies the mime type currently being used by the "
|
|
"Printer if the CurrentLanguage is set to indicate a "
|
|
"mime type is in use (value = 47)."),
|
|
ModelCorrespondence {"CIM_Printer.CurrentLanguage"}
|
|
]
|
|
string CurrentMimeType;
|
|
[read, Description (
|
|
"Indicates the default printer language. A language that "
|
|
"is used as a default by the Printer should also be listed "
|
|
"in LanguagesSupported."),
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
|
|
"11", "12", "13", "14", "15", "16", "17", "18", "19",
|
|
"20", "21", "22", "23", "24", "25", "26", "27", "28",
|
|
"29", "30", "31", "32", "33", "34", "35", "36", "37",
|
|
"38", "39", "40", "41", "42", "43", "44", "45", "46", "47"},
|
|
Values {"Other", "Unknown", "PCL", "HPGL", "PJL", "PS",
|
|
"PSPrinter", "IPDS", "PPDS", "EscapeP", "Epson", "DDIF",
|
|
"Interpress", "ISO6429", "Line Data", "MODCA", "REGIS",
|
|
"SCS", "SPDL", "TEK4014", "PDS", "IGP", "CodeV", "DSCDSE",
|
|
"WPS", "LN03", "CCITT", "QUIC", "CPAP", "DecPPL",
|
|
"Simple Text", "NPAP", "DOC", "imPress", "Pinwriter",
|
|
"NPDL", "NEC201PL", "Automatic", "Pages", "LIPS", "TIFF",
|
|
"Diagnostic", "CaPSL", "EXCL", "LCDS", "XES", "MIME"},
|
|
ModelCorrespondence {"CIM_Printer.LanguagesSupported",
|
|
"CIM_Printer.DefaultMimeType"}
|
|
]
|
|
uint16 DefaultLanguage;
|
|
[read, Description (
|
|
"Specifies the default mime type used by the Printer if the "
|
|
"DefaultLanguage is set to indicate a mime type is in use "
|
|
"(value=47)."),
|
|
ModelCorrespondence {"CIM_Printer.DefaultLanguage"}
|
|
]
|
|
string DefaultMimeType;
|
|
[read, Description (
|
|
"Printer jobs processed since last reset. These jobs may be "
|
|
"processed from one or more PrintQueues."),
|
|
Counter
|
|
]
|
|
uint32 JobCountSinceLastReset;
|
|
[read, Description ("Time of last reset of the Printer Device.")]
|
|
datetime TimeOfLastReset;
|
|
[read, Description (
|
|
"An array of integers indicating Printer capabilities. "
|
|
"Information such as \"Duplex Printing\" (value=3) or "
|
|
"\"Transparency Printing\" (7) is specified in this "
|
|
"property."),
|
|
ArrayType ("Indexed"),
|
|
Values {"Unknown", "Other", "Color Printing",
|
|
"Duplex Printing", "Copies", "Collation", "Stapling",
|
|
"Transparency Printing", "Punch", "Cover", "Bind",
|
|
"Black and White Printing", "One Sided",
|
|
"Two Sided Long Edge", "Two Sided Short Edge",
|
|
"Portrait", "Landscape", "Reverse Portrait",
|
|
"Reverse Landscape", "Quality High", "Quality Normal",
|
|
"Quality Low"},
|
|
ModelCorrespondence {"CIM_Printer.CapabilityDescriptions",
|
|
"CIM_PrintJob.Finishing",
|
|
"CIM_PrintService.Capabilities"}
|
|
]
|
|
uint16 Capabilities[];
|
|
[read, Description (
|
|
"An array of free-form strings providing more detailed "
|
|
"explanations for any of the Printer features indicated in "
|
|
"the Capabilities array. Note, each entry of this array "
|
|
"is related to the entry in the Capabilities array that "
|
|
"is located at the same index."),
|
|
ArrayType ("Indexed"),
|
|
ModelCorrespondence {"CIM_Printer.Capabilities"}
|
|
]
|
|
string CapabilityDescriptions[];
|
|
[read, Description (
|
|
"Specifies which finishings and other capabilities of "
|
|
"the Printer will be used by default. An entry in Default"
|
|
"Capabilities should also be listed in the Capabilities "
|
|
"array."),
|
|
Values {"Unknown", "Other", "Color Printing",
|
|
"Duplex Printing", "Copies", "Collation", "Stapling",
|
|
"Transparency Printing", "Punch", "Cover", "Bind",
|
|
"Black and White Printing", "One Sided",
|
|
"Two Sided Long Edge", "Two Sided Short Edge",
|
|
"Portrait", "Landscape", "Reverse Portrait",
|
|
"Reverse Landscape", "Quality High", "Quality Normal",
|
|
"Quality Low"},
|
|
ModelCorrespondence {"CIM_Printer.Capabilities"}
|
|
]
|
|
uint16 DefaultCapabilities[];
|
|
[read, Description (
|
|
"Specifies which finishings and other capabilities of "
|
|
"the Printer are currently being used. An entry in this "
|
|
"property should also be listed in the Capabilities array."),
|
|
Values {"Unknown", "Other", "Color Printing",
|
|
"Duplex Printing", "Copies", "Collation", "Stapling",
|
|
"Transparency Printing", "Punch", "Cover", "Bind",
|
|
"Black and White Printing", "One Sided",
|
|
"Two Sided Long Edge", "Two Sided Short Edge",
|
|
"Portrait", "Landscape", "Reverse Portrait",
|
|
"Reverse Landscape", "Quality High", "Quality Normal",
|
|
"Quality Low"},
|
|
ModelCorrespondence {"CIM_Printer.Capabilities"}
|
|
]
|
|
uint16 CurrentCapabilities[];
|
|
[read, Description (
|
|
"The maximum number of copies that can be produced by "
|
|
"the Printer from a single Job."),
|
|
ModelCorrespondence {"CIM_PrintJob.Copies"}
|
|
]
|
|
uint32 MaxCopies;
|
|
[read, Description (
|
|
"The number of copies that will be produced for a "
|
|
"single Job unless otherwise specified.")
|
|
]
|
|
uint32 DefaultCopies;
|
|
[read, Description (
|
|
"The maximum number of print-stream pages that the "
|
|
"Printer can render onto a single media sheet."),
|
|
ModelCorrespondence {"CIM_PrintJob.NumberUp"}
|
|
]
|
|
uint32 MaxNumberUp;
|
|
[read, Description (
|
|
"The number of print-stream pages that the Printer will "
|
|
"render onto a single media sheet unless a Job specifies "
|
|
"otherwise.")
|
|
]
|
|
uint32 DefaultNumberUp;
|
|
[read, Description (
|
|
"Printer's horizontal resolution in Pixels per Inch."),
|
|
Units ("Pixels per Inch"),
|
|
ModelCorrespondence {"CIM_PrintJob.HorizontalResolution"}
|
|
]
|
|
uint32 HorizontalResolution;
|
|
[read, Description (
|
|
"Printer's vertical resolution in Pixels per Inch."),
|
|
Units ("Pixels per Inch"),
|
|
ModelCorrespondence {"CIM_PrintJob.HorizontalResolution"}
|
|
]
|
|
uint32 VerticalResolution;
|
|
[read, Description (
|
|
"Identifies the available character sets for the output "
|
|
"of text related to managing the Printer. Strings "
|
|
"provided in this property should conform to the "
|
|
"semantics and syntax specified by section 4.1.2 "
|
|
"(\"Charset parameter\") in RFC 2046 (MIME Part 2) and "
|
|
"contained in the IANA character-set registry. Examples "
|
|
"include \"utf-8\", \"us-ascii\" and \"iso-8859-1\"."),
|
|
ArrayType ("Indexed"),
|
|
ModelCorrespondence {"CIM_PrintJob.CharSet"},
|
|
MappingStrings {
|
|
"MIB.IETF|Printer-MIB.prtLocalizationCharacterSet"}
|
|
]
|
|
string CharSetsSupported[];
|
|
[read, Description (
|
|
"Specifies the current character set being used for "
|
|
"the output of text relating to management of the "
|
|
"Printer. The character set described by this property "
|
|
"should also be listed in CharsetsSupported. The string "
|
|
"specified by this property should conform to the "
|
|
"semantics and syntax specified by section 4.1.2 "
|
|
"(\"Charset parameter\") in RFC 2046 (MIME Part 2) and "
|
|
"contained in the IANA character-set registry. Examples "
|
|
"include \"utf-8\", \"us-ascii\" and \"iso-8859-1\"."),
|
|
ModelCorrespondence {"CIM_Printer.CharSetsSupported"}
|
|
]
|
|
string CurrentCharSet;
|
|
[read, Description (
|
|
"Identifies the available languages for strings used by "
|
|
"the Printer for the output of management information. "
|
|
"The strings should conform to RFC 1766, for example "
|
|
"\"en\" is used for English."),
|
|
ArrayType ("Indexed"),
|
|
MappingStrings {
|
|
"MIB.IETF|Printer-MIB.prtLocalizationLanguage"},
|
|
ModelCorrespondence {"CIM_PrintJob.NaturalLanguage"}
|
|
]
|
|
string NaturalLanguagesSupported[];
|
|
[read, Description (
|
|
"Identifies the current language being used by the "
|
|
"Printer for management. The language listed in the "
|
|
"CurrentNaturalLanguage property should also be listed "
|
|
"in NaturalLanguagesSupported."),
|
|
ModelCorrespondence {"CIM_Printer.NaturalLanguagesSupported"}
|
|
]
|
|
string CurrentNaturalLanguage;
|
|
[read, Description (
|
|
"Specifies the largest Job (as a byte stream) that the "
|
|
"Printer will accept in units of Kbytes. A value of zero "
|
|
"indicates that no limit has been set."),
|
|
Units ("KiloBytes"),
|
|
ModelCorrespondence {"CIM_PrintJob.JobSize"}
|
|
]
|
|
uint32 MaxSizeSupported;
|
|
[read, Description (
|
|
"Describes all of the job sheets that are available on "
|
|
"the Printer. This can also be used to describe the banner "
|
|
"that a Printer might provide at the beginning of each Job, "
|
|
"or can describe other user specified options."),
|
|
ModelCorrespondence {"CIM_PrintJob.RequiredJobSheets"}
|
|
]
|
|
string AvailableJobSheets[];
|
|
[read, Description (
|
|
"Specifies the marking technology used by the Printer."),
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9",
|
|
"10", "11", "12", "13", "14", "15", "16", "17",
|
|
"18", "19", "20", "21", "22", "23", "24", "25",
|
|
"26", "27"},
|
|
Values {"Other", "Unknown", "Electrophotographic LED",
|
|
"Electrophotographic Laser",
|
|
"Electrophotographic Other",
|
|
"Impact Moving Head Dot Matrix 9pin",
|
|
"Impact Moving Head Dot Matrix 24pin",
|
|
"Impact Moving Head Dot Matrix Other",
|
|
"Impact Moving Head Fully Formed",
|
|
"Impact Band", "Impact Other", "Inkjet Aqueous",
|
|
"Inkjet Solid", "Inkjet Other", "Pen",
|
|
"Thermal Transfer", "Thermal Sensitive",
|
|
"Thermal Diffusion", "Thermal Other",
|
|
"Electroerosion", "Electrostatic",
|
|
"Photographic Microfiche",
|
|
"Photographic Imagesetter", "Photographic Other",
|
|
"Ion Deposition", "eBeam", "Typesetter"},
|
|
MappingStrings {"MIB.IETF|Printer-MIB.prtMarkerMarkTech"}
|
|
]
|
|
uint16 MarkingTechnology;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of the processor logical device."),
|
|
Locale (0x409), UUID ("{8502C54B-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Processor:CIM_LogicalDevice
|
|
{
|
|
[Description ("Processor address width in bits.") , Units ("Bits") , Read
|
|
]
|
|
uint16 AddressWidth ;
|
|
[Description ("The current speed (in MHz) of this processor.") , Units (
|
|
"MegaHertz") , MappingStrings {"MIF.DMTF|Processor|006.6"} , Read ]
|
|
uint32 CurrentClockSpeed ;
|
|
[Description ("Processor data width in bits.") , Units ("Bits") , Read ]
|
|
uint16 DataWidth ;
|
|
[ read, Description (
|
|
"The processor family type. For example, values include "
|
|
"\"Pentium(R) processor with MMX(TM) technology\" (14) and \"68040\" (96)."),
|
|
ValueMap {
|
|
"1", "2", "3", "4", "5",
|
|
"6", "7", "8", "9", "10",
|
|
"11", "12", "13", "14", "15",
|
|
"16", "17", "18", "19", "25",
|
|
"26", "27", "28", "29", "32",
|
|
"33", "34", "35", "36", "48",
|
|
"64", "80", "96", "97", "98",
|
|
"99", "100", "101", "112", "128",
|
|
"144", "160", "176", "180", "200",
|
|
"250", "251", "260", "261", "280",
|
|
"281", "300", "301", "302", "320"},
|
|
Values {
|
|
"Other", "Unknown", "8086", "80286", "80386",
|
|
"80486", "8087", "80287", "80387", "80487",
|
|
"Pentium Family", "Pentium Pro", "Pentium II", "Pentium MMX", "Celeron",
|
|
"Pentium II Xeon", "Pentium III", "M1 Family", "M2 Family", "K5 Family",
|
|
"K6 Family", "K6-2", "K6-III", "Athlon", "Power PC Family",
|
|
"Power PC 601", "Power PC 603", "Power PC 603+", "Power PC 604", "Alpha Family",
|
|
"MIPS Family", "SPARC Family", "68040", "68xxx Family", "68000",
|
|
"68010", "68020", "68030", "Hobbit Family", "Weitek",
|
|
"PA-RISC Family", "V30 Family", "Pentium III Xeon", "AS400 Family", "IBM390 Family",
|
|
"i860", "i960", "SH-3", "SH-4", "ARM",
|
|
"StrongARM", "6x86", "MediaGX", "MII", "WinChip"},
|
|
MappingStrings {"SMBIOS|Processor Information|Type 4|Processor Family"} ,
|
|
ModelCorrespondence {"CIM_Processor.OtherFamilyDescription"} ]
|
|
uint16 Family;
|
|
[Read, Description (
|
|
"A string describing the processor family type - used when "
|
|
"the family property is set to 1 (\"Other\"). This string "
|
|
"should be set to NULL when the family property is any "
|
|
"value other than 1."),
|
|
MaxLen (64) ,
|
|
ModelCorrespondence {"CIM_Processor.Family"} ]
|
|
string OtherFamilyDescription;
|
|
[Description (
|
|
"Loading of this processor, averaged over the last minute, "
|
|
"in Percent.") ,
|
|
Read , Units ("Percent"),
|
|
MappingStrings {"MIB.IETF|HOST-RESOURCES-MIB.hrProcessorLoad"}]
|
|
uint16 LoadPercentage ;
|
|
[Description ("The maximum speed (in MHz) of this processor.") , Units (
|
|
"MegaHertz") , MappingStrings {"MIF.DMTF|Processor|006.5"} , Read ]
|
|
uint32 MaxClockSpeed ;
|
|
[Description (
|
|
"A free form string describing the role of the processor - for example, \""
|
|
"Central Processor\"' or \"Math Processor\"") , Read ]
|
|
string Role ;
|
|
[read , Description (
|
|
"CPU socket information including data on how this "
|
|
"Processor can be upgraded (if upgrades are supported). "
|
|
"This property is an integer enumeration.") ,
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9",
|
|
"10", "11", "12" } ,
|
|
Values {"Other", "Unknown", "Daughter Board", "ZIF Socket",
|
|
"Replacement/Piggy Back", "None", "LIF Socket", "Slot 1", "Slot 2",
|
|
"370 Pin Socket", "Slot A", "Slot M"} ,
|
|
MappingStrings {"MIF.DMTF|Processor|006.7"} ]
|
|
uint16 UpgradeMethod ;
|
|
[Description (
|
|
"Stepping is a free-form string indicating the revision "
|
|
"level of the processor within the processor family."),
|
|
ModelCorrespondence {"CIM_Processor.Family"} , Read ]
|
|
string Stepping;
|
|
[Description (
|
|
"A globally unique identifier for the processor. This "
|
|
"identifier may only be unique within a processor family.") , Read ]
|
|
string UniqueId;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of an uninterruptible power supply. "
|
|
"The properties of the UPS device indicate when incoming power "
|
|
"is trimmed or boosted, and the aggregated information of the "
|
|
"batteries, generators, etc. that comprise the device. These "
|
|
"individual components (for example, multiple batteries) can "
|
|
"also be independently modeled and associated with the UPS."),
|
|
Locale (0x409), UUID ("{8502C54F-5FBB-11D2-AAC1-006008C78BC7}")]
|
|
class CIM_UninterruptiblePowerSupply:CIM_PowerSupply
|
|
{
|
|
[read , Override ("Range1InputVoltageLow") , Description (
|
|
"If the voltage (in Millivolts) drops below the value specified by "
|
|
"Range1InputVoltageLow property, the UPS will compensate by boosting the voltage "
|
|
"using its power source(s). A value of 0 indicates that the voltage at "
|
|
"which boosting occurs is 'unknown'.") , Units ("Millivolts") ]
|
|
uint32 Range1InputVoltageLow ;
|
|
[read , Override ("Range1InputVoltageHigh") , Description (
|
|
"If the voltage (in Millivolts) rises above the value specified by "
|
|
"Range1InputVoltageHigh property, the UPS will compensate by trimming the voltage."
|
|
" A value of 0 indicates that the voltage at which trimming occurs is '"
|
|
"unknown'.") , Units ("Millivolts") ]
|
|
uint32 Range1InputVoltageHigh ;
|
|
[read , Override ("Range2InputVoltageLow") , Description (
|
|
"If the voltage (in Millivolts) drops below the value specified by "
|
|
"Range2InputVoltageLow property, the UPS will compensate by boosting the voltage "
|
|
"using its power source(s). A value of 0 indicates that the voltage at "
|
|
"which boosting occurs is 'unknown'.") , Units ("Millivolts") ]
|
|
uint32 Range2InputVoltageLow ;
|
|
[read , Override ("Range2InputVoltageHigh") , Description (
|
|
"If the voltage (in Millivolts) rises above the value specified by "
|
|
"Range2InputVoltageHigh property, the UPS will compensate by trimming the voltage."
|
|
" A value of 0 indicates that the voltage at which trimming occurs is '"
|
|
"unknown'.") , Units ("Millivolts") ]
|
|
uint32 Range2InputVoltageHigh ;
|
|
[read , Description (
|
|
"The indication of the capacity remaining in the UPS' batteries, "
|
|
"generator, ... A value of \"Normal\" (2) indicates that the remaining "
|
|
"estimated minutes of run-time is greater than the UPS' defined 'low "
|
|
"power' state (typically two minutes). A value of \"Low\" (3) indicates "
|
|
"that the remaining estimated minutes of run-time is less than or equal "
|
|
"to the UPS' defined 'low power' state. A value of \"Depleted\" (4) "
|
|
"indicates that the UPS will be unable to sustain the present load when "
|
|
"and if the utility power is lost (including the possibility that the "
|
|
"utility power is currently absent).") , ValueMap {"1", "2", "3", "4"}
|
|
, Values {"Unknown", "Normal", "Low", "Depleted"} , MappingStrings {
|
|
"MIF.DMTF|UPS Battery|001.1"} ]
|
|
uint16 RemainingCapacityStatus ;
|
|
[read , Description (
|
|
"TimeOnBackup indicates the elapsed time in seconds since the UPS last "
|
|
"switched to battery power, generator, ... Or, the time since the UPS "
|
|
"was last restarted, whichever is less. Zero shall be returned if the "
|
|
"UPS is 'on line'.") , Units ("Seconds") , MappingStrings {
|
|
"MIF.DMTF|UPS Battery|001.2"} ]
|
|
uint32 TimeOnBackup ;
|
|
[read , Description (
|
|
"EstimatedRunTime is an estimate in minutes of the time to battery, "
|
|
"generator, ... depletion under the present load conditions if the "
|
|
"utility power is off, or lost and remains off.") , Units ("Minutes") ,
|
|
MappingStrings {"MIF.DMTF|UPS Battery|001.3"} ]
|
|
uint32 EstimatedRunTime ;
|
|
[read , Description (
|
|
"An estimate of the percentage of full charge remaining for a UPS (that "
|
|
"uses battery technology).") , Units ("Percent") , MappingStrings {
|
|
"MIF.DMTF|UPS Battery|001.4"} ]
|
|
uint16 EstimatedChargeRemaining ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of the parallel port logical device"),
|
|
Locale (0x409), UUID ("{8502C552-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_ParallelController:CIM_Controller
|
|
{
|
|
[read, Description (
|
|
"An integer enumeration indicating the capabilities of the parallel controller") ,
|
|
ArrayType ("Indexed"),
|
|
Values {"Unknown", "Other", "XT/AT Compatible",
|
|
"PS/2 Compatible", "ECP", "EPP", "PC-98", "PC-98-Hireso", "PC-H98"} ,
|
|
MappingStrings {"MIF.DMTF|Parallel Ports|003.8"} ,
|
|
ModelCorrespondence {"CIM_ParallelController.CapabilityDescriptions"} ]
|
|
uint16 Capabilities[] ;
|
|
[read, Description (
|
|
"An array of free-form strings providing more detailed explanations for "
|
|
"any of the parallel controller features indicated in the Capabilities "
|
|
"array. Note, each entry of this array is related to the entry in the "
|
|
"Capabilities array that is located at the same index.") ,
|
|
ArrayType ("Indexed"),
|
|
ModelCorrespondence {"CIM_ParallelController.Capabilities"} ]
|
|
string CapabilityDescriptions[] ;
|
|
[read, Description ("Set to true if the ParallelController supports DMA.") ,
|
|
MappingStrings {"MIF.DMTF|Parallel Ports|003.7"} ]
|
|
boolean DMASupport ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of the SCSI controller, logical device."),
|
|
Locale (0x409), UUID ("{8502C553-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_SCSIController:CIM_Controller
|
|
{
|
|
[Read, Description (
|
|
"Number of SCSIController timeouts that have occurred since "
|
|
"the TimeOfLastReset.")]
|
|
uint32 ControllerTimeouts ;
|
|
[Units ("Bits") , read, Description (
|
|
"Maximum data width (in bits) supported by the SCSI"
|
|
"Controller.")]
|
|
uint32 MaxDataWidth ;
|
|
[Units ("Bits per Second") , read, Description (
|
|
"Maximum transfer rate (in Bits per Second) supported by the "
|
|
"SCSIController.")]
|
|
uint64 MaxTransferRate ;
|
|
[read, Description (
|
|
"An integer enumeration indicating whether or not the "
|
|
"SCSI controller provides redundancy or protection against "
|
|
"device failures.") ,
|
|
ValueMap {"1", "2", "3", "4", "5", "6"} ,
|
|
Values {"Other", "Unknown", "Unprotected", "Protected",
|
|
"Protected through SCC (SCSI-3 Controller Command)",
|
|
"Protected through SCC-2 (SCSI-3 Controller Command)"} ,
|
|
MappingStrings {"MIF.DMTF|Storage Controller|001.3"} ]
|
|
uint16 ProtectionManagement ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of the serial port, logical device."),
|
|
Locale (0x409), UUID ("{8502C554-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_SerialController:CIM_Controller
|
|
{
|
|
[read, Description (
|
|
"The Capabilities property defines chip level compatibility "
|
|
"for the serial controller. Therefore, this property describes "
|
|
"the buffering and other capabilities of the serial controller, "
|
|
"that may be inherent in the chip hardware. The property is "
|
|
"an enumerated integer.") ,
|
|
ArrayType ("Indexed"),
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "160", "161"} ,
|
|
Values {"Other", "Unknown", "XT/AT Compatible", "16450 Compatible", "16550 Compatible",
|
|
"16550A Compatible", "8251 Compatible", "8251FIFO Compatible"} ,
|
|
MappingStrings {"MIF.DMTF|Serial Ports|004.7"} ,
|
|
ModelCorrespondence {"CIM_SerialController.CapabilityDescriptions"} ]
|
|
uint16 Capabilities[] ;
|
|
[read, Description (
|
|
"An array of free-form strings providing more detailed explanations for "
|
|
"any of the serial controller features indicated in the Capabilities "
|
|
"array. Note, each entry of this array is related to the entry in the "
|
|
"Capabilities array that is located at the same index.") , ArrayType (
|
|
"Indexed") ,
|
|
ModelCorrespondence {"CIM_SerialController.Capabilities"} ]
|
|
string CapabilityDescriptions[] ;
|
|
[Description (
|
|
"Maximum baud rate in Bits per Second supported by the "
|
|
"SerialController."), Units ("Bits per Second"),
|
|
MappingStrings {"MIF.DMTF|Serial Ports|004.6"}, read]
|
|
uint32 MaxBaudRate ;
|
|
};
|
|
[DisplayName("Files (CIM)"), SupportsDelete, DeleteBy("DeleteInstance"),
|
|
Abstract, Provider ("CIMWin32") , Description (
|
|
"The CIM_LogicalFile class represents a named collection of "
|
|
"data (this can be executable code) located in a file system "
|
|
"on a storage extent."),
|
|
Locale (0x409), UUID ("{8502C559-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_LogicalFile:CIM_LogicalElement
|
|
{
|
|
[DisplayName("Current File Open Count"),
|
|
read, Description (
|
|
"The InUseCount property is an integer indicating the number of "
|
|
"'file opens' that are currently active against the file." ) ]
|
|
uint64 InUseCount ;
|
|
[DisplayName("Should Be Archived"),
|
|
Description (
|
|
"The Archive property is a boolean value "
|
|
"indicating that the file should be archived.") ,
|
|
read, Schema ("Win32") ]
|
|
boolean Archive ;
|
|
[DisplayName("Computer System Class Name"),
|
|
Propagated ("CIM_FileSystem.CSCreationClassName") , CIM_Key, read, Description (
|
|
"The CSCreationClassName property is a string indicating "
|
|
"the class of the computer system."
|
|
) ]
|
|
string CSCreationClassName ;
|
|
[DisplayName("Computer System Name"),
|
|
Propagated ("CIM_FileSystem.CSName") , CIM_Key, Read, Description (
|
|
"The CSName property is a string indicating the name of the "
|
|
"computer system." ) ]
|
|
string CSName ;
|
|
[DisplayName("Compressed"),
|
|
Schema ("Win32") , Description (
|
|
"The Compressed property is a boolean value indicating "
|
|
"that the file is compressed.") , read]
|
|
boolean Compressed ;
|
|
[DisplayName("Class Name"),
|
|
CIM_Key, read, Description (
|
|
"The CreationClassName property is a string indicating the name of this class."
|
|
) ]
|
|
string CreationClassName ;
|
|
[DisplayName("Creation Date"),
|
|
Description (
|
|
"The CreationDate property is a datetime "
|
|
"value indicating the file's creation date.") , read]
|
|
datetime CreationDate ;
|
|
[DisplayName("Encrypted"),
|
|
Schema ("Win32") , Description (
|
|
"The Encrypted property is a boolean value indicating that the file is encrypted.") , read]
|
|
boolean Encrypted ;
|
|
[DisplayName("File System Class Name"),
|
|
Propagated ("CIM_FileSystem.CreationClassName") , CIM_Key, read, Description (
|
|
"The FSCreationClassName property is a string indicating the class of the file system." ) ]
|
|
string FSCreationClassName ;
|
|
[DisplayName("File System Name"),
|
|
Propagated ("CIM_FileSystem.Name") , CIM_Key, read, Description (
|
|
"The FSName property is string indicating the name of the file system." ) ]
|
|
string FSName ;
|
|
[DisplayName("Last Accessed"),
|
|
Description (
|
|
"The LastAccessed property is a datetime value indicating "
|
|
"the time the file was last accessed.") , read]
|
|
datetime LastAccessed ;
|
|
[DisplayName("Last Modified"),
|
|
Description (
|
|
"The LastModified property is a datetime value indicating "
|
|
"the time the file was last modified.") , read]
|
|
datetime LastModified ;
|
|
[DisplayName("Readable"),
|
|
Description (
|
|
"The Readable property is a boolean value indicating "
|
|
"if the file can be read.") , read]
|
|
boolean Readable ;
|
|
[DisplayName("Size"),
|
|
Description (
|
|
"The FileSize property represents the size of the "
|
|
"file (in bytes).") , Units ("Bytes") , read]
|
|
uint64 FileSize ;
|
|
[DisplayName("Writeable"),
|
|
Description (
|
|
"The Writeable property is a boolean value indicating "
|
|
"if the file can be written.") , Read
|
|
]
|
|
boolean Writeable ;
|
|
[DisplayName("Hidden"),
|
|
Description (
|
|
"The Hidden property is a boolean value indicating "
|
|
"if the file is hidden.") , read,
|
|
Schema ("Win32") ]
|
|
boolean Hidden ;
|
|
[DisplayName("System File"),
|
|
Description (
|
|
"The system property is a boolean value indicating "
|
|
"if the file is a system file.") ,
|
|
read, Schema ("Win32") ]
|
|
boolean System ;
|
|
[DisplayName("File Type"),
|
|
read, Schema ("Win32") , Description (
|
|
"The FileType property is a string descriptor representing "
|
|
"the file type (indicated by the Extension property)."
|
|
) ]
|
|
string FileType ;
|
|
[DisplayName("Eight Dot Three File Name"),
|
|
read, Description (
|
|
"The EightDotThreeFileName property is a string representing "
|
|
"the DOS-compatible file name for this file.\nExample: c:\\progra~1") , Schema ("Win32") ]
|
|
string EightDotThreeFileName ;
|
|
[DisplayName("Compression Method"),
|
|
read, Description (
|
|
"The CompressionMethod property is a free form string indicating "
|
|
"the algorithm or tool used to compress the logical file. If it "
|
|
"is not possible (or not desired) to describe the compression "
|
|
"scheme (perhaps because it is not known), use the following "
|
|
"words: \"Unknown\" to represent that it is not known whether "
|
|
"the logical file is compressed or not, \"Compressed\" to represent "
|
|
"that the file is compressed but either its compression scheme is not "
|
|
"known or not disclosed, and \"Not Compressed\" to represent that "
|
|
"the logical file is not compressed.") ]
|
|
string CompressionMethod ;
|
|
[DisplayName("Encryption Method"),
|
|
read, Description (
|
|
"The EncryptionMethod property is a free form string indicating "
|
|
"the algorithm or tool used to encrypt the logical file. If it is "
|
|
"not possible (or not desired) to describe the encryption scheme "
|
|
"(perhaps for security reasons), use the following words: \"Unknown\" "
|
|
"to represent that it is not known whether the logical file is encrypted "
|
|
"or not, \"Encrypted\" to represent that the file is encrypted but either "
|
|
"its encryption scheme is not known or not disclosed, and \"Not Encrypted\" "
|
|
"to represent that the logical file is not encrypted.") ]
|
|
string EncryptionMethod ;
|
|
[Override ("Name") , Description (
|
|
"The Name property is a string representing the inherited name "
|
|
"that serves as a key of a logical file instance within a "
|
|
"file system. Full path names should be provided. "
|
|
"Example: c:\\winnt\\system\\win.ini") , Key, read]
|
|
string Name ;
|
|
[Fixed, DisplayName("Drive"),
|
|
read, Schema ("Win32") , Description (
|
|
"The Drive property is a string representing the drive "
|
|
"letter (including colon) of the file. Example: c:") ]
|
|
string Drive ;
|
|
[Fixed, DisplayName("Path"),
|
|
read, Schema ("Win32") , Description (
|
|
"The Path property is a string representing the path of the "
|
|
"file. This includes leading and trailing backslashes. "
|
|
"Example: \\windows\\system\\") ]
|
|
string Path ;
|
|
[Fixed, DisplayName("File Name"),
|
|
read, Schema ("Win32") , Description (
|
|
"The FileName property is a string representing the filename "
|
|
"(without extension) of the file. Example: autoexec") ]
|
|
string FileName ;
|
|
[Fixed, DisplayName("File Extension"),
|
|
Description (
|
|
"The Extension property is a string representing the "
|
|
"file's extension (without the dot). Example: txt, mof, mdb.") ,
|
|
read, Schema ("Win32") ]
|
|
string Extension ;
|
|
[DisplayName("Access Rights"),
|
|
Description (
|
|
"The AccessMask property is a bit array representing the "
|
|
"access rights to the given file or directory held by the "
|
|
"user or group on whose behalf the instance is returned. This "
|
|
"property is only supported under Windows NT and Windows 2000. "
|
|
"On Windows 98 and on Windows NT/2000 FAT volumes, FULL_ACCESS "
|
|
"is returned, indicating no security has been set on the object.") ,
|
|
read, Schema ("Win32"),
|
|
BitValues {
|
|
"FILE_READ_DATA (file) or FILE_LIST_DIRECTORY (directory)" ,
|
|
"FILE_WRITE_DATA (file) or FILE_ADD_FILE (directory)" ,
|
|
"FILE_APPEND_DATA (file) or FILE_ADD_SUBDIRECTORY (directory)" ,
|
|
"FILE_READ_EA" ,
|
|
"FILE_WRITE_EA" ,
|
|
"FILE_EXECUTE (file) or FILE_TRAVERSE (directory)" ,
|
|
"FILE_DELETE_CHILD (directory)" ,
|
|
"FILE_READ_ATTRIBUTES" ,
|
|
"FILE_WRITE_ATTRIBUTES" ,
|
|
"DELETE" ,
|
|
"READ_CONTROL" ,
|
|
"WRITE_DAC" ,
|
|
"WRITE_OWNER" ,
|
|
"SYNCHRONIZE"
|
|
} : ToSubClass,
|
|
BitMap {
|
|
"0" ,
|
|
"1" ,
|
|
"2" ,
|
|
"3" ,
|
|
"4" ,
|
|
"5" ,
|
|
"6" ,
|
|
"7" ,
|
|
"8" ,
|
|
"16" ,
|
|
"17" ,
|
|
"18" ,
|
|
"19" ,
|
|
"20"
|
|
}: ToSubClass ]
|
|
uint32 AccessMask ;
|
|
|
|
[Implemented, Description(
|
|
"The TakeOwnerShip method obtains ownership of the logical file "
|
|
"specified in the object path . If the logical file is actually a "
|
|
"directory, then TakeOwnerShip will act recursively, taking "
|
|
"ownership of all the files and sub-directories the directory "
|
|
"contains. \n"
|
|
"It returns one of the following integer values:\n"
|
|
"0 - The request was successful.\n"
|
|
"2 - Access was denied.\n"
|
|
"8 - An unspecified failure occurred.\n"
|
|
"9 - The name specified was invalid.\n"
|
|
"10 - The object specified already exists.\n"
|
|
"11 - The file system is not NTFS.\n"
|
|
"12 - The platform is not Windows NT or Windows 2000.\n"
|
|
"13 - The drive is not the same.\n"
|
|
"14 - The directory is not empty.\n"
|
|
"15 - There has been a sharing violation.\n"
|
|
"16 - The start file specified was invalid.\n"
|
|
"17 - A privilege required for the operation is not held.\n"
|
|
"21 - A parameter specified is invalid.\n"): ToSubClass,
|
|
ValueMap {"0","2","8","9","10","11","12","13","14","15","16","17","21"},
|
|
Values {"Success","Access Denied","Unspecified failure",
|
|
"Invalid object","Object already exists","File system not NTFS",
|
|
"Platform not NT/Windows 2000","Drive not the same","Directory not empty",
|
|
"Sharing violation","Invalid start file","Privilege not held","Invalid parameter"} : ToSubclass,
|
|
Schema ("Win32") ]
|
|
uint32 TakeOwnerShip();
|
|
|
|
[Implemented, Description(
|
|
"The ChangeSecurityPermissions method changes the security "
|
|
"permissions for the logical file specified in the object "
|
|
"path. If the logical file is actually a directory, then "
|
|
"ChangeSecurityPermissions will act recursively, changing "
|
|
"the security permissions of all the files and sub-directories "
|
|
"the directory contains. ChangeSecurityPermissions returns an "
|
|
"integer value of 0 if the permissions were changed, and any "
|
|
"other number to indicate an error.\n"
|
|
"It returns one of the following integer values:\n"
|
|
"0 - The request was successful.\n"
|
|
"2 - Access was denied.\n"
|
|
"8 - An unspecified failure occurred.\n"
|
|
"9 - The name specified was invalid.\n"
|
|
"10 - The object specified already exists.\n"
|
|
"11 - The file system is not NTFS.\n"
|
|
"12 - The platform is not Windows NT or Windows 2000.\n"
|
|
"13 - The drive is not the same.\n"
|
|
"14 - The directory is not empty.\n"
|
|
"15 - There has been a sharing violation.\n"
|
|
"16 - The start file specified was invalid.\n"
|
|
"17 - A privilege required for the operation is not held.\n"
|
|
"21 - A parameter specified is invalid.\n"): ToSubClass,
|
|
ValueMap {"0","2","8","9","10","11","12","13","14","15","16","17","21"},
|
|
Values {"Success","Access Denied","Unspecified failure",
|
|
"Invalid object","Object already exists","File system not NTFS",
|
|
"Platform not NT/Windows 2000","Drive not the same","Directory not empty",
|
|
"Sharing violation","Invalid start file","Privilege not held","Invalid parameter"} : ToSubclass,
|
|
Schema ("Win32") ]
|
|
uint32 ChangeSecurityPermissions(
|
|
|
|
[In, Description(
|
|
"The SecurityDescriptor input parameter specifies "
|
|
"the security information") ]
|
|
Win32_SecurityDescriptor SecurityDescriptor,
|
|
|
|
[In, Description(
|
|
|
|
"The Option input parameter specifies the actual security "
|
|
"privilege to be modified. "
|
|
"Change_Owner_Security_Information - Change the owner of the logical file. "
|
|
"Change_Group_Security_Information - Change the group of the logical file. "
|
|
"Change_Dacl_Security_Information - Change the Access Control List of the logical file. "
|
|
"Change_Sacl_Security_Information - Change the System Access Control List of the logical file." ) ,
|
|
BitMap { "0" , "1" , "2" , "3" } ,
|
|
BitValues {
|
|
|
|
"Change_Owner_Security_Information" ,
|
|
"Change_Group_Security_Information" ,
|
|
"Change_Dacl_Security_Information" ,
|
|
"Change_Sacl_Security_Information"
|
|
}
|
|
|
|
] uint32 Option
|
|
|
|
);
|
|
|
|
[Implemented, Description(
|
|
"The Copy method copies the logical file or directory "
|
|
"specified in the object path to the location specified "
|
|
"by the input parameter. Copy returns an integer value of 0 "
|
|
"if the file was successfully copied, and any other number "
|
|
"to indicate an error. A copy is not supported if overwriting "
|
|
"an existing logical file is required.\n"
|
|
"It returns one of the following integer values:\n"
|
|
"0 - The request was successful.\n"
|
|
"2 - Access was denied.\n"
|
|
"8 - An unspecified failure occurred.\n"
|
|
"9 - The name specified was invalid.\n"
|
|
"10 - The object specified already exists.\n"
|
|
"11 - The file system is not NTFS.\n"
|
|
"12 - The platform is not Windows NT or Windows 2000.\n"
|
|
"13 - The drive is not the same.\n"
|
|
"14 - The directory is not empty.\n"
|
|
"15 - There has been a sharing violation.\n"
|
|
"16 - The start file specified was invalid.\n"
|
|
"17 - A privilege required for the operation is not held.\n"
|
|
"21 - A parameter specified is invalid.\n"): ToSubClass,
|
|
ValueMap {"0","2","8","9","10","11","12","13","14","15","16","17","21"},
|
|
Values {"Success","Access Denied","Unspecified failure",
|
|
"Invalid object","Object already exists","File system not NTFS",
|
|
"Platform not NT/Windows 2000","Drive not the same","Directory not empty",
|
|
"Sharing violation","Invalid start file","Privilege not held","Invalid parameter"} : ToSubclass,
|
|
Schema ("Win32") ]
|
|
uint32 Copy(
|
|
|
|
[In, Description(
|
|
"The FileName input parameter is a string representing "
|
|
"the fully qualified name of the copy of the file "
|
|
"(or directory). Example: c:\\temp\\newdirectory" )
|
|
]
|
|
string FileName
|
|
) ;
|
|
|
|
[Implemented, Description(
|
|
"The Rename method renames the logical file (or directory) "
|
|
"specified in the object path. Rename returns an integer "
|
|
"value of 0 if the file was successfully renamed, and any "
|
|
"other number to indicate an error. A rename is not supported "
|
|
"if the destination is on another drive or overwriting an "
|
|
"existing logical file is required\n"
|
|
"It returns one of the following integer values:\n"
|
|
"0 - The request was successful.\n"
|
|
"2 - Access was denied.\n"
|
|
"8 - An unspecified failure occurred.\n"
|
|
"9 - The name specified was invalid.\n"
|
|
"10 - The object specified already exists.\n"
|
|
"11 - The file system is not NTFS.\n"
|
|
"12 - The platform is not Windows NT or Windows 2000.\n"
|
|
"13 - The drive is not the same.\n"
|
|
"14 - The directory is not empty.\n"
|
|
"15 - There has been a sharing violation.\n"
|
|
"16 - The start file specified was invalid.\n"
|
|
"17 - A privilege required for the operation is not held.\n"
|
|
"21 - A parameter specified is invalid.\n"): ToSubClass,
|
|
ValueMap {"0","2","8","9","10","11","12","13","14","15","16","17","21"},
|
|
Values {"Success","Access Denied","Unspecified failure",
|
|
"Invalid object","Object already exists","File system not NTFS",
|
|
"Platform not NT/Windows 2000","Drive not the same","Directory not empty",
|
|
"Sharing violation","Invalid start file","Privilege not held","Invalid parameter"} : ToSubclass,
|
|
Schema ("Win32") ]
|
|
uint32 Rename(
|
|
|
|
[In, Description(
|
|
"The FileName input parameter is a string representing "
|
|
"the new name for the logical file (or directory). The "
|
|
"FileName input parameter must be a fully qualified path "
|
|
"name. Example: c:\\temp\\newfile.txt." ) ] string FileName
|
|
) ;
|
|
|
|
[Destructor, Implemented, Description(
|
|
"The Delete method will delete the logical file (or directory) "
|
|
"specified in the object path. Delete returns an integer value "
|
|
"of 0 if the file was successfully deleted, and any other number "
|
|
"to indicate an error.\n"
|
|
"It returns one of the following integer values:\n"
|
|
"0 - The request was successful.\n"
|
|
"2 - Access was denied.\n"
|
|
"8 - An unspecified failure occurred.\n"
|
|
"9 - The name specified was invalid.\n"
|
|
"10 - The object specified already exists.\n"
|
|
"11 - The file system is not NTFS.\n"
|
|
"12 - The platform is not Windows NT or Windows 2000.\n"
|
|
"13 - The drive is not the same.\n"
|
|
"14 - The directory is not empty.\n"
|
|
"15 - There has been a sharing violation.\n"
|
|
"16 - The start file specified was invalid.\n"
|
|
"17 - A privilege required for the operation is not held.\n"
|
|
"21 - A parameter specified is invalid.\n"): ToSubClass,
|
|
ValueMap {"0","2","8","9","10","11","12","13","14","15","16","17","21"},
|
|
Values {"Success","Access Denied","Unspecified failure",
|
|
"Invalid object","Object already exists","File system not NTFS",
|
|
"Platform not NT/Windows 2000","Drive not the same","Directory not empty",
|
|
"Sharing violation","Invalid start file","Privilege not held","Invalid parameter"} : ToSubclass,
|
|
Schema ("Win32") ]
|
|
uint32 Delete() ;
|
|
|
|
[Implemented,Schema ("Win32") , Description(
|
|
"The Compress method compresses the logical file (or directory) "
|
|
"specified in the object path. Compress returns an integer value "
|
|
"of 0 if the file was successfully compressed, and any other number "
|
|
"to indicate an error.\n"
|
|
"It returns one of the following integer values:\n"
|
|
"0 - The request was successful.\n"
|
|
"2 - Access was denied.\n"
|
|
"8 - An unspecified failure occurred.\n"
|
|
"9 - The name specified was invalid.\n"
|
|
"10 - The object specified already exists.\n"
|
|
"11 - The file system is not NTFS.\n"
|
|
"12 - The platform is not Windows NT or Windows 2000.\n"
|
|
"13 - The drive is not the same.\n"
|
|
"14 - The directory is not empty.\n"
|
|
"15 - There has been a sharing violation.\n"
|
|
"16 - The start file specified was invalid.\n"
|
|
"17 - A privilege required for the operation is not held.\n"
|
|
"21 - A parameter specified is invalid.\n"): ToSubClass,
|
|
ValueMap {"0","2","8","9","10","11","12","13","14","15","16","17","21"},
|
|
Values {"Success","Access Denied","Unspecified failure",
|
|
"Invalid object","Object already exists","File system not NTFS",
|
|
"Platform not NT/Windows 2000","Drive not the same","Directory not empty",
|
|
"Sharing violation","Invalid start file","Privilege not held","Invalid parameter"} : ToSubclass ]
|
|
uint32 Compress() ;
|
|
|
|
[Implemented, Description(
|
|
"The Uncompress method uncompresses the logical file (or directory) "
|
|
"specified in the object path. Uncompress returns an integer value "
|
|
"of 0 if the file was successfully decompressed, and any other number "
|
|
"to indicate an error.\n"
|
|
"It returns one of the following integer values:\n"
|
|
"0 - The request was successful.\n"
|
|
"2 - Access was denied.\n"
|
|
"8 - An unspecified failure occurred.\n"
|
|
"9 - The name specified was invalid.\n"
|
|
"10 - The object specified already exists.\n"
|
|
"11 - The file system is not NTFS.\n"
|
|
"12 - The platform is not Windows NT or Windows 2000.\n"
|
|
"13 - The drive is not the same.\n"
|
|
"14 - The directory is not empty.\n"
|
|
"15 - There has been a sharing violation.\n"
|
|
"16 - The start file specified was invalid.\n"
|
|
"17 - A privilege required for the operation is not held.\n"
|
|
"21 - A parameter specified is invalid.\n"): ToSubClass,
|
|
ValueMap {"0","2","8","9","10","11","12","13","14","15","16","17","21"},
|
|
Values {"Success","Access Denied","Unspecified failure",
|
|
"Invalid object","Object already exists","File system not NTFS",
|
|
"Platform not NT/Windows 2000","Drive not the same","Directory not empty",
|
|
"Sharing violation","Invalid start file","Privilege not held","Invalid parameter"} : ToSubclass,
|
|
Schema ("Win32") ]
|
|
uint32 Uncompress() ;
|
|
|
|
[Implemented, Description(
|
|
"The TakeOwnerShipEx method obtains ownership of the logical file "
|
|
"specified in the object path. If the logical file is actually a "
|
|
"directory, then this method will act recursively, taking ownership "
|
|
"of all the files and sub-directories the directory contains. "
|
|
"TakeOwnerShipEx returns an integer value of 0 on success, and "
|
|
"any other number to indicate an error. TakeOwnerShipEx is an "
|
|
"extended version of the TakeOwnerShip method.\n"
|
|
"It returns one of the following integer values:\n"
|
|
"0 - The request was successful.\n"
|
|
"2 - Access was denied.\n"
|
|
"8 - An unspecified failure occurred.\n"
|
|
"9 - The name specified was invalid.\n"
|
|
"10 - The object specified already exists.\n"
|
|
"11 - The file system is not NTFS.\n"
|
|
"12 - The platform is not Windows NT or Windows 2000.\n"
|
|
"13 - The drive is not the same.\n"
|
|
"14 - The directory is not empty.\n"
|
|
"15 - There has been a sharing violation.\n"
|
|
"16 - The start file specified was invalid.\n"
|
|
"17 - A privilege required for the operation is not held.\n"
|
|
"21 - A parameter specified is invalid.\n"): ToSubClass,
|
|
ValueMap {"0","2","8","9","10","11","12","13","14","15","16","17","21"},
|
|
Values {"Success","Access Denied","Unspecified failure",
|
|
"Invalid object","Object already exists","File system not NTFS",
|
|
"Platform not NT/Windows 2000","Drive not the same","Directory not empty",
|
|
"Sharing violation","Invalid start file","Privilege not held","Invalid parameter"} : ToSubclass,
|
|
Schema ("Win32") ]
|
|
uint32 TakeOwnerShipEx(
|
|
|
|
[Out, Description(
|
|
"The StopFileName output parameter is a string representing the "
|
|
"name of the file/directory where TakeOwnerShipEx method failed. "
|
|
"StopFileName parameter will be null if the method succeeds." )
|
|
]
|
|
string StopFileName,
|
|
|
|
[In, optional, Description(
|
|
"The StartFileName input parameter is a string that names the child file/directory to use as a starting point for TakeOwnerShipEx."
|
|
"The StartFileName property typically, is the StopFileName parameter specifying the file or directory at which an"
|
|
"error occurred from the previous method call. If this parameter is NULL, the operation is performed on the file or"
|
|
"directory specified in the ExecMethod call." )
|
|
]
|
|
string StartFileName ,
|
|
|
|
[In, optional, Description(
|
|
"The Recursive input parameter is a boolean that indicates whether the change of ownership will be "
|
|
"applied recursively to files and directories within the directory specified by the CIM_LogicalFile instance."
|
|
"Note for file instances the Recursive input parameter is ignored." )
|
|
]
|
|
boolean Recursive
|
|
) ;
|
|
|
|
[Implemented, Description(
|
|
"The ChangeSecurityPermissionsEx method changes the security permissions for "
|
|
"the logical file specified in the object path. If the logical file is actually "
|
|
"a directory, then this method will act recursively, changing the security "
|
|
"permissions of all the files and sub-directories the directory contains. "
|
|
"ChangeSecurityPermissionsEx returns an integer value of 0 if the permissions "
|
|
"were changed, and any other number to indicate an error. The ChangeSecurityPermissionsEx method "
|
|
"is an extended version of the ChangeSecurityPermissions method.\n"
|
|
"It returns one of the following integer values:\n"
|
|
"0 - The request was successful.\n"
|
|
"2 - Access was denied.\n"
|
|
"8 - An unspecified failure occurred.\n"
|
|
"9 - The name specified was invalid.\n"
|
|
"10 - The object specified already exists.\n"
|
|
"11 - The file system is not NTFS.\n"
|
|
"12 - The platform is not Windows NT or Windows 2000.\n"
|
|
"13 - The drive is not the same.\n"
|
|
"14 - The directory is not empty.\n"
|
|
"15 - There has been a sharing violation.\n"
|
|
"16 - The start file specified was invalid.\n"
|
|
"17 - A privilege required for the operation is not held.\n"
|
|
"21 - A parameter specified is invalid.\n"): ToSubClass,
|
|
ValueMap {"0","2","8","9","10","11","12","13","14","15","16","17","21"},
|
|
Values {"Success","Access Denied","Unspecified failure",
|
|
"Invalid object","Object already exists","File system not NTFS",
|
|
"Platform not NT/Windows 2000","Drive not the same","Directory not empty",
|
|
"Sharing violation","Invalid start file","Privilege not held","Invalid parameter"} : ToSubclass,
|
|
Schema ("Win32") ]
|
|
uint32 ChangeSecurityPermissionsEx(
|
|
|
|
[in, Description(
|
|
"The SecurityDescriptor input parameter specifies the security information."
|
|
) ]
|
|
Win32_SecurityDescriptor SecurityDescriptor,
|
|
|
|
[In, Description(
|
|
"The Option input parameter specifies the actual security permission "
|
|
"to be modified. "
|
|
"Change_Owner_Security_Information - Change the owner of the logical file. "
|
|
"Change_Group_Security_Information - Change the group of the logical file. "
|
|
"Change_Dacl_Security_Information - Change the Access Control List of the logical file. "
|
|
"Change_Sacl_Security_Information - Change the System Access Control List of the logical file."
|
|
) ,
|
|
BitMap { "0" , "1" , "2" , "3" } ,
|
|
BitValues {
|
|
|
|
"Change_Owner_Security_Information" ,
|
|
"Change_Group_Security_Information" ,
|
|
"Change_Dacl_Security_Information" ,
|
|
"Change_Sacl_Security_Information"
|
|
|
|
}
|
|
] uint32 Option,
|
|
|
|
[Out, Description(
|
|
"The StopFileName output parameter is a string representing "
|
|
"the name of the file/directory where ChangeSecurityPermissionsEx "
|
|
"failed. StopFileName will be null if the method succeeds." )
|
|
] string StopFileName,
|
|
|
|
[In, optional, Description(
|
|
"The StartFileName input parameter is a string representing the child file/directory to use as a starting point "
|
|
"for ChangeSecurityPermissionsEx."
|
|
"The StartFileName property typically, is the StopFileName parameter specifying the file or directory at which an"
|
|
"error occurred from the previous method call. If this parameter is NULL, the operation is performed on the file or"
|
|
"directory specified in the ExecMethod call." )
|
|
] string StartFileName ,
|
|
|
|
[In, optional, Description(
|
|
"The Recursive input parameter is a boolean that indicates whether the security permissions will be "
|
|
"applied recursively to files and directories within the directory specified by the CIM_LogicalFile instance."
|
|
"Note for file instances the Recursive input parameter is ignored." )
|
|
]
|
|
boolean Recursive
|
|
|
|
);
|
|
|
|
[Implemented, Description(
|
|
"The CopyEx method copies the logical file or directory specified "
|
|
"in the object path to the location specified by the FileName parameter. "
|
|
"CopyEx returns an integer value of 0 if the file was successfully copied, "
|
|
"and any other number to indicate an error. A copy is not supported if "
|
|
"overwriting an existing logical file is required. CopyEx is an extended "
|
|
"version of the Copy method.\n"
|
|
"It returns one of the following integer values:\n"
|
|
"0 - The request was successful.\n"
|
|
"2 - Access was denied.\n"
|
|
"8 - An unspecified failure occurred.\n"
|
|
"9 - The name specified was invalid.\n"
|
|
"10 - The object specified already exists.\n"
|
|
"11 - The file system is not NTFS.\n"
|
|
"12 - The platform is not Windows NT or Windows 2000.\n"
|
|
"13 - The drive is not the same.\n"
|
|
"14 - The directory is not empty.\n"
|
|
"15 - There has been a sharing violation.\n"
|
|
"16 - The start file specified was invalid.\n"
|
|
"17 - A privilege required for the operation is not held.\n"
|
|
"21 - A parameter specified is invalid.\n"): ToSubClass,
|
|
ValueMap {"0","2","8","9","10","11","12","13","14","15","16","17","21"},
|
|
Values {"Success","Access Denied","Unspecified failure",
|
|
"Invalid object","Object already exists","File system not NTFS",
|
|
"Platform not NT/Windows 2000","Drive not the same","Directory not empty",
|
|
"Sharing violation","Invalid start file","Privilege not held","Invalid parameter"} : ToSubclass,
|
|
Schema ("Win32") ]
|
|
uint32 CopyEx(
|
|
|
|
[In, Description(
|
|
"The FileName input parameter is a string representing the fully "
|
|
"qualified name of the copy of the file (or directory). "
|
|
"Example: c:\\temp\\newdirectory." )
|
|
] string FileName,
|
|
|
|
[Out, Description(
|
|
"The StopFileName output parameter is a string representing the "
|
|
"name of the file/directory where CopyEx failed. "
|
|
"This string parameter will be null if the method succeeds." )
|
|
] string StopFileName,
|
|
|
|
[In, optional, Description(
|
|
"The StartFileName input parameter is a string that names the child file/directory to use as a starting point "
|
|
"for CopyEx."
|
|
"The StartFileName property typically, is the StopFileName parameter specifying the file or directory at which an"
|
|
"error occurred from the previous method call. If this parameter is NULL, the operation is performed on the file or"
|
|
"directory specified in the ExecMethod call." )
|
|
] string StartFileName ,
|
|
|
|
[In, optional, Description(
|
|
"The Recursive input parameter is a boolean that indicates whether the copy will be "
|
|
"applied recursively to files and directories within the directory specified by the CIM_LogicalFile instance."
|
|
"Note for file instances the Recursive input parameter is ignored." )
|
|
]
|
|
boolean Recursive
|
|
|
|
) ;
|
|
|
|
|
|
[Implemented, Description(
|
|
"The DeleteEx method will delete the logical file (or directory) specified in "
|
|
"the object path. DeleteEx returns an integer value of 0 if the file was "
|
|
"successfully deleted, and any other number to indicate an error. "
|
|
"DeleteEx is an extended version of the Delete method.\n"
|
|
"It returns one of the following integer values:\n"
|
|
"0 - The request was successful.\n"
|
|
"2 - Access was denied.\n"
|
|
"8 - An unspecified failure occurred.\n"
|
|
"9 - The name specified was invalid.\n"
|
|
"10 - The object specified already exists.\n"
|
|
"11 - The file system is not NTFS.\n"
|
|
"12 - The platform is not Windows NT or Windows 2000.\n"
|
|
"13 - The drive is not the same.\n"
|
|
"14 - The directory is not empty.\n"
|
|
"15 - There has been a sharing violation.\n"
|
|
"16 - The start file specified was invalid.\n"
|
|
"17 - A privilege required for the operation is not held.\n"
|
|
"21 - A parameter specified is invalid.\n"): ToSubClass,
|
|
ValueMap {"0","2","8","9","10","11","12","13","14","15","16","17","21"},
|
|
Values {"Success","Access Denied","Unspecified failure",
|
|
"Invalid object","Object already exists","File system not NTFS",
|
|
"Platform not NT/Windows 2000","Drive not the same","Directory not empty",
|
|
"Sharing violation","Invalid start file","Privilege not held","Invalid parameter"} : ToSubclass,
|
|
Schema ("Win32") ]
|
|
uint32 DeleteEx(
|
|
|
|
[Out, Description(
|
|
"The StopFileName output parameter is a string representing the name of the file/directory "
|
|
"where DeleteEx failed. This string parameter will be null if DeleteEx succeeds." )
|
|
] string StopFileName,
|
|
|
|
[In, optional, Description(
|
|
"The StartFileName input parameter is a string that names the child file/directory to use as a starting "
|
|
"point for DeleteEx."
|
|
"The StartFileName property typically, is the StopFileName parameter specifying the file or directory at which an"
|
|
"error occurred from the previous method call. If this parameter is NULL, the operation is performed on the file or"
|
|
"directory specified in the ExecMethod call." )
|
|
] string StartFileName
|
|
|
|
) ;
|
|
|
|
[Implemented, Description(
|
|
"The CompressEx method compresses the logical file (or directory) specified in the object path. CompressEx "
|
|
"returns an integer value of 0 if the file was successfully compressed, and any other number to "
|
|
"indicate an error. CompressEx is an extended version of the Compress method.\n"
|
|
"It returns one of the following integer values:\n"
|
|
"0 - The request was successful.\n"
|
|
"2 - Access was denied.\n"
|
|
"8 - An unspecified failure occurred.\n"
|
|
"9 - The name specified was invalid.\n"
|
|
"10 - The object specified already exists.\n"
|
|
"11 - The file system is not NTFS.\n"
|
|
"12 - The platform is not Windows NT or Windows 2000.\n"
|
|
"13 - The drive is not the same.\n"
|
|
"14 - The directory is not empty.\n"
|
|
"15 - There has been a sharing violation.\n"
|
|
"16 - The start file specified was invalid.\n"
|
|
"17 - A privilege required for the operation is not held.\n"
|
|
"21 - A parameter specified is invalid.\n"): ToSubClass,
|
|
ValueMap {"0","2","8","9","10","11","12","13","14","15","16","17","21"},
|
|
Values {"Success","Access Denied","Unspecified failure",
|
|
"Invalid object","Object already exists","File system not NTFS",
|
|
"Platform not NT/Windows 2000","Drive not the same","Directory not empty",
|
|
"Sharing violation","Invalid start file","Privilege not held","Invalid parameter"} : ToSubclass,
|
|
Schema ("Win32") ]
|
|
uint32 CompressEx(
|
|
|
|
[Out, Description(
|
|
"The StopFileName output parameter is a string representing the name of the file/directory where "
|
|
"CompressEx failed. StopFileName will be null if the method succeeds." )
|
|
] string StopFileName,
|
|
|
|
[In, optional, Description(
|
|
"The StartFileName input parameter is a string that names the child file/directory to use as a starting point for "
|
|
"CompressEx."
|
|
"The StartFileName property typically, is the StopFileName parameter specifying the file or directory at which an"
|
|
"error occurred from the previous method call. If this parameter is NULL, the operation is performed on the file or"
|
|
"directory specified in the ExecMethod call." )
|
|
] string StartFileName ,
|
|
|
|
[In, optional, Description(
|
|
"The Recursive input parameter is a boolean that indicates whether the compression will be "
|
|
"applied recursively to files and directories within the directory specified by the CIM_LogicalFile instance."
|
|
"Note for file instances the Recursive input parameter is ignored." )
|
|
]
|
|
boolean Recursive
|
|
|
|
) ;
|
|
|
|
[Implemented, Description(
|
|
"The UncompressEx method uncompresses the logical file (or directory) specified in the object path. UncompressEx "
|
|
"returns an integer value of 0 if the file was successfully decompressed, and any other number to "
|
|
"indicate an error. UncompressEx is an extended version of the Uncompress method.\n"
|
|
"It returns one of the following integer values:\n"
|
|
"0 - The request was successful.\n"
|
|
"2 - Access was denied.\n"
|
|
"8 - An unspecified failure occurred.\n"
|
|
"9 - The name specified was invalid.\n"
|
|
"10 - The object specified already exists.\n"
|
|
"11 - The file system is not NTFS.\n"
|
|
"12 - The platform is not Windows NT or Windows 2000.\n"
|
|
"13 - The drive is not the same.\n"
|
|
"14 - The directory is not empty.\n"
|
|
"15 - There has been a sharing violation.\n"
|
|
"16 - The start file specified was invalid.\n"
|
|
"17 - A privilege required for the operation is not held.\n"
|
|
"21 - A parameter specified is invalid.\n"): ToSubClass,
|
|
ValueMap {"0","2","8","9","10","11","12","13","14","15","16","17","21"},
|
|
Values {"Success","Access Denied","Unspecified failure",
|
|
"Invalid object","Object already exists","File system not NTFS",
|
|
"Platform not NT/Windows 2000","Drive not the same","Directory not empty",
|
|
"Sharing violation","Invalid start file","Privilege not held","Invalid parameter"} : ToSubclass,
|
|
Schema ("Win32") ]
|
|
uint32 UncompressEx(
|
|
|
|
[Out, Description(
|
|
"The StopFileName output parameter is a string representing the name of the file/directory where UncompressEx failed. "
|
|
"StopFileName will be null if the method succeeds." )
|
|
] string StopFileName,
|
|
|
|
[In, optional, Description(
|
|
"The StartFileName input parameter is a string that names the child file/directory to use as a starting point for UncompressEx."
|
|
"The StartFileName property typically, is the StopFileName parameter specifying the file or directory at which an"
|
|
"error occurred from the previous method call. If this parameter is NULL, the operation is performed on the file or"
|
|
"directory specified in the ExecMethod call." )
|
|
] string StartFileName ,
|
|
|
|
[In, optional, Description(
|
|
"The Recursive input parameter is a boolean that indicates whether the decompression will be "
|
|
"applied recursively to files and directories within the directory specified by the CIM_LogicalFile instance."
|
|
"Note for file instances the Recursive input parameter is ignored." )
|
|
]
|
|
boolean Recursive
|
|
|
|
) ;
|
|
|
|
[Privileges{"SeSecurityPrivilege"},
|
|
Implemented, Description (
|
|
"The GetEffectivePermission method determines whether the caller "
|
|
"has the aggregated permissions specified by the Permission argument not "
|
|
"only on the file object, but on the share the file or directory "
|
|
"resides on (if it is on a share)."): ToSubClass,
|
|
Schema ("Win32") ]
|
|
boolean GetEffectivePermission(
|
|
[In, Description (
|
|
"The Permissions input parameter is a bit array of the permissions that the "
|
|
"caller wishes to inquire about.") ,
|
|
BitValues {
|
|
"FILE_READ_DATA (file) or FILE_LIST_DIRECTORY (directory)" ,
|
|
"FILE_WRITE_DATA (file) or FILE_ADD_FILE (directory)" ,
|
|
"FILE_APPEND_DATA (file) or FILE_ADD_SUBDIRECTORY (directory)" ,
|
|
"FILE_READ_EA" ,
|
|
"FILE_WRITE_EA" ,
|
|
"FILE_EXECUTE (file) or FILE_TRAVERSE (directory)" ,
|
|
"FILE_DELETE_CHILD (directory)" ,
|
|
"FILE_READ_ATTRIBUTES" ,
|
|
"FILE_WRITE_ATTRIBUTES" ,
|
|
"DELETE" ,
|
|
"READ_CONTROL" ,
|
|
"WRITE_DAC" ,
|
|
"WRITE_OWNER" ,
|
|
"SYNCHRONIZE"
|
|
} : ToSubClass,
|
|
BitMap {
|
|
"0" ,
|
|
"1" ,
|
|
"2" ,
|
|
"3" ,
|
|
"4" ,
|
|
"5" ,
|
|
"6" ,
|
|
"7" ,
|
|
"8" ,
|
|
"16" ,
|
|
"17" ,
|
|
"18" ,
|
|
"19" ,
|
|
"20"
|
|
}: ToSubClass ]
|
|
uint32 Permissions
|
|
);
|
|
};
|
|
|
|
[DisplayName("All Files (CIM)"),
|
|
Dynamic, Provider ("CIMWin32") , Description (
|
|
"CIM_DataFile is a type of logical file that is a named collection of data or "
|
|
"executable code.\n"
|
|
"<B>The behavior of the provider backing this class will be "
|
|
"changed in future releases. Currently the provider returns "
|
|
"both files on fixed disks as well as files on mapped logical"
|
|
" disks. In the future, only instances of files on local fixed "
|
|
"disks will be returned.<B>"),
|
|
Locale (0x409), UUID ("{8502C55A-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_DataFile:CIM_LogicalFile
|
|
{
|
|
[DisplayName("Version"),
|
|
read, Schema ("Win32") , Description (
|
|
"Version string from version resource if one is present.") ]
|
|
string Version ;
|
|
[DisplayName("Manufacturer"),
|
|
read, Schema ("Win32") , Description (
|
|
"Manufacturer string from version resource if one is present.") ]
|
|
string Manufacturer ;
|
|
};
|
|
|
|
[Dynamic, Provider ("CIMWin32") , Description (
|
|
"A link between a process and a data file indicating that the file "
|
|
"participates in the execution of the process."),
|
|
Locale (0x409), UUID ("{8502C542-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_ProcessExecutable:CIM_Dependency
|
|
{
|
|
[read, key, Description (
|
|
"The data file participating in the execution of the process.") ]
|
|
CIM_DataFile REF Antecedent;
|
|
[read, key, Description ("The process.") ]
|
|
CIM_Process REF Dependent;
|
|
[read, Schema ("Win32") , Description (
|
|
"GlobalProcessCount is the current number of processes that have "
|
|
"the file loaded in memory.") ]
|
|
uint32 GlobalProcessCount ;
|
|
[read, Schema ("Win32") , Description (
|
|
"ProcessCount represents the reference count of the file "
|
|
"in the associated process.") ]
|
|
uint32 ProcessCount ;
|
|
[DEPRECATED, read, Schema ("Win32") , Description (
|
|
"ModuleInstance represents the Win32 instance handle."
|
|
"The ModuleInstance property has been deprecated. There "
|
|
"is no replacement value and this property is now considered "
|
|
"obsolete.") ]
|
|
uint32 ModuleInstance ;
|
|
[read, Schema ("Win32") , Description (
|
|
"BaseAddress represents the base address of the module in the "
|
|
"address space of the associated process.") ]
|
|
uint64 BaseAddress ;
|
|
};
|
|
|
|
|
|
[DisplayName("Directories (CIM)"),
|
|
Abstract, Description (
|
|
"Directory is a type of file that logically groups data files 'contained' "
|
|
"in it, and provides path information for the grouped files."),
|
|
Locale (0x409), UUID ("{8502C55F-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Directory:CIM_LogicalFile
|
|
{
|
|
};
|
|
|
|
[abstract, Description (
|
|
" The CIM_SoftwareElement class is used to decompose a "
|
|
"CIM_SoftwareFeature object into a set of individually manageable or "
|
|
"deployable parts for a particular platform. A software element's "
|
|
"platform is uniquely identified by its underlying hardware "
|
|
"architecture and operating system (for example Sun Solaris on Sun "
|
|
"Sparc or Windows NT on Intel). As such, to understand the details of "
|
|
"how the functionality of a particular software feature is provided on "
|
|
"a particular platform, the CIM_SoftwareElement objects referenced by "
|
|
"CIM_SoftwareFeatureSoftwareElement associations are organized in "
|
|
"disjoint sets based on the TargetOperatingSystem property. A "
|
|
"CIM_SoftwareElement object captures the management details of a part "
|
|
"or component in one of four states characterized by the "
|
|
"SoftwareElementState property. "),
|
|
Locale (0x409), UUID ("{8502C561-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_SoftwareElement:CIM_LogicalElement
|
|
{
|
|
[read, key, maxlen (256) , override ("Name") , Description (
|
|
"The name used to identify this software element") ]
|
|
string Name ;
|
|
[read, key, Maxlen (64) , Description (
|
|
"Version should be in the form <Major>.<Minor>.<Revision> or <Major>."
|
|
"<Minor><letter><revision>") , Mappingstrings {
|
|
"MIF.DMTF|ComponentID|001.3"} ]
|
|
string Version ;
|
|
[read, key, Description (
|
|
" The SoftwareElementState is defined in this model to identify various "
|
|
"states of a software elements life cycle. - A software element in the "
|
|
"deployable state describes the details necessary to successful "
|
|
"distribute it and the details (conditions and actions) required to "
|
|
"create a software element in the installable state (i.e., the next "
|
|
"state). - A software element in the installable state describes "
|
|
"the details necessary to successfully install it and the details ("
|
|
"conditions and actions required to create a software element in the "
|
|
"executable state (i.e., the next state). - A software element in the "
|
|
"executable state describes the details necessary to successfully "
|
|
"start it and the details (conditions and actions required to create "
|
|
"a software element in the running state (i.e., the next state). - "
|
|
"A software element in the running state describes the details "
|
|
"necessary to monitor and operate on a start element.") , Values {
|
|
"Deployable", "Installable", "Executable", "Running"} ]
|
|
uint16 SoftwareElementState ;
|
|
[read, key, maxlen (256) , Description (
|
|
" This is an identifier for this software element and is designed to be "
|
|
"used in conjunction with other keys to create a unique representation "
|
|
"of this CIM_SoftwareElement") ]
|
|
string SoftwareElementID ;
|
|
[read, key, Mappingstrings {
|
|
"MIF.DMTF|Software Component Information|002.5"} , Description (
|
|
"The TargetOperatingSystem property allows the provider to specify "
|
|
"the operating system environment. The value of this property does not "
|
|
"ensure binary executable. Two other pieces of information are needed. "
|
|
" First, the version of the OS needs to be specified using the OS "
|
|
"version check. The second piece of information is the architecture the "
|
|
"OS runs on. The combination of these constructs allows the provider to "
|
|
"clearly identify the level of OS required for a particular software "
|
|
"element.") , Values {"Unknown", "Other", "MACOS", "ATTUNIX", "DGUX",
|
|
"DECNT", "Digital Unix", "OpenVMS", "HPUX", "AIX", "MVS", "OS400",
|
|
"OS/2", "JavaVM", "MSDOS", "WIN3x", "WIN95", "WIN98", "WINNT", "WINCE",
|
|
"NCR3000", "NetWare", "OSF", "DC/OS", "Reliant UNIX", "SCO UnixWare",
|
|
"SCO OpenServer", "Sequent", "IRIX", "Solaris", "SunOS", "U6000",
|
|
"ASERIES", "TandemNSK", "TandemNT", "BS2000", "LINUX", "Lynx", "XENIX",
|
|
"VM/ESA", "Interactive UNIX", "BSDUNIX", "FreeBSD", "NetBSD", "GNU Hurd"
|
|
, "OS9", "MACH Kernel", "Inferno", "QNX", "EPOC", "IxWorks", "VxWorks",
|
|
"MiNT", "BeOS", "HP MPE", "NextStep", "PalmPilot", "Rhapsody",
|
|
"Windows 2000", "Dedicated", "VSE", "TPF"},
|
|
ModelCorrespondence ("CIM_OperatingSystem.OSType") ]
|
|
uint16 TargetOperatingSystem ;
|
|
[read, Description (
|
|
" The OtherTargetOS property records the manufacturer and operating "
|
|
"system type for a software element when the TargetOperatingSystem "
|
|
"property has a value of 1 (\"Other\"). Therefore, when the "
|
|
"TargetOperatingSystem property has a value of \"Other\", the "
|
|
"OtherTargetOS property must have a non-null value. For all other "
|
|
"values of TargetOperatingSystem, the OtherTargetOS property is to be "
|
|
"NULL. ") , Maxlen (64) ,
|
|
ModelCorrespondence ("CIM_OperatingSystem.OtherTypeDescription") ]
|
|
string OtherTargetOS ;
|
|
[read, Maxlen (256) , Description (
|
|
"Manufacturer of this software element"), Mappingstrings {"MIF.DMTF|ComponentID|001.1"} ]
|
|
string Manufacturer ;
|
|
[read, Maxlen (64) , Mappingstrings {
|
|
"MIF.DMTF|Software Component Information|002.4"} , Description (
|
|
"The internal identifier for this compilation of this software element."
|
|
) ]
|
|
string BuildNumber ;
|
|
[read, Maxlen (64) , Description (
|
|
"The assigned serial number of this software element."), Mappingstrings {"MIF.DMTF|ComponentID|001.4"} ]
|
|
string SerialNumber ;
|
|
[read, Maxlen (64) , Description (
|
|
"The code set used by this software element. ") ]
|
|
string CodeSet ;
|
|
[read, Maxlen (64) , Mappingstrings {
|
|
"MIF.DMTF|Software Component Information|002.7"} , Description (
|
|
" The value of this property is the manufacturer's identifier for this "
|
|
"software element. Often this will be a stock keeping unit (SKU) or a "
|
|
"part number.") ]
|
|
string IdentificationCode ;
|
|
[read, Maxlen (32) , Mappingstrings {
|
|
"MIF.DMTF|Software Component Information|002.6"} , Description (
|
|
"The value of this property identifies the language edition of this "
|
|
"software element. The language codes defined in ISO 639 should be used. "
|
|
"Where the software element represents multi-lingual or international "
|
|
"version of a product, the string multilingual should be used.") ]
|
|
string LanguageEdition ;
|
|
};
|
|
|
|
[abstract, Description (
|
|
"CIM_BIOSElement represents the low-level software that is loaded into "
|
|
"non-volatile storage and used to bring up and configure a "
|
|
"computer system."),
|
|
Locale (0x409), UUID ("{8502C562-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_BIOSElement:CIM_SoftwareElement
|
|
{
|
|
[read, Override ("Version") , MappingStrings {
|
|
"MIF.DMTF|System BIOS|001.3"} ]
|
|
string Version ;
|
|
[read, Override ("Manufacturer") , MappingStrings {
|
|
"MIF.DMTF|System BIOS|001.2"} ]
|
|
string Manufacturer ;
|
|
[read, Description ("If true, this is the primary BIOS of the computer system."
|
|
) , MappingStrings {"MIF.DMTF|System BIOS|001.9"} ]
|
|
boolean PrimaryBIOS ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"CIM_Job is a logical element representing a unit of work for a system, "
|
|
"such as a print job. A job is distinct from a process in that a job can "
|
|
"be scheduled."),
|
|
Locale (0x409), UUID ("{8502C564-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Job:CIM_LogicalElement
|
|
{
|
|
[Description ("Length of time that the job has been executing.") , read]
|
|
datetime ElapsedTime ;
|
|
[Description ("User to be notified upon job completion or failure.") ,
|
|
read]
|
|
string Notify ;
|
|
[Description ("User that submitted the job.") , read]
|
|
string Owner ;
|
|
[Description (
|
|
"Priority indicates the urgency or importance of execution of a job.")
|
|
, read]
|
|
uint32 Priority ;
|
|
[Description ("Time that the job was begun.") , read]
|
|
datetime StartTime ;
|
|
[read, Description ("A free form string representing the job's status."
|
|
) ]
|
|
string JobStatus ;
|
|
[Description ("Time that the job was submitted.") , read]
|
|
datetime TimeSubmitted ;
|
|
[Description ("Time after which the job is invalid or should be stopped."
|
|
) , read]
|
|
datetime UntilTime ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"An operating system is software/firmware that makes a computer system's "
|
|
"hardware usable, and implements and/or manages the resources, file "
|
|
"systems, processes, user interfaces, services, ... available on the "
|
|
"computer system."),
|
|
Locale (0x409), UUID ("{8502C565-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_OperatingSystem:CIM_LogicalElement
|
|
{
|
|
[Propagated ("CIM_ComputerSystem.CreationClassName") , CIM_Key, read,
|
|
Description ("CSCreationClassName contains the scoping computer system's "
|
|
"creation class name."), MaxLen (256)]
|
|
string CSCreationClassName ;
|
|
[Propagated ("CIM_ComputerSystem.Name") , CIM_Key, read, Description (
|
|
"CSName contains the scoping computer system's name."), MaxLen (256)]
|
|
string CSName ;
|
|
[CIM_Key, read, MaxLen (256), Description (
|
|
"CreationClassName indicates the name of the class or the subclass used "
|
|
"in the creation of an instance. When used with the other key properties "
|
|
"of this class, this property allows all instances of this class and its "
|
|
"subclasses to be uniquely identified.")]
|
|
string CreationClassName ;
|
|
[Description (
|
|
"Boolean indicating whether the operating system is distributed across "
|
|
"several computer system nodes. If so, these nodes should be grouped as a "
|
|
"cluster.") , read]
|
|
boolean Distributed ;
|
|
[Description (
|
|
"Number of kilobytes of physical memory currently unused and available") ,
|
|
Units ("KiloBytes") , read]
|
|
uint64 FreePhysicalMemory ;
|
|
[Description (
|
|
"Number of kilobytes of virtual memory currently unused and "
|
|
"available. For example, this may be calculated by adding "
|
|
"the amount of free RAM to the amount of free paging space "
|
|
"(i.e., adding the properties, FreePhysicalMemory and FreeSpace"
|
|
"InPagingFiles).") ,
|
|
Units ("KiloBytes") , read]
|
|
uint64 FreeVirtualMemory ;
|
|
[read, Description (
|
|
"Maximum number of kilobytes of memory that can be allocated to a process. For "
|
|
"operating systems with no virtual memory, this value is typically equal to the total "
|
|
"amount of physical memory minus memory used by the BIOS and OS. For some operating "
|
|
"systems, this value may be infinity - in which case, 0 should be entered. In "
|
|
"other cases, this value could be a constant - for example, 2G or 4G."),
|
|
Units("KiloBytes") ]
|
|
uint64 MaxProcessMemorySize;
|
|
[read, Description (
|
|
"A integer indicating the type of operating system.") ,
|
|
Values {"Unknown", "Other", "MACOS", "ATTUNIX", "DGUX", "DECNT",
|
|
"Digital Unix", "OpenVMS", "HPUX", "AIX", "MVS", "OS400", "OS/2",
|
|
"JavaVM", "MSDOS", "WIN3x", "WIN95", "WIN98", "WINNT", "WINCE",
|
|
"NCR3000", "NetWare", "OSF", "DC/OS", "Reliant UNIX", "SCO UnixWare",
|
|
"SCO OpenServer", "Sequent", "IRIX", "Solaris", "SunOS", "U6000",
|
|
"ASERIES", "TandemNSK", "TandemNT", "BS2000", "LINUX", "Lynx", "XENIX",
|
|
"VM/ESA", "Interactive UNIX", "BSDUNIX", "FreeBSD", "NetBSD", "GNU Hurd"
|
|
, "OS9", "MACH Kernel", "Inferno", "QNX", "EPOC", "IxWorks", "VxWorks",
|
|
"MiNT", "BeOS", "HP MPE", "NextStep", "PalmPilot", "Rhapsody",
|
|
"Windows 2000", "Dedicated", "OS/390", "VSE", "TPF"} ,
|
|
ModelCorrespondence {"CIM_OperatingSystem.OtherTypeDescription"} ]
|
|
uint16 OSType ;
|
|
[read, Description (
|
|
"A string describing the manufacturer and operating system type - used "
|
|
"when the operating system property, OSType, is set to 1 (\"Other\"). The "
|
|
"format of the string inserted in OtherTypeDescription should be similar "
|
|
"in format to the Values strings defined for OSType. "
|
|
"OtherTypeDescription should be set to NULL when OSType is any value "
|
|
"other than 1.") , MaxLen (64) ,
|
|
ModelCorrespondence {"CIM_OperatingSystem.OSType"} ]
|
|
string OtherTypeDescription ;
|
|
[read, Description (
|
|
"A string describing the operating system's version number. The format "
|
|
"of the version information is as follows: <Major Number>.<Minor Number>."
|
|
"<Revision> or <Major Number>.<Minor Number>.<Revision Letter>.") ,
|
|
MappingStrings {"MIF.DMTF|Operating System|001.3"} ]
|
|
string Version ;
|
|
[read,
|
|
Description (
|
|
"Operating system's notion of the local date and time of day.") ,
|
|
MappingStrings {"MIB.IETF|HOST-RESOURCES-MIB.hrSystemDate",
|
|
"MIF.DMTF|General Information|001.6"} ]
|
|
datetime LocalDateTime ;
|
|
|
|
[read,
|
|
Write,
|
|
Description (
|
|
"CurrentTimeZone indicates the number of minutes the operating system is "
|
|
"offset from Greenwich Mean Time. Either the number is positive, "
|
|
"negative or zero.") , Units ("Minutes") ]
|
|
sint16 CurrentTimeZone ;
|
|
|
|
[read, Description (
|
|
"The total number of kilobytes that can be stored in the operating system's "
|
|
"paging files. Note that this number does not represent the actual physical "
|
|
"size of the paging file on disk. 0 indicates that there are no paging files.") ,
|
|
Units ("KiloBytes") , MappingStrings {"MIF.DMTF|System Memory Settings|001.3"}
|
|
]
|
|
uint64 SizeStoredInPagingFiles ;
|
|
|
|
[read, Description (
|
|
"The total number of KBytes that can be mapped into the "
|
|
"OperatingSystem's paging files without causing any other "
|
|
"pages to be swapped out. 0 indicates that there are no "
|
|
"paging files.") ,
|
|
Units ("KiloBytes") , MappingStrings {"MIF.DMTF|System Memory Settings|001.4"} ]
|
|
uint64 FreeSpaceInPagingFiles ;
|
|
[Description ("Time when the operating system was last booted") , read]
|
|
datetime LastBootUpTime ;
|
|
[Description (
|
|
"Maximum number of process contexts the operating system can support. If "
|
|
"there is no fixed maximum, the value should be 0. On systems that have "
|
|
"a fixed maximum, this object can help diagnose failures that occur when "
|
|
"the maximum is reached. If unknown, enter -1.") , MappingStrings {
|
|
"MIB.IETF|HOST-RESOURCES-MIB.hrSystemMaxProcesses"} , read]
|
|
uint32 MaxNumberOfProcesses ;
|
|
[Override ("Name") , Description (
|
|
"The inherited Name property serves as key of an operating system instance within "
|
|
"a computer system.") , Key, read]
|
|
string Name ;
|
|
[Description (
|
|
"Number of user licenses for the operating system. If unlimited, enter 0. "
|
|
"If unknown, enter -1.") , read]
|
|
uint32 NumberOfLicensedUsers ;
|
|
[Description (
|
|
"Number of process contexts currently loaded or running on the "
|
|
"operating system.") , MappingStrings {
|
|
"MIB.IETF|HOST-RESOURCES-MIB.hrSystemProcesses"} , Read
|
|
]
|
|
uint32 NumberOfProcesses ;
|
|
[Description (
|
|
"Number of user sessions for which the operating system is currently "
|
|
"storing state information") , MappingStrings {
|
|
"MIB.IETF|HOST-RESOURCES-MIB.hrSystemNumUsers"} , read]
|
|
uint32 NumberOfUsers ;
|
|
[Description ("Total swap space in kilobytes. This value may be "
|
|
"NULL (unspecified) if swap space is not distinguished from "
|
|
"page files. However, some operating systems distinguish "
|
|
"these concepts. For example, in UNIX, whole processes can be "
|
|
"'swapped out' when the free page list falls and remains "
|
|
"below a specified amount.") , Units ("KiloBytes") , read]
|
|
uint64 TotalSwapSpaceSize ;
|
|
[Description ("Number of kilobytes of virtual memory. For example, "
|
|
"this may be calculated by adding the amount of total RAM to "
|
|
"the amount of paging space (i.e., adding the amount of "
|
|
"memory in/aggregated by the computer system to the property, "
|
|
"SizeStoredInPagingFiles.") , Units (
|
|
"KiloBytes") , read]
|
|
uint64 TotalVirtualMemorySize ;
|
|
[read, Description (
|
|
"The total amount of physical memory (in Kbytes) available "
|
|
"to the OperatingSystem. This value does not necessarily "
|
|
"indicate the true amount of physical memory, but what is "
|
|
"reported to the OperatingSystem as available to it." ),
|
|
Units("KiloBytes") ]
|
|
uint64 TotalVisibleMemorySize;
|
|
[Description (
|
|
"Requests a reboot of the operating system. The return value should be 0 "
|
|
"if the request was successfully executed, 1 if the request is not "
|
|
"supported and some other value if an error occurred. "
|
|
" The strings to which the ValueMap contents are 'translated' "
|
|
"may also be specified in the subclass as a Values array qualifier.") ]
|
|
uint32 Reboot() ;
|
|
[Description (
|
|
"Requests a shutdown of the operating system. The return value should be "
|
|
"0 if the request was successfully executed, 1 if the request is not "
|
|
"supported and some other value if an error occurred. It is up to the "
|
|
"implementation or subclass of operating system to establish dependencies "
|
|
"between the Shutdown and Reboot methods, and for example, to provide "
|
|
"more sophisticated capabilities such as scheduled shutdown/reboot, etc."
|
|
) ]
|
|
uint32 Shutdown() ;
|
|
};
|
|
|
|
[DisplayName("Processes (CIM)"),
|
|
Abstract, Description (
|
|
"Each instance of the CIM_Process class represents a single "
|
|
"instance of a running program. A user of the OperatingSystem "
|
|
"will typically see a Process as an application or task. Within "
|
|
"an OperatingSystem, a Process is defined by a workspace of "
|
|
"memory resources and environmental settings that are allocated "
|
|
"to it. On a multitasking System, this workspace prevents "
|
|
"intrusion of resources by other Processes. Additionally, a "
|
|
"Process can execute as multiple Threads, all which run within "
|
|
"the same workspace."),
|
|
Locale (0x409), UUID ("{8502C566-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Process : CIM_LogicalElement
|
|
{
|
|
[DisplayName("Computer System Class Name"),
|
|
Propagated ("CIM_OperatingSystem.CSCreationClassName"), CIM_Key, Read,
|
|
Description ("CSCreationClassName contains the scoping computer system's "
|
|
"creation class name."), MaxLen (256)]
|
|
string CSCreationClassName ;
|
|
[DisplayName("Computer System Name"),
|
|
Propagated ("CIM_OperatingSystem.CSName") , CIM_Key, read, Description (
|
|
"The scoping computer system's name.") , MaxLen (256)]
|
|
string CSName ;
|
|
[DisplayName("Class Name"),
|
|
CIM_Key, Read, Description (
|
|
"CreationClassName indicates the name of the class or the subclass used "
|
|
"in the creation of an instance. When used with the other key properties "
|
|
"of this class, this property allows all instances of this class and its "
|
|
"subclasses to be uniquely identified."), MaxLen (256)]
|
|
string CreationClassName ;
|
|
[Fixed, DisplayName("CreationDate"),
|
|
Description ("Time that the process began executing.") , read]
|
|
datetime CreationDate ;
|
|
[DisplayName("Handle"),
|
|
Key, Read, MaxLen (256), Description ("A string used to identify the process. A "
|
|
"process ID is a kind of process handle.")]
|
|
string Handle ;
|
|
[DisplayName("Kernel Model Time"),
|
|
Description (
|
|
"Time in kernel mode, in milliseconds. If this information is not "
|
|
"available, a value of 0 should be used.") , Units ("Milliseconds") ,
|
|
read]
|
|
uint64 KernelModeTime ;
|
|
[DisplayName("Operating System Class Name"),
|
|
Propagated ("CIM_OperatingSystem.CreationClassName") , CIM_Key, read,
|
|
MaxLen (256), Description (
|
|
"The scoping operating system's creation class name.")]
|
|
string OSCreationClassName ;
|
|
[DisplayName("Operating System Name"),
|
|
Propagated ("CIM_OperatingSystem.Name") , CIM_Key, read, Description (
|
|
"The scoping operating system's name.") , MaxLen (256)]
|
|
string OSName ;
|
|
[DisplayName("Priority"),
|
|
Description (
|
|
"Priority indicates the urgency or importance of execution of a process. "
|
|
"If a priority is not defined for a process, a value of 0 should be used."
|
|
) , read]
|
|
uint32 Priority ;
|
|
[DisplayName("Execution State"),
|
|
read, Description (
|
|
"Indicates the current operating condition of the process. Values include "
|
|
"ready (2), running (3), and blocked (4), among others.") ,
|
|
Values {"Unknown", "Other", "Ready", "Running", "Blocked", "Suspended Blocked",
|
|
"Suspended Ready", "Terminated", "Stopped", "Growing"} ]
|
|
uint16 ExecutionState ;
|
|
[DisplayName("Termination Date"),
|
|
Description ("Time that the process was stopped or terminated.") , Read
|
|
]
|
|
datetime TerminationDate ;
|
|
[DisplayName("User Mode Time"),
|
|
Description (
|
|
"Time in user mode, in milliseconds. If this information is not "
|
|
"available, a value of 0 should be used.") , Units ("Milliseconds") ,
|
|
read]
|
|
uint64 UserModeTime ;
|
|
[DisplayName("Working Set Size"),
|
|
read, Description (
|
|
"The amount of memory in bytes that a process needs to execute "
|
|
"efficiently, for an operating system that uses page-based memory "
|
|
"management. If an insufficient amount of memory is available (< working "
|
|
"set size), thrashing will occur. If this information is not known, NULL "
|
|
"or 0 should be entered. If this data is provided, it could be "
|
|
"monitored to understand a process' changing memory requirements as "
|
|
"execution proceeds.") , Units ("Bytes") ]
|
|
uint64 WorkingSetSize ;
|
|
};
|
|
|
|
|
|
[Abstract, Description (
|
|
"Threads represent the ability to execute units of a process or task in "
|
|
"parallel. A process can have many threads, each of which is weak to "
|
|
"the process."),
|
|
Locale (0x409), UUID ("{8502C571-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Thread:CIM_LogicalElement
|
|
{
|
|
[read, Propagated ("CIM_Process.CSCreationClassName") , Cim_Key, Description (
|
|
"The scoping computer system's creation class name.") , MaxLen (256) ]
|
|
string CSCreationClassName ;
|
|
[read, Propagated ("CIM_Process.CSName") , Cim_Key, Description (
|
|
"The scoping computer system's name.") , MaxLen (256) ]
|
|
string CSName ;
|
|
[read, Propagated ("CIM_Process.OSCreationClassName") , Cim_Key, Description (
|
|
"The scoping operating system's creation class name.") , MaxLen (256) ]
|
|
string OSCreationClassName ;
|
|
[read, Propagated ("CIM_Process.OSName") , Cim_Key, Description (
|
|
"The scoping operating system's name.") , MaxLen (256) ]
|
|
string OSName ;
|
|
[read, Propagated ("CIM_Process.CreationClassName") , Cim_Key, Description (
|
|
"The scoping process' CreationClassName.") , MaxLen (256) ]
|
|
string ProcessCreationClassName ;
|
|
[read, Propagated ("CIM_Process.Handle") , Key, Description (
|
|
"The scoping process' Handle.") , MaxLen (256) ]
|
|
string ProcessHandle ;
|
|
[read, Cim_Key, Description (
|
|
"CreationClassName indicates the name of the class or the subclass used "
|
|
"in the creation of an instance. When used with the other key properties "
|
|
"of this class, this property allow all instances of this class and its "
|
|
"subclasses to be uniquely identified.") , MaxLen (256) ]
|
|
string CreationClassName ;
|
|
[read, Key, Description ("A string used to identify the thread.") , MaxLen (
|
|
256) ]
|
|
string Handle ;
|
|
[read, Description (
|
|
"Priority indicates the urgency or importance of execution of a thread. "
|
|
"A thread may have a different priority than its owning process. If this "
|
|
"information is not available for a thread, a value of 0 should be used."
|
|
) ]
|
|
uint32 Priority ;
|
|
[read, Description (
|
|
"Indicates the current operating condition of the thread. Values include "
|
|
"ready (2), running (3), and blocked (4), among others.") ,
|
|
Values {"Unknown", "Other", "Ready", "Running", "Blocked", "Suspended Blocked",
|
|
"Suspended Ready"} ]
|
|
uint16 ExecutionState ;
|
|
[read, Description (
|
|
"Time in user mode, in milliseconds. If this information is not "
|
|
"available, a value of 0 should be used.") , Units ("MilliSeconds") ]
|
|
uint64 UserModeTime ;
|
|
[read, Description (
|
|
"Time in kernel mode, in milliseconds. If this information is not "
|
|
"available, a value of 0 should be used.") , Units ("MilliSeconds") ]
|
|
uint64 KernelModeTime ;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The Setting class represents configuration-related and "
|
|
"operational parameters for one or more ManagedSystem"
|
|
"Element(s). A ManagedSystemElement may have multiple Setting "
|
|
"objects associated with it. The current operational values "
|
|
"for an Element's parameters are reflected by properties in "
|
|
"the Element itself or by properties in its associations. "
|
|
"These properties do not have to be the same values present "
|
|
"in the Setting object. For example, a modem may have a "
|
|
"Setting baud rate of 56Kb/sec but be operating "
|
|
"at 19.2Kb/sec.") ,
|
|
Locale (0x409), UUID ("{8502C572-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Setting
|
|
{
|
|
[read, MaxLen (256) , Description (
|
|
"The identifier by which the CIM_Setting object is known.") ]
|
|
string SettingID ;
|
|
[read, MaxLen (64) , Description (
|
|
"A short textual description (one-line string) of the CIM_Setting object.")
|
|
]
|
|
string Caption ;
|
|
[read, Description ("A textual description of the CIM_Setting object.") ]
|
|
string Description ;
|
|
};
|
|
|
|
[Dynamic, Provider ("CIMWin32"), Description (
|
|
"CIM_VideoControllerResolution describes the various video modes "
|
|
"that a video controller can support. Video modes are defined by "
|
|
"the possible horizontal and vertical resolutions, refresh rate, "
|
|
"scan mode and number of colors settings supported by a controller. "
|
|
"The actual resolutions, etc. that are in use, are the values "
|
|
"specified in the CIM_VideoController object."),
|
|
Locale (0x409), UUID ("{1008CCEA-7BFF-11D2-AAD2-006008C78BC7}") ]
|
|
class CIM_VideoControllerResolution : CIM_Setting
|
|
{
|
|
[Read, Override ("SettingID"),
|
|
Key, MaxLen (256), Description (
|
|
"The inherited SettingID serves as part of the key for a "
|
|
"CIM_VideoControllerResolution instance.") ]
|
|
string SettingID;
|
|
[Read, Description (
|
|
"Controller's horizontal resolution in Pixels."),
|
|
Units ("Pixels"),
|
|
ModelCorrespondence {"CIM_VideoController.CurrentHorizontalResolution"},
|
|
MappingStrings {"MIF.DMTF|Monitor Resolutions|002.2"} ]
|
|
uint32 HorizontalResolution;
|
|
[Read, Description (
|
|
"Controller's vertical resolution in Pixels."),
|
|
Units ("Pixels"),
|
|
ModelCorrespondence {"CIM_VideoController.CurrentVerticalResolution"},
|
|
MappingStrings {"MIF.DMTF|Monitor Resolutions|002.3"} ]
|
|
uint32 VerticalResolution;
|
|
[Read, Description (
|
|
"Refresh rate in Hertz. If a range of rates is supported, "
|
|
"use the MinRefreshRate and MaxRefreshRate properties, and "
|
|
"set RefreshRate (this property) to 0."),
|
|
Units ("Hertz"),
|
|
ModelCorrespondence {"CIM_VideoController.CurrentRefreshRate"},
|
|
MappingStrings {"MIF.DMTF|Monitor Resolutions|002.4"} ]
|
|
uint32 RefreshRate;
|
|
[Read, Description (
|
|
"Minimum refresh rate in Hertz, when a range of "
|
|
"rates is supported at the specified resolutions."),
|
|
Units ("Hertz"),
|
|
ModelCorrespondence {"CIM_VideoController.MinRefreshRate"},
|
|
MappingStrings {"MIF.DMTF|Monitor Resolutions|002.6"} ]
|
|
uint32 MinRefreshRate;
|
|
[Read, Description (
|
|
"Maximum refresh rate in Hertz, when a range of "
|
|
"rates is supported at the specified resolutions."),
|
|
Units ("Hertz"),
|
|
ModelCorrespondence {"CIM_VideoController.MaxRefreshRate"},
|
|
MappingStrings {"MIF.DMTF|Monitor Resolutions|002.7"} ]
|
|
uint32 MaxRefreshRate;
|
|
[Read, Description (
|
|
"Integer indicating whether the controller operates in "
|
|
"interlaced (value=5) or non-interlaced (4) mode."),
|
|
ValueMap {"1", "2", "3", "4", "5"},
|
|
Values {"Other", "Unknown", "Not Supported",
|
|
"Non-Interlaced Operation", "Interlaced Operation"},
|
|
ModelCorrespondence {"CIM_VideoController.CurrentScanMode"},
|
|
MappingStrings {"MIF.DMTF|Monitor Resolutions|002.5"} ]
|
|
uint16 ScanMode;
|
|
[Read, Description ("Number of colors supported at the current "
|
|
"resolutions."),
|
|
ModelCorrespondence {"CIM_VideoController.CurrentNumberOfColors"} ]
|
|
uint64 NumberOfColors;
|
|
};
|
|
|
|
[Association, Abstract, Aggregation ,
|
|
Description (
|
|
"CIM_Component is a generic association used to establish "
|
|
"'part of' relationships between Managed System Elements. For "
|
|
"example, the SystemComponent association defines parts of "
|
|
"a System."),
|
|
Locale (0x409), UUID ("{8502C573-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_Component
|
|
{
|
|
[Read , Aggregate , Description ("The parent element in the association.") ]
|
|
CIM_ManagedSystemElement REF GroupComponent;
|
|
[Description (
|
|
"The child element in the association.") , read]
|
|
CIM_ManagedSystemElement REF PartComponent;
|
|
};
|
|
|
|
//RuleBased("Select * From "
|
|
// "Win32_Directory As A "
|
|
// "Join "
|
|
// "CIM_DataFile As B "
|
|
// "On A.Name = B.Path")
|
|
[Dynamic, Provider ("CIMWin32") ,
|
|
Description (
|
|
"The CIM_DirectoryContainsFile class represents an association "
|
|
"between a directory and files contained within that directory."),
|
|
Locale (0x409), UUID("{6F9D4740-8324-11d2-AAD9-006008C78BC7}") ]
|
|
class CIM_DirectoryContainsFile:CIM_Component
|
|
{
|
|
[read, Key, Override ("GroupComponent") , Description ("The directory."),
|
|
Max (1) ]
|
|
CIM_Directory REF GroupComponent;
|
|
[read, Key, Override ("PartComponent") , Description (
|
|
"The LogicalFile 'contained within' the Directory.") ]
|
|
CIM_DataFile REF PartComponent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"CIM_SystemComponent is a specialization of the CIM_Component "
|
|
"association that establishes 'part of' relationships between "
|
|
"a System and the Managed System Elements of which it is "
|
|
"composed."),
|
|
Locale (0x409), UUID ("{527BC6CE-BAFE-11d2-85E5-0000F8102E5F}") ]
|
|
class CIM_SystemComponent:CIM_Component
|
|
{
|
|
[Override ("GroupComponent") , Description (
|
|
"The parent system in the association.") , read]
|
|
CIM_System REF GroupComponent;
|
|
[Override ("PartComponent") , Description (
|
|
"The child element that is a component of a system.") , read]
|
|
CIM_ManagedSystemElement REF PartComponent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Logical devices may be aggregated by a system. This "
|
|
"relationship is made explicit by the CIM_SystemDevice "
|
|
"association. ") , Locale (0x409), UUID ("{4B2C30D7-BAFE-11d2-85E5-0000F8102E5F}") ]
|
|
class CIM_SystemDevice:CIM_SystemComponent
|
|
{
|
|
[read, Override ("GroupComponent") , Max (1) , Min (1) , Description (
|
|
"The parent system in the association.") ]
|
|
CIM_System REF GroupComponent;
|
|
[read, Override ("PartComponent") , Weak , Description (
|
|
"The logical device that is a component of a system.") ]
|
|
CIM_LogicalDevice REF PartComponent;
|
|
};
|
|
|
|
|
|
[Abstract, Description (
|
|
"A link between the computer system and the operating system(s) installed "
|
|
"or loaded on it. An operating system is 'installed' on a computer system, "
|
|
"when placed on one of its storage extents - for example, copied to a "
|
|
"disk drive or downloaded to memory. Using this definition, an "
|
|
"operating system is 'installed' on a NetPC when downloaded via the "
|
|
"network."),
|
|
Locale (0x409), UUID ("{8502C575-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_InstalledOS:CIM_SystemComponent
|
|
{
|
|
[read, Override ("GroupComponent") , Description ("The computer system."
|
|
) , Min (1) , Max (1) ]
|
|
CIM_ComputerSystem REF GroupComponent;
|
|
[read, Override ("PartComponent") , Description (
|
|
"The operating system installed on the computer system.") , Weak]
|
|
CIM_OperatingSystem REF PartComponent;
|
|
[read, Description (
|
|
"Boolean indicating that the operating system is the default OS for the "
|
|
"computer system.") , MappingStrings {"MIF.DMTF|Operating System|001.4"}
|
|
]
|
|
boolean PrimaryOS ;
|
|
};
|
|
|
|
[Abstract, Association, Description (
|
|
"ElementSetting represents the association between Managed"
|
|
"SystemElements and the Setting class(es) defined for them."),
|
|
Locale (0x409), UUID ("{8502C577-5FBB-11D2-AAC1-006008C78BC7}")]
|
|
class CIM_ElementSetting
|
|
{
|
|
[read, Description (
|
|
"The Element reference represents the role of the CIM_ManagedSystemElement "
|
|
"object of the CIM_ElementSetting association. Role: The associated managed "
|
|
"system element provides the element that implements the element setting."
|
|
) ]
|
|
CIM_ManagedSystemElement REF Element;
|
|
[read, Description (
|
|
"The CIM_Setting reference represents the role of the CIM_Setting object of the "
|
|
"CIM_ElementSetting association. Role: The associated setting provides the "
|
|
"setting that implements the element setting.") ]
|
|
CIM_Setting REF Setting;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_VideoSetting class associates the CIM_VideoControllerResolution setting "
|
|
"object with the controller to which it applies."),
|
|
Locale (0x409), UUID ("{1008CCEB-7BFF-11D2-AAD2-006008C78BC7}") ]
|
|
class CIM_VideoSetting : CIM_ElementSetting
|
|
{
|
|
[Read, Override ("Element"), Description (
|
|
"The video controller.") ]
|
|
CIM_VideoController REF Element;
|
|
[Read, Override ("Setting"), Description (
|
|
"The resolutions, refresh rates, scan mode and number of "
|
|
"colors that can be set for the Controller.") ]
|
|
CIM_VideoControllerResolution REF Setting;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"CIM_MonitorResolution describes the relationship between "
|
|
"horizontal and vertical resolutions, refresh rate and scan "
|
|
"mode for a desktop monitor. The actual resolutions, etc. that "
|
|
"are in use, are the values specified in the video controller "
|
|
"object."),
|
|
Locale (0x409), UUID ("{1008CCEC-7BFF-11D2-AAD2-006008C78BC7}") ]
|
|
class CIM_MonitorResolution : CIM_Setting
|
|
{
|
|
[Read, Override ("SettingID"),
|
|
Key, MaxLen (256), Description (
|
|
"The inherited SettingID serves as part of the key for a "
|
|
"CIM_MonitorResolution instance.") ]
|
|
string SettingID;
|
|
[Read, Description (
|
|
"Monitor's horizontal resolution in Pixels."),
|
|
Units ("Pixels"),
|
|
ModelCorrespondence {"CIM_VideoController.CurrentHorizontalResolution"},
|
|
MappingStrings {"MIF.DMTF|Monitor Resolutions|002.2"} ]
|
|
uint32 HorizontalResolution;
|
|
[Read, Description (
|
|
"Monitor's vertical resolution in Pixels."),
|
|
Units ("Pixels"),
|
|
ModelCorrespondence {"CIM_VideoController.CurrentVerticalResolution"},
|
|
MappingStrings {"MIF.DMTF|Monitor Resolutions|002.3"} ]
|
|
uint32 VerticalResolution;
|
|
[Read, Description (
|
|
"Monitor's refresh rate in Hertz. If a range of rates is "
|
|
"supported, use the MinRefreshRate and MaxRefreshRate "
|
|
"properties, and set RefreshRate (this property) to "
|
|
"0."),
|
|
Units ("Hertz"),
|
|
ModelCorrespondence {"CIM_VideoController.CurrentRefreshRate"},
|
|
MappingStrings {"MIF.DMTF|Monitor Resolutions|002.4"} ]
|
|
uint32 RefreshRate;
|
|
[Read, Description (
|
|
"Monitor's minimum refresh rate in Hertz, when a range of "
|
|
"rates is supported at the specified resolutions."),
|
|
Units ("Hertz"),
|
|
ModelCorrespondence {"CIM_VideoController.MinRefreshRate"},
|
|
MappingStrings {"MIF.DMTF|Monitor Resolutions|002.6"} ]
|
|
uint32 MinRefreshRate;
|
|
[Read, Description (
|
|
"Monitor's maximum refresh rate in Hertz, when a range of "
|
|
"rates is supported at the specified resolutions."),
|
|
Units ("Hertz"),
|
|
ModelCorrespondence {"CIM_VideoController.MaxRefreshRate"},
|
|
MappingStrings {"MIF.DMTF|Monitor Resolutions|002.7"} ]
|
|
uint32 MaxRefreshRate;
|
|
[Read, Description (
|
|
"Integer indicating whether the monitor operates in "
|
|
"interlaced (value=5) or non-interlaced (4) mode."),
|
|
ValueMap {"1", "2", "3", "4", "5"},
|
|
Values {"Other", "Unknown", "Not Supported",
|
|
"Non-Interlaced Operation", "Interlaced Operation"},
|
|
ModelCorrespondence {"CIM_VideoController.CurrentScanMode"},
|
|
MappingStrings {"MIF.DMTF|Monitor Resolutions|002.5"} ]
|
|
uint16 ScanMode;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"CIM_MonitorSetting associates the monitor resolution "
|
|
"with the desktop monitor to which it applies."),
|
|
Locale (0x409), UUID ("{1008CCED-7BFF-11D2-AAD2-006008C78BC7}") ]
|
|
class CIM_MonitorSetting : CIM_ElementSetting
|
|
{
|
|
[Read, Key, Override ("Element"), Description (
|
|
"The desktop monitor.") ]
|
|
CIM_DesktopMonitor REF Element;
|
|
[Read, Key, Override ("Setting"), Description (
|
|
"The monitor resolution associated with the "
|
|
"desktop monitor.") ]
|
|
CIM_MonitorResolution REF Setting;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"A logical device may use or require one or more batteries. This "
|
|
"relationship is described by the CIM_AssociatedBattery dependency. It is "
|
|
"also possible to model the individual batteries that comprise a UPS, "
|
|
"using this association."),
|
|
Locale (0x409), UUID ("{8502C578-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_AssociatedBattery:CIM_Dependency
|
|
{
|
|
[read, Override ("Antecedent") , Description (
|
|
"The battery.") ]
|
|
CIM_Battery REF Antecedent;
|
|
[read, Override ("Dependent") , Description (
|
|
"The logical device needing or associated with the battery") ]
|
|
CIM_LogicalDevice REF Dependent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"An association between logical devices and system resources, indicating "
|
|
"that the resource is assigned to the device."),
|
|
Locale (0x409), UUID ("{8502C579-5FBB-11D2-AAC1-006008C78BC7}") ]
|
|
class CIM_AllocatedResource:CIM_Dependency
|
|
{
|
|
[read, Override ("Antecedent") , Description ("The resource.") ]
|
|
CIM_SystemResource REF Antecedent;
|
|
[read, Override ("Dependent") , Description (
|
|
"The logical device to which the resource is assigned.") ]
|
|
CIM_LogicalDevice REF Dependent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"CIM_StatisticalInformation is a root class for any arbitrary "
|
|
"collection of statistical data and/or metrics applicable to "
|
|
"one or more managed system elements.") ,
|
|
Locale (0x409), UUID ("{956597A1-7D80-11D2-AAD3-006008C78BC7}") ]
|
|
class CIM_StatisticalInformation
|
|
{
|
|
[read, MaxLen (256) , Description (
|
|
"The Name property defines the label by which the statistic "
|
|
"or metric is known. When subclassed, the property can be "
|
|
"overridden to be a Key property. ") ]
|
|
string Name;
|
|
[read, Description (
|
|
"A textual description of the statistic or metric.") ]
|
|
string Description;
|
|
[read, MaxLen (64) , Description (
|
|
"A short textual description (one-line string) for the "
|
|
"statistic or metric.") ]
|
|
string Caption;
|
|
};
|
|
|
|
[Abstract,Association, Description (
|
|
"CIM_Statistics is an association that relates "
|
|
"managed system elements to the statistical group(s) that "
|
|
"apply to them."),
|
|
Locale (0x409), UUID ("{956597A3-7D80-11D2-AAD3-006008C78BC7}") ]
|
|
class CIM_Statistics
|
|
{
|
|
[read, Description ("The statistical information/object.") ]
|
|
CIM_StatisticalInformation REF Stats;
|
|
[read, Description (
|
|
"The CIM_ManagedSystemElement for which statistical or metric "
|
|
"data is defined.") ]
|
|
CIM_ManagedSystemElement REF Element;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"CIM_DeviceErrorCounts is a statistical class containing "
|
|
"error-related counters for a logical device. The types of errors "
|
|
"are as defined by CCITT (Rec X.733) and ISO (IEC 10164-4)."),
|
|
Locale (0x409), UUID ("{117FDB8C-D025-11d2-85F5-0000F8102E5F}")
|
|
]
|
|
class CIM_DeviceErrorCounts:CIM_StatisticalInformation
|
|
{
|
|
[Read, Propagated ("CIM_LogicalDevice.SystemCreationClassName"), CIM_Key, Description (
|
|
"The scoping system's creation class name. "),
|
|
MaxLen(256) ]
|
|
string SystemCreationClassName;
|
|
|
|
[Read, Propagated ("CIM_LogicalDevice.SystemName"), CIM_Key, Description (
|
|
"The scoping system's name. "), MaxLen (256)]
|
|
string SystemName;
|
|
|
|
[Read, Propagated ("CIM_LogicalDevice.CreationClassName"), Key, Description (
|
|
"The scoping device's creation class name. "),
|
|
MaxLen(256) ]
|
|
string DeviceCreationClassName;
|
|
|
|
[Read, Propagated ("CIM_LogicalDevice.DeviceID"), Key, Description (
|
|
"The scoping device's ID. "), MaxLen (64) ]
|
|
string DeviceID;
|
|
|
|
[Read, Override ("Name"), Key, Description (
|
|
"The inherited Name property serves as part of the key "
|
|
"for the CIM_DeviceErrorCounts instance. The object is scoped by "
|
|
"the logical device to which the statistics apply. "),
|
|
MaxLen (256) ]
|
|
string Name;
|
|
|
|
[Read, Description ("Count of the indeterminate errors. ") ]
|
|
uint64 IndeterminateErrorCount;
|
|
|
|
[Read, Description ("Count of the critical errors. ") ,
|
|
MappingStrings {"MIF.DMTF|Operational State|003.7"} ]
|
|
uint64 CriticalErrorCount;
|
|
|
|
[Read, Description ("Count of the major errors. ") ,
|
|
MappingStrings {"MIF.DMTF|Operational State|003.8"} ]
|
|
uint64 MajorErrorCount;
|
|
|
|
[Read, Description ("Count of the minor errors. ") ]
|
|
uint64 MinorErrorCount;
|
|
|
|
[Read, Description ("Count of the warnings. ") ,
|
|
MappingStrings {"MIF.DMTF|Operational State|003.9"} ]
|
|
uint64 WarningCount;
|
|
|
|
[Description ("Method to reset the error and warning counters. The method "
|
|
"takes one parameter as input an integer indicating which counter to "
|
|
"reset. For this input parameter, 0 indicates all, 1 indicates "
|
|
"a reset of the indeterminate error counter, 2 the critical error counter, "
|
|
"3 the major error counter, 4 the minor error counter and 5 the warning "
|
|
"counter. The method returns 0 if successful, 1 if not supported, and any "
|
|
"other value if an error occurred. A method is specified so that the "
|
|
"logical device's instrumentation, which tabulates the errors and "
|
|
"warnings, can also reset its internal processing and counters.\n"
|
|
"In a subclass, the set of possible return codes could be "
|
|
"specified, using a ValueMap qualifier on the method. The "
|
|
"strings to which the ValueMap contents are 'translated' "
|
|
"may also be specified in the subclass as a Values "
|
|
"array qualifier.") ]
|
|
uint32 ResetCounter ([IN, Values {"All",
|
|
"Indeterminate Error Counter", "Critical Error Counter",
|
|
"Major Error Counter", "Minor Error Counter",
|
|
"Warning Counter"}] uint16 SelectedCounter);
|
|
};
|
|
|
|
|
|
[Abstract, Description ("CIM_ErrorCountersForDevice relates the CIM_Device"
|
|
"ErrorCounts class to the logical device to which it applies. ") ,
|
|
Locale (0x409), UUID ("{2D79F3A0-D025-11d2-85F5-0000F8102E5F}")
|
|
]
|
|
class CIM_ErrorCountersForDevice:CIM_Statistics
|
|
{
|
|
[Read, Override ("Stats") , Description (
|
|
"The statistical object - in this "
|
|
"case, the error counter class. ") , Weak
|
|
]
|
|
CIM_DeviceErrorCounts REF Stats;
|
|
|
|
[Read, Override ("Element") , Description (
|
|
"The device to which the error "
|
|
"counters apply. ") , Min(1), Max(1)
|
|
]
|
|
CIM_LogicalDevice REF Element;
|
|
};
|
|
|
|
[Abstract,Association, Description(
|
|
"CIM_RelatedStatistics is an association that defines "
|
|
"hierarchies and/or dependencies of related CIM_Statistical"
|
|
"Information classes."),
|
|
Locale (0x409), UUID ("{956597A4-7D80-11D2-AAD3-006008C78BC7}") ]
|
|
class CIM_RelatedStatistics
|
|
{
|
|
[read, Description ("The statistic information/object.") ]
|
|
CIM_StatisticalInformation REF Stats;
|
|
[read, Description ("The related statistics or metrics.") ]
|
|
CIM_StatisticalInformation REF RelatedStats;
|
|
};
|
|
|
|
|
|
|
|
[Abstract, Description (
|
|
"Subclasses of CIM_PhysicalElement define any component of a "
|
|
"system that has a distinct physical identity. Instances of "
|
|
"this class can be defined in terms of labels that can be "
|
|
"physically attached to the object. All processes, files, "
|
|
"and logical devices are considered not to be physical "
|
|
"elements. For example, it is not possible to attach a "
|
|
"label to a modem. It is only possible to attach a label to "
|
|
"the card that implements the modem. The same card could "
|
|
"also implement a LAN adapter. These are tangible managed "
|
|
"system elements (usually actual hardware items) that have a "
|
|
"physical manifestation of some sort. A managed system "
|
|
"element is not necessarily a discrete component. For "
|
|
"example, it is possible for a single card (which is a type "
|
|
"of physical element) to host more than one logical device. "
|
|
"The card would be represented by a single physical element "
|
|
"associated with multiple logical devices."),
|
|
Locale (0x409), UUID ("{FAF76B61-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PhysicalElement:CIM_ManagedSystemElement
|
|
{
|
|
[CIM_Key, read, MaxLen (256) , Description (
|
|
"CreationClassName indicates the name of the class or the "
|
|
"subclass used in the creation of an instance. When used "
|
|
"with the other key properties of this class, this property "
|
|
"allows all instances of this class and its subclasses to "
|
|
"be uniquely identified.") ]
|
|
string CreationClassName;
|
|
[read, MaxLen (256) , Description (
|
|
"The name of the organization responsible for producing the "
|
|
"physical element. "
|
|
"This may be the entity from whom the element is purchased, "
|
|
"but this is not necessarily true. The latter information "
|
|
"is contained in the Vendor property of CIM_Product.") ]
|
|
string Manufacturer;
|
|
[read, MaxLen (64) , Description (
|
|
"The name by which the physical element is generally known.") ]
|
|
string Model;
|
|
[read,MaxLen (64) , Description (
|
|
"The stock keeping unit number for this physical element.") ]
|
|
string SKU;
|
|
[read, MaxLen (64) , Description (
|
|
"A manufacturer-allocated number used to identify the PhysicalElement.")
|
|
]
|
|
string SerialNumber;
|
|
[CIM_Key, read, MaxLen (256) , Description (
|
|
"An arbitrary string that uniquely identifies the physical"
|
|
"element and serves as the element's key. The Tag property "
|
|
"can contain information such as asset tag or serial number "
|
|
"data. The key for CIM_PhysicalElement is placed very high in the "
|
|
"object hierarchy in order to independently identify the "
|
|
"hardware/entity, regardless of physical placement in or on "
|
|
"cabinets, adapters, etc. For example, a removable component "
|
|
"that can be hot swapped, may be taken from its containing "
|
|
"(scoping) package and be temporarily unused. The object "
|
|
"still continues to exist - and may even be inserted into a "
|
|
"different scoping container. Therefore, the key for physical"
|
|
"element is an arbitrary string and is defined independently "
|
|
"of any placement or location-oriented hierarchy.") ]
|
|
string Tag;
|
|
[read, MaxLen (64) , Description (
|
|
"A string indicating the version of the physical element.") ]
|
|
string Version;
|
|
[read, MaxLen (256) , Description (
|
|
"The part number assigned by the organization responsible for "
|
|
"producing or manufacturing the physical element.") ]
|
|
string PartNumber;
|
|
[Description (
|
|
"OtherIdentifyingInfo captures additional data, beyond asset "
|
|
"tag information, that could be used to identify a physical "
|
|
"element. One example is bar code data associated with an "
|
|
"element that also has an asset tag. Note that if only bar "
|
|
"code data is available and is unique/able to be used as an "
|
|
"element key, this property would be NULL and the bar code "
|
|
"data used as the class key, in the tag property."), read ]
|
|
string OtherIdentifyingInfo;
|
|
[Description (
|
|
"Boolean indicating that the physical element is powered on "
|
|
"(TRUE), or is currently off (FALSE)."), read ]
|
|
boolean PoweredOn;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"CIM_Realizes is the association that defines the mapping "
|
|
"between a logical device and the physical component that "
|
|
"implements the device."),
|
|
Locale (0x409), UUID ("{FAF76B62-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_Realizes:CIM_Dependency
|
|
{
|
|
[Override ("Antecedent") , Description (
|
|
"The physical component that implements the device."), read ]
|
|
CIM_PhysicalElement REF Antecedent;
|
|
[Override ("Dependent") , Description ("The logical device."), read ]
|
|
CIM_LogicalDevice REF Dependent;
|
|
};
|
|
|
|
[abstract, Description (
|
|
"CIM_Product is a concrete class that is a collection of "
|
|
"physical elements, software features and/or other products, "
|
|
"acquired as a unit. Acquisition implies an agreement "
|
|
"between supplier and consumer which may have implications "
|
|
"to product licensing, support and warranty."),
|
|
Locale (0x409), UUID ("{FAF76B63-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_Product
|
|
{
|
|
[read, MaxLen (64) , Description (
|
|
"A short textual description (one-line string) for the "
|
|
"Product.") ]
|
|
string Caption;
|
|
[Description ("A textual description of the product."), read ]
|
|
string Description;
|
|
[Key, read, MaxLen (64) , Description (
|
|
"Product identification such as a serial number on software, "
|
|
"a die number on a hardware chip, or (for non-commercial "
|
|
"Products) a project number."),
|
|
MappingStrings {"MIF.DMTF|ComponentID|001.4"} ]
|
|
string IdentifyingNumber;
|
|
[Key, read, MaxLen (256) , Description (
|
|
"Commonly used product name."),
|
|
MappingStrings {"MIF.DMTF|ComponentID|001.2"} ]
|
|
string Name;
|
|
[read, MaxLen (64) , Description (
|
|
"Product SKU (stock keeping unit) information.") ]
|
|
string SKUNumber;
|
|
[CIM_Key, read, MaxLen (256) , Description (
|
|
"The name of the Product's supplier, or entity selling the "
|
|
"Product (the manufacturer, reseller, OEM, etc.). "
|
|
"Corresponds to the Vendor property in the Product object "
|
|
"in the DMTF Solution Exchange Standard."),
|
|
MappingStrings {"MIF.DMTF|ComponentID|001.1"} ]
|
|
string Vendor;
|
|
[Key, read, MaxLen (64) , Description (
|
|
"Product version information. Corresponds to the Version "
|
|
"property in the product object in the DMTF Solution "
|
|
"Exchange Standard."),
|
|
MappingStrings {"MIF.DMTF|ComponentID|001.3"} ]
|
|
string Version;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Capabilities and management of memory-related logical devices."),
|
|
Locale (0x409), UUID ("{FAF76B64-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_Memory : CIM_StorageExtent
|
|
{
|
|
[Override ("ErrorMethodology") , Description (
|
|
"ErrorMethodology for CIM_Memory is a string property that "
|
|
"indicates whether parity or CRC algorithms, ECC or other "
|
|
"mechanisms are used. Details on the algorithm can also "
|
|
"be supplied."),
|
|
MappingStrings {"MIF.DMTF|Physical Memory Array|001.7"} ,
|
|
read ]
|
|
string ErrorMethodology;
|
|
[Description (
|
|
"The beginning address, referenced by an application or "
|
|
"operating system and mapped by a memory controller, for "
|
|
"this memory object. The starting address is specified in "
|
|
"KBytes."),
|
|
Units ("KiloBytes"),
|
|
MappingStrings {"MIF.DMTF|Memory Array Mapped Addresses|001.3",
|
|
"MIF.DMTF|Memory Device Mapped Addresses|001.4"} ,
|
|
read ]
|
|
uint64 StartingAddress;
|
|
[Description (
|
|
"The ending address, referenced by an application or "
|
|
"operating system and mapped by a memory controller, for "
|
|
"this memory object. The ending address is specified in "
|
|
"KBytes."),
|
|
Units ("KiloBytes"),
|
|
MappingStrings {"MIF.DMTF|Memory Array Mapped Addresses|001.4",
|
|
"MIF.DMTF|Memory Device Mapped Addresses|001.5"} ,
|
|
read ]
|
|
uint64 EndingAddress;
|
|
[Description (
|
|
"An integer enumeration describing the type of error that "
|
|
"occurred most recently. For example, single (value=6) or "
|
|
"double bit errors (7) can be specified using this property. "
|
|
"The values, 12-14, are undefined in the CIM Schema since in "
|
|
"DMI, they mix the semantics of the type of error and whether "
|
|
"it was correctable or not. The latter is indicated in the "
|
|
"property, CorrectableError."),
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
|
|
"11", "12", "13", "14"},
|
|
Values {"Other", "Unknown", "OK", "Bad Read", "Parity Error",
|
|
"Single-Bit Error", "Double-Bit Error", "Multi-Bit Error",
|
|
"Nibble Error", "Checksum Error", "CRC Error", "Undefined",
|
|
"Undefined", "Undefined"},
|
|
MappingStrings {"MIF.DMTF|Memory Device|002.12",
|
|
"MIF.DMTF|Physical Memory Array|001.8"} ,
|
|
ModelCorrespondence {"CIM_Memory.OtherErrorDescription"} ,
|
|
read ]
|
|
uint16 ErrorInfo;
|
|
[Description (
|
|
"Free form string providing more information if the Error"
|
|
"Type property is set to 1, \"Other\". If not set to 1, this "
|
|
"string has no meaning."),
|
|
ModelCorrespondence {"CIM_Memory.ErrorInfo"} ,
|
|
read ]
|
|
string OtherErrorDescription;
|
|
[Description (
|
|
"Boolean indicating that the most recent error was "
|
|
"correctable. If the ErrorInfo property is equal to 3, "
|
|
"\"OK\", then this property has no meaning."),
|
|
MappingStrings {"MIF.DMTF|Memory Device|002.12",
|
|
"MIF.DMTF|Physical Memory Array|001.8"} ,
|
|
read ]
|
|
boolean CorrectableError;
|
|
[Description (
|
|
"The time that the last memory error occurred. The type of "
|
|
"error is described by the ErrorInfo property. If the Error"
|
|
"Info property is equal to 3, \"OK\", then this property has "
|
|
"no meaning."),
|
|
read ]
|
|
datetime ErrorTime;
|
|
[Description (
|
|
"An integer enumeration indicating the memory access "
|
|
"operation that caused the last error. The type of error is "
|
|
"described by the ErrorInfo property. If the ErrorInfo "
|
|
"property is equal to 3, \"OK\", then this property "
|
|
"has no meaning."),
|
|
ValueMap {"1", "2", "3", "4", "5"},
|
|
Values {"Other", "Unknown", "Read", "Write", "Partial Write"},
|
|
MappingStrings {"MIF.DMTF|Memory Device|002.15",
|
|
"MIF.DMTF|Physical Memory Array|001.10"} ,
|
|
read ]
|
|
uint16 ErrorAccess;
|
|
[Description (
|
|
"The size of the data transfer in bits that caused the last "
|
|
"error. 0 indicates no error. If the ErrorInfo property "
|
|
"is equal to 3, \"OK\", then this property should be set "
|
|
"to 0."),
|
|
Units ("Bits") ,
|
|
MappingStrings {"MIF.DMTF|Memory Device|002.16",
|
|
"MIF.DMTF|Physical Memory Array|001.11"} ,
|
|
read ]
|
|
uint32 ErrorTransferSize;
|
|
[Description (
|
|
"Data captured during the last erroneous memory access. "
|
|
"The data occupies the first n octets of the array necessary "
|
|
"to hold the number of bits specified by the ErrorTransferSize "
|
|
"property. If ErrorTransferSize is 0, then this property "
|
|
"has no meaning."),
|
|
ArrayType ("Indexed"),
|
|
MappingStrings {"MIF.DMTF|Memory Device|002.17",
|
|
"MIF.DMTF|Physical Memory Array|001.12"} ,
|
|
read ]
|
|
uint8 ErrorData[64];
|
|
[Description (
|
|
"The ordering for data stored in the ErrorData property. "
|
|
"\"Least Significant Byte First\" (value=1) or "
|
|
"\"Most Significant Byte First\" (2) can be specified. If "
|
|
"ErrorTransferSize is 0, then this property has no meaning."),
|
|
Values {"Unknown", "Least Significant Byte First",
|
|
"Most Significant Byte First"},
|
|
read ]
|
|
uint16 ErrorDataOrder;
|
|
[Description (
|
|
"Specifies the address of the last memory error. The type "
|
|
"of error is described by the ErrorInfo property. "
|
|
"If the ErrorInfo property is equal to 3, \"OK\", then this "
|
|
"property has no meaning."),
|
|
MappingStrings {"MIF.DMTF|Memory Device|002.19",
|
|
"MIF.DMTF|Memory Device|002.20",
|
|
"MIF.DMTF|Physical Memory Array|001.14"} ,
|
|
read ]
|
|
uint64 ErrorAddress;
|
|
[Description (
|
|
"Boolean indicating whether the address information in "
|
|
"the property, ErrorAddress, is a system-level address (TRUE) "
|
|
"or a physical address (FALSE). If the ErrorInfo property is "
|
|
"equal to 3, \"OK\", then this property has no meaning."),
|
|
read ]
|
|
boolean SystemLevelAddress;
|
|
[Description (
|
|
"Specifies the range, in bytes, to which the last error can be "
|
|
"resolved. For example, if error addresses are resolved to bit "
|
|
"11 (i.e., on a typical page basis), then errors can be "
|
|
"resolved to 4K boundaries and this property is set to 4000. "
|
|
"If the ErrorInfo property is equal to 3, \"OK\", then this "
|
|
"property has no meaning."),
|
|
Units ("Bytes"),
|
|
MappingStrings {"MIF.DMTF|Memory Device|002.21",
|
|
"MIF.DMTF|Physical Memory Array|001.15"} ,
|
|
read ]
|
|
uint64 ErrorResolution;
|
|
[Description (
|
|
"An array of octets holding additional error information. "
|
|
"An example is ECC Syndrome or the return of the check bits "
|
|
"if a CRC-based error methodology is used. In the latter case, "
|
|
"if a single bit error is recognized and the CRC algorithm "
|
|
"is known, it is possible to determine the exact bit that "
|
|
"failed. This type of data (ECC Syndrome, Check Bit or "
|
|
"Parity Bit data, or other vendor supplied information) is "
|
|
"included in this field. If the ErrorInfo property is "
|
|
"equal to 3, \"OK\", then the AdditionalErrorData property has no meaning."),
|
|
MappingStrings {"MIF.DMTF|Memory Device|002.18",
|
|
"MIF.DMTF|Physical Memory Array|001.13"} ,
|
|
read ]
|
|
uint8 AdditionalErrorData[64];
|
|
};
|
|
|
|
[Abstract,Locale(0x409),UUID ("{18074AFA-F0FE-11d2-8617-0000F8102E5F}" ),
|
|
Description ("Capabilities and management of NV Storage. "
|
|
"Non-volatile memory natively includes flash and ROM storage. "
|
|
"In addition, NV memory can be BasedOn VolatileStorage, if the "
|
|
"volatile memory is backed by a Battery. This scenario would "
|
|
"be completely described by an instance of the AssociatedBattery "
|
|
"relationship, referencing the NonVolatileStorage as the "
|
|
"Dependent and the Battery as the Antecedent, and an instance "
|
|
"of the BasedOn relationship, referencing the NonVolatileStorage "
|
|
"as the Dependent and the VolatileStorage as the Antecedent.")]
|
|
class CIM_NonVolatileStorage : CIM_Memory
|
|
{
|
|
[read, Description ("Indicating that the NV storage is writeable.")]
|
|
boolean IsWriteable;
|
|
};
|
|
|
|
[Abstract,Locale(0x409),UUID ("{36851DFE-F0FE-11d2-8617-0000F8102E5F}" ),
|
|
Description ("Capabilities and management of volatile storage.")]
|
|
class CIM_VolatileStorage : CIM_Memory
|
|
{
|
|
[read, Description (
|
|
"Indicates whether this memory can be cached or not."),
|
|
MappingStrings {"MIF.DMTF|System Resource Memory Info|001.5"}
|
|
]
|
|
boolean Cacheable;
|
|
[read, Description (
|
|
"An enumeration indicating the cache type that is "
|
|
"compatible with this memory. For example, 4 indicates "
|
|
"write-through cache. If the Cacheable property is "
|
|
"set to false, then this property does not have meaning and "
|
|
"should be set to 5, \"Not Applicable\"."),
|
|
Values {"Other", "Unknown", "Write-Back", "Write-Through",
|
|
"Not Applicable"},
|
|
MappingStrings {"MIF.DMTF|System Resource Memory Info|001.6"}
|
|
]
|
|
uint16 CacheType;
|
|
};
|
|
|
|
[abstract, Description (
|
|
"Logical devices may have memory installed on them or "
|
|
"otherwise associated with them - such as cache memory. "
|
|
"This is made explicit in this association."),
|
|
Locale (0x409), UUID ("{464FFAB0-946F-11d2-AAE2-006008C78BC7}")
|
|
]
|
|
class CIM_AssociatedMemory : CIM_Dependency
|
|
{
|
|
[Override ("Antecedent") , Description (
|
|
"Memory installed on or associated with a device."),
|
|
read ]
|
|
CIM_Memory REF Antecedent;
|
|
[Override ("Dependent") , Description (
|
|
"The logical device."), read ]
|
|
CIM_LogicalDevice REF Dependent;
|
|
};
|
|
|
|
[abstract, Description(
|
|
"Associates the processor and system memory, or a processor's cache."),
|
|
Locale (0x409), UUID ("{464FFAB1-946F-11d2-AAE2-006008C78BC7}")
|
|
]
|
|
class CIM_AssociatedProcessorMemory : CIM_AssociatedMemory
|
|
{
|
|
[Override ("Dependent") , Description (
|
|
"The processor that accesses the memory or uses the cache."),
|
|
read ]
|
|
CIM_Processor REF Dependent;
|
|
[Description (
|
|
"Speed of the bus, in MHertz, between the processor and "
|
|
"memory. "),
|
|
Units ("MegaHertz"),
|
|
read ]
|
|
uint32 BusSpeed;
|
|
};
|
|
|
|
[abstract, Description ("Capabilities and management of cache memory. "
|
|
"Cache memory is dedicated or allocated RAM that a Processor "
|
|
"searches first for data, before going to 'regular' memory. "
|
|
"CacheMemory is used to speed up the delivery of data to a "
|
|
"Processor. It is usually described by its closeness to the "
|
|
"Processor (for example, Primary or Secondary Cache).\\nIf a "
|
|
"DiskDrive includes RAM allocated for holding the disk's most "
|
|
"recently read and/or adjacent data (in order to speed up "
|
|
"retrieval), this also would be modeled as CacheMemory. "
|
|
"Note that CacheMemory is NOT operating system or application "
|
|
"level buffers but actual RAM allocated for caching data "
|
|
"for a Processor, from a hard disk, etc."),
|
|
Locale (0x409), UUID ("{FAF76B65-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_CacheMemory : CIM_Memory
|
|
{
|
|
[Description (
|
|
"Defines whether this is the primary (value=3), secondary "
|
|
"(value=4) or tertiary (value=5) cache. Also, \"Other\" (1)"
|
|
", \"Unknown\" (2) and \"Not Applicable\" (6) can be defined."),
|
|
ValueMap {"1", "2", "3", "4", "5", "6"},
|
|
Values {"Other", "Unknown", "Primary", "Secondary", "Tertiary",
|
|
"Not Applicable"},
|
|
MappingStrings {"MIF.DMTF|System Cache|003.2"} ,
|
|
read ]
|
|
uint16 Level;
|
|
[Description (
|
|
"Defines whether this is write-back (value=3) or write-through "
|
|
"(value=4) Cache, or whether this information \"Varies with "
|
|
"Address\" (5) or is defined individually for each I/O (6). "
|
|
"Also, \"Other\" (1) and \"Unknown\" (2) can be specified."),
|
|
ValueMap {"1", "2", "3", "4", "5", "6"},
|
|
Values {"Other", "Unknown", "Write Back", "Write Through",
|
|
"Varies with Address", "Determination Per I/O"},
|
|
MappingStrings {"MIF.DMTF|System Cache|003.5"} ,
|
|
read ]
|
|
uint16 WritePolicy;
|
|
[Description (
|
|
"Defines whether this is for instruction caching (value=3), "
|
|
"data caching (value=4) or both (value=5, \"Unified\"). "
|
|
"Also, \"Other\" (1) and \"Unknown\" (2) can be defined."),
|
|
ValueMap {"1", "2", "3", "4", "5"},
|
|
Values {"Other", "Unknown", "Instruction", "Data", "Unified"},
|
|
MappingStrings {"MIF.DMTF|System Cache|003.9"} ,
|
|
read ]
|
|
uint16 CacheType;
|
|
[Description (
|
|
"Size, in bytes, of a single cache bucket or line."),
|
|
Units ("Bytes") ,
|
|
MappingStrings {"MIF.DMTF|System Cache|003.10"} ,
|
|
read ]
|
|
uint32 LineSize;
|
|
[Description (
|
|
"An integer enumeration describing the algorithm to "
|
|
"determine which cache lines or buckets should be re-used."),
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8"},
|
|
Values {"Other", "Unknown", "Least Recently Used (LRU)",
|
|
"First In First Out (FIFO)", "Last In First Out (LIFO)",
|
|
"Least Frequently Used (LFU)",
|
|
"Most Frequently Used (MFU)",
|
|
"Data Dependent Multiple Algorithms"},
|
|
MappingStrings {"MIF.DMTF|System Cache|003.12"} ,
|
|
read ]
|
|
uint16 ReplacementPolicy;
|
|
[Description (
|
|
"Policy that shall be employed by the cache for handling "
|
|
"read requests. For example, \"Read\", \"Read-Ahead\" or "
|
|
"both can be specified using the values, 3, 4 or 5, "
|
|
"respectively. "
|
|
"If the read policy is determined individually (ie, for "
|
|
"each request), then the value 6 (\"Determination per I/O\") "
|
|
"should be specified. \"Other\" (1) and \"Unknown\" (2) are "
|
|
"also valid values."),
|
|
ValueMap {"1", "2", "3", "4", "5", "6"},
|
|
Values {"Other", "Unknown", "Read", "Read-Ahead",
|
|
"Read and Read-Ahead", "Determination Per I/O"},
|
|
MappingStrings {"MIF.DMTF|System Cache|003.13"} ,
|
|
read ]
|
|
uint16 ReadPolicy;
|
|
[Description (
|
|
"Maximum amount of time, in seconds, dirty lines or "
|
|
"buckets may remain in the cache before they are flushed. "
|
|
"A value of zero indicated that a cache flush is not "
|
|
"controlled by a flushing timer."),
|
|
Units ("Seconds"),
|
|
MappingStrings {"MIF.DMTF|System Cache|003.14"} ,
|
|
read ]
|
|
uint32 FlushTimer;
|
|
[Description (
|
|
"An integer enumeration defining the system cache "
|
|
"associativity. For example, 6 indicates a fully associative "
|
|
"cache."),
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8"},
|
|
Values {"Other", "Unknown", "Direct Mapped",
|
|
"2-way Set-Associative",
|
|
"4-way Set-Associative", "Fully Associative",
|
|
"8-way Set-Associative", "16-way Set-Associative"},
|
|
MappingStrings {"MIF.DMTF|System Cache|003.15"} ,
|
|
read ]
|
|
uint16 Associativity;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"An alarm device is a type of device that emits audible or "
|
|
"visible indications related to a problem situation. "),
|
|
Locale (0x409), UUID ("{FAF76B66-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_AlarmDevice : CIM_LogicalDevice
|
|
{
|
|
[Description ("Boolean indicating that the alarm is audible. "), read]
|
|
boolean AudibleAlarm;
|
|
[Description ("Boolean indicating that the alarm is visible. "), read]
|
|
boolean VisibleAlarm;
|
|
[Description (
|
|
"Urgency is an enumerated value that indicates the relative "
|
|
"frequency at which the Alarm flashes, vibrates and/or "
|
|
"emits audible tones. "),
|
|
Values {"Unknown", "Other", "Not Supported", "Informational",
|
|
"Non-Critical", "Critical", "Unrecoverable"},
|
|
read ]
|
|
uint16 Urgency;
|
|
[Description (
|
|
"SetUrgency is a method for defining the desired urgency "
|
|
"level for the alarm. Its input parameter, RequestedUrgency, "
|
|
"is specified using the Values list of CIM_AlarmDevice's Urgency "
|
|
"property. SetUrgency returns 0 if the request is successfully "
|
|
"implemented, 1 if the specified urgency level is not "
|
|
"supported, and some other value if any other error occurred.") ]
|
|
uint32 SetUrgency ([IN] uint16 RequestedUrgency);
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The Location class specifies the position and address of "
|
|
"a physical element."),
|
|
Locale (0x409), UUID ("{FAF76B67-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_Location
|
|
{
|
|
[Key, read, MaxLen (256) , Description (
|
|
"Name is a free-form string defining a label for the "
|
|
"location. It is a part of the key for the object.")
|
|
]
|
|
string Name;
|
|
[Key, read, MaxLen (256) , Description (
|
|
"Position is a free-form string indicating the placement "
|
|
"of a physical element. It can specify slot information on "
|
|
"a hosting board, mounting site in a cabinet, or latitude and "
|
|
"longitude information, for example, from a GPS. It is "
|
|
"part of the key of the CIM_Location object.")
|
|
]
|
|
string PhysicalPosition;
|
|
[read, MaxLen (1024) , Description (
|
|
"Address is a free-form string indicating a street, building "
|
|
"or other type of address for the physical element's location.")
|
|
]
|
|
string Address;
|
|
};
|
|
|
|
[Abstract,Association, Description (
|
|
"CIM_PhysicalElementLocation associates a physical element with "
|
|
"a CIM_Location object for inventory or replacement purposes."),
|
|
Locale (0x409), UUID ("{FAF76B68-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PhysicalElementLocation
|
|
{
|
|
[Description (
|
|
"The physical element whose location is specified."),
|
|
read ]
|
|
CIM_PhysicalElement REF Element;
|
|
[Max (1), Description ("The physical element's location."),
|
|
read ]
|
|
CIM_Location REF PhysicalLocation;
|
|
};
|
|
|
|
[Abstract, Description ("CIM_PhysicalCapacity is an abstract class describing "
|
|
"a physical element's minimum/maximum requirements and "
|
|
"ability to support different types of hardware. For example, "
|
|
"minimum and maximum memory requirements can be modeled as a "
|
|
"subclass of CIM_PhysicalCapacity."),
|
|
Locale (0x409), UUID ("{FAF76B69-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PhysicalCapacity
|
|
{
|
|
[read, MaxLen (256) , Description (
|
|
"The Name property defines the label by which "
|
|
"the CIM_PhysicalCapacity object is known. When subclassed, "
|
|
"the Name property can be overridden to be a Key property.")
|
|
]
|
|
string Name;
|
|
[read, MaxLen (64) , Description (
|
|
"Caption is a short textual description "
|
|
"(one-line string) of the CIM_PhysicalCapacity object.")
|
|
]
|
|
string Caption;
|
|
[Description ("The Description property provides a textual "
|
|
"description of the CIM_PhysicalCapacity object."),
|
|
read ]
|
|
string Description;
|
|
};
|
|
|
|
[Abstract,Association, Description ("CIM_ElementCapacity associates "
|
|
"a CIM_PhysicalCapacity object with one or more physical elements. "
|
|
"It serves to associate a description of min/max hardware "
|
|
"requirements or capabilities (stored as a kind of "
|
|
"CIM_PhysicalCapacity), with the physical elements being described."),
|
|
Locale (0x409), UUID ("{FAF76B6A-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_ElementCapacity
|
|
{
|
|
[Description ("CIM_PhysicalCapacity describes the minimum and "
|
|
"maximum requirements and ability to support different "
|
|
"types of hardware for a physical element."),
|
|
read ]
|
|
CIM_PhysicalCapacity REF Capacity;
|
|
[Min(1), Description ("The physical element being described."),
|
|
read]
|
|
CIM_PhysicalElement REF Element;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"CIM_MemoryCapacity describes the type of memory that "
|
|
"can be installed on a physical element and its minimum/maximum "
|
|
"configurations. Information on what memory is currently "
|
|
"'installed', versus an element's min/max requirements, is "
|
|
"located in instances of the CIM_PhysicalMemory class."),
|
|
Locale (0x409), UUID ("{FAF76B6B-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_MemoryCapacity : CIM_PhysicalCapacity
|
|
{
|
|
[Override ("Name") ,
|
|
Key, read, Description (
|
|
"The inherited Name property serves as a part of the "
|
|
"CIM_MemoryCapacity object key.")
|
|
]
|
|
string Name;
|
|
[Key, read, Description (
|
|
"The type of memory. This is a part of the object "
|
|
"key. Values correspond to the list of possible memory types "
|
|
"in the CIM_PhysicalMemory class."),
|
|
Values {"Unknown", "Other", "DRAM", "Synchronous DRAM",
|
|
"Cache DRAM", "EDO", "EDRAM", "VRAM", "SRAM", "RAM",
|
|
"ROM", "Flash", "EEPROM", "FEPROM", "EPROM", "CDRAM",
|
|
"3DRAM", "SDRAM", "SGRAM",
|
|
"RDRAM", "DDR"},
|
|
ModelCorrespondence {"CIM_PhysicalMemory.MemoryType"} ]
|
|
uint16 MemoryType;
|
|
[Description ("Minimum amount of memory, in Kbytes, that is "
|
|
"needed for the associated physical element to operate "
|
|
"correctly. "),
|
|
Units ("KiloBytes"),
|
|
read ]
|
|
uint64 MinimumMemoryCapacity;
|
|
[Description ("Maximum amount of memory, in Kbytes, that can be "
|
|
"supported by the associated physical element. "),
|
|
Units ("KiloBytes"),
|
|
read ]
|
|
uint64 MaximumMemoryCapacity;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_ReplacementSet class aggregates physical elements that "
|
|
"must be 'replaced' or 'FRUed' together. For example, when "
|
|
"replacing a memory card, the component memory chips could "
|
|
"be removed and replaced as well. Or, a set of memory chips "
|
|
"may be specified to be replaced or upgraded together using "
|
|
"this association."),
|
|
Locale (0x409), UUID ("{FAF76B6C-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_ReplacementSet
|
|
{
|
|
[Key, read, MaxLen (256) , Description (
|
|
"Name is a free-form string defining a label for the "
|
|
"CIM_ReplacementSet. It is the key for the object.")
|
|
]
|
|
string Name;
|
|
[Description (
|
|
"A free-form string specifying information related to the "
|
|
"CIM_ReplacementSet. The purpose of the set or information "
|
|
"related to how the component elements are replaced may be "
|
|
"included in this property."),
|
|
read ]
|
|
string Description;
|
|
};
|
|
|
|
[Abstract,Association,
|
|
Aggregation, Description (
|
|
"CIM_ParticipatesInSet indicates which physical elements should "
|
|
"be replaced together."),
|
|
Locale (0x409), UUID ("{FAF76B6D-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_ParticipatesInSet
|
|
{
|
|
[Aggregate, read, Description (
|
|
"The CIM_ReplacementSet.")
|
|
]
|
|
CIM_ReplacementSet REF Set;
|
|
[Description (
|
|
"The physical element which should be replaced with other "
|
|
"elements, as a set."),
|
|
read ]
|
|
CIM_PhysicalElement REF Element;
|
|
};
|
|
|
|
[abstract, Description (
|
|
"The CIM_PhysicalPackage class represents physical elements that "
|
|
"contain or host other components. Examples are a rack "
|
|
"enclosure or an adapter card."),
|
|
Locale (0x409), UUID ("{FAF76B6E-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PhysicalPackage : CIM_PhysicalElement
|
|
{
|
|
[Description (
|
|
"A physical package is removable if it is designed to be "
|
|
"taken in and out of the physical container in which it is "
|
|
"normally found, without impairing the function of the "
|
|
"overall packaging. A package can still be removable if "
|
|
"power must be 'off' in order to perform the removal. If "
|
|
"power can be 'on' and the package removed, then the element "
|
|
"is removable and can be hot swapped. For example, an extra "
|
|
"battery in a laptop is removable, as is a disk drive package "
|
|
"inserted using SCA connectors. However, the latter can be hot "
|
|
"swapped. A laptop's display is not removable, nor "
|
|
"is a non-redundant power supply. Removing these "
|
|
"components would impact the function of the overall packaging "
|
|
"or is impossible due to the tight integration of the package."),
|
|
read ]
|
|
boolean Removable;
|
|
[Description (
|
|
"A physical package is replaceable if it is possible to "
|
|
"replace (FRU or upgrade) the element with a physically "
|
|
"different one. For example, some computer systems "
|
|
"allow the main processor chip to be upgraded to one of a "
|
|
"higher clock rating. In this case, the processor is said "
|
|
"to be replaceable . Another example is a power supply "
|
|
"package mounted on sliding rails. All removable packages "
|
|
"are inherently replaceable ."),
|
|
read ]
|
|
boolean Replaceable;
|
|
[Description (
|
|
"A physical package can be hot swapped if it is possible to "
|
|
"replace the element with a physically different "
|
|
"but equivalent one while the containing package has power "
|
|
"applied to it (i.e., is 'on'). For example, a disk drive "
|
|
"package inserted using SCA connectors is removable "
|
|
"and can be hot swapped. All packages that can be hot swapped "
|
|
"are inherently removable and replaceable."),
|
|
read ]
|
|
boolean HotSwappable;
|
|
[Description (
|
|
"The height of the physical package in inches."),
|
|
Units ("Inches"),
|
|
read ]
|
|
real32 Height;
|
|
[Description (
|
|
"The depth of the physical package in inches."),
|
|
Units ("Inches"),
|
|
read ]
|
|
real32 Depth;
|
|
[Description (
|
|
"The width of the physical package in inches."),
|
|
Units ("Inches"),
|
|
read ]
|
|
real32 Width;
|
|
[Description (
|
|
"The weight of the physical package in pounds."),
|
|
Units ("Pounds"),
|
|
read ]
|
|
real32 Weight;
|
|
[Description (
|
|
"The IsCompatible method verifies whether the referenced "
|
|
"physical element may be contained by or inserted into "
|
|
"the physical package. The return value should be 0 if "
|
|
"the request was successfully executed, 1 if the request "
|
|
"is not supported and some other value if an error "
|
|
"occurred. "
|
|
" In a subclass, the set of possible return codes "
|
|
"could be specified, using a ValueMap qualifier on the "
|
|
"method. The strings to which the ValueMap contents are "
|
|
"'translated' may also be specified in the subclass as a "
|
|
"Values array qualifier.")]
|
|
uint32 IsCompatible([IN] CIM_PhysicalElement REF ElementToCheck);
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_Container association represents the relationship "
|
|
"between a contained and a containing physical element. "
|
|
"A containing object must be a physical package."),
|
|
Locale (0x409), UUID ("{FAF76B6F-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_Container : CIM_Component
|
|
{
|
|
[Override ("GroupComponent") , read, Max (1) , Description (
|
|
"The physical package that contains other physical elements, "
|
|
"including other packages.")
|
|
]
|
|
CIM_PhysicalPackage REF GroupComponent;
|
|
[Override ("PartComponent") , read, Description (
|
|
"The physical element which is contained in the package.")
|
|
]
|
|
CIM_PhysicalElement REF PartComponent;
|
|
[Description (
|
|
"A free-form string representing the positioning of the "
|
|
"PhysicalElement within the PhysicalPackage. Information "
|
|
"relative to stationary elements in the Container (for "
|
|
"example, 'second drive bay from the top'), angles, "
|
|
"altitudes and other data may be recorded in this property. "
|
|
"This string could supplement or be used in place of "
|
|
"instantiating the CIM_Location object."),
|
|
read ]
|
|
string LocationWithinContainer;
|
|
};
|
|
|
|
[abstract, Description (
|
|
"CIM_PhysicalFrame is a superclass of rack, chassis and "
|
|
"other frame enclosures, as they are defined in extension "
|
|
"classes. Properties like visible or audible alarm, and data "
|
|
"related to security breaches are in this superclass." ),
|
|
Locale (0x409), UUID ("{FAF76B70-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PhysicalFrame : CIM_PhysicalPackage
|
|
{
|
|
[Description ("CableManagementStrategy is a free-form string "
|
|
"that contains information on how the various cables are "
|
|
"connected and bundled for the frame. With many networking, "
|
|
"storage-related and power cables, cable management can be "
|
|
"a complex and challenging endeavor. This string property "
|
|
"contains information to aid in assembly and service "
|
|
"of the frame."),
|
|
read ]
|
|
string CableManagementStrategy;
|
|
[Description (
|
|
"ServicePhilosophy is an enumerated, integer-valued "
|
|
"array that indicates whether the frame is serviced from the "
|
|
"top (value=2), front (3), back (4) or side (5), whether it "
|
|
"has sliding trays (6) or removable sides (7), and/or whether "
|
|
"the frame is moveable (8), for example, having rollers."),
|
|
ArrayType ("Indexed"),
|
|
Values {"Unknown", "Other", "Service From Top",
|
|
"Service From Front", "Service From Back",
|
|
"Service From Side", "Sliding Trays",
|
|
"Removable Sides", "Moveable"},
|
|
ModelCorrespondence {"CIM_PhysicalFrame.ServiceDescriptions"} ,
|
|
read ]
|
|
uint16 ServicePhilosophy[];
|
|
[Description ("An array of free-form strings providing more "
|
|
"detailed explanations for any of the entries in the Service"
|
|
"Philosophy array. Note, each entry of this array "
|
|
"is related to the entry in ServicePhilosophy that is "
|
|
"located at the same index."),
|
|
ArrayType ("Indexed"),
|
|
ModelCorrespondence {"CIM_PhysicalFrame.ServicePhilosophy"} ,
|
|
read ]
|
|
string ServiceDescriptions[];
|
|
[Description ("Boolean indicating whether the frame is protected "
|
|
"with a lock."),
|
|
read ]
|
|
boolean LockPresent;
|
|
[Description ("Boolean indicating whether the frame is equipped "
|
|
"with an audible alarm."),
|
|
read ]
|
|
boolean AudibleAlarm;
|
|
[Description ("Boolean indicating that the equipment includes "
|
|
"a visible alarm."),
|
|
read ]
|
|
boolean VisibleAlarm;
|
|
[Description ("SecurityBreach is an enumerated, integer-valued "
|
|
"property indicating whether a physical breach of the frame "
|
|
"was attempted but unsuccessful (value=4) or attempted and "
|
|
"successful (5). Also, the values, \"Unknown\", \"Other\" or "
|
|
"\"No Breach\", can be specified."),
|
|
ValueMap {"1", "2", "3", "4", "5"},
|
|
Values {"Other", "Unknown", "No Breach", "Breach Attempted",
|
|
"Breach Successful"},
|
|
MappingStrings {
|
|
"MIF.DMTF|Physical Container Global Table|002.12"} ,
|
|
ModelCorrespondence {"CIM_PhysicalFrame.BreachDescription"} ,
|
|
read ]
|
|
uint16 SecurityBreach;
|
|
[Description ("BreachDescription is a free-form string providing "
|
|
"more information if the SecurityBreach property indicates "
|
|
"that a breach or some other security-related event "
|
|
"occurred."),
|
|
ModelCorrespondence {"CIM_PhysicalFrame.SecurityBreach"} ,
|
|
read ]
|
|
string BreachDescription;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"A rack is a physical frame that represents an enclosure in "
|
|
"which chassis are placed. Typically a rack is nothing more "
|
|
"than the enclosure, and all the functioning components are "
|
|
"packaged in the chassis, loaded in the rack."),
|
|
Locale (0x409), UUID ("{FAF76B71-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_Rack : CIM_PhysicalFrame
|
|
{
|
|
[Override ("Height") , read, Description (
|
|
"The height of the physical package in 'U's. A 'U' is a "
|
|
"standard unit of measure for the height of a rack or "
|
|
"rack-mountable component. It is equal to 1.75 inches or "
|
|
"4.445 cm."),
|
|
Units ("Us")
|
|
]
|
|
real32 Height;
|
|
[Description ("Enumeration indicating the type of rack."
|
|
"Information such as \"Telco\" rack (value=2) or standard "
|
|
"19 inch rack (1) can be specified. The country/region for which "
|
|
"the rack is manufactured is defined in the Country"
|
|
"Designation property."),
|
|
Values {"Unknown", "Standard 19 Inch", "Telco",
|
|
"Equipment Shelf", "Non-Standard"},
|
|
ModelCorrespondence {"CIM_Rack.CountryDesignation"} ,
|
|
read ]
|
|
uint16 TypeOfRack;
|
|
[Description ("Designation of the country/region for which the rack "
|
|
"is designed. Country/region code strings are as defined by "
|
|
"ISO/IEC 3166. The rack type is specified in the TypeOf"
|
|
"Rack property."),
|
|
ModelCorrespondence {"CIM_Rack.TypeOfRack"} , read ]
|
|
string CountryDesignation;
|
|
};
|
|
|
|
[abstract, Description (
|
|
"The CIM_Chassis class represents the physical elements that "
|
|
"enclose other elements and provide definable functionality, "
|
|
"such as a desktop, processing node, UPS, disk or tape storage, "
|
|
"or a combination of these."),
|
|
Locale (0x409), UUID ("{FAF76B72-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_Chassis : CIM_PhysicalFrame
|
|
{
|
|
[Description (
|
|
"Integer indicating the number of power cords which must be "
|
|
"connected to the chassis, for all the components to "
|
|
"operate."),
|
|
read ]
|
|
uint16 NumberOfPowerCords;
|
|
[Description (
|
|
"Current required by the chassis at 120V. If power is "
|
|
"provided by the chassis (as in the case of a UPS), this "
|
|
"property may indicate the amperage produced, as a negative "
|
|
"number."),
|
|
Units ("Amps at 120 Volts"),
|
|
read ]
|
|
sint16 CurrentRequiredOrProduced;
|
|
[Description (
|
|
"Amount of heat generated by the chassis in BTU/hour."),
|
|
Units ("BTU per Hour"),
|
|
read ]
|
|
uint16 HeatGeneration;
|
|
[Description (
|
|
"An enumerated, integer-valued array indicating the type of "
|
|
"chassis."),
|
|
ArrayType ("Indexed"),
|
|
ValueMap {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10",
|
|
"11", "12", "13", "14", "15", "16", "17", "18", "19",
|
|
"20", "21", "22", "23", "24"},
|
|
Values {"Other", "Unknown", "Desktop", "Low Profile Desktop",
|
|
"Pizza Box", "Mini Tower", "Tower", "Portable", "Laptop",
|
|
"Notebook", "Hand Held", "Docking Station", "All in One",
|
|
"Sub Notebook", "Space-Saving", "Lunch Box",
|
|
"Main System Chassis", "Expansion Chassis", "SubChassis",
|
|
"Bus Expansion Chassis", "Peripheral Chassis",
|
|
"Storage Chassis", "Rack Mount Chassis",
|
|
"Sealed-Case PC"},
|
|
MappingStrings {
|
|
"MIF.DMTF|Physical Container Global Table|002.1"} ,
|
|
ModelCorrespondence {"CIM_Chassis.TypeDescriptions"} ,
|
|
read ]
|
|
uint16 ChassisTypes[];
|
|
[Description (
|
|
"An array of free-form strings providing more information "
|
|
"on the ChassisTypes array entries. Note, each entry of this "
|
|
"array is related to the entry in ChassisTypes that is "
|
|
"located at the same index."),
|
|
ArrayType ("Indexed"),
|
|
ModelCorrespondence {"CIM_Chassis.ChassisTypes"} ,
|
|
read ]
|
|
string TypeDescriptions[];
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Racks, as simple enclosures, contain chassis that provide "
|
|
"the physical components realizing processing nodes, "
|
|
"storage devices, UPSs, etc. The CIM_ChassisInRack association "
|
|
"makes explicit the 'containing' relationship between the "
|
|
"rack and the chassis."),
|
|
Locale (0x409), UUID ("{FAF76B73-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_ChassisInRack : CIM_Container
|
|
{
|
|
[Override ("GroupComponent") , read, Max (1) , Description (
|
|
"The rack that contains the chassis.")
|
|
]
|
|
CIM_Rack REF GroupComponent;
|
|
[Override ("PartComponent") , read, Description (
|
|
"The chassis which is mounted in the rack.")
|
|
]
|
|
CIM_Chassis REF PartComponent;
|
|
[Description (
|
|
"An integer indicating the lowest or 'bottom' U in which "
|
|
"the chassis is mounted. A 'U' is a standard unit of "
|
|
"measure for the height of a rack or rack-mountable "
|
|
"component. It is equal to 1.75 inches or 4.445 cm."),
|
|
Units ("Us"),
|
|
read ]
|
|
uint16 BottomU;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"A chassis can contain other packages, such as other chassis "
|
|
"and cards. The CIM_PackageInChassis association makes explicit "
|
|
"this relationship."),
|
|
Locale (0x409), UUID ("{FAF76B74-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PackageInChassis : CIM_Container
|
|
{
|
|
[Override ("GroupComponent") , Max (1) , Description (
|
|
"The chassis that contains other physical packages."),
|
|
read ]
|
|
CIM_Chassis REF GroupComponent;
|
|
[Override ("PartComponent") , Description (
|
|
"The physical package which is contained in the chassis."),
|
|
read ]
|
|
CIM_PhysicalPackage REF PartComponent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"A laptop, a type of chassis, may be docked in another "
|
|
"type of chassis, a docking station. This is the relationship "
|
|
"represented by the CIM_Docked association. Because this is "
|
|
"such a typical relationship, it is explicitly described."),
|
|
MappingStrings {"MIF.DMTF|Dynamic States|001.2"} ,
|
|
Locale (0x409), UUID ("{FAF76B75-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_Docked : CIM_Dependency
|
|
{
|
|
[Override ("Antecedent") , read,
|
|
Max (1) , Description ("The docking station.")
|
|
]
|
|
CIM_Chassis REF Antecedent;
|
|
[Override ("Dependent") , read,
|
|
Max (1) , Description (
|
|
"The laptop that is 'docked'.")
|
|
]
|
|
CIM_Chassis REF Dependent;
|
|
};
|
|
|
|
[abstract, Description (
|
|
"The CIM_Card class represents a type of physical container that "
|
|
"can be plugged into another card or hosting board, or is "
|
|
"itself a hosting board/motherboard in a chassis. The CIM_Card "
|
|
"class includes any package capable of carrying signals and "
|
|
"providing a mounting point for physical components, such as "
|
|
"chips, or other physical packages, such as other cards."),
|
|
Locale (0x409), UUID ("{FAF76B76-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_Card : CIM_PhysicalPackage
|
|
{
|
|
[Description (
|
|
"Boolean indicating that this card is a motherboard or, "
|
|
"more generically, a baseboard in a chassis."),
|
|
read ]
|
|
boolean HostingBoard;
|
|
[Description (
|
|
"SlotLayout is a free-form string that describes the "
|
|
"slot positioning, typical usage, restrictions, individual "
|
|
"slot spacings or any other pertinent information for the "
|
|
"slots on a card."),
|
|
read ]
|
|
string SlotLayout;
|
|
[Description (
|
|
"Boolean indicating that at least one daughterboard or "
|
|
"auxiliary card is required in order to function properly."),
|
|
read ]
|
|
boolean RequiresDaughterBoard;
|
|
[Description ("Boolean indicating that this card is physically "
|
|
"unique from other cards of the same type and therefore "
|
|
"requires a special slot. For example, a double-wide card "
|
|
"requires two slots. Another example is where a certain card "
|
|
"may be used for the same general function as other cards but "
|
|
"requires a special slot (e.g., extra long), whereas the "
|
|
"other cards can be placed in any available slot. "
|
|
"If set to TRUE, then the corresponding property, "
|
|
"RequirementsDescription, should specify the nature of the "
|
|
"uniqueness or purpose of the card."),
|
|
ModelCorrespondence{"CIM_Card.RequirementsDescription"} ,
|
|
read ]
|
|
boolean SpecialRequirements;
|
|
[Description ("A free-form string describing the way(s) in which "
|
|
"this card is physically unique from other cards. This "
|
|
"property only has meaning when the corresponding boolean "
|
|
"property, SpecialRequirements, is set to TRUE."),
|
|
ModelCorrespondence{"CIM_Card.SpecialRequirements"} ,
|
|
read ]
|
|
string RequirementsDescription;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Cards may be plugged into motherboards/baseboards, are "
|
|
"daughtercards of an adapter, or support special card-like "
|
|
"modules. These relationships are described by the CIM_CardOnCard "
|
|
"association."),
|
|
Locale (0x409), UUID ("{FAF76B77-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_CardOnCard : CIM_Container
|
|
{
|
|
[Override ("GroupComponent") , read, Max (1) , Description (
|
|
"The card that hosts another card.")
|
|
]
|
|
CIM_Card REF GroupComponent;
|
|
[Override ("PartComponent") , Description (
|
|
"The card that is plugged into or otherwise mounted on "
|
|
"another card."),
|
|
read ]
|
|
CIM_Card REF PartComponent;
|
|
[Description (
|
|
"A string describing and identifying how the card is "
|
|
"mounted on or plugged into the 'other' card. slot "
|
|
"information could be included in this field and may be "
|
|
"sufficient for certain management purposes. If so, "
|
|
"this avoids creating instantiations of connector/slot "
|
|
"objects just to model the relationship of cards to "
|
|
"hosting boards or other adapters. On the other hand, "
|
|
"if slot and connector information is available, this "
|
|
"field could be used to provide more detailed mounting "
|
|
"or slot insertion data."),
|
|
read ]
|
|
string MountOrSlotDescription;
|
|
};
|
|
|
|
[abstract, Description (
|
|
"The CIM_PhysicalComponent class represents any low-level or "
|
|
"basic component within a package. Any physical element that is "
|
|
"not a link, connector, or package is a descendent (or "
|
|
"member) of this class. For example, the UART chipset on an "
|
|
"internal modem card would be a subclass (if additional "
|
|
"properties or associations are defined) or an instance of "
|
|
"CIM_PhysicalComponent."),
|
|
Locale (0x409), UUID ("{FAF76B78-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PhysicalComponent : CIM_PhysicalElement
|
|
{
|
|
[Description (
|
|
"A physical component is removable if it is designed to be "
|
|
"taken in and out of the physical container in which it is "
|
|
"normally found, without impairing the function of the "
|
|
"overall packaging. A component can still be removable if "
|
|
"power must be 'off' in order to perform the removal. If "
|
|
"power can be 'on' and the component removed, then the element "
|
|
"is removable and can be hot swapped. For example, an "
|
|
"upgradeable processor chip is removable."),
|
|
read ]
|
|
boolean Removable;
|
|
[Description (
|
|
"A physical component is replaceable if it is possible to "
|
|
"replace (FRU or upgrade) the element with a physically "
|
|
"different one. For example, some computer systems "
|
|
"allow the main processor chip to be upgraded to one of a "
|
|
"higher clock rating. In this case, the processor is said "
|
|
"to be replaceable . All removable components are "
|
|
"inherently replaceable ."),
|
|
read ]
|
|
boolean Replaceable;
|
|
[Description (
|
|
"A physical component can be hot swapped if it is possible to "
|
|
"replace the element with a physically different "
|
|
"but equivalent one while the containing package has power "
|
|
"applied to it (i.e., is 'on'). For example, a fan component "
|
|
"may be designed to be hot swapped. All components that can "
|
|
"be hot swapped are inherently removable and replaceable ."),
|
|
read ]
|
|
boolean HotSwappable;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"A component is typically contained by a physical package, such "
|
|
"as a chassis or card. The CIM_PackagedComponent association makes "
|
|
"this relationship explicit. In the first sentence, the word, "
|
|
"'typically', is used. This is because a component may be "
|
|
"removed from, or not yet inserted into, its containing "
|
|
"package (i.e., the Removable boolean property is TRUE). Therefore, a "
|
|
"component may not always be associated with a container."),
|
|
Locale (0x409), UUID ("{FAF76B79-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PackagedComponent : CIM_Container
|
|
{
|
|
[Override ("GroupComponent") , read, Max (1) , Description (
|
|
"The physical package that contains component(s).")
|
|
]
|
|
CIM_PhysicalPackage REF GroupComponent;
|
|
[Override ("PartComponent") , read, Description (
|
|
"The physical component which is contained in the package.")
|
|
]
|
|
CIM_PhysicalComponent REF PartComponent;
|
|
};
|
|
|
|
[abstract, Description (
|
|
"The CIM_Chip class represents any type of integrated circuit "
|
|
"hardware, including ASICs, processors, memory chips, etc."),
|
|
Locale (0x409), UUID ("{FAF76B7A-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_Chip : CIM_PhysicalComponent
|
|
{
|
|
[Description ("The implementation form factor for the chip."
|
|
"For example, values such as SIMM (7), TSOP (9) or PGA (10) "
|
|
"can be specified."),
|
|
Values {"Unknown", "Other", "SIP", "DIP", "ZIP", "SOJ",
|
|
"Proprietary", "SIMM", "DIMM", "TSOP", "PGA", "RIMM",
|
|
"SODIMM",
|
|
"SRIMM", "SMD", "SSMP", "QFP", "TQFP", "SOIC", "LCC",
|
|
"PLCC", "BGA", "FPBGA", "LGA"},
|
|
read ]
|
|
uint16 FormFactor;
|
|
};
|
|
|
|
[abstract, Description (
|
|
"CIM_PhysicalMemory is a subclass of CIM_Chip, representing "
|
|
"low level memory devices - SIMMS, DIMMs, raw memory chips, "
|
|
"etc."),
|
|
Locale (0x409), UUID ("{FAF76B7B-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PhysicalMemory : CIM_Chip
|
|
{
|
|
[read, Override ("FormFactor") ,
|
|
MappingStrings {"MIF.DMTF|Memory Device|002.6"}
|
|
]
|
|
uint16 FormFactor;
|
|
[Description ("The type of physical memory."),
|
|
Values {"Unknown", "Other", "DRAM", "Synchronous DRAM",
|
|
"Cache DRAM", "EDO", "EDRAM", "VRAM", "SRAM", "RAM",
|
|
"ROM", "Flash", "EEPROM", "FEPROM", "EPROM", "CDRAM",
|
|
"3DRAM", "SDRAM", "SGRAM",
|
|
"RDRAM", "DDR"},
|
|
MappingStrings {"MIF.DMTF|Memory Device|002.9"} ,
|
|
read ]
|
|
uint16 MemoryType;
|
|
[Description (
|
|
"Total width, in bits, of the physical memory, including check "
|
|
"or error correction bits. If there are no error correction "
|
|
"bits, the value in this property should match that specified "
|
|
"for the DataWidth property."),
|
|
Units ("Bits"),
|
|
MappingStrings {"MIF.DMTF|Memory Device|002.7"} ,
|
|
read ]
|
|
uint16 TotalWidth;
|
|
[Description (
|
|
"Data width of the physical memory, in bits. A data width of 0 "
|
|
"and a total width of 8 would indicate that the memory is "
|
|
"solely used to provide error correction bits."),
|
|
Units ("Bits"),
|
|
MappingStrings {"MIF.DMTF|Memory Device|002.8"} ,
|
|
read ]
|
|
uint16 DataWidth;
|
|
[Description ("The speed of the physical memory, in nanoseconds."),
|
|
Units ("NanoSeconds"),
|
|
read ]
|
|
uint32 Speed;
|
|
[Description (
|
|
"The total capacity of this physical memory, in bytes."),
|
|
Units ("Bytes"),
|
|
MappingStrings {"MIF.DMTF|Memory Device|002.5"} ,
|
|
read ]
|
|
uint64 Capacity;
|
|
[Description (
|
|
"A string identifying the physically labeled bank where the "
|
|
"memory is located - for example, 'Bank 0' or 'Bank A'."),
|
|
MaxLen (64),
|
|
MappingStrings {"MIF.DMTF|Memory Device|002.4"} ,
|
|
read ]
|
|
string BankLabel;
|
|
[Description (
|
|
"Specifies the position of the physical memory in a 'row'. For "
|
|
"example, if it takes two 8-bit memory devices to form a 16-"
|
|
"bit row, then a value of '2'means that this memory is the "
|
|
"second device. 0 is an invalid value for this property."),
|
|
MappingStrings {"MIF.DMTF|Memory Device Mapped Addresses|001.6"} ,
|
|
read ]
|
|
uint32 PositionInRow;
|
|
[Description (
|
|
"The position of this physical memory in an interleave. 0 "
|
|
"indicates non-interleaved. 1 indicates the first position, 2 "
|
|
"the second position and so on. For example, in a 2:1 "
|
|
"interleave, a value of '1' would indicate that the memory "
|
|
"is in the 'even' position."),
|
|
MappingStrings {"MIF.DMTF|Memory Device Mapped Addresses|001.7"} ,
|
|
read ]
|
|
uint32 InterleavePosition;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Physical memory can be located on hosting boards, adapter cards, "
|
|
"etc. This association explicitly defines this relationship of "
|
|
"memory to cards."),
|
|
Locale (0x409), UUID ("{FAF76B7C-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_MemoryOnCard : CIM_PackagedComponent
|
|
{
|
|
[Override ("GroupComponent") , read, Max (1) , Description (
|
|
"The card that includes or 'contains' memory.")
|
|
]
|
|
CIM_Card REF GroupComponent;
|
|
[Override ("PartComponent") , read, Description (
|
|
"The physical memory which is located on the card.")
|
|
]
|
|
CIM_PhysicalMemory REF PartComponent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_PhysicalMedia class represents any type of documentation "
|
|
"or storage medium, such as tapes, CD ROMs, etc. This class "
|
|
"is typically used to locate and manage removable media "
|
|
"(versus media sealed with the media access device, as a single "
|
|
"package, as is the case with hard disks). However, 'sealed' "
|
|
"media can also be modeled using this class, where the media "
|
|
"would then be associated with the physical package using the "
|
|
"CIM_PackagedComponent relationship."),
|
|
Locale (0x409), UUID ("{FAF76B7D-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PhysicalMedia : CIM_PhysicalComponent
|
|
{
|
|
[Description (
|
|
"The number of bytes that can be read from or written to a "
|
|
"Media. This property is not applicable to \"Hard Copy\" "
|
|
"(documentation) or cleaner Media. Data compression should not "
|
|
"be assumed, as it would increase the value in this property. "
|
|
"For tapes, it should be assumed that no filemarks or blank "
|
|
"space areas are recorded on the Media."),
|
|
Units ("Bytes"),
|
|
read ]
|
|
uint64 Capacity;
|
|
[Description (
|
|
"Specifies the type of the physical media, as an enumerated "
|
|
"integer. The MediaDescription property is "
|
|
"used to provide more explicit definition of the media type, "
|
|
"whether it is pre-formatted, compatibility features, etc."),
|
|
Values {"Unknown", "Other", "Tape Cartridge", "QIC Cartridge",
|
|
"AIT Cartridge", "DTF Cartridge", "DAT Cartridge",
|
|
"8mm Tape Cartridge", "19mm Tape Cartridge",
|
|
"DLT Cartridge", "Half-Inch Magnetic Tape Cartridge",
|
|
"Cartridge Disk", "JAZ Disk", "ZIP Disk", "SyQuest Disk",
|
|
"Winchester Removable Disk", "CD-ROM", "CD-ROM/XA",
|
|
"CD-I", "CD Recordable", "WORM", "Magneto-Optical", "DVD",
|
|
"DVD+RW", "DVD-RAM", "DVD-ROM", "DVD-Video", "Divx",
|
|
"Floppy/Diskette", "Hard Disk", "Memory Card",
|
|
"Hard Copy", "Clik Disk", "CD-RW", "CD-DA", "CD+",
|
|
"DVD Recordable", "DVD-RW", "DVD-Audio", "DVD-5", "DVD-9",
|
|
"DVD-10", "DVD-18", "Magneto-Optical Rewriteable",
|
|
"Magneto-Optical Write Once",
|
|
"Magneto-Optical Rewriteable (LIMDOW)",
|
|
"Phase Change Write Once", "Phase Change Rewriteable",
|
|
"Phase Change Dual Rewriteable", "Ablative Write Once",
|
|
"Near Field Recording", "MiniQic", "Travan",
|
|
"8mm Metal Particle", "8mm Advanced Metal Evaporate",
|
|
"NCTP", "LTO Ultrium", "LTO Accelis", "9 Track Tape",
|
|
"18 Track Tape", "36 Track Tape", "Magstar 3590",
|
|
"Magstar MP", "D2 Tape", "Tape - DST Small ",
|
|
"Tape - DST Medium", "Tape - DST Large"},
|
|
ModelCorrespondence {"CIM_PhysicalMedia.MediaDescription"} ,
|
|
read ]
|
|
uint16 MediaType;
|
|
[Description (
|
|
"Additional detail related to the MediaType enumeration. For "
|
|
"example, if value 3 (\"QIC Cartridge\") is specified, this "
|
|
"property could indicate whether the tape is wide or 1/4 inch, "
|
|
"whether it is pre-formatted, whether it is Travan compatible, "
|
|
"etc."),
|
|
ModelCorrespondence {"CIM_PhysicalMedia.MediaType"} ,
|
|
read ]
|
|
string MediaDescription;
|
|
[Description (
|
|
"Boolean specifying whether the media is currently write "
|
|
"protected by some kind of physical mechanism, such as a "
|
|
"protect tab on a floppy diskette."),
|
|
read ]
|
|
boolean WriteProtectOn;
|
|
[Description ("Boolean indicating that the physical media "
|
|
"is used for cleaning purposes and not data storage."),
|
|
read ]
|
|
boolean CleanerMedia;
|
|
};
|
|
|
|
[Abstract, Description ("CIM_MemoryWithMedia indicates that memory is associated "
|
|
"with a physical media and its cartridge. The memory provides "
|
|
"media identification and also stores user-specific data. "),
|
|
Locale (0x409), UUID ("{FAF76B7E-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_MemoryWithMedia : CIM_Dependency
|
|
{
|
|
[Override ("Antecedent") , read, Description (
|
|
"The memory associated with physical media. ")
|
|
]
|
|
CIM_PhysicalMemory REF Antecedent;
|
|
[Override ("Dependent") , read, Description (
|
|
"The physical media.")
|
|
]
|
|
CIM_PhysicalMedia REF Dependent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Physical extents are realized on a physical media. This "
|
|
"relationship is made explicit by the CIM_RealizesPExtent "
|
|
"association. In addition, the starting address of the "
|
|
"physical extent on the physical media is specified here."),
|
|
Locale (0x409), UUID ("{FAF76B7F-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_RealizesPExtent : CIM_Realizes
|
|
{
|
|
[Override ("Antecedent") , read, Description (
|
|
"The physical media on which the extent is realized."),
|
|
Max (1)
|
|
]
|
|
CIM_PhysicalMedia REF Antecedent;
|
|
[Override ("Dependent") , read, Description (
|
|
"The physical extent that is located on the media.")
|
|
]
|
|
CIM_PhysicalExtent REF Dependent;
|
|
[Description (
|
|
"The starting address on the physical media where the "
|
|
"physical extent begins. Ending address of the physical"
|
|
"extent is determined using the NumberOfBlocks and Block"
|
|
"Size properties of the CIM_PhysicalExtent object."),
|
|
read ]
|
|
uint64 StartingAddress;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"DiskPartitions can be directly realized on a PhysicalMedia. "
|
|
"This is used to model the creation of Partitions on a raw SCSI "
|
|
"or IDE drive, using the fdisk (DOS and Unix) or pdisk (Unix) "
|
|
"command. The StartingAddress of the DiskPartition on the "
|
|
"PhysicalMedia is also specified as a property of this "
|
|
"relationship. An alternative is that Partitions can "
|
|
"be BasedOn StorageVolumes, such as a VolumeSet or a Volume "
|
|
"exposed by a hardware RAID cabinet. The latter relationship is "
|
|
"modeled using the DiskPartitionBasedOnVolume association."),
|
|
Locale (0x409), UUID ("{FAF76B80-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_RealizesDiskPartition : CIM_Realizes
|
|
{
|
|
[Override ("Antecedent") , read, Description (
|
|
"The physical media on which the extent is realized."),
|
|
Max (1)
|
|
]
|
|
CIM_PhysicalMedia REF Antecedent;
|
|
[Override ("Dependent") , read, Description (
|
|
"The disk partition that is located on the media.")
|
|
]
|
|
CIM_DiskPartition REF Dependent;
|
|
[Description (
|
|
"The starting address on the physical media where the "
|
|
"disk partition begins. Ending address of the partition "
|
|
"is determined using the NumberOfBlocks and Block"
|
|
"Size properties of the disk partition object."),
|
|
read ]
|
|
uint64 StartingAddress;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"CIM_AggregatePExtent is realized on a physical media. This "
|
|
"relationship is made explicit by the CIM_RealizesAggregatePExtent "
|
|
"association."),
|
|
Locale (0x409), UUID ("{FAF76B81-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_RealizesAggregatePExtent : CIM_Realizes
|
|
{
|
|
[Override ("Antecedent") , read, Description (
|
|
"The physical media on which the extent is realized."),
|
|
Max (1)
|
|
]
|
|
CIM_PhysicalMedia REF Antecedent;
|
|
[Override ("Dependent") , read, Description (
|
|
"The CIM_AggregatePExtent that is located on the media.")
|
|
]
|
|
CIM_AggregatePExtent REF Dependent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_PhysicalLink class represents the cabling of "
|
|
"physical elements together. For example, serial or Ethernet "
|
|
"cables, and infrared Links would be subclasses (if additional "
|
|
"properties or associations are defined) or instances of "
|
|
"CIM_PhysicalLink. In many cases, the numerous physical cables "
|
|
"within a physical package or network will not be modeled. "
|
|
"However, where these cables or links are critical components, "
|
|
"or are tagged assets of the company, these objects can be "
|
|
"instantiated using this class or one of its descendent "
|
|
"classes."),
|
|
Locale (0x409), UUID ("{FAF76B82-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PhysicalLink : CIM_PhysicalElement
|
|
{
|
|
[Description ("The maximum length of the physical link in feet."),
|
|
Units ("Feet"),
|
|
read ]
|
|
real64 MaxLength;
|
|
[Description (
|
|
"The current length of the physical link in feet. For some "
|
|
"connections, especially wireless technologies, this property "
|
|
"may not be applicable and should be left uninitialized."),
|
|
Units ("Feet"),
|
|
read ]
|
|
real64 Length;
|
|
[Description (
|
|
"Boolean indicating whether the physical link is an actual "
|
|
"cable (TRUE) or a wireless connection (FALSE)."),
|
|
read ]
|
|
boolean Wired;
|
|
[Description("The MediaType property defines the particular "
|
|
"type of media through which transmission signals pass. "
|
|
"Common network media include twisted-pair (value=11 or 12), "
|
|
"coaxial (7, 8 or 9) and fiber-optic cable (10)."),
|
|
Values {"Unknown", "Other", "Cat1", "Cat2", "Cat3", "Cat4",
|
|
"Cat5", "50-ohm Coaxial", "75-ohm Coaxial",
|
|
"100-ohm Coaxial", "Fiber-optic", "UTP", "STP",
|
|
"Ribbon Cable",
|
|
"Twinaxial", "Optical 9um", "Optical 50um", "Optical 62.5um"},
|
|
read ]
|
|
uint16 MediaType;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"The CIM_ElementsLinked association indicates which physical "
|
|
"elements are cabled together by a physical link."),
|
|
Locale (0x409), UUID ("{FAF76B83-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_ElementsLinked : CIM_Dependency
|
|
{
|
|
[Override ("Antecedent") , read, Description (
|
|
"The physical link.")
|
|
]
|
|
CIM_PhysicalLink REF Antecedent;
|
|
[Override ("Dependent") , read, Description (
|
|
"The physical element that is linked.")
|
|
]
|
|
CIM_PhysicalElement REF Dependent;
|
|
};
|
|
|
|
[abstract, Description (
|
|
"The CIM_PhysicalConnector class represents any physical element "
|
|
"that is used to connect to other elements. Any object that "
|
|
"can be used to connect and transmit signals or power between "
|
|
"two or more physical elements is a descendant (or member) "
|
|
"of this class. For example, slots and D-shell connectors are "
|
|
"types of physical connectors."),
|
|
Locale (0x409), UUID ("{FAF76B84-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PhysicalConnector : CIM_PhysicalElement
|
|
{
|
|
[Description (
|
|
"A free-form string describing the pin configuration and "
|
|
"signal usage of a physical connector."),
|
|
read ]
|
|
string ConnectorPinout;
|
|
[Description (
|
|
"An array of integers defining the type of physical connector. "
|
|
"An array is specified to allow the description of "
|
|
"'combinations' of connector information. For example, one "
|
|
"array entry could specify RS-232 (value=25), another DB-25 "
|
|
"(value=23) and a third entry define the connector as \"Male\" "
|
|
"(value=2)."),
|
|
Values {"Unknown", "Other", "Male", "Female", "Shielded",
|
|
"Unshielded", "SCSI (A) High-Density (50 pins)",
|
|
"SCSI (A) Low-Density (50 pins)",
|
|
"SCSI (P) High-Density (68 pins)", "SCSI SCA-I (80 pins)",
|
|
"SCSI SCA-II (80 pins)",
|
|
"SCSI Fibre Channel (DB-9, Copper)",
|
|
"SCSI Fibre Channel (Fibre)",
|
|
"SCSI Fibre Channel SCA-II (40 pins)",
|
|
"SCSI Fibre Channel SCA-II (20 pins)",
|
|
"SCSI Fibre Channel BNC",
|
|
"ATA 3-1/2 Inch (40 pins)", "ATA 2-1/2 Inch (44 pins)",
|
|
"ATA-2", "ATA-3", "ATA/66", "DB-9", "DB-15", "DB-25",
|
|
"DB-36", "RS-232C", "RS-422", "RS-423", "RS-485", "RS-449",
|
|
"V.35", "X.21", "IEEE-488", "AUI", "UTP Category 3",
|
|
"UTP Category 4", "UTP Category 5", "BNC", "RJ11", "RJ45",
|
|
"Fiber MIC", "Apple AUI", "Apple GeoPort", "PCI", "ISA",
|
|
"EISA", "VESA", "PCMCIA", "PCMCIA Type I",
|
|
"PCMCIA Type II", "PCMCIA Type III", "ZV Port", "CardBus",
|
|
"USB", "IEEE 1394", "HIPPI", "HSSDC (6 pins)", "GBIC",
|
|
"DIN", "Mini-DIN", "Micro-DIN", "PS/2", "Infrared",
|
|
"HP-HIL", "Access.bus", "NuBus", "Centronics",
|
|
"Mini-Centronics", "Mini-Centronics Type-14",
|
|
"Mini-Centronics Type-20", "Mini-Centronics Type-26",
|
|
"Bus Mouse", "ADB", "AGP", "VME Bus", "VME64",
|
|
"Proprietary", "Proprietary Processor Card Slot",
|
|
"Proprietary Memory Card Slot", "Proprietary I/O Riser Slot",
|
|
"PCI-66MHZ", "AGP2X", "AGP4X", "PC-98", "PC-98-Hireso",
|
|
"PC-H98", "PC-98Note", "PC-98Full", "SSA SCSI",
|
|
"Circular", "On Board IDE Connector",
|
|
"On Board Floppy Connector", "9 Pin Dual Inline",
|
|
"25 Pin Dual Inline", "50 Pin Dual Inline",
|
|
"68 Pin Dual Inline", "On Board Sound Connector",
|
|
"Mini-jack", "PCI-X", "Sbus IEEE 1396-1993 32 bit",
|
|
"Sbus IEEE 1396-1993 64 bit", "MCA", "GIO", "XIO",
|
|
"HIO", "NGIO", "PMC", "MTRJ", "VF-45", "Future I/O",
|
|
"SC", "SG", "Electrical", "Optical", "Ribbon", "GLM",
|
|
"1x9", "Mini SG", "LC", "HSSC","VHDCI Shielded (68 pins)",
|
|
"InfiniBand"},
|
|
read ]
|
|
uint16 ConnectorType[];
|
|
};
|
|
|
|
[Abstract, Description ("The CIM_ConnectedTo association indicates that two or "
|
|
"more physical connectors are connected together."),
|
|
Locale (0x409), UUID ("{FAF76B85-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_ConnectedTo : CIM_Dependency
|
|
{
|
|
[Override ("Antecedent") , read, Description (
|
|
"The Antecedent represents a physical connector "
|
|
"that serves as one end of the connection.")
|
|
]
|
|
CIM_PhysicalConnector REF Antecedent;
|
|
[Override ("Dependent") , read, Description (
|
|
"The Dependent represents another physical connector "
|
|
"that serves as the other end of the connection.")
|
|
]
|
|
CIM_PhysicalConnector REF Dependent;
|
|
};
|
|
|
|
[abstract, Description (
|
|
"The Slot class represents Connectors into which Packages are "
|
|
"inserted. For example, a PhysicalPackage that is a DiskDrive "
|
|
"may be inserted into an SCA 'Slot'. As another example, "
|
|
"a Card (subclass of PhysicalPackage) may be inserted into "
|
|
"a 16-, 32-, or 64-bit expansion 'Slot' on a HostingBoard. "
|
|
"PCI or PCMCIA Type III Slots are examples of the latter."),
|
|
Locale (0x409), UUID ("{FAF76B86-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_Slot : CIM_PhysicalConnector
|
|
{
|
|
[Override ("ConnectorType") , read,
|
|
MappingStrings {"MIF.DMTF|System Slot|004.2"}
|
|
]
|
|
uint16 ConnectorType[];
|
|
[Description (
|
|
"Boolean indicating whether the slot supports hot-plug of "
|
|
"adapter cards."),
|
|
read ]
|
|
boolean SupportsHotPlug;
|
|
[Description (
|
|
"Maximum height of an adapter card that can be inserted into "
|
|
"the slot, in inches."),
|
|
Units ("Inches"),
|
|
read ]
|
|
real32 HeightAllowed;
|
|
[Description (
|
|
"Maximum length of an adapter card that can be inserted into "
|
|
"the slot, in inches."),
|
|
Units ("Inches"),
|
|
read ]
|
|
real32 LengthAllowed;
|
|
[Description (
|
|
"Maximum bus width of adapter cards that can be inserted into "
|
|
"this slot, in bits."),
|
|
Units ("Bits"),
|
|
Values {"8", "16", "32", "64", "128"},
|
|
MappingStrings {"MIF.DMTF|System Slot|004.3"} ,
|
|
read ]
|
|
uint16 MaxDataWidth;
|
|
[Description (
|
|
"An array of enumerated integers indicating the Vcc voltage "
|
|
"supported by this slot."),
|
|
Values {"Unknown", "Other", "3.3V", "5V"},
|
|
MappingStrings {"MIF.DMTF|System Slot|004.9"} ,
|
|
read ]
|
|
uint16 VccMixedVoltageSupport[];
|
|
[Description (
|
|
"An array of enumerated integers indicating the Vpp voltage "
|
|
"supported by this slot."),
|
|
Values {"Unknown", "Other", "3.3V", "5V", "12V"},
|
|
MappingStrings {"MIF.DMTF|System Slot|004.10"} ,
|
|
read]
|
|
uint16 VppMixedVoltageSupport[];
|
|
[Description (
|
|
"Maximum thermal dissipation of the slot in Milliwatts."),
|
|
Units ("MilliWatts"),
|
|
MappingStrings {"MIF.DMTF|System Slot|004.11"} ,
|
|
read ]
|
|
uint32 ThermalRating;
|
|
[Description (
|
|
"Boolean indicating that this slot is physically unique "
|
|
"and may hold special types of hardware, e.g. a graphics "
|
|
"processor slot. If set to TRUE, then the property, "
|
|
"PurposeDescription property (a string), should specify the nature of "
|
|
"the uniqueness or purpose of the slot."),
|
|
ModelCorrespondence {"CIM_Slot.PurposeDescription"} ,
|
|
read ]
|
|
boolean SpecialPurpose;
|
|
[Description ("A free-form string describing that this slot is "
|
|
"physically unique and may hold special types of hardware. "
|
|
"This property only has meaning when the corresponding "
|
|
"boolean property, SpecialPurpose, is set to TRUE."),
|
|
ModelCorrespondence {"CIM_Slot.SpecialPurpose"} ,
|
|
read ]
|
|
string PurposeDescription;
|
|
[Description ("The Number property indicates the physical slot "
|
|
"number, which can be used as an index into a system "
|
|
"slot table, whether or not that slot is physically occupied."),
|
|
read ]
|
|
uint16 Number;
|
|
};
|
|
|
|
[Abstract, Description ("Slots are special types of connectors into which "
|
|
"adapter cards are typically inserted. The CIM_SlotInSlot "
|
|
"relationship represents the ability of a special adapter to "
|
|
"extend the existing slot structure to enable otherwise "
|
|
"incompatible cards to be plugged into a frame or hosting "
|
|
"board. The adapter effectively creates a new slot and can "
|
|
"be thought of (conceptually) as a slot in a slot. This "
|
|
"enables cards that would otherwise be physically and/or "
|
|
"electrically incompatible with the existing slots to be "
|
|
"supported, by interfacing to the slot provided by the "
|
|
"adapter. This has many practical uses. For example, "
|
|
"networking boards are very expensive. As new hardware "
|
|
"becomes available, chassis and even card configurations "
|
|
"change. To protect the investment of their customers, "
|
|
"networking vendors will manufacture special adapters "
|
|
"that enable old cards to fit into new chassis or Hosting"
|
|
"Boards and/or new cards to fit into old. This is done using "
|
|
"a special adapter that fits over one or more existing slots "
|
|
"and presents a new slot into which the card can plug."),
|
|
Locale (0x409), UUID ("{FAF76B87-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_SlotInSlot : CIM_ConnectedTo
|
|
{
|
|
[Override ("Antecedent") , Description (
|
|
"The Antecedent reference represents the existing slot(s) "
|
|
"of the hosting board, or frame that are being adapted "
|
|
"to accommodate a card that would otherwise not be "
|
|
"physically and/or electrically compatible with it."),
|
|
read ]
|
|
CIM_Slot REF Antecedent;
|
|
[Override ("Dependent") , read,
|
|
Max (1), Description (
|
|
"The new slot provided by the adapter board.")
|
|
]
|
|
CIM_Slot REF Dependent;
|
|
};
|
|
|
|
[Abstract,Association, Description ("CIM_AdjacentSlots describes the layout of slots on a "
|
|
"hosting board or adapter card. Information like the distance "
|
|
"between the slots and whether they are 'shared' (if one is "
|
|
"populated, then the other slot can not be used), is conveyed "
|
|
"as properties of the association."),
|
|
Locale (0x409), UUID ("{FAF76B88-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_AdjacentSlots
|
|
{
|
|
[Description ("One of the adjacent slots."), read]
|
|
CIM_Slot REF SlotA;
|
|
[Description ("The 'other' adjacent slot."), read]
|
|
CIM_Slot REF SlotB;
|
|
[Description ("The distance, in inches, between adjacent slots."),
|
|
Units ("Inches"),
|
|
read ]
|
|
real32 DistanceBetweenSlots;
|
|
[Description ("Slots can be located in close proximity on hosting"
|
|
"boards or other cards, such that if one of these slots is "
|
|
"populated by an adapter card, the other slot must be left "
|
|
"empty. This relationship is indicated by the SharedSlots "
|
|
"boolean set to TRUE."), read]
|
|
boolean SharedSlots;
|
|
};
|
|
|
|
[Abstract, Description ("Complex networking devices often are chassis-based. "
|
|
"These chassis allow for enhancement and/or augmentation of "
|
|
"their base functionality by accepting additional chassis "
|
|
"devices, similar to accepting functionality in the form of "
|
|
"adding cards. This association models this capability."),
|
|
Locale (0x409), UUID ("{FAF76B89-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PackageInSlot : CIM_Dependency
|
|
{
|
|
[Override ("Antecedent") , read, Description (
|
|
"The slot into which the physical package is inserted.")
|
|
]
|
|
CIM_Slot REF Antecedent;
|
|
[Override ("Dependent") , read,
|
|
Max (1), Description (
|
|
"The package in the slot.")
|
|
]
|
|
CIM_PhysicalPackage REF Dependent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Slots are special types of connectors into which adapter "
|
|
"cards are inserted. This relationship of a card in a slot "
|
|
"is made explicit using the CIM_CardInSlot association."),
|
|
MappingStrings {"MIF.DMTF|System Slot|004.4"} ,
|
|
Locale (0x409), UUID ("{FAF76B8A-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_CardInSlot : CIM_PackageInSlot
|
|
{
|
|
[Override ("Antecedent") , read, Description (
|
|
"The slot into which the card is inserted.")
|
|
]
|
|
CIM_Slot REF Antecedent;
|
|
[Override ("Dependent") , read,
|
|
Max (1) , Description ("The card in the slot.")]
|
|
CIM_Card REF Dependent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Cables and links utilize physical connectors to actually "
|
|
"'connect' physical elements. This association explicitly "
|
|
"defines this relationship of connectors for CIM_PhysicalLink."),
|
|
Locale (0x409), UUID ("{FAF76B8B-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_LinkHasConnector : CIM_Component
|
|
{
|
|
[Override ("GroupComponent") , read, Max (1), Description (
|
|
"The physical link that has a connector.")
|
|
]
|
|
CIM_PhysicalLink REF GroupComponent;
|
|
[Override ("PartComponent") , read, Description (
|
|
"The physical connector.")
|
|
]
|
|
CIM_PhysicalConnector REF PartComponent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Physical packages contain connectors as well as other "
|
|
"physical elements. The CIM_ConnectorOnPackage association makes "
|
|
"explicit the containment relationship between connectors and "
|
|
"packages."),
|
|
Locale (0x409), UUID ("{FAF76B8C-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_ConnectorOnPackage : CIM_Container
|
|
{
|
|
[Override ("GroupComponent") , read, Max (1), Description (
|
|
"The physical package that has a connector.")
|
|
]
|
|
CIM_PhysicalPackage REF GroupComponent;
|
|
[Override ("PartComponent") , read, Description (
|
|
"The physical connector.")
|
|
]
|
|
CIM_PhysicalConnector REF PartComponent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Similar to the way that logical devices are 'Realized' by "
|
|
"physical elements, unitary computer systems are realized in "
|
|
"one or more physical packages. The CIM_ComputerSystemPackage "
|
|
"association explicitly defines this relationship."),
|
|
Locale (0x409), UUID ("{FAF76B8D-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_ComputerSystemPackage : CIM_Dependency
|
|
{
|
|
[Override ("Antecedent") , read, Description (
|
|
"The physical package(s) that realize a unitary computer system.")
|
|
]
|
|
CIM_PhysicalPackage REF Antecedent;
|
|
[Override ("Dependent") , read, Description (
|
|
"The unitary computer system.")
|
|
]
|
|
CIM_UnitaryComputerSystem REF Dependent;
|
|
};
|
|
|
|
[Abstract, Description (
|
|
"Often, a cooling device is installed in a package such as "
|
|
"a chassis or a rack, not for a specific device, but to assist "
|
|
"in the cooling of the package in general. This relationship "
|
|
"is described by the CIM_PackageCooling association."),
|
|
Locale (0x409), UUID ("{FAF76B8E-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PackageCooling : CIM_Dependency
|
|
{
|
|
[Override ("Antecedent") , read, Description (
|
|
"The cooling device for the package.")
|
|
]
|
|
CIM_CoolingDevice REF Antecedent;
|
|
[Override ("Dependent") , read, Description (
|
|
"The physical package whose environment is cooled.")
|
|
]
|
|
CIM_PhysicalPackage REF Dependent;
|
|
};
|
|
|
|
[Abstract,Aggregation, Description (
|
|
"Often, a temperature sensor is installed in a package such as "
|
|
"a chassis or a rack, not to measure any particular device, but "
|
|
"the package's environment in general. This relationship is "
|
|
"described by the CIM_PackageTempSensor association."),
|
|
Locale (0x409), UUID ("{FAF76B8F-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PackageTempSensor : CIM_Dependency
|
|
{
|
|
[Override ("Antecedent") , read, Description (
|
|
"The temperature sensor for the package.")
|
|
]
|
|
CIM_TemperatureSensor REF Antecedent;
|
|
[Override ("Dependent") , read, Description (
|
|
"The physical package whose environment is monitored.")
|
|
]
|
|
CIM_PhysicalPackage REF Dependent;
|
|
};
|
|
|
|
[Abstract,Aggregation, Description (
|
|
"Often, an alarm device is installed as part of a package, "
|
|
"not to indicate issues with any particular logical device "
|
|
"or physical component, but with the package's environment "
|
|
"in general, its security state or its overall health. "
|
|
"This relationship is described by the CIM_PackageAlarm "
|
|
"association. "),
|
|
Locale (0x409), UUID ("{FAF76B90-798C-11D2-AAD1-006008C78BC7}") ]
|
|
class CIM_PackageAlarm : CIM_Dependency
|
|
{
|
|
[Override ("Antecedent") , read, Description (
|
|
"The alarm device for the package. ")
|
|
]
|
|
CIM_AlarmDevice REF Antecedent;
|
|
[Override ("Dependent") , read, Description (
|
|
"The physical package whose health, security, environment, "
|
|
"etc. is alarmed. ")
|
|
]
|
|
CIM_PhysicalPackage REF Dependent;
|
|
};
|
|
|
|
[Abstract,Association, Locale ( 0x409 ) , UUID ( "{64C1726E-DB21-11d2-85FC-0000F8102E5F}" ), Description(
|
|
"The CIM_ActsAsSpare association indicates which elements can spare "
|
|
"or replace the other aggregated elements. The fact that a spare "
|
|
"can operate in \"hot standby\" mode is specified on an element "
|
|
"by element basis.")]
|
|
class CIM_ActsAsSpare
|
|
{
|
|
[Read: ToSubClass,
|
|
Description("The Group reference represents the CIM_SpareGroup.")]
|
|
CIM_SpareGroup Ref Group;
|
|
[Read: ToSubClass,
|
|
Description("HotStandby property is a boolean indicating that the spare is operating "
|
|
"as a hot standby.")]
|
|
BOOLEAN HotStandby;
|
|
[Read: ToSubClass,
|
|
Description("A managed system element acting as a spare and participating in "
|
|
"the spare group.")]
|
|
CIM_ManagedSystemElement Ref Spare;
|
|
|
|
};
|
|
|
|
[Abstract,Locale ( 0x409 ) , UUID ( "{2F648FBA-DB22-11d2-85FC-0000F8102E5F}" ),
|
|
Association, Description(
|
|
"CIM_CompatibleProduct is an association between products that "
|
|
"can indicate a wide variety of information. For example, it can "
|
|
"indicate that the two referenced products interoperate, that "
|
|
"they can be installed together, that one can be the physical "
|
|
"container for the other, etc. The string property, CompatibilityDescription, "
|
|
"defines how the products interoperate or are compatible, any "
|
|
"limitations regarding interoperability or installation, ...")]
|
|
class CIM_CompatibleProduct
|
|
{
|
|
[read, Description("CompatibilityDescription is a free-form string defining how the "
|
|
"two referenced products interoperate or are compatible, any limitations "
|
|
"to compatibility, etc.")]
|
|
STRING CompatibilityDescription;
|
|
[read, Description("The compatible product.")]
|
|
CIM_Product Ref CompatibleProduct;
|
|
[read, Description("The product for which compatible offerings are defined.")]
|
|
CIM_Product Ref Product;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{A2ABF536-DB35-11d2-85FC-0000F8102E5F}" ),
|
|
Description("The CIM_CollectionOfSensors association indicates the binary sensors "
|
|
"that make up the multi-state sensor.")]
|
|
class CIM_CollectionOfSensors: CIM_Component
|
|
{
|
|
[read, Description("The multi-state sensor."),
|
|
Max(1),
|
|
Override("GroupComponent")]
|
|
CIM_MultiStateSensor Ref GroupComponent;
|
|
[read, Description("A binary sensor that is part of the multi-state sensor."),
|
|
Min(2),
|
|
Override("PartComponent")]
|
|
CIM_BinarySensor Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{4A626026-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("A link between the file system and the logical file(s) addressed "
|
|
"through this file system.")]
|
|
class CIM_FileStorage: CIM_Component
|
|
{
|
|
[read, Description("The file system."),
|
|
Max(1),
|
|
Min(1),
|
|
Override("GroupComponent")]
|
|
CIM_FileSystem Ref GroupComponent;
|
|
[read, Description("The logical file stored in the context of the file system."),
|
|
Override("PartComponent"),
|
|
Weak]
|
|
CIM_LogicalFile Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{96B4C734-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("Indicates the software features that make up the operating system. "
|
|
"The software features can be part of different products.")]
|
|
class CIM_OperatingSystemSoftwareFeature: CIM_Component
|
|
{
|
|
[read, Description("The operating system."),
|
|
Override("GroupComponent")]
|
|
CIM_OperatingSystem Ref GroupComponent;
|
|
[read, Description("The software features that make up the operating system."),
|
|
Override("PartComponent")]
|
|
CIM_SoftwareFeature Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{A361A7AE-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("A link between the operating system and one or more processes running in "
|
|
"the context of this operating system.")]
|
|
class CIM_OSProcess: CIM_Component
|
|
{
|
|
[read, Description("The operating system."),
|
|
Max(1),
|
|
Min(1),
|
|
Override("GroupComponent")]
|
|
CIM_OperatingSystem Ref GroupComponent;
|
|
[read, Description("The process running in the context of the operating system"),
|
|
Override("PartComponent"),
|
|
Weak]
|
|
CIM_Process Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{B7E6042C-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("A link between a process and the thread(s) running in the context "
|
|
"of this process.")]
|
|
class CIM_ProcessThread: CIM_Component
|
|
{
|
|
[read, Description("The process."),
|
|
Max(1),
|
|
Min(1),
|
|
Override("GroupComponent")]
|
|
CIM_Process Ref GroupComponent;
|
|
[read, Description("The thread running in the context of the process."),
|
|
Override("PartComponent"),
|
|
Weak]
|
|
CIM_Thread Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{FB9D6E62-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("The CIM_RedundancyComponent class associates a redundancy "
|
|
"group composed of managed system elements and indicates "
|
|
"that these elements, taken together, provide redundancy. All "
|
|
"elements aggregated in a redundancy group should be instantiations "
|
|
"of the same object class.")]
|
|
class CIM_RedundancyComponent: CIM_Component
|
|
{
|
|
[read, Description("The CIM_RedundancyComponent association indicates that 'this set "
|
|
"of fans' or 'these physical extents' participate in a single "
|
|
"redundancy group."),
|
|
Override("GroupComponent")]
|
|
CIM_RedundancyGroup Ref GroupComponent;
|
|
[read]
|
|
CIM_ManagedSystemElement Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{154E66D8-DB35-11d2-85FC-0000F8102E5F}" ),
|
|
Description("Describes the aggregate physical extent in a storage redundancy group.")]
|
|
class CIM_AggregateRedundancyComponent: CIM_RedundancyComponent
|
|
{
|
|
[read, Description("The storage redundancy group."),
|
|
Override("GroupComponent")]
|
|
CIM_StorageRedundancyGroup Ref GroupComponent;
|
|
[read, Description("The aggregate physical extent participating in the redundancy group."),
|
|
Override("PartComponent")]
|
|
CIM_AggregatePExtent Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{AD3C1FA2-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("Describes the physical extents participating in a storage redundancy group.")]
|
|
class CIM_PExtentRedundancyComponent: CIM_RedundancyComponent
|
|
{
|
|
[read, Description("The storage redundancy group."),
|
|
Override("GroupComponent")]
|
|
CIM_StorageRedundancyGroup Ref GroupComponent;
|
|
[read, Description("The physical extent participating in the redundancy group."),
|
|
Override("PartComponent")]
|
|
CIM_PhysicalExtent Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{9B81340A-E3D3-11d2-8601-0000F8102E5F}" ),
|
|
Description("An association between a computer system and the system resources "
|
|
"available on it.")]
|
|
class CIM_ComputerSystemResource: CIM_SystemComponent
|
|
{
|
|
[read, Description("The computer system."),
|
|
Max(1),
|
|
Min(1),
|
|
Override("GroupComponent")]
|
|
CIM_ComputerSystem Ref GroupComponent;
|
|
[read, Description("A system resource of the computer system."),
|
|
Override("PartComponent")]
|
|
CIM_SystemResource Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{9B81340B-E3D3-11d2-8601-0000F8102E5F}" ),
|
|
Description("An association between a computer system and the DMA channels "
|
|
"available on it.")]
|
|
class CIM_ComputerSystemDMA: CIM_ComputerSystemResource
|
|
{
|
|
[read, Override("GroupComponent")]
|
|
CIM_ComputerSystem Ref GroupComponent;
|
|
[read, Description("A DMA channel of the computer system."),
|
|
Override("PartComponent"),
|
|
Weak]
|
|
CIM_DMA Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{A2EFC896-E3D3-11d2-8601-0000F8102E5F}" ),
|
|
Description("An association between a computer system and the IRQs available "
|
|
"on it.")]
|
|
class CIM_ComputerSystemIRQ: CIM_ComputerSystemResource
|
|
{
|
|
[read]
|
|
CIM_ComputerSystem Ref GroupComponent;
|
|
[read, Description("An IRQ of the computer system."),
|
|
Override("PartComponent"),
|
|
Weak]
|
|
CIM_IRQ Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{A2EFC897-E3D3-11d2-8601-0000F8102E5F}" ),
|
|
Description("An association between a computer system and the memory mapped "
|
|
"I/O ports available on it.")]
|
|
class CIM_ComputerSystemMappedIO: CIM_ComputerSystemResource
|
|
{
|
|
[read]
|
|
CIM_ComputerSystem Ref GroupComponent;
|
|
[read, Description("A memory mapped I/O port of the computer system."),
|
|
Override("PartComponent"),
|
|
Weak]
|
|
CIM_MemoryMappedIO Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{A2EFC898-E3D3-11d2-8601-0000F8102E5F}" ),
|
|
Description("A link between the computer system and the file system(s) hosted "
|
|
"on this computer system.")]
|
|
class CIM_HostedFileSystem: CIM_SystemComponent
|
|
{
|
|
[read, Description("The computer system."),
|
|
Max(1),
|
|
Min(1),
|
|
Override("GroupComponent")]
|
|
CIM_ComputerSystem Ref GroupComponent;
|
|
[read, Description("The file system owned by the computer system."),
|
|
Override("PartComponent"),
|
|
Weak]
|
|
CIM_FileSystem Ref PartComponent;
|
|
|
|
};
|
|
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{4C51D7AE-DB22-11d2-85FC-0000F8102E5F}" ),
|
|
Description("The Configuration object allows the grouping of sets of parameters "
|
|
"(defined in CIM_Setting objects) and dependencies for one or more "
|
|
"managed system elements. The Configuration object represents a "
|
|
"certain behavior, or a desired functional state for the managed system elements. "
|
|
"The desired functional state is typically driven by external "
|
|
"requirements such as time or location. For example, to connect "
|
|
"to a mail system from 'home', a dependency on a modem exists, "
|
|
"but a dependency on a network adapter exists at 'work'. Settings "
|
|
"for the pertinent logical devices (in this example, POTS modem "
|
|
"and network adapter) can be defined and aggregated by CIM_Configuration. "
|
|
"Therefore, two 'Connect to Mail' configurations may be defined "
|
|
"grouping the relevant dependencies and CIM_Setting objects.")]
|
|
class CIM_Configuration
|
|
{
|
|
[read, Description("A short textual description (one-line string) of the CIM_Configuration "
|
|
"object."),
|
|
MaxLen(64)]
|
|
STRING Caption;
|
|
[read, Description("A textual description of the CIM_Configuration object.")]
|
|
STRING Description;
|
|
[read, Description("The label by which the CIM_Configuration object is known."),
|
|
Key,
|
|
MaxLen(256)]
|
|
STRING Name;
|
|
|
|
};
|
|
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{2280CB02-DB35-11d2-85FC-0000F8102E5F}" ),
|
|
Description("Logical devices may have one or more alarm devices associated with "
|
|
"them, in order to indicate problem situations. This relationship "
|
|
"is indicated by the CIM_AssociatedAlarm dependency. ")]
|
|
class CIM_AssociatedAlarm: CIM_Dependency
|
|
{
|
|
[read, Description("The alarm device. "),
|
|
Override("Antecedent")]
|
|
CIM_AlarmDevice Ref Antecedent;
|
|
[read, Description("The logical device that is alarmed. "),
|
|
Override("Dependent")]
|
|
CIM_LogicalDevice Ref Dependent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{306F88F2-DB35-11d2-85FC-0000F8102E5F}" ),
|
|
Description("Many devices, such as processors or power supplies, require their "
|
|
"own cooling devices. This association indicates where fans or "
|
|
"other cooling devices are specific to a device, versus providing "
|
|
"enclosure or cabinet cooling.")]
|
|
class CIM_AssociatedCooling: CIM_Dependency
|
|
{
|
|
[read, Description("The cooling device."),
|
|
Override("Antecedent")]
|
|
CIM_CoolingDevice Ref Antecedent;
|
|
[read, Description("The logical device being cooled."),
|
|
Override("Dependent")]
|
|
CIM_LogicalDevice Ref Dependent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{29B273F2-E3D3-11d2-8601-0000F8102E5F}" ),
|
|
Description("A power supply may have an associated current sensor, monitoring "
|
|
"its input frequency. This is described by this association.")]
|
|
class CIM_AssociatedSupplyCurrentSensor: CIM_AssociatedSensor
|
|
{
|
|
[read, Description("The current sensor."),
|
|
Override("Antecedent")]
|
|
CIM_CurrentSensor Ref Antecedent;
|
|
[read, Description("The power supply associated with the current sensor."),
|
|
Override("Dependent")]
|
|
CIM_PowerSupply Ref Dependent;
|
|
[read, Description("Indicates the power supply's input frequency range measured by "
|
|
"the associated sensor. Range 1, 2 or both can be specified using "
|
|
"the values 2, 3 or 4, respectively."),
|
|
Values{"Unknown", "Other", "Range 1", "Range 2", "Both Range 1 and 2"}]
|
|
UINT16 MonitoringRange;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{327ABD78-E3D3-11d2-8601-0000F8102E5F}" ),
|
|
Description("A power supply may have an associated voltage sensor, monitoring "
|
|
"its input voltage. This is described by this association.")]
|
|
class CIM_AssociatedSupplyVoltageSensor: CIM_AssociatedSensor
|
|
{
|
|
[read, Description("The voltage sensor."),
|
|
Override("Antecedent")]
|
|
CIM_VoltageSensor Ref Antecedent;
|
|
[read, Description("The power supply associated with the voltage sensor."),
|
|
Override("Dependent")]
|
|
CIM_PowerSupply Ref Dependent;
|
|
[read, Description("Indicates the power supply's input voltage range measured by the "
|
|
"associated sensor. Range 1, 2 or both can be specified using "
|
|
"the values 2, 3 or 4, respectively."),
|
|
Values{"Unknown", "Other", "Range 1", "Range 2", "Both Range 1 and 2"}]
|
|
UINT16 MonitoringRange;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{3A608798-E3D3-11d2-8601-0000F8102E5F}" ),
|
|
Description("LogicalDisks can be BasedOn a single Volume (for example, "
|
|
"exposed by a software volume manager), or be BasedOn a Disk"
|
|
"Partition directly. The former relationship is made explicit "
|
|
"in this association.")]
|
|
class CIM_LogicalDiskBasedOnVolumeSet: CIM_BasedOn
|
|
{
|
|
[read, Description("The volume set."),
|
|
Max(1),
|
|
Override("Antecedent")]
|
|
CIM_VolumeSet Ref Antecedent;
|
|
[read, Description("The logical disk which is built on the volume set."),
|
|
Override("Dependent")]
|
|
CIM_LogicalDisk Ref Dependent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{451FE14C-E3D3-11d2-8601-0000F8102E5F}" ),
|
|
Description("Protected space extents are based on a physical extent. This relationship "
|
|
"is made explicit in this association.")]
|
|
class CIM_PSExtentBasedOnPExtent: CIM_BasedOn
|
|
{
|
|
[read, Description("The physical extent."),
|
|
Max(1),
|
|
Override("Antecedent")]
|
|
CIM_PhysicalExtent Ref Antecedent;
|
|
[read, Description("The protected space extent which is built on the physical extent."),
|
|
Override("Dependent")]
|
|
CIM_ProtectedSpaceExtent Ref Dependent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{524ED194-DB35-11d2-85FC-0000F8102E5F}" ),
|
|
Description("A link between BIOS element and non-volatile storage where the BIOS "
|
|
"is loaded.")]
|
|
class CIM_BIOSLoadedInNV: CIM_Dependency
|
|
{
|
|
[read, Description("The non-volatile storage."),
|
|
Override("Antecedent")]
|
|
CIM_NonVolatileStorage Ref Antecedent;
|
|
[read, Description("The BIOS stored in the non-volatile extent."),
|
|
Override("Dependent")]
|
|
CIM_BIOSElement Ref Dependent;
|
|
[read, Description("The ending address where the BIOS is located in non-volatile "
|
|
"storage.")]
|
|
UINT64 EndingAddress;
|
|
[read, Description("The starting address where the BIOS is located in non-volatile "
|
|
"storage.")]
|
|
UINT64 StartingAddress;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{5F5B101E-DB35-11d2-85FC-0000F8102E5F}" ),
|
|
Description("A link between the operating system and the file system(s) from "
|
|
"which this operating system is loaded. The association is many-to-many "
|
|
"since a distributed OS could depend on several file systems in "
|
|
"order to correctly and completely load.")]
|
|
class CIM_BootOSFromFS: CIM_Dependency
|
|
{
|
|
[read, Description("The file system from which the operating system is loaded."),
|
|
Override("Antecedent")]
|
|
CIM_FileSystem Ref Antecedent;
|
|
[read, Description("The operating system."),
|
|
Override("Dependent")]
|
|
CIM_OperatingSystem Ref Dependent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{05D1FFF2-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("Specifies the logical device that is associated with, and accessed "
|
|
"using the referenced CIM_DeviceFile.")]
|
|
class CIM_DeviceAccessedByFile: CIM_Dependency
|
|
{
|
|
[read, Description("The device file."),
|
|
Override("Antecedent")]
|
|
CIM_DeviceFile Ref Antecedent;
|
|
[read, Description("The device that is accessed using the device file."),
|
|
Max(1),
|
|
Override("Dependent")]
|
|
CIM_LogicalDevice Ref Dependent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{7CE7448E-E3D4-11d2-8601-0000F8102E5F}" ),
|
|
Description("CIM_SCSIInterface is a CIM_ControlledBy relationship indicating which "
|
|
"devices are accessed through a SCSI controller and the characteristics "
|
|
"of this access.")]
|
|
class CIM_SCSIInterface: CIM_ControlledBy
|
|
{
|
|
[read, Description("The SCSI controller."),
|
|
Override("Antecedent")]
|
|
CIM_SCSIController Ref Antecedent;
|
|
[read, Override ("Dependent"), Description ("The logical device.")]
|
|
CIM_LogicalDevice Ref Dependent;
|
|
[read, Description("Number of SCSI retries that have occurred since last hard "
|
|
"or soft reset related to the controlled Device. The time of "
|
|
"last reset is indicated in the TimeOfDeviceReset property, "
|
|
"inherited from the ControlledBy association.")]
|
|
UINT32 SCSIRetries;
|
|
[read, Description("Number of SCSI timeouts that have occurred since last hard "
|
|
"or soft reset related to the controlled Device. The time of "
|
|
"last reset is indicated in the TimeOfDeviceReset property, "
|
|
"inherited from the ControlledBy association.")]
|
|
UINT32 SCSITimeouts;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{8B309BDA-E3D4-11d2-8601-0000F8102E5F}" ),
|
|
Description("CIM_SerialInterface is a CIM_ControlledBy relationship indicating which "
|
|
"devices are accessed through the serial controller and the characteristics "
|
|
"of this access.")]
|
|
class CIM_SerialInterface: CIM_ControlledBy
|
|
{
|
|
[read, Description("The serial controller."),
|
|
Override("Antecedent")]
|
|
CIM_SerialController Ref Antecedent;
|
|
[read, Override ("Dependent"), Description ("The logical device.")]
|
|
CIM_LogicalDevice Ref Dependent;
|
|
[read, Description("An integer enumeration indicating the flow control (Xon-Xoff "
|
|
"and/or RTS/CTS) for transmitted data."),
|
|
Values{"Unknown", "Not Supported", "None", "XonXoff", "RTS/CTS",
|
|
"Both XonXoff and RTS/CTS"}]
|
|
UINT16 FlowControlInfo;
|
|
[read, Description("Number of stop bits to be transmitted."),
|
|
Units("Bits")]
|
|
UINT16 NumberOfStopBits;
|
|
[read, Description("Information on the parity setting for transmitted data. No parity "
|
|
"(value=1), even (2) or odd (3) can be specified."),
|
|
Values{"Unknown", "None", "Even", "Odd"}]
|
|
UINT16 ParityInfo;
|
|
|
|
};
|
|
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{290FC242-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("An association between a service and how it is implemented. The "
|
|
"cardinality of this association is many-to-many. A service may "
|
|
"be provided by more than one logical device, operating in conjunction. "
|
|
" And, any device may provide more than one service. When multiple "
|
|
"devices are associated with a single service, it is assumed that "
|
|
"these elements operate in conjunction to provide the service. "
|
|
" If different implementations of a service exist, each of these "
|
|
"implementations would result in individual instantiations of "
|
|
"the service object. These individual instantiations would then "
|
|
"have associations to the unique implementations.")]
|
|
class CIM_DeviceServiceImplementation: CIM_Dependency
|
|
{
|
|
[read, Description("The logical device."),
|
|
Override("Antecedent")]
|
|
CIM_LogicalDevice Ref Antecedent;
|
|
[read, Description("The service implemented using the logical device."),
|
|
Override("Dependent")]
|
|
CIM_Service Ref Dependent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{36363AAA-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("The CIM_DeviceSoftware relationship identifies any software that "
|
|
"is associated with a device - such as drivers, configuration "
|
|
"or application software, or firmware.")]
|
|
class CIM_DeviceSoftware: CIM_Dependency
|
|
{
|
|
[read, Description("The software element."),
|
|
Override("Antecedent")]
|
|
CIM_SoftwareElement Ref Antecedent;
|
|
[read, Description("The logical device that requires or uses the software."),
|
|
Override("Dependent")]
|
|
CIM_LogicalDevice Ref Dependent;
|
|
[read, Description("An enumerated integer to indicate the role this software plays "
|
|
"in regards to its associated device. For example, this software "
|
|
"could be instrumentation (value=5) or firmware (6)."),
|
|
ModelCorrespondence{"CIM_DeviceSoftware.PurposeDescription"},
|
|
Values{"Unknown", "Other", "Driver", "Configuration Software", "Application Software",
|
|
"Instrumentation", "Firmware",
|
|
"BIOS", "Boot ROM"}]
|
|
UINT16 Purpose;
|
|
[read, Description("A free-form string to provide more information for the Purpose "
|
|
"property, e.g. \"Application Software\"."),
|
|
ModelCorrespondence{"CIM_DeviceSoftware.Purpose"}]
|
|
STRING PurposeDescription;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{576C3C56-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description (
|
|
"CIM_HostedAccessPoint is an association between a service"
|
|
"access point and the system on which it is provided. The "
|
|
"cardinality of this association is 1-to-many and is weak "
|
|
"with respect to the system. Each system may host many "
|
|
"service access points. Heuristic: If the implementation of "
|
|
"the service access point is modeled, it must be "
|
|
"implemented by a device or software feature that is part of "
|
|
"the system hosting the service access point.") ]
|
|
class CIM_HostedAccessPoint:CIM_Dependency
|
|
{
|
|
[read, Override ("Antecedent"), Max (1), Min (1), Description (
|
|
"The hosting system.") ]
|
|
CIM_System REF Antecedent;
|
|
[read, Override ("Dependent"), Weak, Description (
|
|
"The SAP(s) that are hosted on this system.") ]
|
|
CIM_ServiceAccessPoint REF Dependent;
|
|
};
|
|
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{625B4512-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("CIM_HostedBootSAP defines the hosting unitary computer system for a "
|
|
"CIM_BootSAP. Since this relationship is subclassed from CIM_HostedAccessPoint, "
|
|
"it inherits the scoping/naming scheme defined for CIM_ServiceAccessPoint "
|
|
"- where an access point is weak to its hosting system. In this "
|
|
"case, CIM_BootSAP must be weak to its hosting CIM_UnitaryComputerSystem.")]
|
|
class CIM_HostedBootSAP: CIM_HostedAccessPoint
|
|
{
|
|
[read, Description("The unitary computer system."),
|
|
Override("Antecedent")]
|
|
CIM_UnitaryComputerSystem Ref Antecedent;
|
|
[read, Description("The Boot SAP hosted on the unitary computer system."),
|
|
Override("Dependent")]
|
|
CIM_BootSAP Ref Dependent;
|
|
|
|
};
|
|
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{7880DD16-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("An association between a job destination and a system on which "
|
|
"it resides. The cardinality of this association is 1-to-many. "
|
|
" A system may host many job queues. Job destinations are weak "
|
|
"with respect to their hosting system. Heuristic: A job destination "
|
|
"is hosted on the system where the logical devices, software features "
|
|
"or services that implement/provide the job destination are located.")]
|
|
class CIM_HostedJobDestination: CIM_Dependency
|
|
{
|
|
[read, Description("The hosting system."),
|
|
Max(1),
|
|
Min(1),
|
|
Override("Antecedent")]
|
|
CIM_System Ref Antecedent;
|
|
[read, Description("The job destination hosted on the system."),
|
|
Override("Dependent"),
|
|
Weak]
|
|
CIM_JobDestination Ref Dependent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{83B2A7AA-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("CIM_HostedService is an association between a service and the "
|
|
"system on which the functionality resides. The cardinality of "
|
|
"this association is 1-to-many. A system may host many services. "
|
|
"services are weak with respect to their hosting system. Heuristic: "
|
|
" A service is hosted on the system where the logical devices or "
|
|
"software features that implement the service are located. The "
|
|
"model does not represent services hosted across multiple systems. "
|
|
" This is modeled as an application system that acts as an aggregation "
|
|
"point for services, that are each located on a single host.")]
|
|
class CIM_HostedService: CIM_Dependency
|
|
{
|
|
[read, Description("The hosting system."),
|
|
Max(1),
|
|
Min(1),
|
|
Override("Antecedent")]
|
|
CIM_System Ref Antecedent;
|
|
[read, Description("The service hosted on the system."),
|
|
Override("Dependent"),
|
|
Weak]
|
|
CIM_Service Ref Dependent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{6DAE7092-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("CIM_HostedBootService defines the hosting system for a boot service. "
|
|
"Since this relationship is subclassed from CIM_HostedService, it "
|
|
"inherits the scoping/naming scheme defined for service - where "
|
|
"a service is weak to its hosting system.")]
|
|
class CIM_HostedBootService: CIM_HostedService
|
|
{
|
|
CIM_System Ref Antecedent;
|
|
[Description("The boot service hosted on the system."),
|
|
Override("Dependent")]
|
|
CIM_BootService Ref Dependent;
|
|
|
|
};
|
|
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{8D079BEE-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("An association describing where a job is submitted for processing, "
|
|
"i.e. to which job destination.")]
|
|
class CIM_JobDestinationJobs: CIM_Dependency
|
|
{
|
|
[read, Description("The job destination, possibly a queue."),
|
|
Max(1),
|
|
Override("Antecedent")]
|
|
CIM_JobDestination Ref Antecedent;
|
|
[read, Description("The job that is in the job queue/Destination."),
|
|
Override("Dependent")]
|
|
CIM_Job Ref Dependent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{10458E26-DB37-11d2-85FC-0000F8102E5F}" ),
|
|
Description(
|
|
"An association between a FileSystem and the StorageExtent "
|
|
"where it is located. Typically, a FileSystem ResidesOn "
|
|
"a LogicalDisk.")]
|
|
class CIM_ResidesOnExtent: CIM_Dependency
|
|
{
|
|
[read, Description("The storage extent."),
|
|
Override("Antecedent")]
|
|
CIM_StorageExtent Ref Antecedent;
|
|
[read, Description("The file system that is located on the storage extent."),
|
|
Override("Dependent")]
|
|
CIM_FileSystem Ref Dependent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{1F2EA300-DB37-11d2-85FC-0000F8102E5F}" ),
|
|
Description("CIM_RunningOS indicates the currently executing operating system. "
|
|
"At most one operating system can execute at any time on a computer system. "
|
|
"'At most one' is specified, since the computer system may not "
|
|
"be currently booted, or its operating system may be unknown.")]
|
|
class CIM_RunningOS: CIM_Dependency
|
|
{
|
|
[read, Description("The operating system currently running on the computer system."),
|
|
Max(1),
|
|
Override("Antecedent")]
|
|
CIM_OperatingSystem Ref Antecedent;
|
|
[read, Description("The computer system."),
|
|
Max(1),
|
|
Min(1),
|
|
Override("Dependent")]
|
|
CIM_ComputerSystem Ref Dependent;
|
|
|
|
};
|
|
|
|
[Abstract,Aggregation, Association, Locale ( 0x409 ) , UUID ( "{A228E208-DB22-11d2-85FC-0000F8102E5F}" ),
|
|
Description(
|
|
"This relationship associates a CIM_Dependency with one or more CIM_Configuration "
|
|
"objects. For example, a computer system's dependencies could change "
|
|
"based on the site/network to which the system is attached.")]
|
|
class CIM_DependencyContext
|
|
{
|
|
[read, Aggregate, Description(
|
|
"The configuration object that aggregates the dependency.")]
|
|
CIM_Configuration Ref Context;
|
|
[read, Description("An aggregated dependency.")]
|
|
CIM_Dependency Ref Dependency;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{BCD64CCE-DB29-11d2-85FC-0000F8102E5F}" ),Association,
|
|
Description(
|
|
" The CIM_DirectorySpecificationFile association identifies the "
|
|
"directorythat contains the file being specified by referencing the "
|
|
"CIM_DirectorySpecification class. ")]
|
|
class CIM_DirectorySpecificationFile
|
|
{
|
|
[read, Max(1), Min(0),
|
|
Description ("The directory specification.")]
|
|
CIM_DirectorySpecification Ref DirectorySpecification;
|
|
[read, Min(0),
|
|
Description ("The file specification.")]
|
|
CIM_FileSpecification Ref FileSpecification;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{FC049DCE-DB29-11d2-85FC-0000F8102E5F}" ),Association,
|
|
Description(
|
|
"This association relates a CIM_Configuration object to one or more "
|
|
"managed system elements. The CIM_Configuration object represents a "
|
|
"certain behavior, or a desired functional state for the associated "
|
|
"CIM_ManagedSystemElement.")]
|
|
class CIM_ElementConfiguration
|
|
{
|
|
[read, Description("The CIM_Configuration object that groups the settings and dependencies "
|
|
"associated with the managed system element.")]
|
|
CIM_Configuration Ref Configuration;
|
|
[read, Description("The managed system element.")]
|
|
CIM_ManagedSystemElement Ref Element;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{55D5B446-DB2A-11d2-85FC-0000F8102E5F}" ),Association,
|
|
Description(
|
|
"The CIM_FromDirectoryAction association identifies the source directory "
|
|
" for the file action. When this association is used, the assumption "
|
|
" is that the source directory was created by a previous action. "
|
|
" This association cannot exist with a CIM_FromDirectorySpecification "
|
|
" association since a file action can only involve a single source "
|
|
"directory. ")]
|
|
class CIM_FromDirectoryAction
|
|
{
|
|
[read, Min(0),
|
|
Description ("The file name.")]
|
|
CIM_FileAction Ref FileName;
|
|
[read, Max(1), Min(0),
|
|
Description ("The source directory.")]
|
|
CIM_DirectoryAction Ref SourceDirectory;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{6715375E-DB2A-11d2-85FC-0000F8102E5F}" ),Association,
|
|
Description(
|
|
"The CIM_FromDirectorySpecification association identifies the source "
|
|
" directory for the file action. When this association is used, "
|
|
" the assumption is that the source directory already existed. "
|
|
" This association cannot exist with a CIM_FromDirectoryAction association "
|
|
"since a file action can only involve single source directory.")]
|
|
class CIM_FromDirectorySpecification
|
|
{
|
|
[read, Min(0),
|
|
Description ("The file name.")]
|
|
CIM_FileAction Ref FileName;
|
|
[read, Max(1), Min(0),
|
|
Description ("The source directory.")]
|
|
CIM_DirectorySpecification Ref SourceDirectory;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{778C74EE-DB2A-11d2-85FC-0000F8102E5F}" ),
|
|
Description("The CIM_FRU class is a vendor-defined collection of products "
|
|
"and/or physical elements that is associated with a product for "
|
|
"the purpose of supporting, maintaining or upgrading that product "
|
|
"at the customer's location. FRU is an acronym for 'field replaceable "
|
|
"unit'. ")]
|
|
class CIM_FRU
|
|
{
|
|
[read, Description("A short textual description (one-line string) for the FRU."),
|
|
MaxLen(64)]
|
|
STRING Caption;
|
|
[read, Description("A textual description of the FRU."),
|
|
MappingStrings{"MIF.DMTF|FRU|002.3"}]
|
|
STRING Description;
|
|
[read, Description("FRU ordering information."),
|
|
Key,
|
|
MappingStrings{"MIF.DMTF|FRU|002.6"},
|
|
MaxLen(64)]
|
|
STRING FRUNumber;
|
|
[read, Description("FRU identification such as a serial number on software or a die "
|
|
"number on a hardware chip."),
|
|
Key,
|
|
MappingStrings{"MIF.DMTF|FRU|002.7"},
|
|
MaxLen(64)]
|
|
STRING IdentifyingNumber;
|
|
[read, Description("FRU name."),
|
|
MaxLen(256)]
|
|
STRING Name;
|
|
[read, Description("The FRU's revision level."),
|
|
MappingStrings{"MIF.DMTF|FRU|002.8"},
|
|
MaxLen(64)]
|
|
STRING RevisionLevel;
|
|
[read, Description("The name of the FRU's supplier."),
|
|
Key,
|
|
MappingStrings{"MIF.DMTF|FRU|002.4"},
|
|
MaxLen(256)]
|
|
STRING Vendor;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{87FEEDCA-DB2A-11d2-85FC-0000F8102E5F}" ),
|
|
Aggregation, Association, Description(
|
|
"Indicates that a FRU may be composed of other product(s).")]
|
|
class CIM_FRUIncludesProduct
|
|
{
|
|
[read, Description("The product which is a part of the FRU.")]
|
|
CIM_Product Ref Component;
|
|
[read, Aggregate, Description("The FRU."),
|
|
Max(1)]
|
|
CIM_FRU Ref FRU;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{977E36CA-DB2A-11d2-85FC-0000F8102E5F}" ),
|
|
Aggregation, Association, Description(
|
|
"Indicates the physical elements that make up a FRU.")]
|
|
class CIM_FRUPhysicalElements{
|
|
[read, Description("The physical element which is a part of the FRU.")]
|
|
CIM_PhysicalElement Ref Component;
|
|
[read, Aggregate, Description("The FRU."),
|
|
Max(1)]
|
|
CIM_FRU Ref FRU;
|
|
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{4DA18760-E3D0-11d2-8601-0000F8102E5F}"),
|
|
Description("A file or data set store local to a computer system or remotely "
|
|
"mounted from a file server.")]
|
|
class CIM_FileSystem: CIM_LogicalElement
|
|
{
|
|
[read, Description("AvailableSpace indicates the total amount of free space for the "
|
|
"file system, in bytes. If unknown, enter 0."),
|
|
MappingStrings{"MIF.DMTF|Partition|002.4"},
|
|
Units("Bytes")]
|
|
UINT64 AvailableSpace;
|
|
[read, Description("File systems can read/write data in blocks which are defined independently "
|
|
"of the underlying storage extents. This property captures the "
|
|
"file system's block size for data storage and retrieval."),
|
|
Units("Bytes")]
|
|
UINT64 BlockSize;
|
|
[read, Description("Indicates that the case of file names are preserved.")]
|
|
BOOLEAN CasePreserved;
|
|
[read, Description("Indicates that case sensitive file names are supported.")]
|
|
BOOLEAN CaseSensitive;
|
|
[read, Description( "Array defining the character sets or encoding supported by "
|
|
"the FileSystem. For example, the values, \"ASCII\" (2) or "
|
|
"\"ISO2022\" (4), may be specified."),
|
|
Values{"Unknown", "Other", "ASCII", "Unicode", "ISO2022",
|
|
"ISO8859", "Extended UNIX Code",
|
|
"UTF-8", "UCS-2"}]
|
|
UINT16 CodeSet[];
|
|
[read, Description("A free form string indicating the algorithm or tool used to compress "
|
|
"the file system. If it is not possible or not desired to describe "
|
|
"the compression scheme (perhaps because it is not known), recommend "
|
|
"using the following words: \"Unknown\" to represent that it is "
|
|
"not known whether the file system is compressed or not, \"Compressed\" "
|
|
"to represent that the file system is compressed but either its "
|
|
"compression scheme is not known or not disclosed, and \"Not Compressed\" "
|
|
"to represent that the file system is not compressed."),
|
|
MappingStrings{"MIF.DMTF|Partition|002.7"}]
|
|
STRING CompressionMethod;
|
|
[read, Description("CreationClassName indicates the name of the class or the subclass "
|
|
"used in the creation of an instance. When used with the other "
|
|
"key properties of this class, this property allows all instances "
|
|
"of this class and its subclasses to be uniquely identified."),
|
|
Key,
|
|
MaxLen(256)]
|
|
STRING CreationClassName;
|
|
[read, Description("The scoping computer system's creation class name."),
|
|
Key,
|
|
MaxLen(256),
|
|
Propagated("CIM_ComputerSystem.CreationClassName")]
|
|
STRING CSCreationClassName;
|
|
[read, Description("The scoping computer system's name."),
|
|
Key,
|
|
MaxLen(256),
|
|
Propagated("CIM_ComputerSystem.Name")]
|
|
STRING CSName;
|
|
[read, Description("A free form string indicating the algorithm or tool used to encrypt "
|
|
"the file system. If it is not possible or not desired to describe "
|
|
"the encryption scheme (perhaps for security reasons), recommend "
|
|
"using the following words: \"Unknown\" to represent that it is "
|
|
"not known whether the file system is encrypted or not, \"Encrypted\" "
|
|
"to represent that the file system is encrypted but either its "
|
|
"encryption scheme is not known or not disclosed, and \"Not Encrypted\" "
|
|
"to represent that the file system is not encrypted."),
|
|
MappingStrings{"MIF.DMTF|Partition|002.8"}]
|
|
STRING EncryptionMethod;
|
|
[read, Description("The FileSystemSize property stores the total size of the file system "
|
|
"in bytes. If unknown, enter 0."),
|
|
Units("Bytes")]
|
|
UINT64 FileSystemSize;
|
|
[read, Description("Integer indicating the maximum length of a file name within the "
|
|
"file system. 0 indicates that there is no limit on file name length.")]
|
|
UINT32 MaxFileNameLength;
|
|
[read, Description("Indicates that the file system is designated as read only."),
|
|
MappingStrings{"MIB.IETF|HOST-RESOURCES-MIB.hrFSAccess"}]
|
|
BOOLEAN ReadOnly;
|
|
[read, Description("Path name or other information defining the root of the file system."),
|
|
MappingStrings{"MIB.IETF|HOST-RESOURCES-MIB.hrFSMountPoint"}]
|
|
STRING Root;
|
|
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{5B6C820A-E3D0-11d2-8601-0000F8102E5F}"),
|
|
Description( "A class derived from FileSystem that represents the file "
|
|
"store controlled by a ComputerSystem through local means "
|
|
"(e.g., direct device driver access). In this case, the "
|
|
"file store is managed directly by the ComputerSystem "
|
|
"without the need for another computer to act as a "
|
|
"file server. This definition does not breakdown in the "
|
|
"case of a Clustered File System. In this scenario, the "
|
|
"FileSystem is a LocalFileSystem, weak to the Cluster.")]
|
|
class CIM_LocalFileSystem: CIM_FileSystem
|
|
{
|
|
};
|
|
|
|
|
|
[Abstract, Locale (0x409), UUID("{673E0A2C-E3D0-11d2-8601-0000F8102E5F}"),
|
|
Description("CIM_JobDestination is a logical element representing where a job is "
|
|
"submitted for processing. It can refer to a queue that contains "
|
|
"zero or more jobs, such as a print queue containing print jobs. "
|
|
"job destinations are hosted on systems, similar to the way that "
|
|
"services are hosted on systems.")]
|
|
class CIM_JobDestination: CIM_LogicalElement{
|
|
[read, Description("CreationClassName indicates the name of the class or the subclass "
|
|
"used in the creation of an instance. When used with the other "
|
|
"key properties of this class, this property allows all instances "
|
|
"of this class and its subclasses to be uniquely identified."),
|
|
Key,
|
|
MaxLen(256)]
|
|
STRING CreationClassName;
|
|
[read, Description("The scoping system's creation class name."),
|
|
Key,
|
|
MaxLen(256),
|
|
Propagated("CIM_System.CreationClassName")]
|
|
STRING SystemCreationClassName;
|
|
[read, Description("The scoping system's name."),
|
|
Key,
|
|
MaxLen(256),
|
|
Propagated("CIM_System.Name")]
|
|
STRING SystemName;
|
|
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{7250D62E-E3D0-11d2-8601-0000F8102E5F}"),
|
|
Description("Capabilities and management of a management controller. An I2C "
|
|
"microcontroller is a type of management controller.")]
|
|
class CIM_ManagementController: CIM_Controller
|
|
{
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{7BB67AE8-E3D0-11d2-8601-0000F8102E5F}"),
|
|
Description( "PCIController is a superclass for the PCIBridge and PCIDevice "
|
|
"classes. These classes model adapters and bridges on a PCI "
|
|
"bus. The properties in PCIController and its subclasses are "
|
|
"defined in the various PCI Specifications published by the "
|
|
"PCI SIG.")]
|
|
class CIM_PCIController: CIM_Controller
|
|
{
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{F62037D8-E3D0-11d2-8601-0000F8102E5F}"),
|
|
Description("Capabilities and management of a magneto-optical drive, a subtype "
|
|
"of media access device.")]
|
|
class CIM_MagnetoOpticalDrive: CIM_MediaAccessDevice
|
|
{
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{FFB58B9A-E3D0-11d2-8601-0000F8102E5F}"),
|
|
Description("Capabilities and management of a WORM drive, a subtype of media access device.")]
|
|
class CIM_WORMDrive: CIM_MediaAccessDevice
|
|
{
|
|
};
|
|
|
|
|
|
[Abstract, Locale (0x409), UUID("{07F12A62-E3D1-11d2-8601-0000F8102E5F}"),
|
|
Description("Capabilities and management of the scanner logical device.")]
|
|
class CIM_Scanner: CIM_LogicalDevice
|
|
{
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{11140D44-E3D1-11d2-8601-0000F8102E5F}"),
|
|
Description("A BinarySensor provides a boolean output. Given the addition "
|
|
"of the CurrentState and PossibleStates properties to Sensor, "
|
|
"the BinarySensor subclass is no longer necessary, but is "
|
|
"retained for backward compatibility. A BinarySensor can be "
|
|
"created by instantiating a Sensor with two PossibleStates.")]
|
|
class CIM_BinarySensor: CIM_Sensor
|
|
{
|
|
[read, Description("The current value indicated by the sensor.")]
|
|
BOOLEAN CurrentReading;
|
|
[read, Description("ExpectedReading indicates the 'normal' value for the sensor.")]
|
|
BOOLEAN ExpectedReading;
|
|
[read, Description("InterpretationOfFalse is a string indicating what a 'False' value "
|
|
"from the binary sensor means. This information could be displayed "
|
|
"to a user."),
|
|
MaxLen(64)]
|
|
STRING InterpretationOfFalse;
|
|
[read, Description("InterpretationOfTrue is a string indicating what a 'True' value "
|
|
"from the Binary sensor means. This information could be displayed "
|
|
"to a user."),
|
|
MaxLen(64)]
|
|
STRING InterpretationOfTrue;
|
|
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{1BF00330-E3D1-11d2-8601-0000F8102E5F}"),
|
|
Description("A DiscreteSensor has a set of legal string values, "
|
|
"that it can report. These values are enumerated in the "
|
|
"Sensor's PossibleValues property. A DiscreteSensor will "
|
|
"always have a 'current reading' that corresponds to one of "
|
|
"the enumerated values.\n"
|
|
"Given the addition of the CurrentState and PossibleStates "
|
|
"properties to Sensor, the DiscreteSensor subclass is no longer "
|
|
"necessary, but is retained for backward compatibility. "
|
|
"Information in the CurrentReading and PossibleValues properties "
|
|
"will typically have the same values and semantics as for the "
|
|
"CurrentState and PossibleStates properties, inherited from "
|
|
"Sensor.")]
|
|
class CIM_DiscreteSensor: CIM_Sensor
|
|
{
|
|
[read, Description("The AcceptableValues property details which "
|
|
"of the strings in the PossibleValues property are considered "
|
|
"'acceptable' (i.e., 'not an error')."),
|
|
MaxLen(64)]
|
|
STRING AcceptableValues[];
|
|
[read, Description("The current value indicated by the sensor."),
|
|
MaxLen(64)]
|
|
STRING CurrentReading;
|
|
[read, Description("The PossibleValues property enumerates the "
|
|
"string outputs that can be output by the discrete sensor."),
|
|
MaxLen(64)]
|
|
STRING PossibleValues[];
|
|
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{237D964E-E3D1-11d2-8601-0000F8102E5F}"),
|
|
Description("A multi-state sensor is a multi-member set of binary sensors, each "
|
|
"binary sensor reporting a boolean result.")]
|
|
class CIM_MultiStateSensor: CIM_Sensor
|
|
{
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{237D964F-E3D1-11d2-8601-0000F8102E5F}"),
|
|
Description("This class exists for backward compatibility to earlier "
|
|
"CIM Schema definitions. With additions to Sensor and Numeric"
|
|
"Sensor in V2.2, it is no longer necessary. A Tachometer can "
|
|
"be defined by setting the SensorType property. inherited from "
|
|
"Sensor, to 5 (\"Tachometer\"). Other properties of this class "
|
|
"are hard-coded to constant values to correspond to definitions "
|
|
"in the Sensor hierarchy.")]
|
|
class CIM_Tachometer: CIM_NumericSensor
|
|
{
|
|
[read, Override ("CurrentReading"),Units ("Revolutions per Minute")]
|
|
sint32 CurrentReading;
|
|
|
|
[read, Override ("NominalReading"),Units ("Revolutions per Minute")]
|
|
sint32 NominalReading;
|
|
|
|
[read, Override ("NormalMax"),Units ("Revolutions per Minute")]
|
|
sint32 NormalMax;
|
|
|
|
[read, Override ("NormalMin"),Units ("Revolutions per Minute")]
|
|
sint32 NormalMin;
|
|
|
|
[read, Override ("MaxReadable"),Units ("Revolutions per Minute")]
|
|
sint32 MaxReadable;
|
|
|
|
[read, Override ("MinReadable"),Units ("Revolutions per Minute")]
|
|
sint32 MinReadable;
|
|
|
|
[read, Override ("Resolution"), Units ("Tenths of Revolutions per Minute")]
|
|
uint32 Resolution;
|
|
|
|
[read, Override ("Tolerance"),Units ("Revolutions per Minute")]
|
|
sint32 Tolerance;
|
|
|
|
[read, Override ("LowerThresholdNonCritical"),Units ("Revolutions per Minute")]
|
|
sint32 LowerThresholdNonCritical;
|
|
|
|
[read, Override ("UpperThresholdNonCritical"),Units ("Revolutions per Minute")]
|
|
sint32 UpperThresholdNonCritical;
|
|
|
|
[read, Override ("LowerThresholdCritical"),Units ("Revolutions per Minute")]
|
|
sint32 LowerThresholdCritical;
|
|
|
|
[read, Override ("UpperThresholdCritical"),Units ("Revolutions per Minute")]
|
|
sint32 UpperThresholdCritical;
|
|
|
|
[read, Override ("LowerThresholdFatal"),Units ("Revolutions per Minute")]
|
|
sint32 LowerThresholdFatal;
|
|
|
|
[read, Override ("UpperThresholdFatal"),Units ("Revolutions per Minute")]
|
|
sint32 UpperThresholdFatal;
|
|
|
|
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{2D0E255C-E3D1-11d2-8601-0000F8102E5F}"),
|
|
Description("CIM_AggregatePSExtent defines the number of addressable logical blocks "
|
|
"on a single storage device, excluding any logical blocks mapped "
|
|
"as check data. These logical blocks are contained within a single "
|
|
"volume set (if volume sets are defined). This is an alternative "
|
|
"grouping for CIM_ProtectedSpaceExtent, when only summary information "
|
|
"is needed or when automatic configuration is used. Automatic "
|
|
"configuration can result in thousands of CIM_ProtectedSpaceExtent "
|
|
"being defined. There is no value in modeling the individual extents. "
|
|
" So, the CIM_AggregatePSExtent object was defined.")]
|
|
class CIM_AggregatePSExtent: CIM_StorageExtent{
|
|
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{35E25AA4-E3D1-11d2-8601-0000F8102E5F}"),
|
|
Description("CIM_ProtectedSpaceExtent define addressable logical block addresses, "
|
|
"treated as a single storage extent, located on a single physical extent. "
|
|
" Protected space extents exclude any logical blocks mapped as check "
|
|
"data and contain user data stripe depth mapping information. "
|
|
"An alternate possibility, if automatic configuration is used, "
|
|
"is to instantiate or extend the CIM_AggregatePSExtent class.")]
|
|
class CIM_ProtectedSpaceExtent: CIM_StorageExtent{
|
|
[read, Description("For a ProtectedSpaceExtent that is allocated to a VolumeSet, "
|
|
"(i.e. is named in a CIM_VolumeSetBasedOnPSExtent "
|
|
"association), this property is the number of user data bytes "
|
|
"placed on this ProtectedSpaceExtent before moving on to the "
|
|
"next ProtectedSpaceExtent in the VolumeSet. Otherwise, this "
|
|
"ProtectedSpaceExtent is considered to be unallocated and "
|
|
"this property shall be set to zero (0h.)"),
|
|
MappingStrings{"MIF.DMTF|Protected Space Extent|001.6"},
|
|
Units("Bytes")]
|
|
UINT64 UserDataStripeDepth;
|
|
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{35E25AA5-E3D1-11d2-8601-0000F8102E5F}"),
|
|
Description("CIM_VolumeSet represents a contiguous range of logical blocks presented "
|
|
"to the operating environment for reading and writing user data. "
|
|
" Volume sets shall not overlap one another. They are based on one "
|
|
"or more physical extents, protected space extents, or aggregate "
|
|
"extents (all of the same type). These based on associations should "
|
|
"be instantiated or subclassed as needed.")]
|
|
class CIM_VolumeSet: CIM_StorageExtent{
|
|
[read, Description("VolumeSets in SCC have additional status information "
|
|
"beyond that captured in the Availability and StatusInfo "
|
|
"properties, inherited from ManagedSystemElement. This "
|
|
"additional information (for example, \"Protection Disabled\", "
|
|
"value=9) is captured in the VolumeStatus property."),
|
|
MappingStrings{"MIF.DMTF|Volume Set|001.5"}]
|
|
UINT64 PSExtentInterleaveDepth;
|
|
[read, Description("Number of contiguous ProtectedSpaceExtents counted "
|
|
"before looping back to the first ProtectedSpaceExtent "
|
|
"of the current stripe. It is the number of Extents forming "
|
|
"the user data stripe."),
|
|
MappingStrings{"MIF.DMTF|Volume Set|001.4"}]
|
|
UINT64 PSExtentStripeLength;
|
|
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{4333BD60-E3D1-11d2-8601-0000F8102E5F}"),
|
|
Description("A device file is a special type of logical file that represents a "
|
|
"device. This convention is useful for some operating systems "
|
|
"that manage devices using a byte stream I/O model. The logical device "
|
|
"that is associated with this file is specified using the CIM_DeviceAccessedByFile "
|
|
"relationship.")]
|
|
class CIM_DeviceFile: CIM_LogicalFile{
|
|
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{4C3A040A-E3D1-11d2-8601-0000F8102E5F}"),
|
|
Description("A class derived from CIM_LogicalElement that is a special collection "
|
|
"of managed system elements. This collection indicates that the "
|
|
"aggregated components together provide redundancy. All elements "
|
|
"aggregated in a redundancy group should be instantiations of the "
|
|
"same object class.")]
|
|
class CIM_RedundancyGroup: CIM_LogicalElement
|
|
{
|
|
[read, Description("CreationClassName indicates the name of the class or the subclass "
|
|
"used in the creation of an instance. When used with the other "
|
|
"key properties of this class, this property allows all instances "
|
|
"of this class and its subclasses to be uniquely identified."),
|
|
Key,
|
|
MaxLen(256)]
|
|
STRING CreationClassName;
|
|
[read, Description("RedundancyStatus provides information on the state of the redundancy group. "
|
|
"\"Fully Redundant\" (value=2) means that all of the configured "
|
|
"redundancy is still available; \"Degraded Redundancy\" (3) means "
|
|
"that some failures have been experienced but some reduced amount "
|
|
"of redundancy is still available; \"Redundancy Lost\" (4) means "
|
|
"that a sufficient number of failures have been experienced such "
|
|
"that no redundancy is available and the next failure experienced "
|
|
"will cause overall failure. Also, the values, \"Other\" (1) and "
|
|
"\"Unknown\" (0), are defined."),
|
|
Values{"Unknown", "Other", "Fully Redundant", "Degraded Redundancy", "Redundancy Lost"}]
|
|
UINT16 RedundancyStatus;
|
|
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{570ED2E8-E3D1-11d2-8601-0000F8102E5F}"),
|
|
Description("A class derived from redundancy group indicating that the aggregated "
|
|
"elements have more capacity or capability than is needed. An "
|
|
"example of this type of redundancy is the installation of N+1 "
|
|
"power supplies or fans in a system.")]
|
|
class CIM_ExtraCapacityGroup: CIM_RedundancyGroup
|
|
{
|
|
[read, Description("MinNumberNeeded indicates the smallest number of elements that "
|
|
"must be operational in order to have redundancy. For example, "
|
|
"in an N+1 redundancy relationship, the MinNumberNeeded property "
|
|
"should be set equal to N.")]
|
|
UINT32 MinNumberNeeded;
|
|
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{64B86CA6-E3D1-11d2-8601-0000F8102E5F}"),
|
|
Description("A class derived from RedundancyGroup indicating that one or "
|
|
"more of the aggregated elements can be spared. (The actual "
|
|
"Spares are defined using the ActsAsSpare association.) An "
|
|
"example is the use of redundant NICs in a ComputerSystem - "
|
|
"where one NIC is primary and the other is Spare. The 'primary' "
|
|
"NIC would be a member of the SpareGroup (associated using the "
|
|
"RedundancyComponent class) and the 'other' NIC would be "
|
|
"associated using the ActsAsSpare relationship.")]
|
|
class CIM_SpareGroup: CIM_RedundancyGroup
|
|
{
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{6D477DBC-E3D1-11d2-8601-0000F8102E5F}"),
|
|
Description("A class derived from redundancy group containing mass storage-related "
|
|
"redundancy information. Storage redundancy groups are used to protect "
|
|
"user data. They are made up of one or more physical extents, "
|
|
"or one or more aggregate physical extents. Storage redundancy groups may "
|
|
"overlap. However, the underlying extents within the overlap "
|
|
"should not contain any check data.")]
|
|
class CIM_StorageRedundancyGroup: CIM_RedundancyGroup
|
|
{
|
|
[read, Description("The TypeOfAlgorithm specifies the algorithm used for data redundancy "
|
|
"and reconstruction. For example, \"P+Q\" (value=5) or \"P+S\" (7) "
|
|
"may be specified. The value, 0, is not valid in the CIM Schema "
|
|
"since in DMI it represents that no redundancy exists. In this "
|
|
"case, the object should not be instantiated."),
|
|
MappingStrings{"MIF.DMTF|Redundancy Group|001.2"},
|
|
Values{"Undefined", "Other", "Unknown", "Copy", "XOR",
|
|
"P+Q", "S", "P+S"}]
|
|
UINT16 TypeOfAlgorithm;
|
|
|
|
};
|
|
|
|
[Abstract, Locale (0x409), UUID("{76148BF6-E3D1-11d2-8601-0000F8102E5F}"),
|
|
Description("CIM_VideoBIOSElement represents the low-level software that is loaded "
|
|
"into non-volatile storage and used to bring up, configure and "
|
|
"access a computer system's video controller and display.")]
|
|
class CIM_VideoBIOSElement: CIM_SoftwareElement
|
|
{
|
|
[read, Description("If true, indicates that the video BIOS is shadowed."),
|
|
MappingStrings{"MIF.DMTF|Video BIOS|001.5"}]
|
|
BOOLEAN IsShadowed;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{120BB700-DB2B-11d2-85FC-0000F8102E5F}" ),
|
|
Description(" The CIM_ApplicationSystem class is used to represent an application "
|
|
"or a software system that supports a particular business function "
|
|
"and that can be managed as an independent units. Such a system "
|
|
"can be decomposed into its functional components using the CIM_SoftwareFeature "
|
|
"class. The software features for a particular application or "
|
|
"software system are located using the CIM_ApplicationSystemSoftwareFeature "
|
|
" association. ")]
|
|
class CIM_ApplicationSystem: CIM_System
|
|
{
|
|
};
|
|
|
|
[Abstract, Locale(0x409),UUID ( "{EB98A1B2-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Association, Description(
|
|
"CIM_ProductFRU is an association between product and FRU that "
|
|
"provides information regarding what product components have been "
|
|
"or are being replaced. The association is one to many, conveying "
|
|
"that a product can have many FRUs, and that a particular instance "
|
|
"of a FRU is only applied to one (instance of a) product.")]
|
|
class CIM_ProductFRU
|
|
{
|
|
[read, Description("The FRU.")]
|
|
CIM_FRU Ref FRU;
|
|
[read, Description("The product to which the FRU is applied."),
|
|
Max(1)]
|
|
CIM_Product Ref Product;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{3E24D5A6-DB2B-11d2-85FC-0000F8102E5F}" ),
|
|
Aggregation, Association, Description(
|
|
"The CIM_ProductParentChild association defines a parent child "
|
|
"hierarchy among products. For example, a product may come bundled "
|
|
"with other products. ")]
|
|
class CIM_ProductParentChild
|
|
{
|
|
[read, Description("The child product in the association.")]
|
|
CIM_Product Ref Child;
|
|
[read, Aggregate, Description("The parent product in the association.")]
|
|
CIM_Product Ref Parent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{502F00A0-DB2B-11d2-85FC-0000F8102E5F}" ),
|
|
Aggregation, Association, Description(
|
|
"Indicates the physical elements that make up a product.")]
|
|
class CIM_ProductPhysicalElements
|
|
{
|
|
[read, Description("The physical element which is a part of the product.")]
|
|
CIM_PhysicalElement Ref Component;
|
|
[read, Aggregate, Description("The product."),
|
|
Max(1)]
|
|
CIM_Product Ref Product;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{65878E68-DB2B-11d2-85FC-0000F8102E5F}" ),
|
|
Association, Description(
|
|
"CIM_ProductProductDependency is an association between two products, "
|
|
"indicating that one must be installed, or must be absent, for "
|
|
"the other to function. This is conceptually equivalent to the "
|
|
"CIM_ServiceServiceDependency association.")]
|
|
class CIM_ProductProductDependency
|
|
{
|
|
[read, Description("The product that is dependent on another product.")]
|
|
CIM_Product Ref DependentProduct;
|
|
[read, Description("The required product.")]
|
|
CIM_Product Ref RequiredProduct;
|
|
[read, Description("The nature of the product dependency. This property describes "
|
|
"that the associated product must be installed (value=2) or must "
|
|
"be absent (value=3) in order for the product to function."),
|
|
Values{"Unknown", "Other", "Product Must Be Installed", "Product Must Not Be Installed"}]
|
|
UINT16 TypeOfDependency;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{8D6D6880-DB2B-11d2-85FC-0000F8102E5F}" ),Association, Description(
|
|
"CIM_ProductSupport is an association between product and support Access "
|
|
"that conveys how support is obtained for the product. This is "
|
|
"a many-to-many relationship, implying that various types of support "
|
|
"are available for a product, and that the same support object "
|
|
"can provide assistance for multiple products.")]
|
|
class CIM_ProductSupport
|
|
{
|
|
[read, Description("The product.")]
|
|
CIM_Product Ref Product;
|
|
[read, Description("Support for the product.")]
|
|
CIM_SupportAccess Ref Support;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{F0B752E8-DB30-11d2-85FC-0000F8102E5F}" ),
|
|
Aggregation, Association, Description(
|
|
"This relationship associates Configuration objects with "
|
|
"Setting objects. For example, a NetworkAdapter's Settings "
|
|
"could change based on the site/network to which its hosting "
|
|
"ComputerSystem is attached. In this case, the ComputerSystem "
|
|
"would have two different Configuration objects, corresponding "
|
|
"to the differences in network configuration for the two network "
|
|
"segments. Configuration A would aggregate a Setting object for "
|
|
"the NetworkAdapter when operating on segment \"ANet\", whereas "
|
|
"Configuration B would aggregate a different NetworkAdapter "
|
|
"Setting object, specific to segment \"BNet\". Note that many "
|
|
"Settings of the computer are independent of the network "
|
|
"Configuration. For example, both Configurations A and B would "
|
|
"aggregate the same Setting object for the ComputerSystem's "
|
|
"MonitorResolution.")]
|
|
class CIM_SettingContext
|
|
{
|
|
[read, Aggregate, Description(
|
|
"The configuration object that aggregates the setting.")]
|
|
CIM_Configuration Ref Context;
|
|
[read, Description("An aggregated setting.")]
|
|
CIM_Setting Ref Setting;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{5CC70817-DB31-11d2-85FC-0000F8102E5F}" ),
|
|
Aggregation, Association, Description(
|
|
"The CIM_StorageDefect aggregation collects the storage errors for "
|
|
"a storage extent.")]
|
|
class CIM_StorageDefect
|
|
{
|
|
[read, Description("CIM_StorageError references the Error object, defining the starting and "
|
|
"ending addresses that are 'mapped out' of the storage extent."),
|
|
Weak]
|
|
CIM_StorageError Ref Error;
|
|
[read, Aggregate, Description(
|
|
"The Extent reference defines the storage extent on which the errors "
|
|
"occurred."),
|
|
Max(1),
|
|
Min(1)]
|
|
CIM_StorageExtent Ref Extent;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{71312AB6-DB31-11d2-85FC-0000F8102E5F}" ),
|
|
Description("CIM_StorageError defines blocks of media or memory space that are "
|
|
"mapped 'out of use' due to errors. The Key of the class is the "
|
|
"StartingAddress property of the bytes in error.")]
|
|
class CIM_StorageError
|
|
{
|
|
[read, Description("The scoping storage extent's creation class name."),
|
|
Key,
|
|
MaxLen(256),
|
|
Propagated("CIM_StorageExtent.CreationClassName")]
|
|
STRING DeviceCreationClassName;
|
|
[read, Description("The scoping storage extent's DeviceID."),
|
|
Key,
|
|
MaxLen(64),
|
|
Propagated("CIM_StorageExtent.DeviceID")]
|
|
STRING DeviceID;
|
|
[read, Description("The ending address of the bytes in error.")]
|
|
UINT64 EndingAddress;
|
|
[read, Description("The starting address of the bytes in error."),
|
|
Key]
|
|
UINT64 StartingAddress;
|
|
[read, Description("The scoping system's creation class name."),
|
|
Key,
|
|
MaxLen(256),
|
|
Propagated("CIM_StorageExtent.SystemCreationClassName")]
|
|
STRING SystemCreationClassName;
|
|
[read, Description("The scoping system's name."),
|
|
Key,
|
|
MaxLen(256),
|
|
Propagated("CIM_StorageExtent.SystemName")]
|
|
STRING SystemName;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{80321714-DB31-11d2-85FC-0000F8102E5F}" ),
|
|
Description("The CIM_SupportAccess association defines how to "
|
|
"obtain assistance for a Product.")]
|
|
class CIM_SupportAccess
|
|
{
|
|
[read, Description("CommunicationInfo provides the details of the communication mode. "
|
|
"For example, if the communication mode is 'Phone', CommunicationInfo "
|
|
"specifies the phone number to be called."),
|
|
MappingStrings{"MIF.DMTF|FRU|002.11", "MIF.DMTF|FRU|002.12"}]
|
|
STRING CommunicationInfo;
|
|
[read, Description("communication mode defines the form of communication in order "
|
|
"to obtain support. For example, phone communication (value=2), "
|
|
"fax (3) or email (8) can be specified."),
|
|
MappingStrings{"MIF.DMTF|Support|001.5"},
|
|
ValueMap{"1", "2", "3", "4", "5",
|
|
"6", "7", "8"},
|
|
Values{"Other", "Phone", "Fax", "BBS", "Online Service",
|
|
"Web Page", "FTP", "E-mail"}]
|
|
UINT16 CommunicationMode;
|
|
[read, Description("A textual description of the type of support provided."),
|
|
MappingStrings{"MIF.DMTF|Support|001.3"}]
|
|
STRING Description;
|
|
[read, Description("Locale defines the geographic region and/or language dialect "
|
|
"to which this Support resource pertains."),
|
|
MappingStrings{"MIF.DMTF|Support|001.2"},
|
|
MaxLen(64)]
|
|
STRING Locale;
|
|
[read, Description("SupportAccessID is an arbitrary, free form string defined by "
|
|
"the product vendor or by the organization that deploys the product. "
|
|
" This property, since it is a key, should be unique throughout "
|
|
"the enterprise."),
|
|
Key,
|
|
MaxLen(256)]
|
|
STRING SupportAccessId;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{B58D172E-DB31-11d2-85FC-0000F8102E5F}" ),
|
|
Association, Description(
|
|
"The CIM_ToDirectoryAction association identifies the target directory "
|
|
"for the file action. When this association is used, the assumption "
|
|
" is that the target directory was created by a previous action. "
|
|
" This association cannot exist with a CIM_ToDirectorySpecification "
|
|
" association since a file action can only involve a single target "
|
|
"directory. ")]
|
|
class CIM_ToDirectoryAction
|
|
{
|
|
[read, Max(1), Min(0),
|
|
Description ("The destination directory.") ]
|
|
CIM_DirectoryAction Ref DestinationDirectory;
|
|
[read, Min(0),
|
|
Description ("The name of the file.")]
|
|
CIM_CopyFileAction Ref FileName;
|
|
|
|
};
|
|
|
|
[Abstract, Locale ( 0x409 ) , UUID ( "{C3E25A3C-DB31-11d2-85FC-0000F8102E5F}" ),
|
|
Association, Description(
|
|
"The CIM_ToDirectorySpecification association identifies the target "
|
|
" directory for the file action. When this association is used, "
|
|
" the assumption is that the target directory already existed. "
|
|
" This association cannot exist with a CIM_ToDirectoryAction association "
|
|
"since a file action can only involve a single target directory.")]
|
|
class CIM_ToDirectorySpecification
|
|
{
|
|
[read, Max(1), Min(0),
|
|
Description ("The destination directory.") ]
|
|
CIM_DirectorySpecification Ref DestinationDirectory;
|
|
[read, Min(0),
|
|
Description ("The file name.")]
|
|
CIM_CopyFileAction Ref FileName;
|
|
|
|
};
|
|
|
|
[Abstract, Description("An association between a FileSystem and a Directory "
|
|
"which indicates that the Directory is being attached to "
|
|
"the FileSystem. The semantics of this relationship require "
|
|
"that the mounted Directory be contained by a FileSystem "
|
|
"(via the FileStorage association) that is different from "
|
|
"the FileSystem referenced as the Dependent. The "
|
|
"Directory's containing FileSystem could be either "
|
|
"local or remote. For example, a LocalFileSystem on a Solaris "
|
|
"ComputerSystem can mount a Directory from the FileSystem "
|
|
"accessed via the machine's CDROM drive, i.e., another LocalFile"
|
|
"System. On the other hand, in a 'remote' case, the Directory "
|
|
"is first exported by its FileSystem, which is hosted on another "
|
|
"ComputerSystem acting (for example) as a file server. In order to "
|
|
"distinguish these two types of Mount, it is recommended that "
|
|
"a CIM_Export association always be defined for the remotely "
|
|
"accessed/mounted Directories."), Locale (0x409), UUID("{75BCF4F6-DB46-11D2-B4C8-80080C7B6371}")]
|
|
class CIM_Mount: CIM_Dependency
|
|
{
|
|
[read, Description("The directory mounted.") ,
|
|
Max(1) ,
|
|
Override("Antecedent") ]
|
|
CIM_Directory Ref Antecedent;
|
|
[read, Description("The FileSystem the Directory is mounted on.") ,
|
|
Override("Dependent") ]
|
|
CIM_NFS Ref Dependent;
|
|
};
|
|
|
|
[Abstract,Association,
|
|
Description (
|
|
"An association between a LocalFileSystem and its Directories "
|
|
"indicating that the specified Directories are available for "
|
|
"mount. When exporting an entire FileSystem, the Directory "
|
|
"should reference the topmost directory of the FileSystem."),
|
|
Locale (0x409), UUID("{75BCF4F8-DB46-11D2-B4C8-80080C7B6371}")]
|
|
class CIM_Export
|
|
{
|
|
[Description("The directory exported for NFS mount.") ,
|
|
Read ]
|
|
CIM_Directory Ref Directory;
|
|
[Description("The local file system.") ,
|
|
Max(1), Read ]
|
|
CIM_LocalFileSystem Ref LocalFS;
|
|
[Description("Name under which the directory is exported."),
|
|
Read ]
|
|
STRING ExportedDirectoryName;
|
|
};
|
|
|
|
[Abstract, Description("A class derived from FileSystem that represents access of the "
|
|
"FileSystem via a network-related service. In this case, the "
|
|
"file store is hosted by a computer, acting as a file server. "
|
|
"For example, the file store for an NFS FileSystem is typically "
|
|
"NOT on a ComputerSystem's locally controlled media, nor is "
|
|
"it directly accessed through a device driver. Subclasses of "
|
|
"RemoteFileSystem contain client-side configuration information "
|
|
"related to the access of the FileSystem.") ,
|
|
Locale (0x409), UUID("{75BCF4F9-DB46-11D2-B4C8-80080C7B6371}")]
|
|
class CIM_RemoteFileSystem: CIM_FileSystem
|
|
{
|
|
};
|
|
|
|
[Abstract, Description("A class derived from RemoteFileSystem representing that "
|
|
"the FileSystem is mounted, using the NFS protocol, from "
|
|
"a ComputerSystem. The properties of the NFS object "
|
|
"deal with the operational aspects of the mount and represent "
|
|
"the client-side configuration for NFS access. The "
|
|
"FileSystemType (inherited from FileSystem) should be set "
|
|
"to indicate the type of this FileSystem as it appears to "
|
|
"the client.") ,
|
|
Locale (0x409), UUID("{75BCF4FB-DB46-11D2-B4C8-80080C7B6371}")]
|
|
class CIM_NFS: CIM_RemoteFileSystem
|
|
{
|
|
[Description("If set to true: control attribute caching is enabled. If set "
|
|
"to false: control attribute caching is disabled."), Read ]
|
|
BOOLEAN AttributeCaching;
|
|
[Description("Maximum number of seconds that cached attributes are held after "
|
|
"directory update."), Read ,
|
|
Units("Seconds") ]
|
|
UINT16 AttributeCachingForDirectoriesMax;
|
|
[Description("Minimum number of seconds that cached attributes are held after "
|
|
"directory update."), Read ,
|
|
Units("Seconds") ]
|
|
UINT16 AttributeCachingForDirectoriesMin;
|
|
[Description("Maximum number of seconds that cached attributes are held after "
|
|
"file modification."), Read ,
|
|
Units("Seconds") ]
|
|
UINT16 AttributeCachingForRegularFilesMax;
|
|
[Description("Minimum number of seconds that cached attributes are held after "
|
|
"file modification."), Read ,
|
|
Units("Seconds") ]
|
|
UINT16 AttributeCachingForRegularFilesMin;
|
|
[Description("If set to true: retries are performed in the foreground. If set "
|
|
"to false: if the first mount attempt fails, retries are performed "
|
|
"in the background."), Read ]
|
|
BOOLEAN ForegroundMount;
|
|
[Description("If set to true: once the file system is mounted, NFS requests "
|
|
"are retried until the hosting system responds. If set to false: "
|
|
"once the file system is mounted, an error is returned if the hosting "
|
|
"system does not respond."), Read ]
|
|
BOOLEAN HardMount;
|
|
[Description("If set to true: interrupts are permitted for hard mounts. If "
|
|
"set to false: interrupts are ignored for hard mounts."), Read ]
|
|
BOOLEAN Interrupt;
|
|
[Description("Maximum number of mount failure retries allowed."),
|
|
Read ]
|
|
UINT16 MountFailureRetries;
|
|
[Description("Read buffer size in bytes."), Read ,
|
|
Units("Bytes") ]
|
|
UINT64 ReadBufferSize;
|
|
[Description("Maximum number of NFS retransmissions allowed."),
|
|
Read ]
|
|
UINT16 RetransmissionAttempts;
|
|
[Description("NFS timeout in tenths of a second."), Read ,
|
|
Units("Tenths of Seconds") ]
|
|
UINT32 RetransmissionTimeout;
|
|
[Description("The remote computer system's (i.e., the NFS File 'Server's) UDP "
|
|
"port number."), Read ]
|
|
UINT32 ServerCommunicationPort;
|
|
[Description("Write buffer size in bytes."), Read ,
|
|
Units("Bytes") ]
|
|
UINT64 WriteBufferSize;
|
|
};
|
|
|
|
[Abstract, Description("CIM_BootService represents the functionality provided by a device, "
|
|
"software or via a network to load an operating system on a unitary computer system."),
|
|
Locale (0x409), UUID("{75BCF4FE-DB46-11D2-B4C8-80080C7B6371}")]
|
|
class CIM_BootService: CIM_Service
|
|
{
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{E527D7F2-E3D4-11d2-8601-0000F8102E5F}" ),
|
|
Description (
|
|
" The CIM_SoftwareFeature class defines a particular function or "
|
|
"capability of a product or application system. This class in intended "
|
|
"to capture the level of granularity that is meaningful to a consumer "
|
|
"or user of a product rather than the units that reflect how the "
|
|
"product is built or packaged. The latter detailed is captured using a "
|
|
"CIM_SoftwareElement class. When a software feature can exist on "
|
|
"multiple platforms or operating systems (for example, a client "
|
|
"component of a three tiered client/server applications might run on "
|
|
"Solaris, Windows NT, and Windows 95), a software feature is a "
|
|
"collection of all the software elements for these different platforms. "
|
|
" In this case, the users of the model must be aware of this situation "
|
|
"since typically they will be interested in a sub-collection of the "
|
|
"software elements required for a particular platform. Software "
|
|
"features are always defined in the context of a CIM_Product class "
|
|
"using the CIM_ProductSoftwareFeatures association since features are "
|
|
"delivered through products. Optionally, software features from one or "
|
|
"more products can be organized into application systems using the "
|
|
"CIM_ApplicationSystemSoftwareFeature association. "), abstract ]
|
|
class CIM_SoftwareFeature:CIM_LogicalElement
|
|
{
|
|
[Propagated ("CIM_Product.IdentifyingNumber") , Key, Maxlen (64) ,
|
|
Read, Description (
|
|
"Product identification such as a serial number on software or a die "
|
|
"number on a hardware chip") , MappingStrings {"DMTF|ComponentID|001.4"
|
|
} ]
|
|
string IdentifyingNumber;
|
|
[Propagated ("CIM_Product.Name") , Key, Maxlen (256) , Read, Description (
|
|
"Commonly used product name") , MappingStrings {"DMTF|ComponentID|001.2"
|
|
} ]
|
|
string ProductName;
|
|
[Propagated ("CIM_Product.Vendor") , CIM_Key, Read, Maxlen (256) , Description (
|
|
"The name of the product's supplier. Corresponds to the Vendor property "
|
|
"in the product object in the DMTF Solution Exchange Standard.") ,
|
|
MappingStrings {"DMTF|ComponentID|001.1"} ]
|
|
string Vendor;
|
|
[Propagated ("CIM_Product.Version") , Key, Maxlen (64) , Description (
|
|
"Product version information. Corresponds to the Version property in "
|
|
"the product object in the DMTF Solution Exchange Standard.") ,
|
|
MappingStrings {"DMTF|ComponentID|001.3"}, Read ]
|
|
string Version;
|
|
[key, override ("Name") , Description (
|
|
"The Name property defines the label by which the object is known to the "
|
|
"world outside the data processing system. This label is a "
|
|
"human-readable name that uniquely identifies the element in the context "
|
|
"of the element's namespace.") , Maxlen (256), Read ]
|
|
string Name;
|
|
};
|
|
|
|
|
|
[Locale(0x409),UUID ( "{7A9135CA-DB21-11d2-85FC-0000F8102E5F}" ),
|
|
Abstract, Description (
|
|
" A check is a condition or characteristic that is expected to be true "
|
|
"in an environment defined or scoped by an instance of a "
|
|
"CIM_ComputerSystem. The checks associated with a particular software "
|
|
"element are organized into one of two groups using the Phase property "
|
|
"of the CIM_SoftwareElementChecks association. Conditions that are "
|
|
"expected to be satisfied when a software element is in a particular "
|
|
"environment are known as in-state conditions. Conditions that need to "
|
|
"be satisfied in order to transition the current software element to "
|
|
"its next state are known as next-state conditions A "
|
|
"CIM_ComputerSystem object represents the environment in which "
|
|
"CIM_SoftwareElement are already installed or in which "
|
|
"CIM_SoftwareElement will be installed. For the case in which a "
|
|
"software element is already installed, the "
|
|
"CIM_InstalledSoftwareElement association is used to identify the "
|
|
"CIM_ComputerSystem object that represents the \"environment\". When a "
|
|
"software elements is being distributed and installed on a different "
|
|
"computer system, the CIM_ComputerSystem object for the targeted system "
|
|
"is the environment.") ]
|
|
class CIM_Check
|
|
{
|
|
[Propagated ("CIM_SoftwareElement.Name") , CIM_key, maxlen (256) ,
|
|
Description ("The name used to identify this software element"), Read ]
|
|
string Name;
|
|
[Propagated ("CIM_SoftwareElement.Version") , CIM_key, Maxlen (64) ,
|
|
Read, Description (
|
|
"Version should be in the form <Major>.<Minor>.<Revision> or <Major>."
|
|
"<Minor><letter><revision>") ,
|
|
Mappingstrings {"MIF.DMTF|ComponentID|001.3"} ]
|
|
string Version;
|
|
[Propagated ("CIM_SoftwareElement.SoftwareElementState") , CIM_key,
|
|
Description (" The software element state of a software element ") ,
|
|
Values {"Deployable", "Installable", "Executable", "Running"}, Read ]
|
|
uint16 SoftwareElementState;
|
|
[Propagated ("CIM_SoftwareElement.SoftwareElementID") , CIM_key, maxlen (256
|
|
) , Description (" This is an identifier for this software element."), Read ]
|
|
string SoftwareElementID;
|
|
[Propagated ("CIM_SoftwareElement.TargetOperatingSystem") , CIM_key,
|
|
Read, Description (
|
|
" The target operating system of the this software element.") , Values {
|
|
"Unknown", "Other", "MACOS", "ATTUNIX", "DGUX", "DECNT", "Digital Unix"
|
|
, "OpenVMS", "HPUX", "AIX", "MVS", "OS400", "OS/2", "JavaVM", "MSDOS",
|
|
"WIN3x", "WIN95", "WIN98", "WINNT", "WINCE", "NCR3000", "NetWare", "OSF"
|
|
, "DC/OS", "Reliant UNIX", "SCO UnixWare", "SCO OpenServer", "Sequent",
|
|
"IRIX", "Solaris", "SunOS", "U6000", "ASERIES", "TandemNSK", "TandemNT"
|
|
, "BS2000", "LINUX", "Lynx", "XENIX", "VM/ESA", "Interactive UNIX",
|
|
"BSDUNIX", "FreeBSD", "NetBSD", "GNU Hurd", "OS9", "MACH Kernel",
|
|
"Inferno", "QNX", "EPOC", "IxWorks", "VxWorks", "MiNT", "BeOS", "HP MPE"
|
|
, "NextStep", "PalmPilot", "Rhapsody",
|
|
"Windows 2000", "Dedicated", "VSE", "TPF"},
|
|
Mappingstrings {"MIF.DMTF|Software Component Information|002.5"}]
|
|
uint16 TargetOperatingSystem;
|
|
[key, maxlen (256) , Description (
|
|
"An identifier used in conjunction with other keys to uniquely identify "
|
|
"the check"), Read ]
|
|
string CheckID;
|
|
[Description (" A description of the objects."), Read ]
|
|
string Description;
|
|
[Maxlen (64), Read ]
|
|
string Caption;
|
|
[Description (
|
|
" The CheckMode property is used to indicate whether the condition is "
|
|
"expected to exist or not exist in the environment. When the value is "
|
|
"True, the condition is expected to exist (e.g., a file is expected to "
|
|
"be on a system) so invoke() is expected to return True. When the "
|
|
"value is False, the condition is not expect to exist (e.g., a file is "
|
|
"not to be on a system) so invoke is expected to return false "), Read ]
|
|
boolean CheckMode;
|
|
[Description (
|
|
" The invoke method is to evaluate a particular check. The details "
|
|
"of how the method evaluates a particular check in a CIM context is "
|
|
"described by the non-abstract CIM_Check sub classes. The results of the "
|
|
"method are based on the return value. - A 0 (zero) is returned if "
|
|
"the condition is satisfied. - A 1 (one) is returned if the method is "
|
|
"not supported. - Any other value indicates the condition is not "
|
|
"satisfied. ") ]
|
|
uint32 Invoke();
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{A524EE6E-DB29-11d2-85FC-0000F8102E5F}" ),Description (
|
|
" The CIM_DirectorySpecification class captures the major directory "
|
|
"structure of a software element. This class is used to organize the "
|
|
"files of a software element into manageable units that can be "
|
|
"relocated on a computer system. ") , abstract]
|
|
class CIM_DirectorySpecification:CIM_Check
|
|
{
|
|
[Read, Description (
|
|
" The DirectoryType property characterizes the type of directory being "
|
|
"described. ") , Values {"Product base directory",
|
|
"Product executable directory", "Product library directory",
|
|
"Product configuration directory", "Product include directory",
|
|
"Product working directory", "Product log directory",
|
|
"Shared base directory", "Shared executable directory",
|
|
"Shared library directory", "Shared include directory",
|
|
"System base directory", "System executable directory",
|
|
"System library directory", "System configuration directory",
|
|
"System include directory", "System log directory", "Other"} ,
|
|
Mappingstrings {"MIF.DMTF|Location|001.2"}]
|
|
uint16 DirectoryType;
|
|
[Maxlen (1024) , Description (
|
|
"The DirectoryPath property is used to capture the name of a directory. "
|
|
"The value supplied by an application provider is actually a default or "
|
|
"recommended path name. The value can be changed for a particular "
|
|
"environment."), Read ]
|
|
string DirectoryPath;
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{41F377B0-DB2A-11d2-85FC-0000F8102E5F}" ),Description (
|
|
" A CIM_FileSpecification identifies a file that is either to be on or "
|
|
"off the system. The file is to be located in the directory identified "
|
|
"by the CIM_DirectorySpecificationFile associations. When the invoke() "
|
|
"method is used, it is expected that it will use the combination of "
|
|
"information provided to check for the file existence. Therefore, any "
|
|
"of the properties with a NULL value are not checked. So, if only the "
|
|
"Name and the MD5 properties have values, they are the only ones "
|
|
"consider by the invoke() method. "), abstract ]
|
|
class CIM_FileSpecification : CIM_Check
|
|
{
|
|
[Fixed, maxlen (1024) , Description (
|
|
" Either the name of the file or the name of the file with a directory "
|
|
"prefix. "), Read ]
|
|
string Name;
|
|
[Fixed, Description ("The creation date and time of the file. "), Read ]
|
|
datetime CreateTimeStamp;
|
|
|
|
[units ("KiloBytes"), Read ]
|
|
uint64 FileSize;
|
|
[Description (
|
|
" The Checksum property is a checksum calculated as the 16-bit "
|
|
"sum of the first 32 bytes of the file.") , Mappingstrings {
|
|
"MIF.DMTF|Software Signature|002.4"}, Read ]
|
|
uint32 CheckSum;
|
|
[Description (
|
|
" The CRC1 property is the CRC value calculated using the middle "
|
|
"512K bytes.") , Mappingstrings {"MIF.DMTF|Software Signature|002.5"}, Read ]
|
|
uint32 CRC1;
|
|
[Description (
|
|
" The CRC2 is the CRC value for the middle 512K bytes with a "
|
|
"offset modulo 3 to the start of the file of zero.") , Mappingstrings {
|
|
"MIF.DMTF|Software Signature|002.6"}, Read ]
|
|
uint32 CRC2;
|
|
[maxlen (16) , Description (
|
|
" The MD5 algorithm is a well-known algorithm for computing a 128-bit "
|
|
"checksum for any file or object. The likelihood of two different "
|
|
"files producing the same MD5 checksum is very small (about 1 in 2^64), "
|
|
"and as such, the MD5 checksum of a file can be used to construct a "
|
|
"reliable content identifier that is very likely to uniquely identify "
|
|
"the file. The reverse is also true. If two files have the same MD5 "
|
|
"checksum, it is very likely that the files are identical. For purposes "
|
|
"of MOF specification of the MD5 property, the MD5 algorithm always "
|
|
"generates a 32 character string. For example: The string "
|
|
"abcdefghijklmnopqrstuvwxyz generates the string "
|
|
"c3fcd3d76192e4007dfb496cca67e13b. See http://www. rsa.com/pub/rfc1321."
|
|
"txt for details on the implementation of the MD5 algorithm."), Read ]
|
|
string MD5Checksum;
|
|
};
|
|
|
|
[Locale(0x409),UUID ("{2F156260-DB21-11d2-85FC-0000F8102E5F}"), Abstract,
|
|
Description (
|
|
"A CIM_Action is an operation that is part of a process to either "
|
|
"create a software element in its next state or to eliminate the "
|
|
"software element in the current state. ") ]
|
|
class CIM_Action
|
|
{
|
|
[Propagated ("CIM_SoftwareElement.Name") , CIM_key, maxlen (256) ,
|
|
Description ("Name is used to identify this software element"), Read ]
|
|
string Name;
|
|
[Propagated ("CIM_SoftwareElement.Version") , CIM_key, Maxlen (64), Read,
|
|
Description (
|
|
"Version should be in the form <major>.<minor>.<revision> or <major>."
|
|
"<minor><letter><revision>."),
|
|
Mappingstrings{"MIF.DMTF|ComponentID|001.3"}]
|
|
string Version;
|
|
[Propagated ("CIM_SoftwareElement.SoftwareElementState") , CIM_key,
|
|
Description (" The SoftwareElementState indicates the state of a "
|
|
"software element ") ,
|
|
Values {"Deployable", "Installable", "Executable", "Running"}, Read ]
|
|
uint16 SoftwareElementState;
|
|
[Propagated ("CIM_SoftwareElement.SoftwareElementID") , CIM_key, maxlen (256
|
|
) , Description (" The SoftwareElementID is an identifier for this software element."), Read ]
|
|
string SoftwareElementID;
|
|
[Propagated ("CIM_SoftwareElement.TargetOperatingSystem") , CIM_key, Read,
|
|
Description (
|
|
"The TargetOperatingSystem indicates the target operating system of the owning software element.") ,
|
|
Values {"Unknown", "Other", "MACOS", "ATTUNIX", "DGUX", "DECNT",
|
|
"Digital Unix", "OpenVMS", "HPUX", "AIX", "MVS", "OS400", "OS/2",
|
|
"JavaVM", "MSDOS", "WIN3x", "WIN95", "WIN98", "WINNT", "WINCE",
|
|
"NCR3000", "NetWare", "OSF", "DC/OS", "Reliant UNIX", "SCO UnixWare",
|
|
"SCO OpenServer", "Sequent", "IRIX", "Solaris", "SunOS", "U6000",
|
|
"ASERIES", "TandemNSK", "TandemNT", "BS2000", "LINUX", "Lynx", "XENIX",
|
|
"VM/ESA", "Interactive UNIX", "BSDUNIX", "FreeBSD", "NetBSD", "GNU Hurd"
|
|
, "OS9", "MACH Kernel", "Inferno", "QNX", "EPOC", "IxWorks", "VxWorks",
|
|
"MiNT", "BeOS", "HP MPE", "NextStep", "PalmPilot", "Rhapsody",
|
|
"Windows 2000", "Dedicated","VSE","TPF"},
|
|
Mappingstrings{"MIF.DMTF|Software Component Information|002.5"}]
|
|
uint16 TargetOperatingSystem;
|
|
[key, Description (
|
|
"The ActionID property is a unique identifier assigned to a particular "
|
|
"action for a software element. ") , maxlen (256), Read ]
|
|
string ActionID;
|
|
[Description (
|
|
"The Direction property indicates whether a particular "
|
|
"CIM_Action object is part of a sequence of actions to transition the "
|
|
"current software element to its next state, such as \"Install\" or to "
|
|
"remove the current software element, such as \"Uninstall\".") , Values {
|
|
"Install", "Uninstall"}, Read ]
|
|
uint16 Direction;
|
|
|
|
[maxlen (64), Read ]
|
|
string Caption;
|
|
[Description ("A description of the object."), Read ]
|
|
string Description;
|
|
[Description (
|
|
" The invoke method is to take a particular action. The details of how "
|
|
"the method performs the action is implementation specific. The "
|
|
"results of the method are based on the return value. - A 0 (zero) is "
|
|
"returned if the condition is satisfied. - A 1 (one) is returned if "
|
|
"the method is not supported. - Any other value indicates the "
|
|
"condition is not satisfied. ") ]
|
|
uint32 Invoke();
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{8875A39E-DB29-11d2-85FC-0000F8102E5F}" ),Abstract, Description (
|
|
" The CIM_DirectoryAction is an abstract class that is used for directories "
|
|
"to be managed. Creation of directories is handled by "
|
|
"CIM_CreateDirectoryAction and removal is handled by "
|
|
"CIM_RemoveDirectoryAction. ") ]
|
|
class CIM_DirectoryAction:CIM_Action
|
|
{
|
|
[maxlen (1024), Read,
|
|
Description("The DirectoryName indicates the name of the directory "
|
|
"to which the action applies.") ]
|
|
string DirectoryName;
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{87946AAC-DB22-11d2-85FC-0000F8102E5F}") ,
|
|
Description (
|
|
" The CIM_CreateDirectoryAction creates empty directories for "
|
|
"software elements to be installed locally."), abstract ]
|
|
class CIM_CreateDirectoryAction:CIM_DirectoryAction
|
|
{
|
|
};
|
|
|
|
[Locale(0x409),Abstract, UUID ( "{B272D2EA-DB22-11d2-85FC-0000F8102E5F}" ),
|
|
Description (
|
|
" The CIM_RemoveDirectoryAction removes directories for software elements. "
|
|
) ]
|
|
class CIM_RemoveDirectoryAction:CIM_DirectoryAction
|
|
{
|
|
[Read, Description ("Indicates if the directory must be empty.")]
|
|
boolean MustBeEmpty;
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{2B590C72-DB2A-11d2-85FC-0000F8102E5F}" ),
|
|
Abstract, Description (
|
|
" The CIM_FileAction allows the author to locate files that already "
|
|
"exist on the users machine, and move or copy those files to a new "
|
|
"location.")]
|
|
class CIM_FileAction:CIM_Action
|
|
{
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{73553260-DB22-11d2-85FC-0000F8102E5F}" ),Description (
|
|
" The CIM_CopyFileAction specifies files that exist on a computer "
|
|
"system, and to move or copy those files to a new location. The "
|
|
"to/from information for the copy is specified using either the "
|
|
"CIM_ToDirectorySpecification/CIM_FromDirectorySpecification or the "
|
|
"CIM_ToDirectoryAction/CIM_FromDirectoryAction associations. The first set is "
|
|
"used when the source and/or the target are to exist before any actions "
|
|
"are taken. The second set is used when the source and/or target are "
|
|
"created as a part of a previous action. In the latter case, the action "
|
|
" to create the directory must occur prior to the CIM_CopyFileAction object."
|
|
" "), abstract ]
|
|
class CIM_CopyFileAction:CIM_FileAction
|
|
{
|
|
[maxlen (1024), Read,
|
|
Description ("The fully qualified source filename.")]
|
|
string Source;
|
|
[maxlen (1024), Read,
|
|
Description ("The fully qualified destination filename.")]
|
|
string Destination;
|
|
[Read,
|
|
Description ("Indicates whether to delete the source file after the "
|
|
"copy operation.")]
|
|
boolean DeleteAfterCopy;
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{C75D89F8-DB30-11d2-85FC-0000F8102E5F}" ),
|
|
Description ("The CIM_RemoveFileAction uninstalls files."), abstract ]
|
|
class CIM_RemoveFileAction:CIM_FileAction
|
|
{
|
|
[maxlen (1024), Read,
|
|
Description ("The file name.")]
|
|
string File;
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{4B82D255-E3CD-11d2-8601-0000F8102E5F}" ),
|
|
Association, Aggregation, Abstract, Description(
|
|
" This association is used to identify the actions for a software element. ")]
|
|
class CIM_SoftwareElementActions
|
|
{
|
|
[Min (1) , Max (1) ,Aggregate, Read]
|
|
CIM_SoftwareElement REF Element;
|
|
[Min (0) , Max(FALSE), Weak, Read]
|
|
CIM_Action REF Action;
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{A91081E2-DB37-11d2-85FC-0000F8102E5F}" ),
|
|
Abstract, Description (
|
|
" The CIM_SoftwareFeatureSoftwareElements associations identifies the "
|
|
"software elements that make up a particular software feature.") ]
|
|
class CIM_SoftwareFeatureSoftwareElements:CIM_Component
|
|
{
|
|
[Min (0) , Max (False), Read,
|
|
Description ("The group component.")]
|
|
CIM_SoftwareFeature REF GroupComponent;
|
|
[Min (1) , Max (False), Read,
|
|
Description ("The part component.")]
|
|
CIM_SoftwareElement REF PartComponent;
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{7C39D12A-DB2B-11d2-85FC-0000F8102E5F}" ),
|
|
Association, Aggregation, Abstract, Description (
|
|
" The CIM_ProductSoftwareFeatures association identifies the software "
|
|
"features for a particular product. ") ]
|
|
class CIM_ProductSoftwareFeatures
|
|
{
|
|
[Min (0) , Max (False), Aggregate, Read,
|
|
Description ("The product.")]
|
|
CIM_Product REF Product;
|
|
[Min (1) , Max (False) , Weak, Read,
|
|
Description ("The component.")]
|
|
CIM_SoftwareFeature REF Component;
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{A7B05028-DB2A-11d2-85FC-0000F8102E5F}" ),Association, Abstract,
|
|
Description (
|
|
" The CIM_InstalledSoftwareElement association allows one to identify "
|
|
"the computer system a particular software element is installed on. ")
|
|
]
|
|
class CIM_InstalledSoftwareElement
|
|
{
|
|
[Min (0) , Max (False) , Description (
|
|
"References the software element that is installed."), Read ]
|
|
CIM_SoftwareElement REF Software;
|
|
[Min (0) , Max (False), Description (
|
|
"References the computer system hosting a particular software element. "
|
|
), Read]
|
|
CIM_ComputerSystem REF System;
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{24783E8A-DB31-11d2-85FC-0000F8102E5F}" ),
|
|
Association,Aggregation,Description (
|
|
" Since software elements in a ready to run state cannot transition into "
|
|
" another state, the value of the phase property is restricted to "
|
|
" in-state for CIM_SoftwareElement objects in a ready to run state. "
|
|
), Abstract
|
|
]
|
|
class CIM_SoftwareElementChecks
|
|
{
|
|
[Min(1), Max(1), Aggregate, Read,
|
|
Description ("The element.")]
|
|
CIM_SoftwareElement REF Element;
|
|
|
|
[Min(0), Max(FALSE), Weak, Read,
|
|
Description ("The check.")]
|
|
CIM_Check REF Check;
|
|
[Description (
|
|
" The Phase property indicates whether the referenced check is an "
|
|
" in-state check or a next-state check."
|
|
), Values {"In-State", "Next-State"}, Read]
|
|
uint16 Phase;
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{714C00BA-DB37-11d2-85FC-0000F8102E5F}" ),
|
|
Description (
|
|
"CIM_ServiceAccessBySAP is an association that identifies the "
|
|
"access points for a service. For example, a printer may be "
|
|
"accessed by NetWare, Macintosh or Windows service access"
|
|
"points, potentially hosted on different systems."), Abstract]
|
|
class CIM_ServiceAccessBySAP:CIM_Dependency
|
|
{
|
|
[Override ("Antecedent"),
|
|
Description ("The service. ") , Read]
|
|
CIM_Service REF Antecedent;
|
|
[Override ("Dependent"), Description (
|
|
"An access point for a service. Access points are dependent "
|
|
"in this relationship since they have no function without a "
|
|
"corresponding service. ") , Read]
|
|
CIM_ServiceAccessPoint REF Dependent;
|
|
};
|
|
|
|
[Locale ( 0x409 ) , UUID ( "{149ADDEE-DB2A-11d2-85FC-0000F8102E5F}" ),
|
|
Description(" The CIM_ExecuteProgram causes files to be executed on the system "
|
|
" where the software element is installed. "), Abstract]
|
|
class CIM_ExecuteProgram: CIM_Action{
|
|
[Description("A string that can be invoked on a system command line."), Read]
|
|
STRING CommandLine;
|
|
[maxlen(1024), Read,
|
|
Description ("The path to the program.")]
|
|
STRING ProgramPath;
|
|
|
|
};
|
|
|
|
[Locale ( 0x409 ) , UUID ( "{ECDE0B90-DB2A-11d2-85FC-0000F8102E5F}" ),
|
|
Description("This class specifies the information to be used to modify a particular "
|
|
"setting file for a specific entry with a specific value. The "
|
|
"value specified is created as a new entry or appends to, replaces, "
|
|
"removes from, or deletes the specified entry. All additions "
|
|
"are assumed to be case sensitive. Removes are assumed to be case "
|
|
"insensitive."), Abstract]
|
|
class CIM_ModifySettingAction: CIM_Action{
|
|
[Description("Type of action to be performed on the specified setting entry. "
|
|
" Create - Creates the specified entry. Delete - Deletes the "
|
|
"specified entry. Append - Append to the end of the specified "
|
|
"entry. Remove - Remove the value from the specified entry."),
|
|
Values{"Create", "Delete", "Append", "Remove"}, Read]
|
|
UINT16 ActionType;
|
|
[Description("Name of entry to be modified."),
|
|
Maxlen(256), Read]
|
|
STRING EntryName;
|
|
[Description("This is the value to be used to add, append, or replace to the "
|
|
"specified setting."), Read]
|
|
STRING EntryValue;
|
|
[Description("File name of setting file entry to be modified."),
|
|
Maxlen(1024), Read]
|
|
STRING FileName;
|
|
[Description("This is the key of the section of the setting entry to be modified."),
|
|
Maxlen(256), Read]
|
|
STRING SectionKey;
|
|
|
|
};
|
|
|
|
[Locale ( 0x409 ) , UUID ( "{AB08D884-DB30-11d2-85FC-0000F8102E5F}" ),
|
|
Description(" The CIM_RebootAction causes a reboot of the system where the software element "
|
|
"is installed. "), Abstract]
|
|
class CIM_RebootAction: CIM_Action {
|
|
|
|
};
|
|
|
|
[Abstract,Association, Locale ( 0x409 ) , UUID ( "{F127E50E-E3E0-11d2-8601-0000F8102E5F}" ) ,
|
|
Description(" The CIM_ActionSequence association is used to define a series "
|
|
"of operations that either transitions the software element, "
|
|
"referenced by the CIM_SoftwareElementActions association, to "
|
|
"its next state or removes the software element from its current "
|
|
"environment. The CIM_Action classes participating in this association "
|
|
"must have the same value for the Direction property since they "
|
|
"are either part of a sequence to transition a software element "
|
|
"into its next state or to uninstall a software element. The "
|
|
"next-state actions and uninstall actions associated with a particular "
|
|
"software element must be a continuous sequence. Since the CIM_ActionSequence "
|
|
"is an association the loops on the CIM_Action class with roles for "
|
|
"the 'prior' action and 'next' action in a sequence, the need "
|
|
"for a continuous sequence implies: (1)Within the set of next-state "
|
|
"or uninstall actions, there is one and only one action that does "
|
|
"not have an instance of the CIM_ActionSequence association referencing "
|
|
"it in the 'next' role. This is the first action in the sequence. "
|
|
"(2) Within the set of next-state or uninstall actions, there "
|
|
"is one and only one action that does not have an instance of "
|
|
"the CIM_ActionSequence association referencing it in the \"prior\" "
|
|
"role. This is the last action in the sequence. (3) All other "
|
|
"actions within the set of next-state and uninstall actions must "
|
|
"participate in two instances of the CIM_ActionSequence association, "
|
|
"one in a prior role and one in the next role.")]
|
|
class CIM_ActionSequence{
|
|
[Max(1),
|
|
Min(0), Read,
|
|
Description ("The next action.")]
|
|
CIM_Action Ref Next;
|
|
[Max(1),
|
|
Min(0), Read,
|
|
Description ("The prior action.")]
|
|
CIM_Action Ref Prior;
|
|
|
|
};
|
|
|
|
[Locale ( 0x409 ) , UUID ( "{D3B1178A-DB29-11d2-85FC-0000F8102E5F}" ),
|
|
Description("CIM_DiskSpaceCheck checks the amount of disk space the needs to "
|
|
"be available on the system. The amount is specified in the AvailableDiskSpace "
|
|
"property. The details of this checks are compared with the "
|
|
"value of the AvailableSpace property of the CIM_FileSystem object "
|
|
"associated with the CIM_ComputerSystem object that describes "
|
|
"the environment. When the value of AvailableSpace property "
|
|
"is greater than or equal to the value specified in AvailableDiskSpace, "
|
|
"the condition is satisfied. "), Abstract]
|
|
class CIM_DiskSpaceCheck: CIM_Check{
|
|
[read, ModelCorrespondence{"CIM_FileSystem.AvailableSpace "},
|
|
units("KiloBytes"),
|
|
Description ("The available disk space.")]
|
|
UINT64 AvailableDiskSpace;
|
|
|
|
};
|
|
|
|
[Locale ( 0x409 ) , UUID ( "{DC0E96FE-DB2A-11d2-85FC-0000F8102E5F}" ),
|
|
Description("CIM_MemoryCheck specifies a condition for the minimum amount "
|
|
" of memory that needs to be available on a system. The amount "
|
|
"is specified in the MemorySize property. The details of this "
|
|
"checks are compared with the value of the FreePhysicalMemory "
|
|
"property of the CIM_OperatingSystem object referenced by an "
|
|
"CIM_InstalledOS association for the CIM_ComputerSystem object that "
|
|
"describes the environment. When the value of FreePhysicalMemory "
|
|
"property is greater than or equal to the value specified in "
|
|
"MemorySize, the condition is satisfied. "), Abstract]
|
|
class CIM_MemoryCheck: CIM_Check{
|
|
[Description("The amount of memory that needs to exist on a computer system "
|
|
"for a software element to executing properly. "),
|
|
ModelCorrespondence{"CIM_OperatingSystem.FreePhysicalMemory"},
|
|
units("KiloBytes"), Read]
|
|
UINT64 MemorySize;
|
|
|
|
};
|
|
|
|
[Locale ( 0x409 ) , UUID ( "{FEE8368A-DB2A-11d2-85FC-0000F8102E5F}" ),
|
|
Description(" The CIM_OSVersionCheck class specifies the versions of the OS "
|
|
"that can support this software element. This check can be for "
|
|
"a specific, minimum, maximum or a range of releases of an OS. "
|
|
" To specify a specific version the minimum and maximum versions "
|
|
"must be the same. To specify a minimum, the minimum version "
|
|
"needs only be specified. To specify a maximum version, the maximum "
|
|
"version needs only be specified. To specify a range both minimum "
|
|
"and maximum version need to be specified. The type of operating "
|
|
"system is specified in the TargetOperatingSystem property of "
|
|
"the owning software element. The details of this checks are compared "
|
|
"with the corresponding details found in a CIM_OperatingSystem "
|
|
" object referenced by CIM_InstalledOS association for the CIM_ComputerSystem "
|
|
"object that describes the environment. As long as there is at "
|
|
"least one CIM_OperatingSystem that satisfies the details of "
|
|
"the condition, the check is satisfied. In other words, all the "
|
|
"operating systems on the relevant computer system do not need "
|
|
"to satisfy the condition. There needs to be at least one. "
|
|
"Also, note the OSType property of the CIM_OperatingSystem "
|
|
" class must match the type of the TargetOperatingSystem property. "
|
|
""), Abstract]
|
|
class CIM_OSVersionCheck: CIM_Check{
|
|
[Description(" Maximum version of required operating system. The value is "
|
|
"encoded as <major>.<minor>.<revision> or <major>.<minor><letter "
|
|
"revision>"),
|
|
maxlen(64),
|
|
ModelCorrespondence{"CIM_OperatingSystem.Version"}, Read]
|
|
STRING MaximumVersion;
|
|
[Description(" Minimum version of required operating system. The value is "
|
|
"encoded as <major>.<minor>.<revision> or <major>.<minor><letter "
|
|
"revision>"),
|
|
maxlen(64),
|
|
ModelCorrespondence{"CIM_OperatingSystem.Version"}, Read]
|
|
STRING MinimumVersion;
|
|
|
|
};
|
|
|
|
[Locale ( 0x409 ) , UUID ( "{DC1D8140-DB30-11d2-85FC-0000F8102E5F}" ),
|
|
Description(" This class specifies information needed to check a particular "
|
|
"setting file for a specific entry that contains a value that "
|
|
"is equal to, or contains, the value specified. All compares "
|
|
"are assumed to be case insensitive."), Abstract]
|
|
class CIM_SettingCheck: CIM_Check{
|
|
[Description("This specifies the way the setting value should be compared."),
|
|
Values{"Matches", "Contains"}, Read]
|
|
UINT16 CheckType;
|
|
[Description("Name of the entry to be checked"),
|
|
Maxlen(256), Read]
|
|
STRING EntryName;
|
|
[Description("Value to be checked that is associated with the named entry."), Read]
|
|
STRING EntryValue;
|
|
[Description("File name of the setting file to be checked."),
|
|
Maxlen(1024), Read]
|
|
STRING FileName;
|
|
[Description("Key of section containing the settings to be checked."),
|
|
Maxlen(256), Read]
|
|
STRING SectionKey;
|
|
|
|
};
|
|
|
|
[Locale ( 0x409 ) , UUID ( "{4D23FBD0-DB31-11d2-85FC-0000F8102E5F}" ),
|
|
Description(" The CIM_SoftwareElementVersionCheck class specifies a type of "
|
|
"software element that must exist in the environment. This check "
|
|
"can be for a specific, minimum, maximum or a range of versions. "
|
|
"To specify a specific version the lower and upper versions must "
|
|
"be the same. To specify a minimum the lower version needs only "
|
|
"be specified. To specify a maximum version the upper version "
|
|
"needs only be specified. To specify a range both upper and lower "
|
|
"version need to be specified. The details of this checks are "
|
|
"compared with the corresponding details found in a CIM_SoftwareElement "
|
|
"object referenced by an CIM_InstalledSoftwareElement association "
|
|
"for the CIM_ComputerSystem object. As long as there is at least "
|
|
"one CIM_SoftwareElement that satisfies the details of the condition, "
|
|
"the check is satisfied. In other words, all the software elements "
|
|
"on the relevant computer system do not need to satisfy the "
|
|
"condition. There needs to be at least one."), Abstract]
|
|
class CIM_SoftwareElementVersionCheck: CIM_Check{
|
|
[Description(" The minimum version of a software elements being checked."),
|
|
maxlen(64),
|
|
ModelCorrespondence{"CIM_SoftwareElement.Version"}, Read]
|
|
STRING LowerSoftwareElementVersion;
|
|
[Description(" The name of the software element being checked. "),
|
|
maxlen(256),
|
|
ModelCorrespondence{"CIM_SoftwareElement.Name"}, Read]
|
|
STRING SoftwareElementName;
|
|
[Description(" The state of the software element being checked."),
|
|
maxlen(64),
|
|
ModelCorrespondence{"CIM_SoftwareElement.SoftwareElementState"},
|
|
Values{"Deployable", "Installable", "Executable", "Running"}, Read]
|
|
UINT16 SoftwareElementStateDesired;
|
|
[Description(" The target operating system of the software element being checked."),
|
|
maxlen(64),
|
|
ModelCorrespondence{"CIM_SoftwareElement.TargetOperatingSystem"},
|
|
Values{"Unknown", "Other", "MACOS", "ATTUNIX", "DGUX",
|
|
"DECNT", "Digital Unix", "OpenVMS", "HPUX", "AIX", "MVS",
|
|
"OS400", "OS/2", "JavaVM", "MSDOS", "WIN3x", "WIN95",
|
|
"WIN98", "WINNT", "WINCE", "NCR3000", "NetWare", "OSF",
|
|
"DC/OS", "Reliant UNIX", "SCO UnixWare", "SCO OpenServer", "Sequent", "IRIX",
|
|
"Solaris", "SunOS", "U6000", "ASERIES", "TandemNSK", "TandemNT",
|
|
"BS2000", "LINUX", "Lynx", "XENIX", "VM/ESA", "Interactive UNIX",
|
|
"BSDUNIX", "FreeBSD", "NetBSD", "GNU Hurd", "OS9", "MACH Kernel",
|
|
"Inferno", "QNX", "EPOC", "IxWorks", "VxWorks", "MiNT",
|
|
"BeOS", "HP MPE", "NextStep", "PalmPilot", "Rhapsody",
|
|
"Windows 2000", "Dedicated", "VSE", "TPF"}, Read]
|
|
UINT16 TargetOperatingSystemDesired;
|
|
[Description(" The maximum version of a software elements being checked."),
|
|
maxlen(64),
|
|
ModelCorrespondence{"CIM_SoftwareElement.Version"}, Read]
|
|
STRING UpperSoftwareElementVersion;
|
|
|
|
};
|
|
|
|
[Locale ( 0x409 ) , UUID ( "{A5AE701E-DB31-11d2-85FC-0000F8102E5F}" ),
|
|
Description(" The CIM_SwapSpaceCheck class specifies the amount of swap space that "
|
|
"needs to be available on the system. The amount is specified "
|
|
"in the SwapSpaceSize property. The details of this checks are "
|
|
"compared with the corresponding details found in a CIM_OperatingSystem "
|
|
" object referenced by CIM_InstalledOS association for the CIM_ComputerSystem "
|
|
"object describing the environment. When the value of TotalSwapSpaceSize "
|
|
"property is greater than or equal to the value specified in "
|
|
" SwapSpacesize, the condition is satisfied. "), Abstract]
|
|
class CIM_SwapSpaceCheck: CIM_Check{
|
|
[Description(" The SwapSpaceSize property specifies the minimum number of Kilo"
|
|
"bytes of swap space that needs to be available on the target "
|
|
"system."),
|
|
ModelCorrespondence{"CIM_OperatingSystem.TotalSwapSpaceSize"},
|
|
units("KiloBytes"), Read]
|
|
UINT64 SwapSpaceSize;
|
|
|
|
};
|
|
|
|
[Locale ( 0x409 ) , UUID ( "{D368CA4A-DB31-11d2-85FC-0000F8102E5F}" ),
|
|
Description(" The CIM_VersionCompatibilityCheck class specifies whether it is "
|
|
" permissible to create the next state of a software element. "
|
|
""), Abstract]
|
|
class CIM_VersionCompatibilityCheck: CIM_Check{
|
|
[Description(" The AllowDownVersion property indicates that this software element "
|
|
" can transition to its next state even if a higher or latter "
|
|
"version of the software element already exists in the environment."), Read]
|
|
BOOLEAN AllowDownVersion;
|
|
[Description(" The AllowMultipleVersions option controls the ability to configure "
|
|
" multiple versions of a product on a system."), Read]
|
|
BOOLEAN AllowMultipleVersions;
|
|
[Description(" The Reinstall property indicates that this software element "
|
|
"can transition to its next state even if a software element "
|
|
"of the same version already exists in the environment."), Read]
|
|
BOOLEAN Reinstall;
|
|
|
|
};
|
|
|
|
|
|
[Locale(0x409),UUID ( "{42B2EC5C-DB35-11d2-85FC-0000F8102E5F}" ), Abstract,
|
|
Description("A link between BIOS feature and its aggregated BIOS elements.")]
|
|
class CIM_BIOSFeatureBIOSElements: CIM_SoftwareFeatureSoftwareElements{
|
|
[Description("The BIOS feature."),
|
|
Override("GroupComponent"), Read]
|
|
CIM_BIOSFeature Ref GroupComponent;
|
|
[Description("The BIOS element that implements the capabilities described by "
|
|
"BIOS feature."),
|
|
Override("PartComponent"), Read]
|
|
CIM_BIOSElement Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{B3F86390-DB37-11d2-85FC-0000F8102E5F}" ), Abstract,
|
|
Description("A link between video BIOS feature and its aggregated video BIOS elements.")]
|
|
class CIM_VideoBIOSFeatureVideoBIOSElements: CIM_SoftwareFeatureSoftwareElements{
|
|
[Description("The video BIOS feature."),
|
|
Override("GroupComponent"), Read]
|
|
CIM_VideoBIOSFeature Ref GroupComponent;
|
|
[Description("The video BIOS element that implements the capabilities described "
|
|
"by video BIOS feature."),
|
|
Override("PartComponent"), Read]
|
|
CIM_VideoBIOSElement Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{0E17B9EA-E3D3-11d2-8601-0000F8102E5F}" ),
|
|
Description(" The CIM_ApplicationSystemSoftwareFeature associations identifies "
|
|
"the software features that make up a particular application "
|
|
"system. The software features can be part of different products. "
|
|
""), Abstract]
|
|
class CIM_ApplicationSystemSoftwareFeature: CIM_SystemComponent{
|
|
[Description("The parent system in the association"),
|
|
Min(0),
|
|
Override("GroupComponent"), Read]
|
|
CIM_ApplicationSystem Ref GroupComponent;
|
|
[Description("The child element that is a component of a system"),
|
|
Min(0),
|
|
Override("PartComponent"), Read]
|
|
CIM_SoftwareFeature Ref PartComponent;
|
|
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{1BE949DA-DB36-11d2-85FC-0000F8102E5F}" ),
|
|
Description("An association between a service access point and how it is implemented. "
|
|
"The cardinality of this association is many-to-many. A SAP may "
|
|
"be provided by more than one logical device, operating in conjunction. "
|
|
" And, any device may provide more than one service access point. "
|
|
"When many logical devices are associated with a single SAP, it "
|
|
"is assumed that these elements operate in conjunction to provide "
|
|
"the access point. If different implementations of a SAP exist, "
|
|
"each of these implementations would result in individual instantiations "
|
|
"of the service access point object. These individual instantiations "
|
|
"would then have associations to the unique implementations."), Abstract]
|
|
class CIM_DeviceSAPImplementation: CIM_Dependency{
|
|
[Description("The logical device."),
|
|
Override("Antecedent"), Read]
|
|
CIM_LogicalDevice Ref Antecedent;
|
|
[Description("The service access point implemented using the logical device."),
|
|
Override("Dependent"), Read]
|
|
CIM_ServiceAccessPoint Ref Dependent;
|
|
|
|
};
|
|
|
|
|
|
[Locale(0x409),UUID ( "{7EFCC186-DB37-11d2-85FC-0000F8102E5F}" ),
|
|
Description(" An association between a service access point and how it is "
|
|
"implemented in software. The cardinality of this association "
|
|
" is many-to-many. A SAP may be provided by more than one software feature, "
|
|
"operating in conjunction. And, any software feature may provide "
|
|
"more than one service access point. a When many software features "
|
|
"are associated with single SAP, it is assumed that these elements "
|
|
"operate in conjunction to provide the access point. If different "
|
|
"implementations of a SAP exist, each of these implementations "
|
|
"would result in individual instantiations of the service access point "
|
|
"object. These individual instantiations would then have associations "
|
|
" to the unique implementations. "), Abstract]
|
|
class CIM_SoftwareFeatureSAPImplementation: CIM_Dependency{
|
|
[Min(0),
|
|
Override("Antecedent"), Read,
|
|
Description ("The antecedent software feature.")]
|
|
CIM_SoftwareFeature Ref Antecedent;
|
|
[Min(0),
|
|
Override("Dependent"), Read,
|
|
Description ("The dependent service access point.")]
|
|
CIM_ServiceAccessPoint Ref Dependent;
|
|
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{8AC984F4-DB37-11d2-85FC-0000F8102E5F}" ),
|
|
Description(" An association between a service and how it is implemented in "
|
|
"software. The cardinality of this association is many-to-many. "
|
|
" A service may be provided by more than one software feature, "
|
|
"operating in conjunction. And, any software Feature may provide "
|
|
"more than one service. When multiple software features are associated "
|
|
"with a single service, it is assumed that these elements operate "
|
|
"in conjunction to provide the service. If different implementations "
|
|
"of a service exist, each of these implementations would result "
|
|
"in individual instantiations of the service object. These individual "
|
|
"instantiations would then have associations to the unique implementations. "
|
|
""), Abstract]
|
|
class CIM_SoftwareFeatureServiceImplementation: CIM_Dependency{
|
|
[Min(0),
|
|
Override("Antecedent"), Read,
|
|
Description ("The antecedent software feature.")]
|
|
CIM_SoftwareFeature Ref Antecedent;
|
|
[Min(0),
|
|
Override("Dependent"), Read,
|
|
Description ("The dependent service.")]
|
|
CIM_Service Ref Dependent;
|
|
|
|
};
|
|
|
|
|
|
|
|
[Locale(0x409),UUID ( "{422D175A-E3D5-11d2-8601-0000F8102E5F}" ),
|
|
Description("CIM_SAPSAPDependency is an association between a service access point "
|
|
"and another service access point indicating that the latter is "
|
|
"required in order for the former service access point to utilize "
|
|
"or connect with its service. For example, to print at a network "
|
|
"printer, local print access points must utilize underlying network-related "
|
|
"SAPs, or protocol endpoints, in order to send the print request."), Abstract]
|
|
class CIM_SAPSAPDependency: CIM_Dependency{
|
|
[Description("The required service access point."),
|
|
Override("Antecedent"), Read]
|
|
CIM_ServiceAccessPoint Ref Antecedent;
|
|
[Description("The service access point that is dependent on an underlying SAP."),
|
|
Override("Dependent"), Read]
|
|
CIM_ServiceAccessPoint Ref Dependent;
|
|
|
|
};
|
|
|
|
|
|
[Locale(0x409),UUID ( "{6EDF1DD2-DB35-11d2-85FC-0000F8102E5F}" ),
|
|
Description("CIM_BootServiceAccessBySAP is the relationship between a boot service "
|
|
"and its access points."), Abstract]
|
|
class CIM_BootServiceAccessBySAP: CIM_ServiceAccessBySAP{
|
|
[Description("The boot service."),
|
|
Override("Antecedent"), Read]
|
|
CIM_BootService Ref Antecedent;
|
|
[Description("An access point for the boot service."),
|
|
Override("Dependent"), Read]
|
|
CIM_BootSAP Ref Dependent;
|
|
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{88F073D8-DB35-11d2-85FC-0000F8102E5F}" ),
|
|
Description("CIM_ClusterServiceAccessBySAP is the relationship between a clustering service "
|
|
"and its access points."), Abstract]
|
|
class CIM_ClusterServiceAccessBySAP: CIM_ServiceAccessBySAP{
|
|
[Description("The clustering service."),
|
|
Override("Antecedent"), Read]
|
|
CIM_ClusteringService Ref Antecedent;
|
|
[Description("An access point for the clustering service."),
|
|
Override("Dependent"), Read]
|
|
CIM_ClusteringSAP Ref Dependent;
|
|
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{652E2D58-DB37-11d2-85FC-0000F8102E5F}" ),
|
|
Description("CIM_ServiceSAPDependency is an association between a service "
|
|
"and a service access point indicating that the referenced SAP is "
|
|
"utilized by the service to provide its functionality. For example, "
|
|
"boot services may invoke BIOS' disk services (interrupts) in "
|
|
"order to function."), Abstract]
|
|
class CIM_ServiceSAPDependency: CIM_Dependency{
|
|
[Description("The required service access point"),
|
|
Override("Antecedent"), Read]
|
|
CIM_ServiceAccessPoint Ref Antecedent;
|
|
[Description("The service that is dependent on an underlying SAP."),
|
|
Override("Dependent"), Read]
|
|
CIM_Service Ref Dependent;
|
|
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{F6FEF20A-E3D2-11d2-8601-0000F8102E5F}" ),
|
|
Description("A representation of the access points of a boot service."), Abstract]
|
|
class CIM_BootSAP: CIM_ServiceAccessPoint{
|
|
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{7D33100E-E3D3-11d2-8601-0000F8102E5F}" ),
|
|
Description("CIM_BIOSFeature represents the capabilities of the low-level software "
|
|
"that is used to bring up and configure a computer system."), Abstract]
|
|
class CIM_BIOSFeature: CIM_SoftwareFeature{
|
|
[ArrayType("Indexed"),
|
|
Description("An array of free-form strings providing more detailed explanations "
|
|
"for any of the BIOS features indicated in the Characteristics "
|
|
"array. Note, each entry of this array is related to the entry "
|
|
"in the Characteristics array that is located at the same index."),
|
|
MappingStrings{"MIF.DMTF|BIOS Characteristic|003.4"},
|
|
ModelCorrespondence{"CIM_BIOSFeature.Characteristics"}, Read]
|
|
STRING CharacteristicDescriptions[];
|
|
[ArrayType("Indexed"),
|
|
Description("An array of integers that specify the features supported by the "
|
|
"BIOS. For example, one can specify that PnP capabilities are "
|
|
"provided (value=9) or that infrared devices are supported (21). "
|
|
"The value, 3, is not valid in the CIM schema since in DMI it "
|
|
"represents that no BIOS features are supported. In this case, "
|
|
"this object should not be instantiated."),
|
|
MappingStrings{"MIF.DMTF|BIOS Characteristic|003.3"},
|
|
ModelCorrespondence{"CIM_BIOSFeature.CharacteristicDescriptions"},
|
|
ValueMap{"1", "2", "3", "4", "5",
|
|
"6", "7", "8", "910", "11", "12",
|
|
"13", "14", "15", "16", "17", "18",
|
|
"19", "20", "21", "22", "23", "24",
|
|
"160"},
|
|
Values{"Other", "Unknown", "Undefined", "ISA Support", "MCA Support",
|
|
"EISA Support", "PCI Support", "PCMCIA Support", "PnP Support", "APM Support", "Upgradeable BIOS",
|
|
"BIOS Shadowing Allowed", "VL VESA Support", "ESCD Support", "LS-120 Support", "ACPI Support", "I2O Boot Support",
|
|
"USB Legacy Support", "AGP Support", "PC Card", "IR", "1394", "I2C",
|
|
"Smart Battery", "PC-98"}, Read]
|
|
UINT16 Characteristics[];
|
|
|
|
};
|
|
|
|
[Locale(0x409),UUID ( "{BAE20634-E3D4-11d2-8601-0000F8102E5F}" ),
|
|
Description("CIM_VideoBIOSFeature represents the capabilities of the low-level "
|
|
"software that is used to bring up, configure and use a computer system's "
|
|
"video controller and display."), Abstract]
|
|
class CIM_VideoBIOSFeature: CIM_SoftwareFeature{
|
|
[ArrayType("Indexed"),
|
|
Description("An array of free-form strings providing more detailed explanations "
|
|
"for any of the video BIOS features indicated in the Characteristics "
|
|
"array. Note, each entry of this array is related to the entry "
|
|
"in the Characteristics array that is located at the same index."),
|
|
MappingStrings{"MIF.DMTF|Video BIOS Characteristic|001.4"},
|
|
ModelCorrespondence{"CIM_VideoBIOSFeature.Characteristics"}, Read]
|
|
STRING CharacteristicDescriptions[];
|
|
[ArrayType("Indexed"),
|
|
Description("An array of integers that specify the features supported by the "
|
|
"video BIOS. For example, one could indicate support for VESA power "
|
|
"management (value=6) or video BIOS shadowing (8). The value, "
|
|
"3, is not valid in the CIM schema since in DMI it represents "
|
|
"that no BIOS features are supported. In this case, the object "
|
|
"should not be instantiated."),
|
|
MappingStrings{"MIF.DMTF|Video BIOS Characteristic|001.3"},
|
|
ModelCorrespondence{"CIM_VideoBIOSFeature.CharacteristicDescriptions"},
|
|
ValueMap{"1", "2", "3", "4", "5",
|
|
"6", "7", "8", "9"}, Read,
|
|
Values{"Other", "Unknown", "Undefined", "Standard Video BIOS", "VESA BIOS Extensions Supported",
|
|
"VESA Power Management Supported", "VESA Display Data Channel Supported", "Video BIOS Shadowing Allowed", "Video BIOS Upgradeable"}]
|
|
UINT16 Characteristics[];
|
|
};
|
|
|
|
|
|
|
|
|
|
[Description (
|
|
"The management characterisitics of a USB Device. These ") ]
|
|
class CIM_USBDevice: CIM_LogicalDevice
|
|
{
|
|
[Description (
|
|
"Indicates the latest USB Version supported by the USB Device. "
|
|
"The property is expressed as a Binary-Coded Decimal (BCD) "
|
|
"where a decimal point is implied between the 2nd and 3rd "
|
|
"digits. For example, a value of 0x201 indicates that "
|
|
"version 2.01 is supported.")
|
|
]
|
|
uint16 USBVersion;
|
|
[Description ("Indicates the USB class code.") ]
|
|
uint8 ClassCode;
|
|
[Description ("Indicates the USB subclass code.") ]
|
|
uint8 SubclassCode;
|
|
[Description ("Indicates the USB protocol code.") ]
|
|
uint8 ProtocolCode;
|
|
[Description (
|
|
"Number of device configurations that are defined for the "
|
|
"Device.")
|
|
]
|
|
uint8 NumberOfConfigs;
|
|
[Description (
|
|
"Indicates the configuration currently selected for the "
|
|
"Device. If this value is zero, the Device is "
|
|
"unconfigured."),
|
|
ModelCorrespondence {"CIM_USBDevice.CurrentAlternateSettings"}
|
|
]
|
|
uint8 CurrentConfigValue;
|
|
[Description (
|
|
"An array of USB 'alternate settings' for each interface "
|
|
"in the currently selected configuration (indicated by the "
|
|
"CurrentConfigValue property). This array has one entry for "
|
|
"each interface in the configuration. If the property, "
|
|
"CurrentConfigValue, is zero (indicating the Device is not "
|
|
"configured), the array is undefined. To understand how "
|
|
"to parse this octet string, refer to the USB Specification."),
|
|
ModelCorrespondence {"CIM_USBDevice.CurrentConfigValue"}
|
|
]
|
|
uint8 CurrentAlternateSettings[];
|
|
[Description (
|
|
"This method returns the USBDevice Descriptor as specified by "
|
|
"the input parameters. Each parameter is briefly described here "
|
|
"with more detail in its Qualifier list. RequestType is an input "
|
|
"parameter that defines whether the request is for standard, "
|
|
"class or vendor-specific information, as well as specifying the "
|
|
"recipient. RequestValue is also an input parameter and defines "
|
|
"the USB Descriptor Type and Index. RequestIndex is an input "
|
|
"parameter which describes the language used to return a string "
|
|
"Descriptor. RequestLength is both an input and output parameter. "
|
|
"It specifies the length of the Descriptor that should be returned "
|
|
"(on input) and what is actually returned in the Buffer parameter "
|
|
"(on output). Buffer is an output parameter, containing the "
|
|
"Descriptor data. The GetDescriptor method returns an integer "
|
|
"value of 0 if the USB Descriptor is successfully returned, "
|
|
"1 if the request is not supported and any other number to "
|
|
"indicate an error.\n"
|
|
"In a subclass, the set of possible return codes could be "
|
|
"specified, using a ValueMap qualifier on the method. The "
|
|
"strings to which the ValueMap contents are 'translated' may "
|
|
"also be specified in the subclass as a Values array qualifier.")
|
|
]
|
|
uint32 GetDescriptor(
|
|
[IN, Description ("RequestType is bit-mapped and identifies the type "
|
|
"of Descriptor request and the recipient. The type of request "
|
|
"may be 'standard', 'class' or 'vendor-specific'. The recipient may "
|
|
"be 'device', 'interface', 'endpoint' or 'other'. Refer to the USB "
|
|
"Specification for the appropriate values for each bit.")]
|
|
uint8 RequestType,
|
|
[IN, Description ("RequestValue contains the Descriptor Type in the "
|
|
"high byte and the Descriptor Index (for example, index or offset "
|
|
"into the Descriptor array) in the low byte. Refer to the USB "
|
|
"Specification for more information.")]
|
|
uint16 RequestValue,
|
|
[IN, Description ("RequestIndex defines the 2 byte Language ID code "
|
|
"used by the USBDevice when returning string Descriptor data. The "
|
|
"parameter is typically 0 for non-string Descriptors. Refer to the "
|
|
"USB Specification for more information.")]
|
|
uint16 RequestIndex,
|
|
[IN, OUT, Description ("On input, RequestLength is the length (in "
|
|
"octets) of the Descriptor that should be returned. If this value "
|
|
"is less than the actual length of the Descriptor, only the requested "
|
|
"length will be returned. If it is more than the actual length, the "
|
|
"actual length is returned. On output, this parameter is the length, "
|
|
"in octets, of the Buffer being returned. If the requested "
|
|
"Descriptor does not exist, the contents of this parameter are "
|
|
"undefined.")]
|
|
uint16 RequestLength,
|
|
[OUT, Description ("Buffer returns the requested Descriptor "
|
|
"information. If the Descriptor does not exist, the contents of "
|
|
"the Buffer are undefined.")]
|
|
uint8 Buffer[]);
|
|
};
|
|
|
|
|
|
|
|
[Description ("USB Hub Device.") ]
|
|
class CIM_USBHub : CIM_USBDevice
|
|
{
|
|
[Description (
|
|
"Indicates whether power to the Hub Ports is individually or "
|
|
"gang-switched. If this value is FALSE, power is switched "
|
|
"individually for each Port. If this value is TRUE, power is "
|
|
"switched to all Ports on the Hub at once.")
|
|
]
|
|
boolean GangSwitched;
|
|
[Description (
|
|
"Number of downstream Ports on the Hub, including those "
|
|
"embedded in the Hub's silicon. Individual USBPorts are "
|
|
"associated with the Hub using the USBPortOnHub association.")
|
|
]
|
|
uint8 NumberOfPorts;
|
|
};
|
|
|
|
[Description (
|
|
"USBControllerHasHub defines the Hub(s) that are downstream "
|
|
"of the USBController.")
|
|
]
|
|
class CIM_USBControllerHasHub : CIM_ControlledBy
|
|
{
|
|
[Override ("Antecedent"),
|
|
Min(1), Max(1),
|
|
Description ("The USBController.")
|
|
]
|
|
CIM_USBController REF Antecedent;
|
|
[Override ("Dependent"),
|
|
Min(1),
|
|
Description (
|
|
"The USBHub that is associated with the Controller.")
|
|
]
|
|
CIM_USBHub REF Dependent;
|
|
};
|
|
|