// ===================================================================
// Title:       System MOF specification 2.6
// Filename:    CIM_System26.mof
// Version:     2.6.0
// Status:      Final
// Date:        06/04/2002
// ===================================================================
// Copyright 1998-2002 Distributed Management Task Force, Inc. (DMTF).
// All rights reserved.  
// DMTF is a not-for-profit association of industry members dedicated 
// to promoting enterprise and systems management and interoperability. 
// DMTF specifications and documents may be reproduced for uses
// consistent with this purpose by members and non-members, 
// provided that correct attribution is given. 
// As DMTF specifications may be revised from time to time, 
// the particular version and release date should always be noted.
//
// Implementation of certain elements of this standard or proposed 
// standard may be subject to third party patent rights, including 
// provisional patent rights (herein "patent rights"). DMTF makes 
// no representations to users of the standard as to the existence 
// of such rights, and is not responsible to recognize, disclose, or
// identify any or all such third party patent right, owners or 
// claimants, nor for any incomplete or inaccurate identification or 
// disclosure of such rights, owners or claimants. DMTF shall have no 
// liability to any party, in any manner or circumstance, under any 
// legal theory whatsoever, for failure to recognize, disclose, or 
// identify any such third party patent rights, or for such party’s
// reliance on the standard or incorporation thereof in its product, 
// protocols or testing procedures. DMTF shall have no liability to 
// any party implementing such standard, whether such implementation 
// is foreseeable or not, nor to any patent owner or claimant, and shall 
// have no liability or responsibility for costs or losses incurred if 
// a standard is withdrawn or modified after publication, and shall be
// indemnified and held harmless by any party implementing the 
// standard from any and all claims of infringement by a patent owner 
// for such implementations.
//
// For information about patents held by third-parties which have 
// notified the DMTF that, in their opinion, such patent may relate to 
// or impact implementations of DMTF standards, visit 
// http://www.dmtf.org/about/policies/disclosures.php.
// ===================================================================
// Description: The System Model extend the management concepts
//              of a System.  This includes the concepts of virtual
//              computer systems, unitary computer systems, file 
//              systems, operating systems, diagnostics, and etc.
//
//              The object classes below are listed in an order that
//              avoids forward references. Required objects, defined 
//              by other working groups, are omitted.
// ==================================================================
//  Date 06/16/1998 - V2.0 Errata
//      - CR233 Format for specifying Propagated keys uses
//          period, not colon and CIM_ missing from class name
//          (CIM_OperatingSystemSoftwareFeature)
//  Date 09/29/1998 - Version 2.1
//      - CR251 Remove DMI mapping reference from OperatingSystem.
//          NumberOfUsers and move to LocalDateTime
//      - CR268 Change cardinality of the Antecedent reference
//          of the ParticipatingCS association (to Min (1))
//      - CR273 Remove repetition of the Values array from the
//          descriptions of several properties
//      - CR276b Add to the enumeration for UnitaryComputerSystem.
//          PowerState
//      - CR290 Add ModelCorrespondence to "linked" properties
//      - CR293 Correct xxxMemory properties of OperatingSystem
//          and add MaxProcessMemorySize property
//  Date 06/08/1999 - Version 2.2
//      - CR354 Update the Values array for "power save" for
//          UnitaryComputerSystem (both the property and method)
//      - CR355a Update the method descriptions for SetPowerState,
//          AddNode, EvictNode, Reboot and Shutdown indicating 
//          that Values-ValueMap qualifiers can be defined for 
//          return codes
//      - CR356a Put keys on the references of Export
//      - CR358a Add ClusterSize property to FileSystem
//      - CR363 Update OperatingSystem.OSType enumeration and the
//          description for OperatingSystem.OtherTypeDescription
//      - CR364 Create TotalVisibleMemorySize property on 
//          OperatingSystem
//      - CR368 Update ComponentCS' Description and add new 
//          associations, SystemPartition and SystemBIOS
//      - CR369 Update FileSystem - CodeSet's Description and 
//          enum, and create a new property, FileSystemType
//      - CR370a Update BIOSFeature.Characteristics enumeration and
//          add ListOfLanguages and CurrentLanguage properties
//          to BIOSElement
//      - CR371 Add WakeUpType property to UnitaryComputerSystem
//      - CR374a Update Process' Description
//      - CR383 and 409 - Add OS/390, VSE and TPF to OS's OSType enum
//      - CR386 Add to the enums for Cluster.Types and 
//          ParticipatingCS.RoleOfNode and update the latter's 
//          Description
//      - CR388a Create StorageLibrary object
//      - CR405 Add Counter and Gauge qualifiers
//      - CR407 Remove the word "automated" from StorageLibrary's
//          Description / Update descriptions for AuditInProgress
//          and MaxAuditTime
//      - CR408 Set ComputerSystem's cardinality in SystemPartition
//          to Max (1)
//      - CR417a Change cardinality of UnitaryComputerSystem in
//          SystemBIOS (add Max (1)) and remove Min (1) from 
//          ComputerSystem for RunningOS
//  Date 07/06/1999 - Version 2.2.1
//      - CR423 Locale should be specified as en_US
//      - CR425 Update the DMI MappingStrings using the June
//          release of the master.mif
//  Date 02/18/2000 - Version 2.3
//      - CR433 Add new properties and enums from Master.MIF and  
//          new ModelCorrespondences 
//      - CR344 Update to CIM_FileSystem classes and associations
//      - CR437e Diagnostic extensions, classes and associations.
//      - CR460a Add Gauge qualifier to properties
//      - CR473 Update to CIM_Mount association 
//  Date 06/09/2000 - Version 2.4
//      - CR480 Add a property to CIM_StorageLibrary, RoboticsEnabled.
//      - CR488 Change descriptions in CIM_Service:DiagnosticTest 
//          RunTest method, DiagnosticResult, DiagnosticSetting
//  Date 07/14/2000 - Version 2.4
//      - CR504 ERRATA to CIM V2.3 Add remainder of the propagated keys 
//          for DiagnosticResult
//      - CR511a Update to the DiagnosticSetting.SettingID Description
//      - CR517 Correct Compile error on RunTest method in the class 
//          CIM_DiagnosticTest
//  Date 12/01/2000 Version 2.5
//      - CR533b Add Windows (R) Me  to Operating System property 
//          enumerations
//      - CR541a Add an association between Process and Service
//      - CR543a Update the Description for LogicalFile.Name
//      - CR582 ERRATA - Change the ValueMap qualifier to a Values 
//          qualifier on the CIM_DiagnosticTest.ResourcesUsed[]
//          property due to type mismatch.
//  Date 05/24/2001 Version 2.5 Final
//      - Reordered classes to match Visio
//      - Changed class format to be consistent
//  Date 05/23/2001 - Final Version 2.5
//      - Reordered classes to match Visio
//      - CR606 Add the Aggregate qualifier where missing:
//          DiagnosticeTestInPackage, DiagnosticResultInPackage,
//  Date 05/24/2001 Version 2.6 Preliminary
//      - CR583d Moved the following properties and methods from
//          UnitaryComputerSystem to ComputerSystem:
//          ResetCapability, PowerManagementCapabilites, and 
//          SetPowerState; Added SetPowerStateWithBootFlags 
//          method to ComputerSystem.
//      - CR608b Add values "Caldera Open UNIX" and "OpenBSD"
//          to OperatingSystem.OSType; Add property 
//          MaxProcessesPerUser to OperatingSystem; Add property 
//          OtherExecutionDescription to Process; Add property 
//          Executable to LogicalFile
//      - Added include pragma for CIM_System26_Add1.mof for
//          CR583d (SystemBootOptions), CR607 (TimeZone), &
//          CR612 (IBSubnetManager)
//      - Added include pragma for CIM_System26_Add2.mof for CR608 
//          (Unix environment) extentions.
//  Date 03/22/2002 - Final Version 2.6
//      - CR689 Clean up descriptions in TimeZone.
//      - CR690, CR734, and CR832 
//          Clean up UNIX model
//      - CR733 Specify "IN (false)" for all out only parameters.
//      - CR746 Add the version qualifier to all classes.
//      - CR755 Move the definition of classes to prevent forward
//          reference
//      - CR828 Errata Update the enumeration for OperatingSystem.
//          OSType to match the Application Model's SoftwareElement.
//          TargetOperatingSystem.
//      - Fix lines taht exceed 72 characters.
//  Date 05/31/2002 - Final Version 2.6
//      - CR841, Incorporate company review comments on TimeZone
//      - CR842, Change NamedPipe to FIFOPipeFile and update 
//          Description
// ===================================================================

// ===================================================================
// Pragmas
// ===================================================================
#pragma locale ("en_US")

// ===================================================================
//  System
// ===================================================================
// ===================================================================
// ComponentCS
// ===================================================================
   [Association, Aggregation, Version ("2.6.0"), Description (
     "A ComputerSystem can aggregate another ComputerSystem. "
     "This association can be used to model MPP Systems with "
     "workstation frontends, an I2O subsystem embedded in a Unitary"
     "ComputerSystem, or a System that splits functionality between "
     "two processors, potentially running different Operating"
     "Systems. For example, if a CISC Processor and its associated "
     "OperatingSystem, are used for user interface and file "
     "support, and a RISC Processor and its OS are used for complex "
     "mathematical operations, this could be modeled as two "
     "ComputerSystems where one aggregates the other. In some cases, "
     "this could be modeled as a Cluster. The difference is the "
     "focus of the relationship. ComponentCS represents that "
     "unique and distinct ComputerSystems are aggregated by a "
     "higher level CS object. However, each of the component CSs are "
     "still distinguishable entities and are only viewed as such. "
     "Alternately, with a Cluster, the ComputerSystems that "
     "participate in it are inconsequential, when viewed through the "
     "'Cluster System'.\n\n"
     "When instantiating or subclassing the ComponentCS "
     "relationship, care should be taken that the component "
     "ComputerSystem meets the definitional requirements of a "
     "ComputerSystem - ie, a functional whole that provides "
     "compute capabilities and aggregates System Devices, an "
     "OperatingSystem, etc.") ] 
class CIM_ComponentCS : CIM_SystemComponent {
      [Override ("GroupComponent"), Aggregate,
       Description (
        "The ComputerSystem that contains and/or aggregates other "
        "Systems.") ]
   CIM_ComputerSystem REF GroupComponent;
      [Override ("PartComponent"), 
       Description ("The contained (Sub)ComputerSystem.") ]
   CIM_ComputerSystem REF PartComponent;
};


// ===================================================================
// StorageLibrary
// ===================================================================
   [Version ("2.6.0"), Description (
     "A StorageLibrary is a collection of ManagedSystemElements "
     "that operate together to provide cartridge library "
     "capabilities. This object serves as an aggregation point to "
     "group the following elements: MediaTransferDevices, a Label"
     "Reader, a library Door, MediaAccessDevices, and other "
     "Library components.") ]
class CIM_StorageLibrary : CIM_System {
      [Description (
        "Capabilities of the StorageLibrary. For example, it can be "
        "indicated that the Library can perform automatic cleaning of "
        "the MediaAccessDevices contained in it (value=1) or that the "
        "Library provides physical door access for an operator "
        "(value=2)."),
       ValueMap {"0", "1", "2", "3", "4"}, 
       Values {"Unknown", "Other", "Automatic Cleaning", 
               "Manual Operation", "Front Panel Lockable"} ]
   uint16 Capabilities[];
      [Description (
        "Boolean set to TRUE if there are more PhysicalMedia in a "
        "Library than there are StorageMediaLocations to contain them. "
        "For instance, if all MediaAccessDevices have a Media loaded "
        "in them, and all StorageMediaLocations are loaded by an "
        "operator, then an Overfilled condition exists.") ]
   boolean Overfilled;
      [Description (
        "Boolean set to TRUE if the Library can not currently report "
        "the correct state of each PhysicalMedia within its proper "
        "StorageMediaLocation.") ]
   boolean AuditNeeded;
      [Description (
        "Boolean set to TRUE if an audit of the location of some or "
        "all of the Library's PhysicalMedia is currently being "
        "performed. That an individual Changer is currently doing an "
        "audit is indicated by a similar AuditInProgress boolean "
        "property on the Changer object.") ]
   boolean AuditInProgress;
      [Description (
        "Maximum time in seconds that it takes for the Storage"
        "Library to perform a complete audit of each StorageMedia"
        "Location, to determine the absence or presence of a Physical"
        "Media. If automated support is not provided, then this "
        "property's value is undefined."),
       Units ("Seconds") ]
   uint64 MaxAuditTime;
      [Description (
        "Boolean set to TRUE if the Library includes a robotics "
        "mechanism that can be controlled by a ComputerSystem, to "
        "automatically load and unload PhysicalMedia to/from "
        "MediaAccessDevices and StorageMediaLocations. The "
        "property is set to FALSE if the Library represents a "
        "repository of Media that are inaccessible to a MediaAccess"
        "Device without human intervention. An example of a non-"
        "automated Library is a 'shelf' or 'vault' where Physical"
        "Media are kept for extended periods of time.") ]
   boolean Automated;
      [Description (
        "Boolean indicating whether the Library's robotics are "
        "currently active/enabled. If TRUE, then the Library may not "
        "be safe for a human to enter.") ] 
    boolean RoboticsEnabled;
      [Description (
        "Requests that the Library robotics be enabled for "
        "automated operation (input parameter, Enabled, set to TRUE), "
        "or disabled for manual operation (input parameter set to "
        "FALSE). 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 EnableRobotics([IN] boolean Enable);
};


// ===================================================================
// UnitaryComputerSystem
// ===================================================================
   [Version ("2.6.0"), Description (
     "A class derived from ComputerSystem that represents a Desktop, "
     "Mobile, NetPC, Server or other type of a single node Computer "
     "System.") ] 
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.") ]
   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."),
       MappingStrings {
        "MIB.IETF|HOST-RESOURCES-MIB.hrSystemInitialLoadDevice",
        "MIB.IETF|HOST-RESOURCES-MIB.hrSystemInitialLoadParameters", 
        "MIF.DMTF|Host System|001.3"} ]
   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.") ]
   boolean PowerManagementSupported;    
      [Description (
        "Indicates the current power state of the ComputerSystem and "
        "its associated OperatingSystem. Regarding the Power Save "
        "states, these are defined as follows: Value 4 (\"Power Save "
        "- Unknown\") indicates that the System is known to be in a "
        "power save mode, but its exact status in this mode is "
        "unknown; 2 (\"Power Save - Low Power Mode\") indicates that "
        "the System is in a power save state but still functioning, "
        "and may exhibit degraded performance; 3 (\"Power Save - "
        "Standby\") describes that the System is not functioning but "
        "could be brought to full power 'quickly'; value 7 (\"Power "
        "Save - Warning\") indicates that the ComputerSystem is in a "
        "warning state, though also in a power save mode; and, values "
        "8 and 9 describe the ACPI \"Hibernate\" and \"Soft Off\" "
        "states."),
       ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}, 
       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;
      [Description (
        "The event that caused the System to power up. This "
        "information is available in SMBIOS, in the Type 1 structure, "
        "the Wake Up Type attribute."),
       ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8"}, 
       Values {"Reserved", "Other", "Unknown", "APM Timer", 
               "Modem Ring", "LAN Remote", "Power Switch", "PCI PME#", 
               "A/C Power Restored"} ]
   uint16 WakeUpType;
};


// ===================================================================
// SystemPartition
// ===================================================================
   [Association, Aggregation, Version ("2.6.0"), Description (
     "A Partition is an instance of a UnitaryComputerSystem (with "
     "its own OperatingSystem and Devices dedicated to the "
     "Partition) that is supported by underlying hardware and "
     "software. A Partition is not a virtualization of a Computer"
     "System, but the segmentation of the System's compute "
     "capabilities. Partitions can run independent copies of "
     "possibly different OperatingSystems and have dedicated "
     "Devices. The 'real', underlying System (perhaps a Cluster "
     "or another UnitaryComputerSystem) aggregates its "
     "Partitions. These semantics are described by the System"
     "Partition association.") ]
class CIM_SystemPartition : CIM_ComponentCS {
      [Override ("GroupComponent"), Aggregate, Max (1),
       Description (
        "The 'underlying' ComputerSystem that hosts a Partition.") ]
   CIM_ComputerSystem REF GroupComponent;
      [Override ("PartComponent"), 
       Description ("The System Partition.") ]
   CIM_UnitaryComputerSystem REF PartComponent;
};


// ===================================================================
// VirtualComputerSystem
// ===================================================================
   [Version ("2.6.0"), Description (
     "A class derived from ComputerSystem that represents the "
     "ability to virtualize or emulate another ComputerSystem.") ] 
class CIM_VirtualComputerSystem : CIM_ComputerSystem {
      [Description (
        "A string describing the type of System or hardware platform "
        "that is virtualized. OperatingSystem information is obtained "
        "via the RunningOS inherited from ComputerSystem.") ]
   string VirtualSystem;
};


// ===================================================================
// HostingCS
// ===================================================================
   [Association, Version ("2.6.0"), Description (
     "A VirtualComputerSystem is hosted on another ComputerSystem. "
     "This association makes that relationship explicit.") ] 
class CIM_HostingCS : CIM_Dependency {
      [Override ("Antecedent"),  Min (1),
       Description ("The hosting ComputerSystem.") ]
   CIM_ComputerSystem REF Antecedent;
      [Override ("Dependent"), 
       Description ("The VirtualComputerSystem.") ]
   CIM_VirtualComputerSystem REF Dependent;
};


// ===================================================================
// Cluster
// ===================================================================
   [Version ("2.6.0"), Description (
     "A class derived from ComputerSystem that 'is made up of' two "
     "or more ComputerSystems which operate together as an atomic, "
     "functional whole to increase the performance, resources and/or "
     "RAS (Reliability, Availability and Serviceability) of the "
     "component ComputerSystems, related to some aspects of these "
     "ComputerSystems.") ] 
class CIM_Cluster : CIM_ComputerSystem {
      [Description (
        "Interconnect is a free form string that describes the "
        "interconnection mechanism for the Cluster.") ]
   string Interconnect; 
      [Description (
        "InterconnectAddress indicates the address of the Cluster "
        "System, which is dependent on the interconnection scheme. "
        "If no address is available or applicable, a null string "
        "should be used.") ]
   string InterconnectAddress;
      [Description (
        "The cluster types. This specifies whether the cluster is for "
        "failover (value=2), performance (3), etc. The values which "
        "can be specified are not mutually exclusive. Thus, Types is "
        "an array."),
       ValueMap {"0", "1", "2", "3", "4", "5", "6"}, 
       Values {"Unknown", "Other", "Failover", 
               "Performance", "Distributed OS", "Node Grouping",
               "SysPlex"} ]
   uint16 Types[];
      [Description (
        "Indicates the maximum number of nodes that may participate in "
        "the Cluster.  If unlimited, enter 0.") ]
   uint32 MaxNumberOfNodes;  
      [Description (
        "Indicates the state of the Cluster.  The cluster can be "
        "defined to be on-line (value=2), off-line (3), in a degraded "
        "mode of operation (4) or unavailable (5)."),
       ValueMap {"0", "1", "2", "3", "4", "5"}, 
       Values {"Unknown", "Other", "On-line", "Off-line", 
               "Degraded", "Unavailable"} ]
   uint16 ClusterState;
};


// ===================================================================
// ParticipatingCS
// ===================================================================
   [Association, Version ("2.6.0"), Description (
     "A Cluster is composed of two or more ComputerSystems, "
     "operating together. A ComputerSystem may participate in "
     "multiple Clusters. \n\n"
     "When first establishing or bringing up a Cluster, only one "
     "ComputerSystem may be defined as participating in it. "
     "Therfore, the cardinality of the association for "
     "the ComputerSystem reference is Min (1). ") ] 
class CIM_ParticipatingCS : CIM_Dependency { 
      [Override ("Antecedent"), Min (1),
       Description ( 
        "The ComputerSystem which participates in the Cluster. ") ] 
   CIM_ComputerSystem REF Antecedent; 
      [Override ("Dependent"), 
       Description ("The Cluster.") ] 
   CIM_Cluster REF Dependent;
      [Description (
        "StateOfNode indicates the condition of the participating "
        "ComputerSystem in the Cluster.  For example, one value is "
        "\"Joining\" (2)."),
       ValueMap {"0", "1", "2", "3", "4", "5", "6"}, 
       Values {"Unknown", "Other", "Joining", "Paused", 
               "Available", "Unavailable", "Degraded"} ] 
   uint16 StateOfNode;
      [Description (
        "RoleOfNode indicates whether the Cluster nodes are "
        "peers (value = 2), connected in a master-slave/primary-"
        "secondary relationship (values = 3 for primary, 4 for "
        "secondary), available in a standby configuration (5) or "
        "of some other (1) or unknown (0) relationship. In a "
        "System/390 environment, the nodes are identified as \"Base "
        "Plex\" (value=6) or \"Enhanced Plex\" (value=7)."),
       ValueMap {"0", "1", "2", "3", "4", "5", "6", "7"}, 
       Values {"Unknown", "Other", "Peer", "Primary", 
               "Secondary", "Standby", "Base Plex", "Enhanced Plex"} ] 
   uint16 RoleOfNode;
};


// ===================================================================
//  Services and SAPs
// ===================================================================
// ===================================================================
// ClusteringService
// ===================================================================
   [Version ("2.6.0"), Description (
     "ClusteringService represents the functionality provided by a "
     "Cluster. For example, failover functionality may be modeled as "
     "a Service of a failover Cluster.") ]
class CIM_ClusteringService : CIM_Service {
      [Description ( 
        "AddNode brings a new ComputerSystem 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. "
        "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 AddNode ([IN] CIM_ComputerSystem ref CS);
      [Description (
        "EvictNode removes a ComputerSystem from a Cluster. "
        "The node to be evicted is specified as a parameter to the "
        "method. The return value should be 0 if the ComputerSystem "
        "is successfully evicted, 1 if the method is not supported "
        "and any other number 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 EvictNode ([IN] CIM_ComputerSystem ref CS);
};


// ===================================================================
// ClusteringSAP
// ===================================================================
   [Version ("2.6.0"), Description (
     "A representation of the access points of a ClusteringService.") ]
class CIM_ClusteringSAP : CIM_ServiceAccessPoint {
};


// ===================================================================
// ClusterServiceAccessBySAP
// ===================================================================
   [Association, Version ("2.6.0"), Description (
     "ClusterServiceAccessBySAP is the relationship between a "
     "ClusteringService and its access points.") ]
class CIM_ClusterServiceAccessBySAP : CIM_ServiceAccessBySAP {
      [Override ("Antecedent"),
       Description ("The ClusteringService.") ]
   CIM_ClusteringService REF Antecedent;
      [Override ("Dependent"),
       Description ("An access point for the ClusteringService.") ]
   CIM_ClusteringSAP REF Dependent;
};


// ===================================================================
// HostedClusterService
// ===================================================================
   [Association,
    Version ("2.6.0"), Description (
     "HostedClusterService defines the hosting Cluster for a "
     "ClusteringService.  Since this relationship is subclassed "
     "from HostedService, it inherits the scoping/naming scheme "
     "defined for Service - where a Service is weak to its "
     "hosting System.  In this case, a ClusteringService must be "
     "weak to its hosting Cluster System.") ]
class CIM_HostedClusterService : CIM_HostedService {
      [Override ("Antecedent"), Min (1), Max (1), 
       Description ("The Cluster.") ]
   CIM_Cluster REF Antecedent;
      [Override ("Dependent"),
       Description (
        "The ClusteringService that is hosted on the Cluster.") ]
   CIM_ClusteringService REF Dependent;
};


// ===================================================================
// HostedClusterSAP
// ===================================================================
   [Association, Version ("2.6.0"), Description (
     "HostedClusterSAP defines the hosting ComputerSystem for a "
     "ClusteringSAP. Since this relationship is subclassed "
     "from HostedAccessPoint, it inherits the scoping/naming scheme "
     "defined for AccessPoint - where an AccessPoint is weak to "
     "its hosting System.  In this case, a ClusteringSAP must be "
     "weak to its hosting ComputerSystem.") ]
class CIM_HostedClusterSAP : CIM_HostedAccessPoint {
      [Override ("Antecedent"), Min (1), Max (1),  
       Description ("The ComputerSystem.") ]
   CIM_ComputerSystem REF Antecedent;
      [Override ("Dependent"),
       Description (
        "The ClusteringSAP that is hosted on the ComputerSystem.") ]
   CIM_ClusteringSAP REF Dependent;
};


// ===================================================================
// BootService
// ===================================================================
   [Version ("2.6.0"), Description (
     "BootService represents the functionality provided by a Device, "
     "software or via a Network to load an Operating System on a "
     "UnitaryComputerSystem.") ]
class CIM_BootService : CIM_Service {
};


// ===================================================================
// BootSAP
// ===================================================================
   [Version ("2.6.0"), Description (
     "A representation of the access points of a BootService.") ]
class CIM_BootSAP : CIM_ServiceAccessPoint {
};


// ===================================================================
// BootServiceAccessBySAP
// ===================================================================
   [Association, Version ("2.6.0"), Description (
     "BootServiceAccessBySAP is the relationship between a Boot"
     "Service and its access points.") ]
class CIM_BootServiceAccessBySAP : CIM_ServiceAccessBySAP {
      [Override ("Antecedent"), 
       Description ("The BootService.") ]
   CIM_BootService REF Antecedent;
      [Override ("Dependent"),
       Description ("An access point for the BootService.") ]
   CIM_BootSAP REF Dependent;
};


// ===================================================================
// HostedBootService
// ===================================================================
   [Association, Version ("2.6.0"), Description (
     "HostedBootService defines the hosting System for a Boot"
     "Service. Since this relationship is subclassed from Hosted"
     "Service, it inherits the scoping/naming scheme defined for "
     "Service - where a Service is weak to its hosting System.") ]
class CIM_HostedBootService : CIM_HostedService {
      [Override ("Dependent"), 
       Description ("The BootService hosted on the System.") ]
   CIM_BootService REF Dependent;
};


// ===================================================================
// HostedBootSAP
// ===================================================================
   [Association, Version ("2.6.0"), Description (
     "HostedBootSAP defines the hosting UnitaryComputerSystem for "
     "a BootSAP. Since this relationship is subclassed from "
     "HostedAccessPoint, it inherits the scoping/naming scheme "
     "defined for AccessPoint - where an AccessPoint is weak to its "
     "hosting System.  In this case, a BootSAP must be "
     "weak to its hosting UnitaryComputerSystem.") ]
class CIM_HostedBootSAP : CIM_HostedAccessPoint {
      [Override ("Antecedent"), Min (1), Max (1),
       Description ("The UnitaryComputerSystem.") ]
   CIM_UnitaryComputerSystem REF Antecedent;
      [Override ("Dependent"),
       Description (
        "The BootSAP hosted on the UnitaryComputerSystem.") ]
   CIM_BootSAP REF Dependent;
};


// ===================================================================
//  File Systems
// ===================================================================
// ===================================================================
// FileSystem
// ===================================================================
   [Version ("2.6.0"), Description (
     "A file or dataset store local to a ComputerSystem or "
     "remotely mounted from a file server.") ]
class CIM_FileSystem : CIM_LogicalElement {
      [Propagated ("CIM_ComputerSystem.CreationClassName"),
       Key, MaxLen (256), Description (
        "The scoping ComputerSystem's CreationClassName.") ]
   string CSCreationClassName;
      [Propagated ("CIM_ComputerSystem.Name"), Key, MaxLen (256),
       Description ("The scoping ComputerSystem's Name.") ]
   string CSName;
      [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;
      [Override ("Name"), Key, MaxLen (256), Description (
        "The inherited Name serves as key of a FileSystem instance "
        "within a ComputerSystem.") ]
   string Name;
      [Description (
        "Path name or other information defining the root of the "
        "FileSystem."),
       MappingStrings {
        "MIB.IETF|HOST-RESOURCES-MIB.hrFSMountPoint", 
        "MIF.DMTF|Host File System|001.2"} ]
   string Root;
      [Description (
        "FileSystems can read/write data in blocks which are defined "
        "independently of the underlying StorageExtents. This property "
        "captures the FileSystem's block size for data storage and "
        "retrieval."),
       Units ("Bytes") ]
   uint64 BlockSize;
      [Description (
        "The FileSystemSize property stores the total size of the File"
        "System in bytes. If unknown, enter 0."),
       Units ("Bytes"), 
       MappingStrings {"MIF.DMTF|Host File System|001.13"} ]
   uint64 FileSystemSize;
      [Gauge, Description (
        "AvailableSpace indicates the total amount of free space "
        "for the FileSystem, in bytes. If unknown, enter 0."),
       Units ("Bytes"), 
       MappingStrings {"MIF.DMTF|Host File System|001.14", 
             "MIF.DMTF|Partition|002.4"} ]
   uint64 AvailableSpace;
      [Description (
        "Indicates that the FileSystem is designated as read only."),
       MappingStrings {"MIB.IETF|HOST-RESOURCES-MIB.hrFSAccess", 
        "MIF.DMTF|Host File System|001.5"} ]
   boolean ReadOnly;
      [Description (
        "A free form string indicating the algorithm or tool used to "
        "encrypt the FileSystem. 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 FileSystem 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 FileSystem is not encrypted."),
       MappingStrings {"MIF.DMTF|Partition|002.8"} ]
   string EncryptionMethod;
      [Description (
        "A free form string indicating the algorithm or tool used to "
        "compress the FileSystem. 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 FileSystem 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 FileSystem is not compressed."),
       MappingStrings {"MIF.DMTF|Partition|002.7"} ]
   string CompressionMethod;
      [Description (
        "Indicates that case sensitive file names are supported.") ]
   boolean CaseSensitive;
      [Description (
        "Indicates that the case of file names are preserved.") ]
   boolean CasePreserved;
      [Description (
        "Array defining the character sets or encoding supported by "
        "the FileSystem. For example, the values, \"ASCII\" (2) or "
        "\"ISO2022\" (4), may be specified."),
       ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8"}, 
       Values {"Unknown", "Other", "ASCII", "Unicode", 
               "ISO2022", "ISO8859", "Extended UNIX Code", "UTF-8",
               "UCS-2"} ]
   uint16 CodeSet[];
      [Description (
        "Integer indicating the maximum length of a file name within "
        "the FileSystem. 0 indicates that there is no limit on file "
        "name length.") ]
   uint32 MaxFileNameLength;
      [Description (
        "The minimum file allocation size (an integral number of "
        "blocks), imposed by the FileSystem. (The size of a block is "
        "specified in the BlockSize property for the FileSystem.) "
        "Minimum allocation size is the smallest amount of storage "
        "allocated to a LogicalFile by the FileSystem. This is not a "
        "mandatory minimum allocation for all FileSystems. Under "
        "stress conditions, some FileSystems may allocate storage "
        "in amounts smaller than the ClusterSize.") ]
   uint32 ClusterSize;
      [Description (
        "String describing the type of FileSystem and therefore, its "
        "conventions. For example, \"NTFS\" or \"S5\" may be listed "
        "as well as any additional information on the FileSystem's "
        "implementation. Since various flavors of FileSystems (like "
        "S5) exist, this property is defined as a string."),
       MappingStrings {"MIF.DMTF|Partition|002.6", 
             "MIF.DMTF|Host File System|001.4"} ]
   string FileSystemType;
};


// ===================================================================
// LocalFileSystem
// ===================================================================
   [Version ("2.6.0"), 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 {
};


// ===================================================================
// RemoteFileSystem
// ===================================================================
   [Version ("2.6.0"), 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.") ]
class CIM_RemoteFileSystem : CIM_FileSystem {
};


// ===================================================================
// NFS (NetworkFileSystem)
// ===================================================================
   [Version ("2.6.0"), 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.") ]
class CIM_NFS : CIM_RemoteFileSystem {
      [Description (
        "If set to true: Once the FileSystem is mounted, NFS requests "
        "are retried until the hosting System responds.\n" 
        "If set to false: Once the FileSystem is mounted, an error "
        "is returned if the hosting System does not respond.") ]
   boolean HardMount;
      [Description (
        "If set to true: Retries are performed in the foreground.\n"
        "If set to false: If the first mount attempt fails, retries "
        "are performed in the background.") ]
   boolean ForegroundMount;
      [Description (
        "If set to true: Interrupts are permitted for hard mounts.\n"
        "If set to false: Interrupts are ignored for hard mounts.") ]
   boolean Interrupt;
      [Description (
        "Maximum number of mount failure retries allowed.") ]
   uint16 MountFailureRetries;
      [Description ("Maximum number of NFS retransmissions allowed.") ]
   uint16 RetransmissionAttempts;
      [Description ("NFS timeout in tenths of a second."),
       Units ("Tenths of Seconds") ]
   uint32 RetransmissionTimeout;
      [Description ("Read buffer size in bytes."),
       Units ("Bytes") ]
   uint64 ReadBufferSize;
      [Description ("Write buffer size in bytes."),
       Units ("Bytes") ]
   uint64 WriteBufferSize;
      [Description (
        "The remote ComputerSystem's (ie, the NFS File "
        "'Server's) UDP port number.") ]
   uint32 ServerCommunicationPort;
      [Description (
        "If set to true: Control attribute caching is enabled.\n"
        "If set to false: Control attribute caching is disabled.") ]
   boolean AttributeCaching;
      [Description (
        "Minimum number of seconds that cached attributes are held "
        "after file modification."),
       Units ("Seconds") ]
   uint16 AttributeCachingForRegularFilesMin;
      [Description (
        "Maximum number of seconds that cached attributes are held "
        "after file modification."),
       Units ("Seconds") ]
   uint16 AttributeCachingForRegularFilesMax;
      [Description (
        "Minimum number of seconds that cached attributes are held "
        "after directory update."),
       Units ("Seconds") ]
   uint16 AttributeCachingForDirectoriesMin;
      [Description (
        "Maximum number of seconds that cached attributes are held "
        "after directory update."),
       Units ("Seconds") ]
   uint16 AttributeCachingForDirectoriesMax;
};


// ===================================================================
// LogicalFile
// ===================================================================
   [Version ("2.6.0"), Description (
     "A LogicalFile is a named collection of data or executable "
     "code, or represents a LogicalDevice or Directory.  It is "
     "located within the context of a FileSystem, on a Storage"
     "Extent.") ]
class CIM_LogicalFile : CIM_LogicalElement {
      [Propagated ("CIM_FileSystem.CSCreationClassName"),
       Key, MaxLen (256),
       Description ("The scoping ComputerSystem's CreationClassName.") ]
   string CSCreationClassName;
      [Propagated ("CIM_FileSystem.CSName"),
       Key, MaxLen (256),
       Description ("The scoping ComputerSystem's Name.") ]
   string CSName;
      [Propagated ("CIM_FileSystem.CreationClassName"), 
       Key, MaxLen (256),
       Description ("The scoping FileSystem's CreationClassName.") ]
   string FSCreationClassName;
      [Propagated ("CIM_FileSystem.Name"),
       Key, MaxLen (256),
       Description ("The scoping FileSystem's Name.") ]
   string FSName;
      [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;    
      [Override ("Name"), Key, MaxLen (1024),
       Description (
        "The inherited Name serves as part of the key of a LogicalFile "
        "instance within a FileSystem. A unique identifier (such as a "
        "full path name) is required as a Name value.  Since Files are "
        "weak to their FileSystem (and not to a Directory which would "
        "provide a more granular naming algorithm), care must be "
        "taken to make LogicalFile's Name unique for a given Creation"
        "ClassName and FileSystem. A full path name is one way "
        "to do this.") ]
   string Name;
      [Gauge, Description ("Size of the File in bytes."),
       Units ("Bytes") ]
   uint64 FileSize;
      [Description ("File's creation date.") ] 
   datetime CreationDate;
      [Description ("Time that the File was last modified.") ] 
   datetime LastModified;
      [Description ("Time that the File was last accessed.") ] 
   datetime LastAccessed;
      [Description ("Boolean indicating that the File can be read.") ] 
   boolean Readable;
      [Description (
        "Boolean indicating that the File can be written.") ]
   boolean Writeable;
      [Description ("Indicates the file is executable.") ] 
   boolean Executable;
      [Description (
        "A free form string indicating the algorithm or tool used to "
        "compress the LogicalFile. 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 "
        "LogicalFile 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 LogicalFile is not "
        "compressed.") ] 
   string CompressionMethod;
      [Description (
        "A free form string indicating the algorithm or tool used to "
        "encrypt the LogicalFile. 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 LogicalFile 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 LogicalFile is not encrypted.") ] 
   string EncryptionMethod;
      [Counter, Description (
        "Integer indicating the number of 'file opens' that are "
        "currently active against the File.") ]
   uint64 InUseCount;
};


// ===================================================================
// DataFile
// ===================================================================
   [Version ("2.6.0"), Description (
     "DataFile is a type of LogicalFile that is a named collection "
     "of data or executable code.") ]
class CIM_DataFile : CIM_LogicalFile {
};


// ===================================================================
// Directory
// ===================================================================
   [Version ("2.6.0"), Description (
     "Directory is a type of File that logically groups Files "
     "'contained' in it, and provides path information for the "
     "grouped Files.") ]
class CIM_Directory : CIM_LogicalFile {
};


// ===================================================================
// DeviceFile
// ===================================================================
   [Version ("2.6.0"), Description (
     "DeviceFile is a special type of LogicalFile 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 DeviceAccessedByFile relationship.") ]
class CIM_DeviceFile : CIM_LogicalFile {
};


// ===================================================================
// FIFOPipeFile
// ===================================================================
[Version ("2.6.0"), Description (
    "FIFOPipeFile is a special type of LogicalFile that represents "
    "an interprocess FIFO (sometimes referred to as a \"named pipe\"). "
    "Operating systems use this convention to manage interprocess "
    "communication through processes reading and writing the FIFO. "
    "The FIFO can be accessed by unrelated processes, in contrast to "
    "the more well-known command line redirection mechanism (e.g. "
    "UNIX's 'ps -eaf | grep foo', also known as an \"unnamed pipe\"). "
    "An exemplary operating system implementation (using the "
    "FIFO concept) is the UNIX S_IFIFO file type.") ]
class CIM_FIFOPipeFile : CIM_LogicalFile {
};


// ===================================================================
// SymbolicLink
// ===================================================================
   [Version ("2.6.0"), Description (
     "This class is a special type of LogicalFile that represents "
     "a Symbolic Link. This convention is useful for some operating "
     "systems that want to represent a single file in multiple "
     "places or a single file that is represented via multiple "
     "names.") ]
class CIM_SymbolicLink : CIM_LogicalFile {
      [Required,
       Description ("The target file of the symbolic link.") ]
   string TargetFile;
};


// ===================================================================
// DeviceAccessedByFile
// ===================================================================
   [Association, Version ("2.6.0"), Description (
     "Specifies the LogicalDevice that is associated with, and "
     "accessed using the referenced DeviceFile.") ]
class CIM_DeviceAccessedByFile : CIM_Dependency {   
      [Override ("Antecedent"),
       Description ("The DeviceFile.") ]
   CIM_DeviceFile REF Antecedent;
      [Override ("Dependent"), Max (1), 
       Description (
        "The Device that is accessed using the DeviceFile.") ]
   CIM_LogicalDevice REF Dependent;
};


// ===================================================================
// DirectoryContainsFile
// ===================================================================
   [Association, Aggregation,  Version ("2.6.0"), Description (
     "Specifies the hierarchical arrangement of LogicalFiles in a "
     "Directory.") ]
class CIM_DirectoryContainsFile : CIM_Component {   
      [Override ("GroupComponent"), Aggregate, Max (1),
       Description ("The Directory.") ]
   CIM_Directory REF GroupComponent;
      [Override ("PartComponent"),
       Description (
          "The LogicalFile 'contained within' the Directory.") ]
   CIM_LogicalFile REF PartComponent;
};


// ===================================================================
// Mount
// ===================================================================
   [Association,  Version ("2.6.0"), 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.") ]
class CIM_Mount : CIM_Dependency { 
      [Override ("Antecedent"), Max (1), 
       Description ("The Directory mounted.") ]
    CIM_Directory REF Antecedent; 
      [Override ("Dependent"), 
       Description ("The FileSystem the Directory is mounted on.") ]
    CIM_FileSystem REF Dependent; 
};


// ===================================================================
// Export
// ===================================================================
   [Association, Version ("2.6.0"), 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.") ]
class CIM_Export { 
      [Key, Max (1), Description (
        "The LocalFileSystem.") ]
    CIM_LocalFileSystem REF LocalFS; 
      [Key, Description ("The Directory exported for mount.") ] 
    CIM_Directory REF Directory; 
      [Description ("Name under which the Directory is exported.") ]
    string ExportedDirectoryName; 
}; 


// ===================================================================
// HostedFileSystem
// ===================================================================
   [Association, Aggregation, Version ("2.6.0"), Description (
     "A link between the ComputerSystem and the FileSystem(s) "
     "hosted on this ComputerSystem.") ]
class CIM_HostedFileSystem : CIM_SystemComponent {
      [Override ("GroupComponent"), Aggregate, Min (1), Max (1),
       Description ("The ComputerSystem.") ]
   CIM_ComputerSystem REF GroupComponent;
      [Override ("PartComponent"), Weak,
       Description ("The FileSystem owned by the ComputerSystem.") ]
   CIM_FileSystem REF PartComponent;
};


// ===================================================================
// FileStorage
// ===================================================================
   [Association, Aggregation, Version ("2.6.0"), Description (
     "A link between the FileSystem and the LogicalFile(s) addressed "
     "through this FileSystem.") ]
class CIM_FileStorage : CIM_Component {
      [Override ("GroupComponent"), Aggregate, Min (1), Max (1),
       Description ("The FileSystem.") ]
   CIM_FileSystem REF GroupComponent;
      [Override ("PartComponent"), Weak,
       Description (
        "The LogicalFile stored in the context of the FileSystem.") ]
   CIM_LogicalFile REF PartComponent;
};


// ===================================================================
//  Software 
// ===================================================================
// ===================================================================
// OperatingSystem
// ===================================================================
   [Version ("2.6.0"), Description (
     "An OperatingSystem is software/firmware that makes a "
     "ComputerSystem's hardware usable, and implements and/or "
     "manages the resources, file systems, processes, user "
     "interfaces, services, ... available on the ComputerSystem.") ] 
class CIM_OperatingSystem : CIM_LogicalElement {
      [Propagated ("CIM_ComputerSystem.CreationClassName"),
       Key, MaxLen (256),
       Description ("The scoping ComputerSystem's CreationClassName.") ]
   string CSCreationClassName;
      [Propagated ("CIM_ComputerSystem.Name"), 
       Key, MaxLen (256),
       Description ("The scoping ComputerSystem's Name.") ]
   string CSName;
      [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;
      [Override ("Name"),
       Key, MaxLen (256),
       Description (
        "The inherited Name serves as key of an OperatingSystem "
        "instance within a ComputerSystem."),
       MappingStrings {"MIF.DMTF|Operating System|001.2"} ]
   string Name;
      [Description (
        "A integer indicating the type of OperatingSystem."),
       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", "32", "33", "34", 
        "35", "36", "37", "38", "39", 
        "40", "41", "42", "43", "44", 
        "45", "46", "47", "48", "49", 
        "50", "51", "52", "53", "54", 
        "55", "56", "57", "58", "59", 
        "60", "61", "62", "63", "64", "65", "66"}, 
       Values {"Unknown", "Other", "MACOS", "ATTUNIX", "DGUX", 
        "DECNT", "Digital Unix", "OpenVMS", "HPUX", "AIX", 
        //10 
        "MVS", "OS400", "OS/2", "JavaVM", "MSDOS", 
        "WIN3x", "WIN95", "WIN98", "WINNT", "WINCE", 
        //20 
        "NCR3000", "NetWare", "OSF", "DC/OS", "Reliant UNIX", 
        "SCO UnixWare", "SCO OpenServer", "Sequent", 
        "IRIX", "Solaris", 
        //30 
        "SunOS", "U6000", "ASERIES", "TandemNSK", "TandemNT", 
        "BS2000", "LINUX", "Lynx", "XENIX", "VM/ESA", 
        //40 
        "Interactive UNIX", "BSDUNIX", "FreeBSD", "NetBSD", 
        "GNU Hurd", "OS9", "MACH Kernel", "Inferno", "QNX", 
        "EPOC", 
        //50 
        "IxWorks", "VxWorks", "MiNT", "BeOS", "HP MPE", 
        "NextStep", "PalmPilot", "Rhapsody", "Windows 2000", 
        "Dedicated", 
        //60 
        "OS/390", "VSE", "TPF","Windows (R) Me", 
        "Caldera Open UNIX", "OpenBSD", "Not Applicable"},
       ModelCorrespondence {
        "CIM_OperatingSystem.OtherTypeDescription"} ]
   uint16 OSType;
      [Description (
        "A string describing the manufacturer and OperatingSystem "
        "type - used when the OperatingSystem property, OSType, is "
        "set to 1 or 59 (\"Other\" or \"Dedicated\"). 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 or 59."),
       MaxLen (64),
       ModelCorrespondence {"CIM_OperatingSystem.OSType"} ]
   string OtherTypeDescription;
      [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;
      [Description ("Time when the OperatingSystem was last booted."),
       MappingStrings {"MIF.DMTF|General Information|001.5"} ]
   datetime LastBootUpTime; 
      [Description (
        "OperatingSystem'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;
      [Description (
        "CurrentTimeZone indicates the number of minutes the "
        "OperatingSystem is offset from Greenwich Mean Time. "
        "Either the number is positive, negative or zero."),
       Units ("Minutes") ]
   sint16 CurrentTimeZone;
      [Description (
       "Number of user licenses for the OperatingSystem. "
       "If unlimited, enter 0.") ]
   uint32 NumberOfLicensedUsers;
      [Description (
        "Number of user sessions for which the OperatingSystem is "
        "currently storing state information."), Gauge,
       MappingStrings {"MIF.DMTF|Host System|001.4",
        "MIB.IETF|HOST-RESOURCES-MIB.hrSystemNumUsers"} ]
   uint32  NumberOfUsers;
      [Description (
        "Number of process contexts currently loaded or running on "
        "the OperatingSystem."), Gauge, 
       MappingStrings {"MIF.DMTF|Host System|001.5",
        "MIB.IETF|HOST-RESOURCES-MIB.hrSystemProcesses"} ]
   uint32 NumberOfProcesses;
      [Description (
        "Maximum number of process contexts the OperatingSystem 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."), 
       MappingStrings {"MIF.DMTF|Host System|001.6",
        "MIB.IETF|HOST-RESOURCES-MIB.hrSystemMaxProcesses"} ]
   uint32 MaxNumberOfProcesses;
      [Description (
        "Total swap space in Kbytes. 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") ]
   uint64 TotalSwapSpaceSize;
      [Description (
        "Number of Kbytes of virtual memory. For example, "
        "this may be calculated by adding the amount of total RAM to "
        "the amount of paging space (ie, adding the amount of "
        "memory in/aggregated by the ComputerSystem to the property, "
        "SizeStoredInPagingFiles."),
       Units ("KiloBytes"),
       MappingStrings {"MIF.DMTF|System Memory Settings|001.5"} ]
   uint64 TotalVirtualMemorySize;
      [Gauge, Description (
        "Number of Kbytes 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 "
        "(ie, adding the properties, FreePhysicalMemory and FreeSpace"
        "InPagingFiles)."),
       Units ("KiloBytes"), 
       MappingStrings {"MIF.DMTF|System Memory Settings|001.6"} ]
   uint64 FreeVirtualMemory;
      [Gauge, Description (
        "Number of Kbytes of physical memory currently unused and "
        "available."),
       Units ("KiloBytes"),
       MappingStrings {"MIF.DMTF|System Memory Settings|001.2", 
        "MIF.UNIX|Host Physical Memory|6.1"} ] 
   uint64 FreePhysicalMemory;
      [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 (
        "The total number of KBytes that can be stored in the "
        "OperatingSystem's paging files. 0 indicates that there "
        "are no paging files."),
       Units ("KiloBytes"),
       MappingStrings {"MIF.DMTF|System Memory Settings|001.3"} ]
   uint64 SizeStoredInPagingFiles;
      [Gauge, 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 (
        "Maximum number of Kbytes 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;
      [Description (
        "Boolean indicating whether the OperatingSystem is "
        "distributed across several ComputerSystem nodes. If so, "
        "these nodes should be grouped as a Cluster.") ]
   boolean Distributed;
      [Description (
        "A value that indicates the maximum processes that a user "
        "can have associate with it.") ]
   uint32  MaxProcessesPerUser;
      [Description (
        "Requests a reboot of the OperatingSystem. 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 Reboot();
      [Description (
        "Requests a shutdown of the OperatingSystem. 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 OperatingSystem to establish dependencies between "
        "the Shutdown and Reboot methods, and for example, to provide "
        "more sophisticated capabilities such as scheduled shutdown/"
        "reboot, etc. 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 Shutdown();
};


// ===================================================================
// InstalledOS
// ===================================================================
   [Association, Aggregation, Version ("2.6.0"), Description (
     "A link between the ComputerSystem and the OperatingSystem(s) "
     "installed or loaded on it. An OperatingSystem is 'installed' "
     "on a ComputerSystem, when placed on one of its StorageExtents "
     "- for example, copied to a disk drive or downloaded to "
     "Memory. Using this definition, an OperatingSystem is "
     "'installed' on a NetPC when downloaded via the network.") ]
class CIM_InstalledOS : CIM_SystemComponent {
      [Override ("GroupComponent"), Aggregate, Min (1), Max (1),
       Description ("The ComputerSystem.") ]
   CIM_ComputerSystem REF GroupComponent;
      [Override ("PartComponent"), Weak,
       Description (
        "The OperatingSystem installed on the ComputerSystem.") ]
   CIM_OperatingSystem REF PartComponent;
      [Description (
        "Boolean indicating that the OperatingSystem is the default "
        "OS for the ComputerSystem."),
       MappingStrings {"MIF.DMTF|Operating System|001.4"} ]
   boolean PrimaryOS;
};


// ===================================================================
// RunningOS
// ===================================================================
   [Association, Version ("2.6.0"), Description (
     "RunningOS indicates the currently executing OperatingSystem. "
     "At most one OperatingSystem can execute at any time on a "
     "ComputerSystem. 'At most one' is specified, since the Computer"
     "System may not be currently booted, or its OperatingSystem "
     "may be unknown.") ]
class CIM_RunningOS : CIM_Dependency {
      [Override ("Antecedent"), Max (1),
       Description (
        "The OperatingSystem currently running on the "
        "ComputerSystem.") ]
   CIM_OperatingSystem REF Antecedent;
      [Override ("Dependent"), Max (1),
       Description ("The ComputerSystem.") ]
   CIM_ComputerSystem REF Dependent;
};


// ==================================================================
// OperatingSystemSoftwareFeature
// ==================================================================
   [Association, Aggregation, Version ("2.6.0"), Description (
     "Indicates the SoftwareFeatures that make up the Operating"
     "System. The SoftwareFeatures can be part of different "
     "Products.") ]
class CIM_OperatingSystemSoftwareFeature : CIM_Component {
      [Override ("GroupComponent"), Aggregate,
       Description ("The OperatingSystem.") ]
    CIM_OperatingSystem REF GroupComponent;
      [Override ("PartComponent"), Description (
        "The SoftwareFeatures that make up the OperatingSystem.") ]
    CIM_SoftwareFeature REF PartComponent;
};


// ===================================================================
// BootOSFromFS
// ===================================================================
   [Association, Version ("2.6.0"), Description (
     "A link between the OperatingSystem and the FileSystem(s) from "
     "which this OperatingSystem 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 {
      [Override ("Antecedent"), Description (
        "The FileSystem from which the OperatingSystem is loaded.") ]
   CIM_FileSystem REF Antecedent;
      [Override ("Dependent"),
       Description ("The OperatingSystem.") ]
   CIM_OperatingSystem REF Dependent;
};


// ===================================================================
// BIOSFeature
// ===================================================================
   [Version ("2.6.0"), Description (
     "BIOSFeature represents the capabilities of the low-level "
     "software that is used to bring up and configure a Computer"
     "System.") ]
class CIM_BIOSFeature : CIM_SoftwareFeature {
      [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). Values specified in the "
        "enumeration are taken from both DMI and SMBIOS (the Type 0 "
        "structure, the BIOS Characteristics and BIOS "
        "Characteristics Extension Bytes attributes."),
       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", "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 Boot Support", "ACPI Support", 
               "I2O Boot Support", "USB Legacy Support", 
               "AGP Support", "PC Card", "IR", "1394", "I2C", 
               "Smart Battery", "ATAPI ZIP Drive Boot Support", 
               "1394 Boot Support", "Boot from CD", 
               "Selectable Boot", "BIOS ROM is Socketed", 
               "Boot from PCMCIA", "EDD Specification Support", 
               "PC-98"},
       MappingStrings {"MIF.DMTF|BIOS Characteristic|004.3"},
       ArrayType ("Indexed"),
       ModelCorrespondence {
        "CIM_BIOSFeature.CharacteristicDescriptions"} ]
   uint16 Characteristics[];
      [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."),
       ArrayType ("Indexed"),
       MappingStrings {"MIF.DMTF|BIOS Characteristic|004.4"},
       ModelCorrespondence {"CIM_BIOSFeature.Characteristics"} ]
   string CharacteristicDescriptions[];
};

 
// ===================================================================
// BIOSElement
// ===================================================================
   [Version ("2.6.0"), Description (
     "BIOSElement represents the low-level software that is loaded "
     "into non-volatile storage and used to bring up and configure "
     "a ComputerSystem.") ]
class CIM_BIOSElement : CIM_SoftwareElement {
      [Override ("Version"),
       MappingStrings {"MIF.DMTF|System BIOS|001.3"} ]
   string Version;
      [Override ("Manufacturer"),
       MappingStrings {"MIF.DMTF|System BIOS|001.2"} ]
   string Manufacturer;     
      [Description (
      "If true, this is the primary BIOS of the ComputerSystem."),
       MappingStrings {"MIF.DMTF|System BIOS|001.9"} ]
   boolean PrimaryBIOS;
      [Description (
        "A list of installable languages for the BIOS. This "
        "information can be obtained from SMBIOS, from the string list "
        "that follows the Type 13 structure. An ISO 639 Language Name "
        "should be used to specify the BIOS' installable languages. "
        "The ISO 3166 Territory Name and the encoding method may also "
        "be specified, following the Language Name.") ]
   string ListOfLanguages[];
      [Description (
        "The currently selected language for the BIOS. This "
        "information can be obtained from SMBIOS, using the Current "
        "Language attribute of the Type 13 structure, to index into "
        "the string list following the structure. The property is "
        "formatted using the ISO 639 Language Name, and may be "
        "followed by the ISO 3166 Territory Name and the encoding "
        "method."),
       ModelCorrespondence {"CIM_BIOSElement.ListOfLanguages"} ]
   string CurrentLanguage;
      [Description (
        "The starting address of the memory which this BIOS "
        "occupies."), 
       MappingStrings {"MIF.DMTF|System BIOS|001.5"} ]
    uint64 LoadedStartingAddress;
      [Description (
        "The ending address of the memory which this BIOS "
        "occupies."),
       MappingStrings {"MIF.DMTF|System BIOS|001.6"} ]
    uint64 LoadedEndingAddress;
      [MaxLen (64), Description (
        "A free form string describing the BIOS flash/load utility "
        "that is required to update the BIOSElement. Version and "
        "other information may be indicated in this property."),
       MappingStrings {"MIF.DMTF|System BIOS|001.7"} ]
    string LoadUtilityInformation;
      [Description (
        "Date that this BIOS was released."),
       MappingStrings {"MIF.DMTF|System BIOS|001.8"} ]
    datetime ReleaseDate;
};


// ===================================================================
// BIOSFeatureBIOSElements
// ===================================================================
   [Association, Aggregation, Version ("2.6.0"), Description (
     "A link between BIOSFeature and its aggregated BIOSElements.") ]
class CIM_BIOSFeatureBIOSElements : 
 CIM_SoftwareFeatureSoftwareElements {
      [Override ("GroupComponent"), Aggregate, 
       Description ("The BIOSFeature.") ]
   CIM_BIOSFeature REF GroupComponent;
      [Override ("PartComponent"),
       Description (
        "The BIOSElement that implements the capabilities described "
        "by BIOSFeature.") ]
   CIM_BIOSElement REF PartComponent;
};


// ===================================================================
// SystemBIOS
// ===================================================================
   [Association, Aggregation, Version ("2.6.0"), Description (
     "SystemBIOS associates a UnitaryComputerSystem's BIOS with the "
     "System itself.") ]
class CIM_SystemBIOS : CIM_SystemComponent {
      [Override ("GroupComponent"), Max (1), Aggregate, 
       Description (
        "The UnitaryComputerSystem that boots from the BIOS.") ]
   CIM_UnitaryComputerSystem REF GroupComponent;
      [Override ("PartComponent"), 
       Description ("The System's BIOS.") ]
   CIM_BIOSElement REF PartComponent;
};


// ===================================================================
//  Processing and Jobs
// ===================================================================
// ===================================================================
// Process
// ===================================================================
   [Version ("2.6.0"), 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.") ]
class CIM_Process : CIM_LogicalElement {
      [Propagated("CIM_OperatingSystem.CSCreationClassName"),
       Key, MaxLen (256),
       Description (
        "The scoping ComputerSystem's CreationClassName.") ]
   string CSCreationClassName;
      [Propagated("CIM_OperatingSystem.CSName"),
       Key, MaxLen (256),
       Description ("The scoping ComputerSystem's Name.") ]
   string CSName;
      [Propagated("CIM_OperatingSystem.CreationClassName"),
       Key, MaxLen (256),
       Description (
         "The scoping OperatingSystem's CreationClassName.") ]
   string OSCreationClassName;
      [Propagated("CIM_OperatingSystem.Name"),
       Key, MaxLen (256),
       Description ("The scoping OperatingSystem's Name.") ]
   string OSName;
      [Override ("Name"), Description (
        "The name of the process."),
       MappingStrings {"MIF.DMTF|Process Information|001.6"} ]
   string Name;
      [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;
      [Key, MaxLen (256), Description (
        "A string used to identify the Process. A Process ID is a "
        "kind of Process Handle."),
       MappingStrings {"MIF.DMTF|Process Information|001.1"} ]
   string Handle;
      [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."), 
       MappingStrings {"MIF.DMTF|Process Information|001.10"} ]
   uint32 Priority;
      [Description (
        "Indicates the current operating condition of the Process. "
        "Values include ready (2), running (3), and blocked (4), "
        "among others."), 
       ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}, 
       Values {"Unknown", "Other", "Ready", "Running", 
               "Blocked", "Suspended Blocked", "Suspended Ready", 
               "Terminated", "Stopped", "Growing"},
       MappingStrings {"MIF.DMTF|Process Information|001.9",
        "MIF.UNIX|Process Information|13.9"} ]
   uint16 ExecutionState;
      [Description (
        "A string describing the state - used when the instance's "
        "ExecutionState property is set to 1 (\"Other\"). Other"
        "ExecutionDescription should be set to NULL when the Execution"
        "State property is any value other than 1.") ]
   string OtherExecutionDescription;
      [Description ("Time that the Process began executing.") ]
   datetime CreationDate;
      [Description (
        "Time that the Process was stopped or terminated.") ]
   datetime TerminationDate;
      [Description (
        "Time in kernel mode, in milliseconds. If this information "
        "is not available, a value of 0 should be used."),
       Units ("MilliSeconds"), 
       MappingStrings {"MIF.DMTF|Process Information|001.13"} ]
   uint64 KernelModeTime;
      [Description (
        "Time in user mode, in milliseconds. If this information "
        "is not available, a value of 0 should be used."),
       Units ("MilliSeconds"), 
       MappingStrings {"MIF.DMTF|Process Information|001.14"} ]
   uint64 UserModeTime;
      [Gauge, Description (
        "The amount of memory in bytes that a Process needs to "
        "execute efficiently, for an OperatingSystem 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;
};


// ===================================================================
// OSProcess
// ===================================================================
   [Association, Aggregation, Version ("2.6.0"), Description (
     "A link between the OperatingSystem and Process(es) running "
     "in the context of this OperatingSystem.") ]
class CIM_OSProcess : CIM_Component {
      [Override ("GroupComponent"), Aggregate, Min (1), Max (1),
       Description ("The OperatingSystem.") ]
   CIM_OperatingSystem REF GroupComponent;
      [Override ("PartComponent"), Weak,
       Description (
        "The Process running in the context of the "
        "OperatingSystem") ]
   CIM_Process REF PartComponent;
};


// ===================================================================
// ProcessExecutable
// ===================================================================
   [Association, Version ("2.6.0"), Description (
     "A link between a Process and a DataFile indicating that the "
     "File participates in the execution of the Process.") ]
class CIM_ProcessExecutable : CIM_Dependency {
      [Override ("Antecedent"),
       Description (
        "The DataFile participating in the execution of the Process.") ]
   CIM_DataFile REF Antecedent;
      [Override ("Dependent"),
       Description ("The Process.") ] 
   CIM_Process REF Dependent;
};


// ================================================================== 
// ServiceProcess 
// ================================================================== 
   [Association, Version ("2.6.0"), Description ( 
     "CIM_ServiceProcess is an association used to establish " 
     "relationships between Services and Processes. " 
     "It is used to indicate if a Service is running in a particular " 
     "Process.  It is also used to indicate, via the ExecutionType " 
     "property, if the Service started and is wholly responsible for " 
     "the Process, or if the Service is running in an existing "
     "Process, perhaps with other unrelated Services, which is owned "
     "or started by a different entity. This association relates " 
     "a Service with an externally visible system signature. ") ] 
class CIM_ServiceProcess { 
      [Key, Description ( 
        "The Service whose Process is described by this "
        "association.") ] 
    CIM_Service REF Service; 
      [Key, Description ( 
        "The Process which represents or hosts the executing " 
        "Service.") ] 
    CIM_Process REF Process; 
      [Description ( 
        "Enumeration indicating how the Service runs in the context "
        "of, or owns the Process. \"Unknown\" indicates that the "
        "ExecutionType is not known. \"Other\" indicates that the "
        "ExecutionType does not match any of the values in the "
        "ExecutionType enumeration. \"Executes in Existing Process\" "
        "indicates that the Service is hosted in a Process that " 
        "already exists in the system.  The lifecycle of the " 
        "Service is separate from that of the Process. "
        "\"Exeutes as Independent Process\" indicates that the "
        "Service is responsible for the lifecycle of the Process. "
        "When the Service is started, the Process is created. " 
        "For example, ServletEngines can run \"InProcess\" " 
        "within the existing Apache processes or \"OutOfProcess\" in "
        "its own servlet engine process.  In this case the Apache "
        "process would communicate with the servlet engine process "
        "based on the content of the request.  The association may "
        "be many to many."), 
       ValueMap {"0", "1", "2", "3"}, 
       Values {"Unknown", "Other", "Executes in Existing Process", 
               "Executes as Independent Process" } ] 
    uint16 ExecutionType; 
}; 

// ===================================================================
// Thread
// ===================================================================
   [Version ("2.6.0"), 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.") ]
class CIM_Thread : CIM_LogicalElement {
      [Propagated("CIM_Process.CSCreationClassName"),
       Key, MaxLen (256),
       Description ("The scoping ComputerSystem's CreationClassName.") ]
   string  CSCreationClassName;
      [Propagated("CIM_Process.CSName"),
       Key, MaxLen (256),
       Description ("The scoping ComputerSystem's Name.") ]
   string CSName;
      [Propagated("CIM_Process.OSCreationClassName"),
       Key, MaxLen (256),
       Description (
          "The scoping OperatingSystem's CreationClassName.") ]
   string OSCreationClassName;
      [Propagated("CIM_Process.OSName"),
       Key, MaxLen (256),
       Description ("The scoping OperatingSystem's Name.") ]
   string OSName;
      [Propagated("CIM_Process.CreationClassName"),
       Key, MaxLen (256),
       Description ("The scoping Process' CreationClassName.") ]
   string ProcessCreationClassName;
      [Propagated("CIM_Process.Handle"),
       Key, MaxLen (256),
       Description ("The scoping Process' Handle.") ]
   string ProcessHandle;
      [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 "
        "allow all instances of this class and its subclasses to "
        "be uniquely identified.") ]
   string CreationClassName;
      [Key, MaxLen(256),
       Description ("A string used to identify the Thread.") ]
   string Handle;
      [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;
      [Description (
        "Indicates the current operating condition of the Thread. " 
        "Values include ready (2), running (3), and blocked (4), "
        "among others."),
       ValueMap {"0", "1", "2", "3", "4", "5", "6"}, 
       Values {"Unknown", "Other", "Ready", "Running", 
               "Blocked", "Suspended Blocked", "Suspended Ready"} ]
   uint16 ExecutionState;
      [Description (
      "Time in kernel mode, in milliseconds. If this information "
      "is not available, a value of 0 should be used."),
       Units ("MilliSeconds") ]
   uint64 KernelModeTime;
      [Description (
        "Time in user mode, in milliseconds. If this information is "
        "not available, a value of 0 should be used."),
       Units ("MilliSeconds") ]
   uint64 UserModeTime;
};


// ===================================================================
// ProcessThread
// ===================================================================
   [Association, Aggregation, Version ("2.6.0"), Description (
     "A link between a Process and the Thread(s) running in the "
     "context of this Process.") ]
class CIM_ProcessThread : CIM_Component {
      [Override ("GroupComponent"), Aggregate, Min (1), Max (1),
       Description ("The Process.") ]
   CIM_Process REF GroupComponent;
      [Override ("PartComponent"), Weak,
       Description (
        "The Thread running in the context of the Process.") ]
   CIM_Thread REF PartComponent;
};


// ===================================================================
// Job
// ===================================================================
   [Abstract, Version ("2.6.0"), Description (
     "A Job is a LogicalElement 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.") ]
class CIM_Job : CIM_LogicalElement {
      [Description (
        "A free form string representing the Job's status.") ]
   string JobStatus;
      [Description ("Time that the Job was submitted.") ]
   datetime TimeSubmitted;
      [Description ("Time that the Job was begun.") ]
   datetime StartTime;
      [Description ("Length of time that the Job has been executing.") ]
   datetime ElapsedTime;
      [Description (
        "Time after which the Job is invalid or should be stopped.") ]
   datetime UntilTime;
      [Description (
        "User to be notified upon Job completion or failure.") ]
   string Notify;
      [Description ("User that submitted the Job.") ] 
   string Owner;
      [Description (
      "Indicates the urgency or importance of execution of a Job.") ]
   uint32 Priority;
};


// ===================================================================
// JobDestination 
// ===================================================================
   [Version ("2.6.0"), Description (
     "JobDestination is a LogicalElement 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. JobDestinations are hosted on Systems, similar to "
     "the way that Services are hosted on Systems.") ]
class CIM_JobDestination : CIM_LogicalElement {
      [Propagated ("CIM_System.CreationClassName"),
       Key, MaxLen (256),
       Description ("The scoping System's CreationClassName.") ]
   string SystemCreationClassName;
      [Propagated ("CIM_System.Name"),
       Key, MaxLen (256),
       Description ("The scoping System's Name.") ]
   string SystemName;
      [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;
      [Override ("Name"), Key, MaxLen (256),
       Description (
        "The inherited Name serves as key of a JobDestination "
        "instance in a System.") ]
   string Name; 
};


// ===================================================================
// HostedJobDestination 
// ===================================================================
   [Association, Version ("2.6.0"), Description (
     "An association between a JobDestination 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 JobDestination is hosted on the System where the "
     "LogicalDevices, SoftwareFeatures or Services that implement/"
     "provide the JobDestination are located.") ]
class CIM_HostedJobDestination : CIM_Dependency {
      [Override ("Antecedent"), Min (1), Max (1),
       Description ("The hosting System.") ]
   CIM_System REF Antecedent;
      [Override ("Dependent"), Weak,
       Description ("The JobDestination hosted on the System.") ]
   CIM_JobDestination REF Dependent;
};


// ===================================================================
// JobDestinationJobs 
// ===================================================================
   [Association, Version ("2.6.0"), Description (
     "An association describing where a Job is submitted for "
     "processing, ie to which JobDestination.") ]
class CIM_JobDestinationJobs : CIM_Dependency {
      [Override ("Antecedent"), Max (1),
       Description ("The JobDestination, possibly a queue.") ]
   CIM_JobDestination REF Antecedent;
      [Override ("Dependent"),
       Description ("The Job that is in the Job queue/Destination.") ]
   CIM_Job REF Dependent;
};



// ===================================================================
//  Diagnostics
// ===================================================================
// ==================================================================
// DiagnosticSetting
// ==================================================================
   [Version ("2.6.0"), Description (
     "Specific diagnostic test parameters and execution "
     "instructions are defined by subclassing and/or instantiating "
     "the DiagnosticSetting object. To provide more detailed "
     "Settings for a type of test (i.e., additional properties), "
     "subclassing is appropriate. When only the generic Setting "
     "information is required, instantiation of the Diagnostic"
     "Setting class may suffice.\n"
     "Data from DiagnosticSetting is captured in DiagnosticResult. "
     "When RunTest starts execution the settings, which are time "
     "sensitive, should be evaluated and captured. This is suggested "
     "since the DiagnosticSetting object can be modified at any time, "
     "and therefore the current test settings could be lost.") ]
class CIM_DiagnosticSetting : CIM_Setting {
      [Key, MaxLen (256), Override ("SettingID"), 
       Description (
        "The identifier by which the DiagnosticSetting object is " 
        "known and uniquely named. One possible naming scheme is " 
        "to name the SettingID using the DiagnosticTest's CreationClass"
        "Name and DiagnosticName, plus a GUID (Globally Unique "
        "IDentifier).\n" 
        "  Note that at an enterprise level, there is typically not a " 
        "one to one mapping between a DiagnosticSetting and all copies " 
        "of the DiagnosticTest.  The proposed naming convention will" 
        "scale to the entrprise level.") ]
    string SettingID;
      [Write, Description (
        "Sets the level of warning messages to be logged. If for "
        "example no warning information is required, the level "
        "would be set to \"No Warnings\" (value=0). Using \"Missing "
        "Resources\" (value=1) will cause warnings to be generated "
        "when required resources or hardware are not found. Setting "
        "the value to 2, \"Testing Impacts\", results in both "
        "missing resources and 'test impact' warnings (for example, "
        "multiple retries required) to be reported."), 
       ValueMap {"0", "1", "2", "3"}, 
       Values {"No Warnings", "Missing Resources", 
               "Testing Impacts", "All Warnings"} ]
    uint16 TestWarningLevel;
      [Write, Description (
        "When this flag is true, the diagnostic test will report "
        "'soft errors'. In this context, a soft error is a message "
        "from the diagnostic reporting a known defect in the "
        "hardware or driver configuration, or execution "
        "environment.  Examples are: \"Not enough memory\", "
        "\"Driver IOCTL not implemented\", \"Video RAM compare "
        "failed during polygon fill test (A known defect in the "
        "video chipset)\", etc.") ] 
    boolean ReportSoftErrors;
      [Write, Description (
        "When this flag is true, the diagnostic test will report "
        "'status messages'. In this context, a status message "
        "indicates that the diagnostic code is at a checkpoint. "
        "Examples are: \"Completion of phase 1\", \"Complex "
        "pattern\", etc.") ]
    boolean ReportStatusMessages;
      [Write, Description (
        "When this flag is true, the test will halt after finding "
        "the first error.") ]
    boolean HaltOnError;
      [Write, Description (
        "When this flag is true, the test software should attempt "
        "to run in an accelerated fashion either by reducing the "
        "coverage or number of tests performed.") ]
    boolean QuickMode;
      [Write, MinValue (0), MaxValue (100), 
       Description (
        "Requests the diagnostic software to reduce test coverage "
        "to the specified percentage.  For example, a hard drive "
        "scan test could be asked to run at 50%. The most "
        "effective way to accomplish this is for the test software "
        "to scan every other track, as opposed to only scanning the "
        "first half of a drive. It is assumed that the effectiveness "
        "of the test is impacted proportional to the percentage of "
        "testing requested. Permissible values for this property "
        "range from 0 to 100. \n"
        "This property may not be applicable to all tests.  If it "
        "can be set for a test, the value 7 (\"Supports PercentOf"
        "TestCoverage\") should be entered into the DiagnosticTest's "
        "Characteristics array."), 
       ModelCorrespondence {"CIM_DiagnosticTest.Characteristics"}, 
       Units ("Percent") ]
    uint8 PercentOfTestCoverage;
 };


// ==================================================================
// DiagnosticResult
// ==================================================================
   [Version ("2.6.0"), Description (
     "When a DiagnosticTest Service is running, test results "
     "are reported using a DiagnosticResult object, or one of its "
     "subclasses. A DiagnosticTest may be running because its "
     "Service is Started or due to an invocation of the RunTest "
     "method. DiagnosticResults are related to their Test via an "
     "instance of the DiagnosticResultsForMSE association.\n"
     "For every running of DiagnosticTest, a new instance of "
     "DiagnosticResult, or one of it's subclasses should be created.") ]
class CIM_DiagnosticResult {
      [Propagated("CIM_DiagnosticTest.CreationClassName"), 
       Key, MaxLen (256),
       Description ("The scoping Test's CreationClassName.") ]
    string DiagnosticCreationClassName;
      [Propagated("CIM_DiagnosticTest.Name"),
       Key, MaxLen (256),
       Description ("The scoping Test's Name.") ]
    string DiagnosticName;
      [Propagated ("CIM_DiagnosticTest.SystemCreationClassName"),
       Key, MaxLen (256),
       Description ("The scoping Test's SystemCreationClassName.") ]
   string DiagSystemCreationClassName;
      [Propagated ("CIM_DiagnosticTest.SystemName"), 
       Key, MaxLen (256),
       Description ("The scoping Test's SystemName.") ]
   string DiagSystemName;
      [Key, MaxLen (1024), 
       Description (
        "The Unique identifier for an instance of Diagnostic"
        "Results.") ]
    string ExecutionID ; 
      [Description (
        "The date and time the result was last updated.") ]
    datetime TimeStamp;
      [Description (
        "If this property is TRUE, then this DiagnosticResult "
        "summarizes the results from the execution of a packaged "
        "set of DiagnosticTests. The Tests in the package can be "
        "identified by following the DiagnosticResultForTest "
        "association to the test and then using the DiagnosticTest"
        "InPackage aggregation. The individual Results can be "
        "broken out by instantiating DiagnosticResults for the "
        "individual lower level tests and aggregating into the "
        "'summary' Result using the DiagnosticResultInPackage "
        "association.") ]
    boolean IsPackage;
      [Description (
        "The date and time  when this test started.") ]
    datetime TestStartTime;
      [Description (
        "The date and time when this test completed.") ]
    datetime TestCompletionTime;
      [Description (
        "Describes how the test is progressing. For example, if "
        "the test was discontinued, the TestState will be "
        "\"Stopped\" (value=5), or if testing is currently "
        "executing, TestState will be \"In Progress\" (4)."),  
       ValueMap {"0", "1", "2", "3", "4", "5"}, 
       Values {"Unknown", "Other", "Passed", "Failed", 
              "In Progress", "Stopped"},
       ModelCorrespondence {
        "CIM_DiagnosticResult.OtherStateDescription"} ]
     uint16 TestState;
      [Description (
        "When \"Other\" (value=1) is entered in the TestState "
        "property, OtherStateDescription can be used to describe "
        "the test's state."),
       ModelCorrespondence {"CIM_DiagnosticResult.TestState"} ]
     string OtherStateDescription;
      [Units ("Seconds"), 
       Description (
        "Estimated number of seconds to perform the Diagnostic"
        "Test indicated by the DiagnosticCreationClassName and "
        "DiagnosticName properties.  After the test has completed, "
        "the actual elapsed time can be determined by subtracting "
        "the TestStartTime from the TestCompletionTime. A similar "
        "property is defined in the association, DiagnosticTest"
        "ForMSE. The difference between the two properties is "
        "that the value stored in the association is a generic "
        "test execution time for the Element and the Test. But, "
        "the value here (in DiagnosticResult) is the estimated "
        "time that this instance with the given settings would "
        "take to run the test.  A CIM Consumer can compare this "
        "value with the value in the association DiagnosticTestForMSE "
        "to get an idea what impact their settings have on test "
        "execution."), 
       ModelCorrespondence {
        "CIM_DiagnosticTestForMSE.EstimatedTimeOfPerforming"} ]
    uint32 EstimatedTimeOfPerforming;
      [Description (
        "TestResults stores one or more textual results from the "
        "execution of the DiagnosticTest(s) referenced by the "
        "DiagnosticCreationClassName and DiagnosticName properties. "
        "One entry is considered a cell location in the array. Each "
        "entry is time stamped and contains the following "
        "information, in the following format: \n"
        " yyymmddhhttssoutc|DiagnosticName|Textual message \n"
        "Where: \n"
        "  yyy = year, e.g. 2000 \n"
        "  mm = month (01 - 12) \n"
        "  dd = day (01 - 31) \n" 
        "  hh = hour (00 - 24) \n"
        "  tt = minute (00-59) \n"
        "  ss = second (00-59) \n"
        "  o = \"+\" or \"-\" indicating the sign of the UTC "
        "correction field \n"
        "  utc = offset from UTC (Universal Coordinated Time) "
        "in minutes \n"
        "  DiagnosticName = string reference to the DiagnosticTest "
        "object which was executed\n"
        "  Textual message = free form string that is the 'test "
        "result'."), 
       ArrayType ("Ordered") ]
    string TestResults[];
      [Units ("Percent"), MinValue (0), MaxValue (100), 
       Description (
        "The percentage of the test that has executed thus far, if "
        "the TestState property is set to \"In Progress\" or the "
        "percentage of the complete test that was executed if the "
        "TestState property is set to any of the completed states "
        "(\"Passed\", \"Failed\" or \"Stopped\"). Final results may "
        "be based on less than 100% coverage due to the parameters "
        "defined in DiagnosticSetting (such as QuickMode, "
        "PercentOfTestCoverage or HaltOnError).") ]
    uint8 PercentComplete;


// ---------  Properties below here are copied from  ------------------
// ---------  DiagnosticSettings                     ------------------
// Note that the DiagnosticSetting object can be modified at any time,
// and the current test settings can be lost. When RunTest starts 
// execution the settings, which are time sensitive, should be evaluated 
// and captured. 

      [Write, Description (
        "Sets the level of warning messages to be logged. If for "
        "example no warning information is required, the level "
        "would be set to \"No Warnings\" (value=0). Using \"Missing "
        "Resources\" (value=1) will cause warnings to be generated "
        "when required resources or hardware are not found. Setting "
        "the value to 2, \"Testing Impacts\", results in both "
        "missing resources and 'test impact' warnings (for example, "
        "multiple retries required) to be reported."), 
       ValueMap {"0", "1", "2", "3"}, 
       Values {"No Warnings", "Missing Resources", 
               "Testing Impacts", "All Warnings"} ]
    uint16 TestWarningLevel;
      [Write, Description (
        "When this flag is true, the diagnostic test will report "
        "'soft errors'. In this context, a soft error is a message "
        "from the diagnostic reporting a known defect in the "
        "hardware or driver configuration, or execution "
        "environment.  Examples are: \"Not enough memory\", "
        "\"Driver IOCTL not implemented\", \"Video RAM compare "
        "failed during polygon fill test (A known defect in the "
        "video chipset)\", etc.") ] 
    boolean ReportSoftErrors;
      [Write, Description (
        "When this flag is true, the diagnostic test will report "
        "'status messages'. In this context, a status message "
        "indicates that the diagnostic code is at a checkpoint. "
        "Examples are: \"Completion of phase 1\", \"Complex "
        "pattern\", etc.") ]
    boolean ReportStatusMessages;
      [Write, Description (
        "When this flag is true, the test will halt after finding "
        "the first error.") ]
    boolean HaltOnError;
      [Write, Description (
        "When this flag is true, the test software should attempt "
        "to run in an accelerated fashion either by reducing the "
        "coverage or number of tests performed.") ]
    boolean QuickMode;
      [Write, MinValue (0), MaxValue (100), 
       Description (
        "Requests the diagnostic software to reduce test coverage "
        "to the specified percentage.  For example, a hard drive "
        "scan test could be asked to run at 50%. The most "
        "effective way to accomplish this is for the test software "
        "to scan every other track, as opposed to only scanning the "
        "first half of a drive. It is assumed that the effectiveness "
        "of the test is impacted proportional to the percentage of "
        "testing requested. Permissible values for this property "
        "range from 0 to 100. \n"
        "This property may not be applicable to all tests.  If it "
        "can be set for a test, the value 7 (\"Supports PercentOf"
        "TestCoverage\") should be entered into the DiagnosticTest's "
        "Characteristics array."), 
       ModelCorrespondence {"CIM_DiagnosticTest.Characteristics"}, 
       Units ("Percent") ]
    uint8 PercentOfTestCoverage;
};


// ==================================================================
// DiagnosticTest
// ==================================================================
   [Version ("2.6.0"), Description (
     "The CIM_DiagnosticTest class represents the ability to "
     "execute a test. Specific diagnostic tests may be defined by "
     "subclassing and/or instantiating this object. To provide "
     "more detail for a type of test (i.e, additional properties "
     "and methods), subclassing is appropriate. To indicatae that a "
     "test exists and may be applied to a specific ManagedSystem"
     "Element, instantiation of the DiagnosticTest class may "
     "suffice.") ]
class CIM_DiagnosticTest : CIM_Service {
      [Description (
        "The descriptions for each Characteristic are below:\n "
        "\n"
        "* \"Is Exclusive\" (value=2) is specified for the test "
        "module only if the diagnostic cannot run more than one test "
        "at a time, regardless of how many SystemElements are "
        "supported. Typically, this occurs when hardware or software "
        "constraints prevent the test from running as multiple, "
        "concurrent instances. If the diagnostic can be run against "
        "multiple SystemElements, but only once per Element, then set "
        "the IsExclusiveForMSE boolean property on the appropriate "
        "instances of DiagnosticTestForMSE. \n"
        "\n"
        "* If \"Is Interactive\" (value=3) is set, then the diagnostic "
        "displays a message either before, during or after testing. \n"
        "\n"
        "* Set \"Is Destructive\" (value=4) if the diagnostic will "
        "destroy data, or reconfigure the Element that is being "
        "tested. \n" 
        "\n"
        "* \"Is Risky\" (value=5) indicates that data loss may occur "
        "if the test is interrupted. Some tests make copies of data, "
        "perform the test, and restore the data returning the tested "
        "entity to its previous configuration. If the test is "
        "interrupted, then loss of data or reconfiguration of the "
        "tested ManagedSystemElement may occur. \n"
        "\n"
        "* If \"Is Package\" (value=6) is set, this test is actually "
        "a set of lower level diagnostics, that are 'packaged' "
        "together. \n"
        "\n"
        "\"Supports PercentOfTestCoverage\" (value=7) indicates that "
        "a request for reduced test coverage can be specified using "
        "the PercentOfTestCoverage property of Diagnostic Setting. \n"
        "\n"
        "Also, the values \"Unknown\" (0) and \"Other\" (1) may be "
        "specified. If \"Other\" is defined, additional detail may be "
        "found in the OtherCharacteristicDescription property of this "
        "class."), 
       ValueMap {"0", "1", "2", "3", "4", "5", "6", "7"}, 
       Values {"Unknown", "Other", "Is Exclusive", "Is Interactive", 
              "Is Destructive", "Is Risky", "Is Package", 
              "Supports PercentOfTestCoverage"},
       ModelCorrespondence {
        "CIM_DiagnosticTest.OtherCharacteristicDescription"} ]
    uint16 Characteristics[];
      [Description (
        "Provides additional information for the Characteristic when "
        "its value is set to 1 (\"Other\")."), 
       ModelCorrespondence {"CIM_DiagnotistTest.Characteristics"} ]
      string OtherCharacteristicDescription;
      [Description (
        "If this test is currently being performed, the InUse "
        "property is set to TRUE. To determine which ManagedSystem"
        "Element is being tested, query the DiagnosticResult objects "
        "associated with this test (query DiagnosticResultForTest), "
        "and for which the TestState equals 4 (\"In Progress\"). "
        "The DiagnosticResult object is associated with the System"
        "Element under test, using DiagnosticResultForMSE.") ]
    boolean IsInUse;
      [Description (
        "The \"Expensive\" qualifier can be applied to this class and "
        "its RunTest method. If so, the ResourcesUsed property "
        "describes the resources that are capitalized, based on a "
        "default setup for the test. Multiple resources can be "
        "specified since the property is an array."), 
       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"}, 
       Values {"CPU", "Memory", "Hard Disk", "CDROM", "Floppy", 
              "PCI Bus", "USB Bus", "1394 Bus", "SCSI Bus", "IDE Bus", 
              "Network", "ISA Bus", "EISA Bus", "VESA Bus", 
              "PCMCIA Bus", "CardBus", "Access.bus", "NuBus", "AGP", 
              "VME Bus", "Sbus IEEE 1396-1993", "MCA Bus", "GIO Bus", 
              "XIO Bus", "HIO Bus", "PMC Bus", "SIO Bus"} ]
    uint16 ResourcesUsed[];
      [Description (
        "The RunTest method executes this test for the specified "
        "ManagedSystemElement (defined using the SystemElement input "
        "parameter). Results of the test are stored in a Diagnostic"
        "Result object, a reference to which is returned as the Result "
        "output parameter. How the test should execute, i.e. its "
        "settings, is defined in a DiagnosticSetting object (or by a "
        "subclass of DiagnosticSetting). A reference to a Setting "
        "object is specified using the Setting input parameter.  If a "
        "reference is not passed into the method, then a default "
        "DiagnosticSetting may be used. This default Setting is "
        "associated with the DiagnoticTest using the DefaultSetting "
        "relationship of the Core Model. \n"
        "When RunTest starts execution, the settings, which are time "
        "sensitive, should be evaluated and captured. This is "
        "suggested since the DiagnosticSetting object can be modified "
        "at any time, and therefore the current test settings could "
        "be lost. \n"
        "The method's return codes are expected to adhere to the XML "
        "return codes as they are introduced. Currently, the standard "
        "return values are: \n"
        "0 = OK (function succeeded, but the test itself may have "
        "failed \n"
        "1 = Unspecified Error (function failed for unspecified "
        "reasons) \n"
        "2 = Not Implemented (function is not implemented for this "
        "instance) \n"
        "3 = Out Of Resources (component could not allocate required "
        "resources, e.g. memory, disk space, etc.) \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 RunTest([IN] CIM_ManagedSystemElement ref SystemElement, 
          [IN] CIM_DiagnosticSetting ref Setting, 
          [IN (false), OUT] CIM_DiagnosticResult ref Result);   
      [Description (
        "Execution of this method will delete all instances of the "
        "DiagnosticResultForMSE object, for this DiagnosticTest "
        "and the specified ManagedSystemElement (defined using the "
        "SystemElement input parameter). The DiagnosticResults "
        "referenced in the DiagnosticResultForMSE instances will be "
        "deleted.  Also the association DiagnosticResultForTest that "
        "referees to the DiagnosticResult object, and this test will "
        " be deleted.\n"
        "  One output parameter is defined - ResultsNotCleared "
        "- which is a string array that lists the keys of the "
        "DiagnosticResults which could not be deleted. This "
        "information enables those Results to be revisited and either "
        "manually removed, or other corrective action taken. \n"
        "The method's return codes are expected to adhere to the XML "
        "return codes as they are introduced. Currently, the standard "
        "return values are: \n"
        "0 = OK (function succeeded, but the test itself may have "
        "failed \n"
        "1 = Unspecified Error (function failed for unspecified "
        "reasons) \n"
        "2 = Not Implemented (function is not implemented for this "
        "instance) \n"
        "3 = Out Of Resources (component could not allocate required "
        "resources, e.g. memory, disk space, etc.) \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 ClearResults(
          [IN] CIM_ManagedSystemElement ref SystemElement, 
          [IN (false), OUT] String ResultsNotCleared[]);   
      [Description (
        "After invocation of this method and its completion, the "
        "specified test(s) will be discontinued for the indicated "
        "ManagedSystemElement (defined by the SystemElement input "
        "parameter). The test to discontinue is specified using the "
        "Result input parameter. If all instances of this test should "
        "be stopped for the SystemElement, then the Result reference "
        "should be NULL. Upon completion of the method, test status "
        "and other information (such as PercentComplete) will be "
        "stored in the DiagnosticResult instance defined by the Result "
        "input parameter. The output parameter, TestingStopped, is "
        "used as follows:\n"
        " Set to TRUE if testing was successfully stopped. \n"
        " Set to FALSE if the current test(s) can not be stopped. \n"
        "If set to FALSE, testing will stop when the diagnostic is "
        "able to do so safely. To determine if/when the testing is "
        "stopped, check the TestState property in the DiagnosticResult "
        "instance defined by the Result parameter. TestState will "
        "change from \"In Progress\" to \"Stopped\" (from 4 to 5). \n"
        "The method's return codes are expected to adhere to the XML "
        "return codes as they are introduced. Currently, the standard "
        "return values are: \n"
        "0 = OK (function succeeded, but the test itself may have "
        "failed \n"
        "1 = Unspecified Error (function failed for unspecified "
        "reasons) \n"
        "2 = Not Implemented (function is not implemented for this "
        "instance) \n"
        "3 = Out Of Resources (component could not allocate required "
        "resources, e.g. memory, disk space, etc.) \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 DiscontinueTest(
          [IN] CIM_ManagedSystemElement ref SystemElement, 
          [IN] CIM_DiagnosticResult ref Result, 
          [IN (false), OUT] Boolean TestingStopped);   
};

// ==================================================================
// DiagnosticResultForMSE
// ==================================================================
   [Association, Version ("2.6.0"), Description (
     "This is an association class relating diagnostic test "
     "results to the ManagedSystemElement that is/was tested.") ]
class CIM_DiagnosticResultForMSE {
      [Key, Description (
        "The diagnostic result.") ]
   CIM_DiagnosticResult REF Result;
      [Key, Description (
        "The ManagedSystemElement to which the diagnostic result "
        "applies.") ]
   CIM_ManagedSystemElement REF SystemElement;
};


// ==================================================================
// DiagnosticResultForTest
// ==================================================================
   [Association, Version ("2.6.0"), Description (
     "This is an association class to relate the results of a test "
     "to the test itself.") ]
class CIM_DiagnosticResultForTest {
      [Key, Min (1), Max (1), Weak,
       Description ("The result object.") ]
   CIM_DiagnosticResult REF DiagnosticResult;
      [Key, Min (1), Max (1),
       Description ("The test that generated the result object.") ]
   CIM_DiagnosticTest REF DiagnosticTest;
};


// ==================================================================
// DiagnosticTestForMSE
// ==================================================================
   [Association, Version ("2.6.0"), Description (
     "This is an association class that relates a DiagnosticTest "
     "to a ManagedSystemElement.  Consumers wishing to 'diagnose' "
     "a particular Element could query this association, for the "
     "Element, to determine what tests are available.") ]
class CIM_DiagnosticTestForMSE : CIM_ProvidesServiceToElement {
      [Override("Antecedent"), Description (
        "The test that may be run against a ManagedSystemElement.") ]
   CIM_DiagnosticTest REF Antecedent;
      [Override("Dependent"), Description (
        "The ManagedSystemElement that can be tested.") ]
   CIM_ManagedSystemElement REF Dependent;
      [Units ("Seconds"), 
       Description (
        "Estimated number of seconds to perform the referenced "
        "DiagnosticTest against the ManagedSystemElement. Since "
        "execution times could vary by Element, this property is "
        "located in the association between the two entities. It is "
        "also captured in DiagnosticResult, in the Estimated"
        "TimeOfPerforming property.\n" 
        "A CIM Consumer can compare this value with the value in"
        "DiagnosticResult to get an idea of what impact their"
        "settings have on test execution."),
       ModelCorrespondence {
        "CIM_DiagnosticResult.EstimatedTimeOfPerforming"} ]
    uint32 EstimatedTimeOfPerforming;
      [Description (
        "If the DiagnosticTest referenced in this object can be run "
        "concurrently against multiple SystemElements, but only "
        "run one at a time for the referenced ManagedSystemElement, "
        "then this boolean is set to TRUE. Alternately, if the test "
        "can NOT be run concurrently irregardless of the System"
        "Elements being tested, then the more general \"Is Exclusive\" "
        "enumerated value (2) should be set in DiagnosticTest."
        "Characteristics.") ]
    boolean IsExclusiveForMSE;
};


// ==================================================================
// DiagnosticTestInPackage
// ==================================================================
   [Association, Aggregation, Version ("2.6.0"), Description (
     "This is an association class that identifies a Diagnostic"
     "Test as made up of lower level Tests. In this case, the "
     "Test identified as the GroupComponent reference (i.e, "
     "the higher level test) would have the \"Is Package\" "
     "enumerated value specified in DiagnosticTest."
     "Characteristics.") ]
class CIM_DiagnosticTestInPackage : CIM_Component {
      [Override("GroupComponent"), Aggregate, 
       Description (
        "The DiagnosticTest object that acts as the container for all "
        "the tests of the package.") ]
   CIM_DiagnosticTest REF GroupComponent;
      [Override("PartComponent"), 
       Description (
        "The DiagnosticTest object that is one of the elements of "
        "the package.") ]
   CIM_DiagnosticTest REF PartComponent;  
};

     
// ==================================================================
// DiagnosticResultInPackage
// ==================================================================
   [Association, Aggregation, Version ("2.6.0"), Description (
     "This is an association class that identifies a Diagnostic"
     "Result as made up of lower level Results. In this case, the "
     "Result identified as the PackageResult reference (i.e., "
     "the higher level result) would have its IsPackage property "
     "set to TRUE.") ]
class CIM_DiagnosticResultInPackage {
      [Key, Aggregate, Description (
       "The DiagnosticResult object that acts as the container for all "
       "the results of the package.") ]
   CIM_DiagnosticResult REF PackageResult;
      [Key, Description (
        "The DiagnosticResult object that is one of the elements of "
        "the package.") ]
   CIM_DiagnosticResult REF Result; 
};

     
// ==================================================================
// DiagnosticTestSoftware
// ==================================================================
   [Association, Version ("2.6.0"), Description (
     "This is an association class relating DiagnosticTest to "
     "the SoftwareElements that provide this test. SoftwareElement "
     "describes vendor/version information and other deployment "
     "data.") ]
class CIM_DiagnosticTestSoftware : CIM_Dependency {
      [Override ("Antecedent"), Description (
        "Vendor/version and other information about the software "
        "that runs as the DiagnosticTest.") ]
   CIM_SoftwareElement REF Antecedent;
      [Override ("Dependent"), Description (
        "The DiagnosticTest whose software is described.") ]
   CIM_DiagnosticTest REF Dependent;
};
  

// ==================================================================
// DiagnosticSettingForTest
// ==================================================================
   [Association, Version ("2.6.0"), Description (
     "This is an association class to relate test settings with "
     "diagnostic tests.") ]
class CIM_DiagnosticSettingForTest : CIM_ElementSetting {
      [Override("Element"), Description (
        "The Test that can use the Setting object.") ]
   CIM_DiagnosticTest REF Element;
      [Override("Setting"), Description (
        "The Setting that can be applied to the execution of the "
        "DiagnosticTest.") ]
   CIM_DiagnosticSetting REF Setting;
};


// ===================================================================
//  Time
// ===================================================================
// ===================================================================
// TimeZone
// =================================================================== 
[Version("2.6.0"), Description (
    "A TimeZone is a presentation of the properties used to describe "
    "a time zone.  These properties include the concepts of daylight "
    "saving time.") ]
class CIM_TimeZone : CIM_Setting {
    [Key, Description (
        "Time zone identifier. TimeZoneID MAY be expressed in the "
        "form 'area name/city name' (e.g. America/New_York) instead of "
        "a time zone name depending on a date (e.g. EST or EDT).") ]
    string TimeZoneID;
    
    [Key, Description (
        "The date and time at which this time zone definition "
        "takes effect. Specify it in UTC.") ]
    datetime TimeZoneStartDate;
    
    [Description (
        "Full name of the time zone (e.g. U.S. East Standard "
        "Time) of the standard time name "
        "in a format suitable for presentation "
        "to the user in the default locale.") ]
    string StandardName;
    
    [Description (
        "Short name of the time zone (e.g. EST) "
        "of the standard time name "
        "in a format suitable for presentation "
        "to the user in the default locale. ") ]
    string StandardCaption;
    
    [Description (
        "The number of minutes by which this standard time "
        "differs from UTC. For example, U.S. EST differs "
        "from UTC by -5.0 hours or -300 minutes whereas "
        "Australia Adelaide Standard Time differs by 9.5 hours "
        "or 570 minutes. "), 
        Units ("Minutes") ]
    sint32 StandardOffset;
    
    [Description (
        "The month in which daylight saving time ends. "
        "Specify 0 for January, 1 for February, and so on."), 
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", 
            "10", "11"},  
        Values {"January", "February", "March", "April",
            "May", "June", "July", "August", "September",
            "October", "November", "December" },
        ModelCorrespondence {"CIM_TimeZone.StandardDay" } ]
    uint8 StandardMonth;
    
    [MinValue (-31), MaxValue (31), Description (
        "The day-in-month on which daylight "
        "saving time ends, if StandardDayOfWeek is 0. "
        "Specify a positive or negative integer to indicate "
        "whether the StandardDay should be calculated "
        "from the beginning of the month or the end of the "
        "month. For example, 5 indicates the fifth day in the "
        "StandardMonth and -1 indicates the last day in the "
        "StandardMonth. \n"
        "\n"
        "The day-in-month from which the StandardDayOfWeek "
        "is calculated, if StandardDayOfWeek is not 0. "
        "If StandardDay is 15 and StandardDayOfWeek is "
        "Saturday, then this indicates the first Saturday on or "
        "after the 15th day in the StandardMonth (i.e. third "
        "Saturday in the StandardMonth). "
        "If StandardDay is 20 and StandardDayOfWeek is "
        "-Saturday, then this indicates the first Saturday on or "
        "before the 20th day in the StandardMonth."
        "If StandardDay is -1 and StandardDayOfWeek is "
        "-Sunday, then this indicates the last Sunday "
        "in the StandardMonth."),
        ModelCorrespondence {"CIM_TimeZone.StandardDayOfWeek" } ]
    sint8 StandardDay;
     
    [Description (
        "Positive or negative integer used in conjunction "
        "with StandardDay to indicate the day of the week "
        "on which daylight saving time ends. Set "
        "StandardDayOfWeek to 0 to indicate an exact day of "
        "month, such as March 1. "
        "Positive integer (Sunday, Monday, ..., Saturday) means "
        "that the day of week is found on or after StandardDay. "
        "Negative integer (-Sunday, -Monday, ..., -Saturday) "
        "means that the day of week is found on or before "
        "StandardDay. "),
        ValueMap {"-7", "-6", "-5", "-4", "-3", "-2", "-1",
            "0", "1", "2", "3", "4", "5", "6", "7" },
        Values {"-Saturday", "-Friday", "-Thursday", "-Wednesday",
            "-Tuesday", "-Monday", "-Sunday", "ExactDayOfMonth",
            "Sunday", "Monday", "Tuesday", "Wednesday",
            "Thursday", "Friday", "Saturday" },
        ModelCorrespondence {"CIM_TimeZone.StandardDay" } ]
    sint8 StandardDayOfWeek;
    
    [Description (
        "The time interval after midnight when daylight "
        "saving time ends. For example: \n"
        "   00000000020000.000000:000 indicates \n"
        "   daylight saving time ends at two o'clock in \n"
        "   the local time (usually, daylight saving time).") ]
    datetime StandardStartInterval;
    
    [Description (
        "Full name of the time zone (e.g. U.S. East Daylight "
        "Saving Time) of the daylight saving time name "
        "in a format suitable for presentation "
        "to the user in the default locale.") ]
    string DaylightName;
    
    [Description (
        "Short name of the time zone (e.g. EDT) "
        "of the daylight saving time name "
        "in a format suitable for presentation "
        "to the user in the default locale. ") ]
    string DaylightCaption;
    
    [Description (
        "The number of minutes by which this daylight saving time "
        "differs from UTC. For example, U.S. EDT differs "
        "from UTC by -4.0 hours or -240 minutes whereas "
        "Australia Adelaide Daylight Time differs by 10.5 hours "
        "or 630 minutes. "), 
        Units ("Minutes") ]
    sint32 DaylightOffset;
    
    [Description (
        "The month in which daylight saving time starts. "
        "Specify 0 for January, 1 for February, and so on."), 
        ValueMap {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", 
            "10", "11"},  
        Values {"January", "February", "March", "April",
            "May", "June", "July", "August", "September",
            "October", "November", "December" },
        ModelCorrespondence {"CIM_TimeZone.DaylightDay" } ]
    uint8 DaylightMonth;
    
    [MinValue (-31), MaxValue (31), Description (
        "The day-in-month on which daylight "
        "saving time starts, if DaylightDayOfWeek is 0. "
        "Specify a positive or negative integer to indicate "
        "whether the DaylightDay should be calculated "
        "from the beginning of the month or the end of the "
        "month. For example, 5 indicates the fifth day in the "
        "DaylightMonth and -1 indicates the last day in the "
        "DaylightMonth. \n"
        "\n"
        "The day-in-month from which the DaylightDayOfWeek "
        "is calculated, if DaylightDayOfWeek is not 0. "
        "If DaylightDay is 15 and DaylightDayOfWeek is "
        "Saturday, then this indicates the first Saturday on or "
        "after the 15th day in the DaylightMonth (i.e. third "
        "Saturday in the DaylightMonth). "
        "If DaylightDay is 20 and DaylightDayOfWeek is "
        "-Saturday, then this indicates the first Saturday on or "
        "before the 20th day in the DaylightMonth."
        "If DaylightDay is -1 and DaylightDayOfWeek is "
        "-Sunday, then this indicates the last Sunday "
        "in the DaylightMonth."),
        ModelCorrespondence {"CIM_TimeZone.DaylightDayOfWeek" } ]
    sint8 DaylightDay;
    
    [Description (
        "Positive or negative integer used in conjunction "
        "with DaylightDay to indicate the day of the week "
        "on which daylight saving time starts. Set "
        "DaylightDayOfWeek to 0 to indicate an exact day of "
        "month, such as March 1. "
        "Positive integer (Sunday, Monday, ..., Saturday) means "
        "that the day of week is found on or after DaylightDay. "
        "Negative integer (-Sunday, -Monday, ..., -Saturday) "
        "means that the day of week is found on or before "
        "DaylightDay. "), 
        ValueMap {"-7", "-6", "-5", "-4", "-3", "-2", "-1",
            "0", "1", "2", "3", "4", "5", "6", "7" },
        Values {"-Saturday", "-Friday", "-Thursday", "-Wednesday",
            "-Tuesday", "-Monday", "-Sunday", "ExactDayOfMonth",
            "Sunday", "Monday", "Tuesday", "Wednesday",
            "Thursday", "Friday", "Saturday" },
        ModelCorrespondence {"CIM_TimeZone.DaylightDay" } ]
    sint8 DaylightDayOfWeek;
    
    [Description (
        "The time interval after midnight when daylight "
        "saving time starts. For example: \n"
        "   00000000020000.000000:000 indicates \n"
        "   daylight saving time starts at two o'clock in \n"
        "   the local time (usually, standard time).") ]
    datetime DaylightStartInterval;
};  


// ===================================================================
//  Unix
// ===================================================================
// ===================================================================
// UnixLocalFileSystem
// ===================================================================
   [Version ("2.6.0"), Description (
     "A class derived from LocalFileSystem that represents the Unix "
     "environment view of a 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_UnixLocalFileSystem : CIM_LocalFileSystem {
      [Description (
        "The number of free inodes present in the file system.  "
        "This value is only valid if TotalSlots is non-zero."),
       MappingStrings {"MIF.DMTF|Host File System|001.12"},
       ModelCorrespondence {"CIM_UnixLocalFileSystem.TotalSlots"} ]
   uint64 FreeInodes;
      [Description (
        "The total number of inodes available in the file system.  "
        "A value of zero for TotalInodes indicates that this file "
        "system does not have a preset limit."),
       MappingStrings {"MIF.DMTF|Host File System|001.11"} ]
   uint64 TotalInodes;
      [Description (
        "The reserve data capacity of the file system in bytes."),
       MappingStrings {"MIF.DMTF|Host File System|001.15"},
       Units ("Bytes") ]
   uint64 FSReservedCapacity;
};


// ===================================================================
// UnixProcess
// ===================================================================
   [Version ("2.6.0"), Description (
     "Each instance of the CIM_UnixProcess class represents a single "
     "instance of a running program. A user of the Operating System "
     "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.") ]
class CIM_UnixProcess : CIM_Process {
      [Required, Description (
        "The parent process ID of this executing process."),
       MappingStrings {"MIF.DMTF|Process Information|001.2"} ]
   string ParentProcessID;
      [Required, Description (
        "The Real User ID of this currently executing process."),
       MappingStrings {"MIF.DMTF|Process Information|001.4"} ]
   uint64 RealUserID;
      [Required, Description (
        "The Group ID of this currently executing process."),
       MappingStrings {"MIF.DMTF|Process Information|001.2"} ]
   uint64 ProcessGroupID;
      [Description (
        "If part of a group of processes are under the control "
        "of a session leader, this property holds the session "
        "ID for the group.") ]
   uint64 ProcessSessionID;
      [Description (
        "The TTY currently associated with this process."),
       MappingStrings {"MIF.DMTF|Process Information|001.5"} ]
   string ProcessTTY;
      [Description (
        "The executing process's command path."),
       MappingStrings {"MIF.DMTF|Process Information|001.7"} ]
   string ModulePath;
      [ Description (
        "The operating system parameters provided to the executing "
        "process. These are the argv[] values."),
       MappingStrings {"MIF.DMTF|Process Information|001.8"} ]
   string Parameters[];
      [Description (
        "The process's 'nice' value.  Used to compute its priority."),
       MappingStrings {"MIF.DMTF|Process Information|001.11"} ]
   uint32 ProcessNiceValue;
      [Description (
        "A description of the event this process is currently "
        "sleeping for.  The precise nature of this string is "
        "implementation defined, but is typically the address of a "
        "system data structure that will be modified when the event "
        "occurs. This string only has meaning when the ExecutionState "
        "is \"Blocked\" or  \"SuspendedBlocked\"."),
        ModelCorrespondence {"CIM_Process.ExecutionState"} ]
   string ProcessWaitingForEvent;

};

// ===================================================================
// UnixProcessStatisticalInformation
// ===================================================================
   [Version ("2.6.0"), Description (
     "The statistics associated with a Unix process. ") ]
class CIM_UnixProcessStatisticalInformation : 
 CIM_StatisticalInformation {
      [Propagated("CIM_Process.CSCreationClassName"),
       Key, MaxLen (256),
       Description (
        "The scoping Process's ComputerSystem CreationClassName.") ]
   string CSCreationClassName;
      [Propagated("CIM_Process.CSName"),
       Key, MaxLen (256),
       Description ("The scoping Process's ComputerSystem Name.") ]
   string CSName;
      [Propagated("CIM_Process.OSCreationClassName"),
       Key, MaxLen (256),
       Description (
        "The scoping Process's OperatingSystem CreationClassName.") ]
   string OSCreationClassName;
      [Propagated("CIM_Process.OSName"),
       Key, MaxLen (256),
       Description ("The scoping Process's OperatingSystem Name.") ]
   string OSName;
      [Propagated("CIM_Process.Handle"),
       Key, MaxLen (256),
       Description ("The scoping Process's Handle.") ]
   string Handle;
      [Propagated("CIM_Process.CreationClassName"),
       Key, MaxLen (256),
       Description (
        "The scoping Process's CreationClassName.") ]
   string ProcessCreationClassName;
      [Key, MaxLen (256), Override ("Name"),
       Description (
        "A string used to identify the related statistics of a "
        "Process. ") ]
   string Name;
      [Description (
        "A string used to identify the related statistics of a "
        "Process. This key allows multiple instances of statistics to "
        "correspond to a single process.  The multiple "
        "instances could be used in applications such as "
        "time-sliced statistics. "),
       MappingStrings {"MIF.DMTF|Process Information|001.12"},
       Units ("Percent") ]
   uint32 CPUTime;
      [Description (
        "The number of KiloBytes of real text space used by "
        "the process."),
       MappingStrings {"MIF.DMTF|Process Information|001.15"},
       Units ("KiloBytes") ]
   uint64 RealText;
      [Description (
        "The number of KiloBytes of real data space used "
        "by the process."),
       MappingStrings {"MIF.DMTF|Process Information|001.16"},
       Units ("KiloBytes") ]
   uint64 RealData;
      [Description (
        "The number of KiloBytes of real stack space used "
        "by the process."),
       MappingStrings {"MIF.DMTF|Process Information|001.17"},
       Units ("KiloBytes") ]
   uint64 RealStack;
      [Description (
        "The number of KiloBytes of virtual text space used by the "
        "process."),
       MappingStrings {"MIF.DMTF|Process Information|001.18"},
       Units ("KiloBytes") ]
   uint64 VirtualText;
      [Description (
        "The number of KiloBytes of virtual data space used by the "
        "process."),
       MappingStrings {"MIF.DMTF|Process Information|001.19"},
       Units ("KiloBytes") ]
   uint64 VirtualData;
      [Description (
        "The number of KiloBytes of virtual stack space used by the "
        "process."),
       MappingStrings {"MIF.DMTF|Process Information|001.20"},
       Units ("KiloBytes") ]
   uint64 VirtualStack;
      [Description (
        "The number of KiloBytes of virtual space used for memory "
        "mapped files by the process."),
       MappingStrings {"MIF.DMTF|Process Information|001.22"},
       Units ("KiloBytes") ]
   uint64 VirtualMemoryMappedFileSize;
      [Description (
        "The number of KiloBytes of shared memory used by the"
        "process."),
       MappingStrings {"MIF.DMTF|Process Information|001.21"},
       Units ("KiloBytes") ]
   uint64 VirtualSharedMemory;
      [Description (
        "CPU time of terminated child processes in clock ticks"),
       Units ("Clock Ticks"), Counter]
   uint64 CpuTimeDeadChildren;
      [Description (
        "System time of terminated child processes in clock ticks"),
       Units ("Clock Ticks"), Counter]
   uint64 SystemTimeDeadChildren;
};

// ==================================================================
// UnixProcessStatistics
// ================================================================== 
   [Association, Version ("2.6.0"), Description ( 
     "CIM_UnixProcessStatistics is an association that relates a " 
     "CIM_UnixProcess to its StatisticalInformation. ") ]
class CIM_UnixProcessStatistics : CIM_Statistics { 
      [Key, Override ("Element"), Min (1), Max (1), Description ( 
        "The Process for which statistical or metric " 
        "data is defined.") ] 
    CIM_UnixProcess REF Element;
      [Key, Override ("Stats"), Weak, Description (
        "The UNIX Process statistical information/object.") ] 
    CIM_UnixProcessStatisticalInformation REF Stats; 
};

// ===================================================================
// UnixThread
// ===================================================================
   [Version ("2.6.0"), Description (
     "Threads represent the ability to execute units of a Process "
     "or task in parallel. A UnixThread inherits from the "
     "superclass, CIM_Thread, which is weak to the Process. The "
     "values used are defined in sched.h and psched.h.") ]
class CIM_UnixThread : CIM_Thread {
      [Description (
        "Indicates the thread's scheduling policy. Set to \"Other\" "
        "when using OtherSchedPolicy to specifiy additional values. "
        "\"Other\" represents SCHED_OTHER as defined in sched.h."),
       ValueMap {"0", "1", "2", "3"},
       Values {"Unknown", "Other", "SCHED_FIFO", "SCHED_RR"},
       ModelCorrespondence {"CIM_UnixThread.OtherSchedPolicy"} ] 
   uint16 SchedPolicy;
      [Description (
        "Indicates the thread's scheduling policy when SchedPolicy "
        "is set to \"Other\"."),
       ModelCorrespondence {"CIM_UnixThread.SchedPolicy"} ] 
   string OtherSchedPolicy;
      [Description (
        "Indicates the size of the guard area for a created thread's "
        "stack.") ]
   string GuardSize;
      [Description (
        "Indicates the creation state of the thread."),
       ValueMap {"0", "2", "3"},
       Values {"Unknown", "PTHREAD_CREATE_DETACHED", 
        "PTHREAD_CREATE_JOINABLE"} ]
   uint16 DetachState;
      [Description (
        "Indicates how the scheduling attributes are to be set."),
       ValueMap {"0", "2", "3"},
       Values {"Unknown", "PTHREAD_INHERIT_SCHED", 
        "PTHREAD_EXPLICIT_SCHED"} ]
   uint16 InheritSched;
      [Description (
        "Indicates the contention scope of the thread."),
       ValueMap {"0", "2", "3"},
       Values {"Unknown", "PTHREAD_SCOPE_SYSTEM", 
        "PTHREAD_SCOPE_PROCESS"} ]
   uint16 ContentionScope;
      [Description (
        "Indicates the size of storage to be used for the thread's "
        "stack.") ]
   string StackSize;
      [Description (
        "Indicates the thread's concurrency level.") ]
   uint64 ConcurrencyLevel;
      [Description (
        "Indicates the thread's cancelability state."),
       ValueMap {"0", "2", "3"},
       Values {"Unknown", "PTHREAD_CANCEL_ENABLE", 
        "PTHREAD_CANCEL_DISABLE"} ]
   uint16 CancelState;
      [Description (
        "Indicates the thread's cancelability type."),
       ValueMap {"0", "2", "3"},
       Values {"Unknown", "PTHREAD_CANCEL_DEFERRED", 
       "PTHREAD_CANCEL_ASYNCHRONOUS"} ]
   uint16 CancelType;
};


// ===================================================================
// UnixFile
// ===================================================================
   [Version ("2.6.0"), Description (
     "The UnixFile class holds properties that are valid for various "
     "subclasses of LogicalFile, in a Unix environment. This is "
     "defined as a separate and unique class since it is applicable "
     "to Unix files, directories, etc. It is associated via a "
     "FileIdentity relationship to these subclasses of LogicalFile. "
     "Unless this approach of creating and associating a separate "
     "class is used, it is necessary to subclass each of the "
     "inheritance hierarchies under LogicalFile, duplicating the "
     "properties in this class. The referenced _PC* and _POSIX* "
     "constants are defined in unistd.h. Some properties indicate "
     "whether the UNIX implementation support a feature such as "
     "asynchronous I/O or priority I/O. If supported, sysconf "
     "returns the value as defined in the appropriate header file "
     "such as unistd.h. If a feature is not supported, then pathconf "
     "returns a -1. In this case, the corresponding property should "
     "be returned without any value.") ]
class CIM_UnixFile : CIM_LogicalElement {
      [Propagated ("CIM_LogicalFile.CSCreationClassName"),
       Key, MaxLen (256),
       Description ("The scoping ComputerSystem's CreationClassName.") ]
   string CSCreationClassName;
      [Propagated ("CIM_LogicalFile.CSName"),
       Key, MaxLen (256),
       Description ("The scoping ComputerSystem's Name.") ]
   string CSName;
      [Propagated ("CIM_LogicalFile.FSCreationClassName"), 
       Key, MaxLen (256),
       Description ("The scoping FileSystem's CreationClassName.") ]
   string FSCreationClassName;
      [Propagated ("CIM_LogicalFile.FSName"),
       Key, MaxLen (256),
       Description ("The scoping FileSystem's Name.") ]
   string FSName;
      [Propagated ("CIM_LogicalFile.CreationClassName"),
       Key, MaxLen (256), Description (
        "The scoping LogicalFile's CreationClassName. ") ]
   string LFCreationClassName;    
      [Propagated ("CIM_LogicalFile.Name"), 
       Key, MaxLen (1024), Description (
        "The scoping LogicalFile's Name. ") ]
   string LFName;
      [Required, Description (
        "An Identifer that uniquely describes the owner "
        "of this file.") ] 
   string UserID;
      [Required, Description (
        "An identifier that describes the group that "
        "owns this file.") ] 
   string GroupID;
      [Description (
        "Indicates restricted deletion for directories, or possible "
        "implementation defined properties for executable files. "
        "For directories this is known as the sticky bit.") ] 
   boolean SaveText;
      [Description ("Count of the number of names for this file."),
       Counter ] 
   uint64 LinkCount;
      [Description ("File Inode number, as printed by \"ls -i\"."),
       MappingStrings {"UNIX.TOG|ls -i"} ] 
   string FileInodeNumber;
      [Description (
        "Indicates whether the associated file has setuid "
        "permissions.") ]
   boolean SetUid;
      [Description (
        "Indicates whether the associated file has setgid "
        "permissions.") ]
   boolean SetGid;
      [Description (
        "The time that the Inode was last modified. This "
        "includes the Inode creation time, state modification, "
        "and etc.") ]
   datetime  LastModifiedInode;
      [Description ("Maximum number of links to a single file. "),
       MinValue (8),
       MappingStrings {"POSIX.TOG|pathconf|_PC_LINK_MAX"} ]
   uint64 LinkMax;  
      [Description (
        "Maximum number of bytes in a filename, not "
        "including terminating null."),
       MinValue (14), Units ("Bytes"),
       MappingStrings {"POSIX.TOG|pathconf|_POSIX_NAME_MAX"} ]
   uint64 NameMax; 
      [Description (
        "Maximum number of bytes in a pathname, including "
        "the terminating null character. "),
       MinValue (255), Units ("Bytes"),
       MappingStrings {"POSIX.TOG|pathconf|_POSIX_PATH_MAX"} ]
   uint64 PathMax;  
      [Description (
        "The use of chown() is restricted to a process with "
        "appropriate privileges. chown() is used to change the "
        "group ID of a file. The group ID can be changed to the "
        "effective group ID or one of its supplementary group IDs. "),
       MappingStrings {"POSIX.TOG|pathconf|_PC_CHOWN_RESTRICTED"} ]
   uint64 PosixChownRestricted; 
      [Description (
        "Indicates whether pathname components longer "
        "than NameMax generate an error. "),
       ModelCorrespondence {"CIM_UnixFile.NameMax"},
       MappingStrings {"POSIX.TOG|pathconf|_PC_NO_TRUNC"} ]
   uint64 PosixNoTrunc;  
      [Description (
        "Indicates whether asynchronous input or output "
        "operations may be performed for the associated file. "),
       MappingStrings {"POSIX.TOG|pathconf|_PC_ASYNC_IO"} ]
   uint64 PosixAsyncIo; 
      [Description (
        "Indicates whether prioritized input or output "
        "operations may be performed for the associated file. "),
       MappingStrings {"POSIX.TOG|pathconf|_PC_PRIO_IO"} ]
   uint64 PosixPrioIo; 
      [Description (
        "Indicates whether synchronised input or output "
        "operations may be performed for the associated file. "),
       MappingStrings {"POSIX.TOG|pathconf|_PC_SYNC_IO"} ]
   uint64 PosixSyncIo; 
};


// ===================================================================
// FileIdentity
// ===================================================================
   [Association, Version ("2.6.0"), Description (
     "CIM_FileIdentity indicates that a UnixFile describes Unix-"
     "specific aspects of the various subclasses of LogicalFile. "
     "The association exists since it forces UnixFile to be "
     "weak to (scoped by) the LogicalFile. This is not true in "
     "the association's superclass, LogicalIdentity.") ]
class CIM_FileIdentity : CIM_LogicalIdentity {
      [Override ("SystemElement"), Min (1), Max (1), Description (
        "The Logical File.") ]
   CIM_LogicalFile ref SystemElement;
      [Override ("SameElement"), Weak, Max (1), Description (
        "SameElement represents the additional aspects of the "
        "Unix/Linux Logical file.") ]
   CIM_UnixFile ref SameElement;
};

 
// ===================================================================
// UnixDirectory
// ===================================================================
   [Version ("2.6.0"), Description (
     "UnixDirectory is a type of File that logically groups UnixFiles "
     "'contained' in it.") ]
class CIM_UnixDirectory : CIM_Directory {
      [Description (
        "Minimum number of bits needed to represent the "
        "maximum size of a Unix file allowed in the specified "
        "directory, as a signed integer value. Thus, a value of 32 "
        "indicates a maximum size of 2**31 bytes."),
       MinValue (32), Units ("Bits"),
       MappingStrings {"POSIX.TOG|pathconf|_PC_FILESIZEBITS"} ]
   uint64 FileSizeBits; 
};


// ===================================================================
// UnixDeviceFile
// ===================================================================
   [Version ("2.6.0"), Description (
     "DeviceFile is a special type of LogicalFile that represents a "
     "Device. This class is a specialization of DeviceFile for a Unix "
     "environment.") ]
class CIM_UnixDeviceFile : CIM_DeviceFile {
      [Description ("The type of device file."),
       ValueMap {"0", "1", "2", "3"},
       Values {"Unknown", "Other", "Block", "Character"},
       ModelCorrespondence {"CIM_UnixDeviceFile.OtherTypeDescription"} ] 
   uint16 DeviceFileType;
      [Description (
        "Additional information when the Type property is "
        "set to \"Other\"."),
       ModelCorrespondence {"CIM_UnixDeviceFile.Type"} ] 
   string OtherTypeDescription;
      [Required, Description (
        "The device Identifier: this is the st_rdev field "
        "in the stat structure.") ] 
   string DeviceId;
      [Description (
        "Additional information provided by the driver. This "
        "property may be null if no information is available, or "
        "a general description of the device when available, e.g. "
        "\"Non-rewind tape streamer\".") ] 
   string DeviceDescription;
      [Required, Description ("The Device's Major Id.") ]
   string DeviceMajor;
      [Required, Description ("The Device's Minor Id.") ]
   string DeviceMinor;
};


// ===================================================================
// end of file
// ===================================================================
