Return to CIM_StoragePool.mof CVS log

Up to [Pegasus] / pegasus / Schemas / CIM231 / DMTF / Device

BUG#:9155
TITLE: Upgrade Pegasus to Include the CIM 2.31 Schema in CVS

DESCRIPTION:

// Copyright (c) 2008 DMTF.  All rights reserved.
   [Version ( "2.19.0" ), 
    UMLPackagePath ( "CIM::Device::StorageServices" ), 
    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, Override ( "InstanceID" ), 
       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[]);

};