archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/admin/wmi/wbem/providers/mofs/win32_cim.mof

9501 lines
438 KiB
Raw Permalink Blame History

// (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",
"24", "25", "26", "27", "28", "29", "30",
"31", "32", "33", "34", "35", "36", "37", "38", "39",
"48", "49", "50", "51", "52", "53", "54", "55",
"64", "65", "66", "67", "68", "69",
"80", "81", "82", "83", "84", "85", "86", "87", "88",
"96", "97", "98", "99", "100", "101",
"112", "120", "121", "128", "130",
"144", "145", "146", "147", "148", "149", "150",
"160", "176", "177", "178", "179",
"180", "181", "182", "183", "184", "185",
"190", "200", "201", "202",
"250", "251", "260", "261", "280", "281",
"300", "301", "302", "320", "350", "500"},
Values {"Other", "Unknown", "8086", "80286", "80386", "80486",
"8087", "80287", "80387", "80487",
// 11
"Pentium(R) brand", "Pentium(R) Pro", "Pentium(R) II",
"Pentium(R) processor with MMX(TM) technology",
"Celeron(TM)", "Pentium(R) II Xeon(TM)",
"Pentium(R) III", "M1 Family", "M2 Family",
//24
"K5 Family", "K6 Family", "K6-2", "K6-3",
"AMD Athlon(TM) Processor Family",
"AMD(R) Duron(TM) Processor", "AMD29000 Family",
//31
"K6-2+", "Power PC Family", "Power PC 601",
"Power PC 603", "Power PC 603+", "Power PC 604",
"Power PC 620", "Power PC X704", "Power PC 750",
// 48
"Alpha Family", "Alpha 21064", "Alpha 21066",
"Alpha 21164", "Alpha 21164PC", "Alpha 21164a",
"Alpha 21264", "Alpha 21364",
// 64
"MIPS Family", "MIPS R4000", "MIPS R4200",
"MIPS R4400", "MIPS R4600", "MIPS R10000",
// 80
"SPARC Family", "SuperSPARC","microSPARC II",
"microSPARC IIep", "UltraSPARC", "UltraSPARC II",
"UltraSPARC IIi", "UltraSPARC III", "UltraSPARC IIIi",
// 96
"68040", "68xxx Family", "68000",
"68010", "68020", "68030",
// 112
"Hobbit Family",
"Crusoe(TM) TM5000 Family", "Crusoe(TM) TM3000 Family",
"Weitek", "Itanium(TM) Processor",
// 144
"PA-RISC Family", "PA-RISC 8500", "PA-RISC 8000",
"PA-RISC 7300LC", "PA-RISC 7200", "PA-RISC 7100LC",
"PA-RISC 7100",
// 160
"V30 Family", "Pentium(R) III Xeon(TM)",
"Pentium(R) III Processor with Intel(R) SpeedStep(TM) "
"Technology",
"Pentium(R) 4", "Intel(R) Xeon(TM)",
// 180
"AS400 Family", "Intel(R) Xeon(TM) processor MP",
"AMD AthlonXP(TM) Family", "AMD AthlonMP(TM) Family",
"Intel(R) Itanium(R) 2", "AMD Opteron(TM) Family",
// 190
"K7",
// 200
"IBM390 Family", "G4", "G5",
// 250
"i860", "i960", "SH-3", "SH-4", "ARM", "StrongARM",
// 300
"6x86", "MediaGX", "MII", "WinChip", "DSP",
"Video Processor"},
MappingStrings {"MIF.DMTF|Processor|014.3"},
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 ;
};
[Privileges{"SeDebugPrivilege"},
Dynamic, Provider ("CIMWin32") , Description (
"A link between a process and a data file indicating that the file "
"participates in the execution of the process.\n"
"Note: In order to receive all possible instances of this class, the "
"SE_DEBUG_PRIVILEGE should be enabled."),
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,
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;
};