cim_storagepool.mof

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

// Copyright (c) 2005 DMTF.  All rights reserved.
// <change cr="CIMCoreCR00688.005" type ="add">Added property
// LowSpaceWarningThreshold.</
// <change cr="DMTFCR01555.000" type ="change">Update class description
// and descriptions for Primordial, TotalManagedSpace, and
// RemainingManagedSpace.</
// <change cr="CIMCoreCR00790" type = "change"> Updated description for
// property TotalManagedSpace. </change>
// <change cr="CIMCoreCR00820.003" type ="change">Remove Experimental
// from methods.</change>

// <change cr="ArchCR00066.004" type="add">Add UmlPackagePath
// qualifier values to CIM Schema.</change>
// ==================================================================
//  CIM_StoragePool
// ==================================================================
   [UMLPackagePath ( "CIM::Device::StorageServices" ),
       Version ( "2.13.0" ), Description (
       "A StoragePool is a conglomeration of storage capacity for the "
       "purpose of assignment and allocation based on service "
       "characteristics, such as location, available space or other "
       "criteria (for example, cost per megabyte or hardware "
       "ownership). A StoragePool is managed within the scope of a "
       "particular System. StoragePools may consist of component "
       "StoragePools or StorageExtents. StorageExtents that belong to "
       "the StoragePool have a Component relationship to the "
       "StoragePool. StorageExtents/StoragePools that are elements of "
       "a pool have their available space aggregated into the pool. "
       "StoragePools, StorageVolumes and LogicalDisks may be created "
       "from StoragePools. This is indicated by the "
       "AllocatedFromStoragePool association. StoragePool is scoped to "
       "a system by the HostedStoragePool association.")]
class CIM_StoragePool : CIM_LogicalElement {

      [Key, Description (
          "Within the scope of the instantiating Namespace, InstanceID "
          "opaquely and uniquely identifies an instance of this class. "
          "In order to ensure uniqueness within the NameSpace, the "
          "value of InstanceID SHOULD be constructed using the "
          "following 'preferred' algorithm: \n"
          "<OrgID>:<LocalID> \n"
          "Where <OrgID> and <LocalID> are separated by a colon ':', "
          "and where <OrgID> MUST include a copyrighted, trademarked "
          "or otherwise unique name that is owned by the business "
          "entity creating/defining the InstanceID, or is a registered "
          "ID that is assigned to the business entity by a recognized "
          "global authority (This is similar to the <Schema "
          "Name>_<Class Name> structure of Schema class names.) In "
          "addition, to ensure uniqueness <OrgID> MUST NOT contain a "
          "colon (':'). When using this algorithm, the first colon to "
          "appear in InstanceID MUST appear between <OrgID> and "
          "<LocalID>. \n"
          "<LocalID> is chosen by the business entity and SHOULD not "
          "be re-used to identify different underlying (real-world) "
          "elements. If the above 'preferred' algorithm is not used, "
          "the defining entity MUST assure that the resultant "
          "InstanceID is not re-used across any InstanceIDs produced "
          "by this or other providers for this instance's NameSpace. \n"
          "For DMTF defined instances, the 'preferred' algorithm MUST "
          "be used with the <OrgID> set to 'CIM'.")]
   string InstanceID;

      [Required, Description (
          "A unique name in the context of the System that identifies "
          "this pool."), 
       MaxLen ( 256 )]
   string PoolID;

      [Description (
          "If true, \"Primordial\" indicates that this StoragePool is "
          "the base from which storage capacity is drawn and returned "
          "in the activity of storage management. Being primordial "
          "means that this StoragePool shall not be created or deleted "
          "by consumers of this model. However, other actions, modeled "
          "or not, may affect the characteristics or size of "
          "primordial StoragePools. If false, \"Primordial\" indicated "
          "that the StoragePool, a concrete Storage Pool, is subject "
          "to storage services functions. This distinction is "
          "important because higher-level StoragePools may be "
          "assembled using the Component or AllocatedFromStoragePool "
          "associations. Although the higher-level abstractions can be "
          "created and deleted, the most basic, (i.e. primordial), "
          "hardware-based StoragePools cannot. They are physically "
          "realized as part of the System, or are actually managed by "
          "some other System and imported as if they were physically "
          "realized.")]
   boolean Primordial = false;

      [Description (
          "The total amount of capacity usable for the allocation of "
          "StorageVolumes, LogicalDisks, or child Storage Pools. \n"
          "For primordial Storage Pools, this capacity reflects the "
          "usable capacity of Disk Drives or LUNs, for example, to the "
          "owning storage device or application. For example, in "
          "storage array, a primordial Storage Pool's "
          "TotalManagedSpace does not include metadata such as the "
          "disk label area and absolute disk drive capacity lost in "
          "disk formatting. \n"
          "For concrete Storage Pools, the same applies, but the "
          "metadata not included in TotalManagedSpace is consumed in "
          "virtualization like RAID and concatenation. Concrete "
          "Storage Pool may also be simple reserve of capacity. In "
          "such a case, no capacity may be lost in formation of the "
          "Storage Pool. \n"
          "Conceptually TotalManagedSpace is the sum of all storage "
          "known via AssociatedComponentExtent associations to "
          "underlying StorageExtents. However, note some of these "
          "underlying storage may not be modeled by the "
          "instrumentation."), 
       Units ( "Bytes" ), 
       ModelCorrespondence { "CIM_StoragePool.RemainingManagedSpace" }]
   uint64 TotalManagedSpace;

      [Required, Description (
          "The remaining usable capacity after the allocation of "
          "StorageVolumes, LogicalDisks, or child Storage Pools. This "
          "property is maintained here to provide efficient access to "
          "this information. However, note that it is possible to "
          "compute RemainingManagedSpace as (TotalManagedSpace minus "
          "the sum of SpaceConsumed from all of the "
          "AllocatedFromStoragePool references from this StoragePool). "
          "Note that SpaceConsumed remains useful to determine the "
          "amount of capacity consumed by a particular allocated "
          "element."), 
       Units ( "Bytes" ), 
       ModelCorrespondence { "CIM_StoragePool.TotalManagedSpace",
          "CIM_AllocatedFromStoragePool.SpaceConsumed" }]
   uint64 RemainingManagedSpace;

      [Description (
          "For pools that support discrete sizes for volume or pool "
          "creation, this method can be used to retrieve a list of "
          "supported sizes. Note that different pool implementations "
          "may support either or both the GetSupportedSizes and "
          "GetSupportedSizeRanges methods at different times, "
          "depending on Pool configuration. Also note that the "
          "advertised sizes may change after the call due to requests "
          "from other clients. If the pool currently only supports a "
          "range of sizes, then the return value will be set to 1."), 
       ValueMap { "0", "1", "2" }, 
       Values { "Method completed OK", "Method not supported",
          "Use GetSupportedSizeRange instead" }]
   uint32 GetSupportedSizes ( 
         [IN, Description (
             "The type of element for which supported sizes are "
             "reported for."), 
          ValueMap { "2", "3", "4" }, 
          Values { "Storage Pool", "Storage Volume", "Logical Disk" }]
      uint16 ElementType, 
         [IN, Description (
             "The StorageSetting for which supported sizes should be "
             "reported for.")]
      CIM_StorageSetting REF Goal, 
         [IN ( false ), OUT, Description (
             "List of supported sizes for a Volume/Pool creation or "
             "modification."), 
          Units ( "Bytes" )]
      uint64 Sizes[] ); 

      [Description (
          "For pools that that support a range of sizes for volume or "
          "pool creation, this method can be used to retrieve the "
          "supported range. Note that different pool implementations "
          "may support either or both the GetSupportedSizes and "
          "GetSupportedSizeRanges methods at different times, "
          "depending on Pool configuration. Also note that the "
          "advertised sizes may change after the call due to requests "
          "from other clients. If the pool currently only supports "
          "discrete sizes, then the return value will be set to 1."), 
       ValueMap { "0", "1", "2" }, 
       Values { "Method completed OK", "Method not supported",
          "Use GetSupportedSizes instead" }]
   uint32 GetSupportedSizeRange ( 
         [IN, Description (
             "The type of element for which supported size ranges are "
             "reported for."), 
          ValueMap { "2", "3", "4" }, 
          Values { "Storage Pool", "Storage Volume", "Logical Disk" }]
      uint16 ElementType, 
         [IN, Description (
             "The StorageSetting for which supported size ranges "
             "should be reported for.")]
      CIM_StorageSetting REF Goal, 
         [IN ( false ), OUT, Description (
             "The minimum size for a volume/pool in bytes."), 
          Units ( "Bytes" )]
      uint64 MinimumVolumeSize, 
         [IN ( false ), OUT, Description (
             "The maximum size for a volume/pool in bytes."), 
          Units ( "Bytes" )]
      uint64 MaximumVolumeSize, 
         [IN ( false ), OUT, Description (
             "A volume/pool size must be a multiple of this value "
             "which is specified in bytes."), 
          Units ( "Bytes" )]
      uint64 VolumeSizeDivisor); 
      [Description (
          "This method can be used to retrieve a list of available "
          "Extents that may be used in the creation or modification of "
          "a StoragePool, StorageVolume, or LogicalDisk. The "
          "GetAvailableExtents method MUST return the Extents from the "
          "set of Component Extents of the Pool on which the method is "
          "being invoked. The returned Extents are available at the "
          "time the method returns. There is no guarantee that the "
          "same Extents will be available later. This method MUST "
          "return the Extents that are not being used as supporting "
          "capacity for any other Pools, Volumes, or LogicalDisks that "
          "have been allocated from this Pool. The Extent returned "
          "MUST be a component Extent of the Pool or subdivisions of a "
          "component Extent, the subdivisions themselves represented "
          "as Extents."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "..",
          "4098..32767", "32768..65535" }, 
       Values { "Completed with No Error", "Not Supported", "Unknown",
          "Timeout", "Failed", "Invalid Parameter", "In Use",
          "DMTF Reserved", "Method Reserved", "Vendor Specific" }]
   uint32 GetAvailableExtents ( 
         [IN, Description (
             "The StorageSetting (Goal) for which supported extents "
             "should be retrieved as available. \n"
             "If a NULL is passed for the Goal, the method will return "
             "all available extents, regardless of the goal. There "
             "exists a possibility of error in creating a Pool, "
             "Volume, or LogicalDisk retrieved in this manner.")]
      CIM_StorageSetting REF Goal, 
         [OUT, Description (
             "List of references to available StorageExtents, or "
             "subclass instances.")]
      CIM_StorageExtent REF AvailableExtents[] ); 
};