1 tony 1.1 // ===================================================================
2 // Title: Device Storage Services 2.8
3 // Filename: Device28_StorageServices.mof
4 // Version: 2.8
5 // Release: Preliminary
6 // Date: 08/18/2003
7 // ===================================================================
8 // Copyright 2002-2003 Distributed Management Task Force, Inc. (DMTF).
9 // All rights reserved.
10 // DMTF is a not-for-profit association of industry members dedicated
11 // to promoting enterprise and systems management and interoperability.
12 // DMTF specifications and documents may be reproduced for uses
13 // consistent with this purpose by members and non-members,
14 // provided that correct attribution is given.
15 // As DMTF specifications may be revised from time to time,
16 // the particular version and release date should always be noted.
17 //
18 // Implementation of certain elements of this standard or proposed
19 // standard may be subject to third party patent rights, including
20 // provisional patent rights (herein "patent rights"). DMTF makes
21 // no representations to users of the standard as to the existence
22 tony 1.1 // of such rights, and is not responsible to recognize, disclose, or
23 // identify any or all such third party patent right, owners or
24 // claimants, nor for any incomplete or inaccurate identification or
25 // disclosure of such rights, owners or claimants. DMTF shall have no
26 // liability to any party, in any manner or circumstance, under any
27 // legal theory whatsoever, for failure to recognize, disclose, or
28 // identify any such third party patent rights, or for such party's
29 // reliance on the standard or incorporation thereof in its product,
30 // protocols or testing procedures. DMTF shall have no liability to
31 // any party implementing such standard, whether such implementation
32 // is foreseeable or not, nor to any patent owner or claimant, and shall
33 // have no liability or responsibility for costs or losses incurred if
34 // a standard is withdrawn or modified after publication, and shall be
35 // indemnified and held harmless by any party implementing the
36 // standard from any and all claims of infringement by a patent owner
37 // for such implementations.
38 //
39 // For information about patents held by third-parties which have
40 // notified the DMTF that, in their opinion, such patent may relate to
41 // or impact implementations of DMTF standards, visit
42 // http://www.dmtf.org/about/policies/disclosures.php.
43 tony 1.1 // ===================================================================
44 // Description: The Device Model extends the management concepts that
45 // are related to LogicalDevices. This file defines
46 // a model for storage services.
47 //
48 // The object classes below are listed in an order that
49 // avoids forward references. Required objects, defined
50 // by other working groups, are omitted.
51 // ==================================================================
52 // Change Log for v2.8 Preliminary
53 // CR997 - clarify StorageEfficiencyHint
54 // CR1028 - Add CreateSetting to StorageCapabilities
55 // CR1033 - Extent copy services.
56 // CR1044 - Add:
57 // StoragePool.TotalManagedSpace
58 // StoragePool.TotalAvailableSpace
59 // StoragePool.Primordial
60 // - Remove TotalAvailableSpace
61 // CR1046 - Add StorageConfigurationCapabilities
62 // CR1141 - Correction of StorageSynchronized.SyncState.
63 //
64 tony 1.1 // Change Log for v2.7.1
65 // - Fix MaxValue declarations in StorageSettingWithHints - the
66 // properties, AccessDirectionHint and AccessBandwidthWeight
67 //
68 // Change Log for v2.7 Final
69 // CR970 - Removal of the Experimental qualifier
70 // - Remove StoragePool.GetSupportedSize and StoragePool.
71 // GetSupportedSizeRange so they can remain experimental in 2.8
72 // CR978 - Clarify the use of settings and capabilities
73 // - Change 'spindle' to 'package'
74 // - Add ElementType in StoragePool methods
75 // - Add ElementName to creation methods
76 // - Fix ValueMap issues
77 // - Generalize the "goal" parameter in CreateOrModifyElement
78 // - Change units from megabytes to bytes.
79 // CR994 - Update description for InstanceID
80 //
81 // Change Log for v2.7
82 // CR775 - Add StorageSetting, StoragePool, StorageCapabilities,
83 // StorageConfigurationService, StorageSettingsWithHints,
84 // HostedStoragePool, and AllocatedStoragePool
85 tony 1.1 // CR759 - Add ConfigurationReportingService
86 // CR777 - Add StorageSynchrononized
87 // Add StorageSetting.DeltaReservation,
88 // StorageCpabilities.DeltaReservationMin,
89 // StorageCpabilities.DeltaReservationMax,
90 // StorageCpabilities.DeltaReservationDefault,
91 // StorageConfigurationService.CreateReplica() and
92 // StorageConfigurationService.ModifySynchronization()
93 // CR895 - Correct the method return Values/ValueMaps for all the
94 // methods in the ConfigurationReportingService.
95 // ==================================================================
96
97 #pragma locale ("en_US")
98
99
100 // ==================================================================
101 // StorageSynchronized
102 // ==================================================================
103 [Association, Version ("2.7.1000"), Description (
104 "Indicates that two Storage objects were replicated at the "
105 "specified point in time. If the CopyType property is set to "
106 tony 1.1 "'Sync' (=3), then synchronization of the Storage objects is "
107 "preserved.") ]
108 class CIM_StorageSynchronized : CIM_Synchronized {
109
110 [Override ("SystemElement"), Description (
111 "SystemElement represents the Storage that is the source of "
112 "the replication.") ]
113 CIM_ManagedElement REF SystemElement;
114
115 [Override ("SyncedElement"), Description (
116 "SyncedElement represents the Storage that is the target of "
117 "the replication.") ]
118 CIM_ManagedElement REF SyncedElement;
119
120 [Description (
121 "CopyType describes the Replication Policy. Values are:\n"
122 "Async: create and maintain an asynchronous copy of the source.\n"
123 "Sync: create and maintain a synchronized copy of the source.\n"
124 "UnSyncAssoc: create an unsynchronized copy and maintain an "
125 "association to the source."),
126 ValueMap {"2", "3", "4", "..", "0x8000.."},
127 tony 1.1 Values {"Async", "Sync", "UnSyncAssoc", "DMTF Reserved",
128 "Vendor Specific"} ]
129 uint16 CopyType;
130
131 [Experimental, Description (
132 "ReplicaType provides information on how the Replica is "
133 "being maintained. Values are:\n"
134 "Full Copy: This indicates that a full copy of the source "
135 "object is (or will be) generated .\n"
136 "Before Delta: This indicates that the source object will be "
137 "maintained as a delta data from the replica.\n"
138 "After Delta: This indicates that the replica will be "
139 "maintained as delta data from the source object.\n"
140 "Log: This indicates that the replica object is being "
141 "maintained as a log of changes to the source.\n"
142 "Not Specified: The method of maintaining the copy is not "
143 "specified."),
144 ValueMap {"0", "2", "3", "4", "5","..", "0x8000.."},
145 Values {"Not Specified", "Full Copy", "Before Delta",
146 "After Delta", "Log","DMTF Reserved", "Vendor Specific"} ]
147 uint16 ReplicaType;
148 tony 1.1
149 [Experimental, Description (
150 "SyncState describes the state of the association with "
151 "respect to Replication activity. Values are:\n"
152 "Initialized: The link to enable replication is established.\n"
153 "PrepareInProgress: Preparation for Replication is in progress.\n"
154 "Prepared: All necessary preparation has completed.\n"
155 "ResyncInProgress: Synchronization or Resynchronization is "
156 "in progress.\n"
157 "This may be the initial 'copy' or subsequent changes being copied.\n"
158 "Synchronized: An Async or Sync replication is currently "
159 "synchronized. When this value is set, SyncMaintained will "
160 "be true.\n"
161 "FractureInProgress: An operation to fracture an Async or "
162 "Sync replication is in progress.\n"
163 "Fractured: An Async or Sync replication is fractured.\n"
164 "QuiesceInProgress: A quiesce operation is in progress.\n"
165 "Quiesced: The replication has been quiesced and is ready "
166 "for a change.\n"
167 "RestoreInProgress: An operation is in progress to copy the "
168 "Synced object to the System object.\n"
169 tony 1.1 "Idle: The 'normal' state for an UnSyncAssoc replica.\n"
170 "Broken: The relationship is non-functional due to errors in "
171 "the source, the target, the path between the two or space "
172 "constraints."),
173 ValueMap {"2", "3", "4", "5", "6", "7", "8", "9", "10", "11",
174 "12", "13", "..", "0x8000.."},
175 Values {"Initialized", "PrepareInProgress", "Prepared",
176 "ResyncInProgress", "Synchronized", "Fracture In Progress",
177 "QuiesceInProgress", "Quiesced", "Restore In Progresss",
178 "Idle", "Broken", "Fractured", "DMTF Reserved",
179 "Vendor Specific"} ]
180 uint16 SyncState;
181 };
182
183
184 // ==================================================================
185 // StorageSetting
186 // ==================================================================
187 [Version ("2.7.0"), Description (
188 "StorageSetting is roughly equivalent to a Service Level "
189 "Agreement (SLA) It defines the characteristics, qualities of "
190 tony 1.1 "service and goals when used in a CreateOrModifyElement "
191 "FromStoragePool or CreateOrModifyStoragePool method in the "
192 "StorageConfigurationService. It specifies a series of "
193 "properties with Maximum and Minimum values that define the "
194 "(inclusive) bounds that the object should maintain. Note that "
195 "the setting is associated to a StorageVolume, using "
196 "ElementSetting.") ]
197 class CIM_StorageSetting : CIM_SettingData {
198
199 [Write, Description (
200 "Indicates the desired value for No Single Point of "
201 "Failure. Possible values are false = single point of "
202 "failure, and true = no single point of failure.") ]
203 boolean NoSinglePointOfFailure;
204
205 [Write, Description (
206 "DataRedundancyMax describes the maximum number of complete "
207 "copies of data to be maintained. Examples would be RAID 5 "
208 "where 1 copy is maintained and RAID 1 where 2 or more "
209 "copies are maintained. Possible values are 1 to n. The "
210 "desired redundancy is specified using DataRedundancyGoal, "
211 tony 1.1 "while the minimum is defined by DataRedundancyMin."),
212 MinValue (1),
213 ModelCorrespondence {"CIM_StorageSetting.DataRedundancyMin",
214 "CIM_StorageSetting.DataRedundancyGoal"} ]
215 uint16 DataRedundancyMax;
216
217 [Write, Description (
218 "DataRedundancyMin describes the minimum number of complete "
219 "copies of data to be maintained. Examples would be RAID 5 "
220 "where 1 copy is maintained and RAID 1 where 2 or more "
221 "copies are maintained. Possible values are 1 to n. The "
222 "desired redundancy is specified using DataRedundancyGoal, "
223 "while the maximum is defined by DataRedundancyMax."),
224 MinValue (1),
225 ModelCorrespondence {"CIM_StorageSetting.DataRedundancyMax",
226 "CIM_StorageSetting.DataRedundancyGoal"} ]
227 uint16 DataRedundancyMin;
228
229 [Write, Description (
230 "DataRedundancyGoal describes the desired number of complete "
231 "copies of data to be maintained. Examples would be RAID 5 "
232 tony 1.1 "where 1 copy is maintained and RAID 1 where 2 or more "
233 "copies are maintained. Possible values are 1 to n. The "
234 "bounds (max and min) for redundancy are defined using the "
235 "properties, DataRedundancyMax and DataRedundancyMin."),
236 MinValue (1),
237 ModelCorrespondence {"CIM_StorageSetting.DataRedundancyMax",
238 "CIM_StorageSetting.DataRedundancyMin"} ]
239 uint16 DataRedundancyGoal;
240
241 [Write, Description (
242 "PackageRedundancyMax describes the maximum number of "
243 "redundant packages to be used. For example, in the storage "
244 "domain, package redundancy describes how many disk spindles "
245 "can fail without data loss including, at most, one spare. "
246 "An example would be RAID5 with a spare disk which would "
247 "have a PackageRedundancy of 2. Possible values are 0 to "
248 "n. The desired redundancy is specified using "
249 "PackageRedundancyGoal, while the minimum is defined by "
250 "PackageRedundancyMin."),
251 ModelCorrespondence {"CIM_StorageSetting.PackageRedundancyMin"
252 "CIM_StorageSetting.PackageRedundancyGoal"} ]
253 tony 1.1 uint16 PackageRedundancyMax;
254
255 [Write, Description (
256 "PackageRedundancyMin describes the minimum number of "
257 "redundant packages to be used. For example, in the storage "
258 "domain, package redundancy describes how many disk spindles "
259 "can fail without data loss including, at most, one spare. "
260 "An example would be RAID5 with a spare disk which would "
261 "have a PackageRedundancy of 2. Possible values are 0 to "
262 "n. The desired redundancy is specified using "
263 "PackageRedundancyGoal, while the maximum is defined by "
264 "PackageRedundancyMax."),
265 ModelCorrespondence {"CIM_StorageSetting.PackageRedundancyMax"
266 "CIM_StorageSetting.PackageRedundancyGoal"} ]
267 uint16 PackageRedundancyMin;
268
269 [Write, Description (
270 "PackageRedundancyGoal describes the desired number of "
271 "redundant packages to be used. For example, in the storage "
272 "domain, package redundancy describes how many disk spindles "
273 "can fail without data loss including, at most, one spare. "
274 tony 1.1 "An example would be RAID5 with a spare disk which would "
275 "have a PackageRedundancy of 2. Possible values are 0 to "
276 "n. The bounds (max and min) for redundancy are defined "
277 "using the properties, PackageRedundancyMax and "
278 "PackageRedundancyMin."),
279 ModelCorrespondence {"CIM_StorageSetting.PackageRedundancyMax"
280 "CIM_StorageSetting.PackageRedundancyMin"} ]
281 uint16 PackageRedundancyGoal;
282
283 [Description (
284 "DeltaReservationMax is a number between 1 (1%) and a 100 "
285 "(100%) which specifies the maximum amount of space that "
286 "should be reserved in a replica for caching changes. For a "
287 "complete copy this would be 100%. The desired reservation "
288 "is specified using DeltaReservationGoal, while the minimum "
289 "is defined by DeltaReservationMin."),
290 Units ("Percentage"), MinValue (1), MaxValue (100),
291 ModelCorrespondence {"CIM_StorageSetting.DeltaReservationMin"
292 "CIM_StorageSetting.DeltaReservationGoal"} ]
293 uint8 DeltaReservationMax;
294
295 tony 1.1 [Description (
296 "DeltaReservationMin is a number between 1 (1%) and a 100 "
297 "(100%) which specifies the minimum amount of space that "
298 "should be reserved in a replica for caching changes. For a "
299 "complete copy this would be 100%. The desired reservation "
300 "is specified using DeltaReservationGoal, while the maximum "
301 "is defined by DeltaReservationMax."),
302 Units ("Percentage"), MinValue (1), MaxValue (100),
303 ModelCorrespondence {"CIM_StorageSetting.DeltaReservationMax"
304 "CIM_StorageSetting.DeltaReservationGoal"} ]
305 uint8 DeltaReservationMin;
306
307 [Description (
308 "DeltaReservationGoal is a number between 1 (1%) and a 100 "
309 "(100%) which specifies the desired amount of space that "
310 "should be reserved in a replica for caching changes. For a "
311 "complete copy this would be 100%. The bounds (max and min) "
312 "for the reservation are defined using the properties, "
313 "DeltaReservationMax and DeltaReservationMin."),
314 Units ("Percentage"), MinValue (1), MaxValue (100),
315 ModelCorrespondence {"CIM_StorageSetting.DeltaReservationMin"
316 tony 1.1 "CIM_StorageSetting.DeltaReservationMax"} ]
317 uint8 DeltaReservationGoal;
318 };
319
320
321 // ==================================================================
322 // StoragePool
323 // ==================================================================
324 [Version ("2.7.1000"), Description (
325 "A pool of Storage that is managed within the scope of a "
326 "particular System. StoragePools may consist of component "
327 "StoragePools or StorageExtents. StorageExtents that belong to "
328 "the StoragePool have a Component relationship to the "
329 "StoragePool. StorageExtents/StoragePools that are elements of "
330 "a pool have their available space aggregated into the pool. "
331 "StoragePools and StorageVolumes may be created from "
332 "StoragePools. This is indicated by the "
333 "AllocatedFromStoragePool association. StoragePool is scoped "
334 "to a system by the HostedStoragePool association.") ]
335 class CIM_StoragePool : CIM_LogicalElement {
336
337 tony 1.1 [Key, Description (
338 "Within the scope of the instantiating Namespace, InstanceID "
339 "opaquely and uniquely identifies an instance of this "
340 "class. In order to ensure uniqueness within the NameSpace, "
341 "the value of InstanceID SHOULD be constructed using the "
342 "following 'preferred' algorithm:\n"
343 " <OrgID>:<LocalID>\n"
344 "Where <OrgID> and <LocalID> are separated by a colon ':', "
345 "and where <OrgID> MUST include a copyrighted, trademarked "
346 "or otherwise unique name that is owned by the business "
347 "entity creating/defining the InstanceID, or is a registered "
348 "ID that is assigned to the business entity by a recognized "
349 "global authority (This is similar to the <Schema "
350 "Name>_<Class Name> structure of Schema class names.) In "
351 "addition, to ensure uniqueness <OrgID> MUST NOT contain a "
352 "colon (':'). When using this algorithm, the first colon to "
353 "appear in InstanceID MUST appear between <OrgID> and <LocalID>.\n"
354 "<LocalID> is chosen by the business entity and SHOULD not "
355 "be re-used to identify different underlying (real-world) "
356 "elements. If the above 'preferred' algorithm is not used, "
357 "the defining entity MUST assure that the resultant "
358 tony 1.1 "InstanceID is not re-used across any InstanceIDs produced "
359 "by this or other providers for this instance's NameSpace.\n"
360 "For DMTF defined instances, the 'preferred' algorithm MUST "
361 "be used with the <OrgID> set to 'CIM'.") ]
362 string InstanceID;
363
364 [Required, Description (
365 "A unique name in the context of the System that identifies "
366 "this pool."),
367 MaxLen (256) ]
368 string PoolID;
369
370 [Experimental, Description (
371 "If true, \"Primordial\" indicates that the containing "
372 "System does not have the ability to create or delete this "
373 "operational element. This is important because "
374 "higher-level StoragePools may be assembled using the "
375 "Component or AllocatedFromStoragePool associations. "
376 "Although the higher-level abstractions can be created and "
377 "deleted, the most basic, (i.e. primordial), hardware-based "
378 "StoragePools cannot. They are physically realized as part "
379 tony 1.1 "of the System, or are actually managed by some other System "
380 "and imported as if they were physically realized.") ]
381 boolean Primordial=false;
382
383 [Experimental, Description (
384 "The total amount of raw storage (in bytes) managed by this "
385 "StoragePool. This includes all of the bytes consumed to "
386 "create the storage surfaced by this StoragePool, including "
387 "all of the overhead bytes that are not reflected in the "
388 "size of the logical storage allocated from this StoragePool.\n"
389 "Conceptually TotalManagedSpace reflects all storage known "
390 "via Component associations to underlying StorageExtents or "
391 "via AllocatedFromStoragePool associations to underlying "
392 "StoragePools. However, note that this underlying storage "
393 "may not be surfaced by the instrumentation."),
394 Units ("Bytes"),
395 ModelCorrespondence {"StoragePool.RemainingManagedSpace"} ]
396 uint64 TotalManagedSpace;
397
398 [Experimental, Description (
399 "The remaining amount of raw storage (in bytes) from the "
400 tony 1.1 "TotalManagedSpace of this StoragePool. This property is "
401 "maintained here to provide efficient access to this "
402 "information. However, note that it is possible to compute "
403 "RemainingManagedSpace as (TotalManagedSpace ? "
404 "SUM(References(AllocatedFromStoragePool, SpaceConsumed)). "
405 "Note that SpaceConsumed remains useful to determine the "
406 "amount of raw storage consumed by a particular allocated "
407 "element."),
408 Units ("Bytes"),
409 ModelCorrespondence {"StoragePool.TotalManagedSpace",
410 "AllocatedFromStoragePool.SpaceConsumed"} ]
411 uint64 RemainingManagedSpace;
412
413 [Description (
414 "For pools that support discrete sizes for volume or pool "
415 "creation, this method can be used to retrieve a list of "
416 "supported sizes. Note that different pool implementations "
417 "may support either or both the GetSupportedSizes and "
418 "GetSupportedSizeRanges methods at different times, "
419 "depending on Pool configuration. Also note that the "
420 "advertised sizes may change after the call due to requests "
421 tony 1.1 "from other clients. If the pool currently only supports a "
422 "range of sizes, then the return value will be set to 1."),
423 ValueMap {"0", "1", "2"},
424 Values {"Method completed OK", "Method not supported",
425 "Use GetSupportedSizeRange instead"} ]
426 uint32 GetSupportedSizes (
427 [IN, Description(
428 "The type of element for which supported sizes are "
429 "reported for."),
430 ValueMap{"2", "3"},
431 Values {"Storage Pool", "Storage Volume"}]
432 uint16 ElementType,
433 [IN, Description (
434 "The StorageSetting for which supported sizes should be "
435 "reported for.")]
436 CIM_StorageSetting REF Goal,
437 [OUT, IN(false), Description (
438 "List of support sizes for a Volume/Pool creation or "
439 "modification."),
440 Units ("Bytes") ]
441 uint64 Sizes[] );
442 tony 1.1
443 [Description (
444 "For pools that that support a range of sizes for volume or "
445 "pool creation, this method can be used to retrieve the "
446 "supported range. Note that different pool implementations "
447 "may support either or both the GetSupportedSizes and "
448 "GetSupportedSizeRanges methods at different times, "
449 "depending on Pool configuration. Also note that the "
450 "advertised sizes may change after the call due to requests "
451 "from other clients. If the pool currently only supports "
452 "discrete sizes, then the return value will be set to 1."),
453 ValueMap {"0", "1", "2"},
454 Values {"Method completed OK", "Method not supported",
455 "Use GetSupportedSizes instead"} ]
456 uint32 GetSupportedSizeRange (
457 [IN, Description(
458 "The type of element for which supported size ranges are "
459 "reported for."),
460 ValueMap{"2", "3"},
461 Values {"Storage Pool", "Storage Volume"}]
462 uint16 ElementType,
463 tony 1.1 [IN, Description (
464 "The StorageSetting for which supported size ranges should "
465 "be reported for.") ]
466 CIM_StorageSetting REF Goal,
467 [OUT, IN(false), Description (
468 "The minimum size for a volume/pool in bytes."),
469 Units ("Bytes") ]
470 uint64 MinimumVolumeSize,
471 [OUT, IN(false), Description (
472 "The maximum size for a volume/pool in bytes."),
473 Units ("Bytes") ]
474 uint64 MaximumVolumeSize,
475 [OUT, IN(false), Description (
476 "A volume/pool size must be a multiple of this value "
477 "which is specified in bytes"),
478 Units ("Bytes") ]
479 uint64 VolumeSizeDivisor);
480 };
481
482
483 // ==================================================================
484 tony 1.1 // StorageCapabilities
485 // ==================================================================
486 [Version ("2.7.1000"), Description (
487 "A subclass of Capabilities that defines the Capabilities of a "
488 "StorageService or StoragePool. For example, an instance of "
489 "StorageCapabilities could be associated with either a "
490 "StorageConfigurationService or StoragePool by using "
491 "ElementCapabilities.") ]
492 class CIM_StorageCapabilities : CIM_Capabilities {
493
494 [Description (
495 "Enumeration indicating the type of element to which this "
496 "StorageCapabilities applies."),
497 ValueMap {"0", "1", "2", "3", "4", "5", "6"},
498 Values {"Unknown", "Reserved", "Any Type", "StorageVolume",
499 "StorageExtent", "StoragePool",
500 "StorageConfigurationService"} ]
501 uint16 ElementType;
502
503 [Description (
504 "Indicates whether or not the associated element supports no "
505 tony 1.1 "single point of failure. Values are: FALSE = does not "
506 "support no single point of failure, and TRUE = supports no "
507 "single point of failure."),
508 ModelCorrespondence {
509 "CIM_StorageCapabilities.NoSinglePointOfFailureDefault"} ]
510 boolean NoSinglePointOfFailure;
511
512 [Description (
513 "Indicates the default value for the NoSinglePointOfFailure "
514 "property."),
515 ModelCorrespondence {
516 "CIM_StorageCapabilities.NoSinglePointOfFailure"} ]
517 boolean NoSinglePointOfFailureDefault;
518
519 [Description (
520 "DataRedundancyMax describes the maximum number of complete "
521 "copies of data that can be maintained. Examples would be "
522 "RAID 5 (where 1 copy is maintained) and RAID 1 (where 2 or "
523 "more copies are maintained). Possible values are 1 to n. "
524 "The default redundancy is specified using "
525 "DataRedundancyDefault, while the minimum is defined by "
526 tony 1.1 "DataRedundancyMin."),
527 MinValue (1),
528 ModelCorrespondence
529 {"CIM_StorageCapabilities.DataRedundancyMin",
530 "CIM_StorageCapabilities.DataRedundancyDefault"} ]
531 uint16 DataRedundancyMax;
532
533 [Description (
534 "DataRedundancyMin describes the minimum number of complete "
535 "copies of data that can be maintained. Examples would be "
536 "RAID 5 where 1 copy is maintained and RAID 1 where 2 or "
537 "more copies are maintained). Possible values are 1 to n. "
538 "The default redundancy is specified using "
539 "DataRedundancyDefault, while the maximum is defined by "
540 "DataRedundancyMax."),
541 MinValue (1),
542 ModelCorrespondence
543 {"CIM_StorageCapabilities.DataRedundancyMax",
544 "CIM_StorageCapabilities.DataRedundancyDefault"} ]
545 uint16 DataRedundancyMin;
546
547 tony 1.1 [Description (
548 "DataRedundancyDefault describes the default number of "
549 "complete copies of data that can be maintained. Examples "
550 "would be RAID 5 where 1 copy is maintained and RAID 1 where "
551 "2 or more copies are maintained. Possible values are 1 to "
552 "n. The bounds for the redundancy (max and min) are defined "
553 "by DataRedundancyMax and DataRedundancyMin."),
554 MinValue (1),
555 ModelCorrespondence
556 {"CIM_StorageCapabilities.DataRedundancyMax",
557 "CIM_StorageCapabilities.DataRedundancyMin"} ]
558 uint16 DataRedundancyDefault;
559
560 [Description (
561 "PackageRedundancyMax describes the maximum number of "
562 "redundant packages that can be used. For example, in the "
563 "storage domain, package redundancy describes how many disk "
564 "spindles can fail without data loss including, at most, one "
565 "spare. An example would be RAID5 with a spare disk which "
566 "would have a PackageRedundancy of 2. Possible values are 0 "
567 "to n. The default redundancy is specified using "
568 tony 1.1 "PackageRedundancyDefault, while the maximum is defined by "
569 "PackageRedundancyMax."),
570 ModelCorrespondence {
571 "CIM_StorageCapabilities.PackageRedundancyMin",
572 "CIM_StorageCapabilities.PackageRedundancyDefault"} ]
573 uint16 PackageRedundancyMax;
574
575 [Description (
576 "PackageRedundancyMin describes the minimum number of "
577 "redundant packages that can be used. For example, in the "
578 "storage domain, package redundancy describes how many disk "
579 "spindles can fail without data loss including, at most, one "
580 "spare. An example would be RAID5 with a spare disk which "
581 "would have a PackageRedundancy of 2. Possible values are 0 "
582 "to n. The default redundancy is specified using "
583 "PackageRedundancyDefault, while the minimum is defined by "
584 "PackageRedundancyMin."),
585 ModelCorrespondence {
586 "CIM_StorageCapabilities.PackageRedundancyMax",
587 "CIM_StorageCapabilities.PackageRedundancyDefault"} ]
588 uint16 PackageRedundancyMin;
589 tony 1.1
590 [Description (
591 "PackageRedundancyDefault describes the default number of "
592 "redundant packages that will be used. For example, in the "
593 "storage domain, package redundancy describes how many disk "
594 "spindles can fail without data loss including, at most, one "
595 "spare. An example would be RAID5 with a spare disk which "
596 "would have a PackageRedundancy of 2. Possible values are 0 "
597 "to n. The bounds for redundancy are specified using the "
598 "properties, PackageRedundancyMax and PackageRedundancyMin."),
599 ModelCorrespondence {
600 "CIM_StorageCapabilities.PackageRedundancyMin",
601 "CIM_StorageCapabilities.PackageRedundancyMax"} ]
602 uint16 PackageRedundancyDefault;
603
604 [Description (
605 "DeltaReservatioMax is a number between 1 (1%) and a 100 "
606 "(100%) that specifies the maximum amount of space reserved "
607 "in a replica for caching changes. For a complete copy this "
608 "would be 100%, but it can be lower in some "
609 "implementations. This parameter sets the upper limit, "
610 tony 1.1 "while DeltaReservationMin sets the lower limit."),
611 Units ("Percentage"), MinValue (0), MaxValue (100),
612 ModelCorrespondence {
613 "CIM_StorageCapabilities.DeltaReservationMin",
614 "CIM_StorageCapabilities.DeltaReservationDefault"} ]
615 uint16 DeltaReservationMax;
616
617 [Description (
618 "DeltaReservationMin is a number between 1 (1%) and a 100 "
619 "(100%) that specifies the minimum amount of space that "
620 "should be reserved in a replica for caching changes. For a "
621 "complete copy this would be 100%, but it can be lower in "
622 "some implementations. This parameter sets the lower limit, "
623 "while DeltaReservationMax sets the upper limit."),
624 Units ("Percentage"), MinValue (0), MaxValue (100),
625 ModelCorrespondence {
626 "CIM_StorageCapabilities.DeltaReservationMax",
627 "CIM_StorageCapabilities.DeltaReservationDefault"} ]
628 uint16 DeltaReservationMin;
629
630 [Description (
631 tony 1.1 "Delta reservation is a number between 1 (1%) and a 100 "
632 "(100%) that specifies how much space should be reserved by "
633 "default in a replica for caching changes. For a complete "
634 "copy this would be 100%, but it can be lower in some "
635 "implementations. This parameter sets the default value, "
636 "while DeletaReservationMax and DeltReservationMin set the "
637 "upper and lower bounds."),
638 Units ("Percentage"), MinValue (0), MaxValue (100),
639 ModelCorrespondence {
640 "CIM_StorageCapabilities.DeltaReservationMax",
641 "CIM_StorageCapabilities.DeltaReservationMin"} ]
642 uint16 DeltaReservationDefault;
643
644 [Experimental, Description (
645 "Method to create and populate a StorageSetting instance "
646 "from a StorageCapability instance. This removes the need "
647 "to populate default settings and other settings in the "
648 "context of each StorageCapabilities (which could be "
649 "numerous). If the underlying instrumentation supports the "
650 "StorageSettingWithHints subclass, then an instance of that "
651 "class will be created instead."),
652 tony 1.1 ValueMap {"0", "1", "2", "3", "4", "5", "..", "32768..65535"},
653 Values {"Success", "Not Supported", "Unspecified Error",
654 "Timeout", "Failed", "Invalid Parameter", "DMTF Reserved",
655 "Vendor Specific"} ]
656 uint32 CreateSetting (
657 [IN, Description(
658 "If 'Default' is passed for the CreateDefault parameter, "
659 "the Max, Goal, and Min setting attributes are set to "
660 "the Default values of the parent StorageCapabilities when "
661 "the instance is created.\n If set to 'Goal' the new "
662 "StorageSetting attributes are set to the related "
663 "attributes of the parent StorageCapabilities, e.g. Min to "
664 "Min, Goal to Default, and Max to Max.\n\n"
665 "This method maybe deprecated in lieu of intrinsics "
666 "once limitations in the CIM Operations are addressed."),
667 ValueMap {"2", "3"},
668 Values {"Default", "Goal"}]
669 uint16 SettingType,
670 [OUT, IN(False), Description(
671 "Reference to the created StorageSetting instance")]
672 CIM_StorageSetting REF NewSetting
673 tony 1.1 );
674 };
675
676 // ==================================================================
677 // StorageConfigurationService
678 // ==================================================================
679 [Version ("2.7.1000"), Description (
680 "This service allows the active management of a Storage "
681 "Server. It allows jobs to be started for the creation, "
682 "modification and deletion of storage objects (StoragePools and "
683 "StorageVolumes).") ]
684 class CIM_StorageConfigurationService : CIM_Service {
685
686 [Description (
687 "Starts a job to create (or modify) a StoragePool. The "
688 "StoragePool will be (or must be) scoped to the same System "
689 "as this Service. One of the parameters for this method is "
690 "Size. As an input parameter, Size specifies the desired "
691 "size of the pool. As an output parameter, it specifies the "
692 "size achieved. Space is taken from either or both of the "
693 "specified input StoragePools and StorageExtents (InPools "
694 tony 1.1 "and InExtents). The capability requirements that the Pool "
695 "must support are defined using the Goal parameter. If the "
696 "requested pool size cannot be created, no action will be "
697 "taken, the Return Value will be 4097/0x1001, and the output "
698 "value of Size will be set to the nearest possible size. If "
699 "0 is returned, then the task completed successfully and the "
700 "use of ConcreteJob was not required. If the task will take "
701 "some time to complete, a ConcreteJob will be created and "
702 "its reference returned in the output parameter Job."),
703 ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", "4096",
704 "4097", "4098..32767", "32768..65535"},
705 Values {"Job Completed with No Error", "Not Supported",
706 "Unknown", "Timeout", "Failed", "Invalid Parameter",
707 "In Use", "DMTF Reserved",
708 "Method Parameters Checked - Job Started",
709 "Size Not Supported", "Method Reserved", "Vendor Specific"} ]
710 uint32 CreateOrModifyStoragePool (
711 [IN, Description (
712 "A end user relevant name for the pool being created. If "
713 "NULL, then a system supplied default name can be used. "
714 "The value will be stored in the 'ElementName' property "
715 tony 1.1 "for the created pool. If not NULL, this parameter "
716 "will supply a new name when modifying an existing pool.") ]
717 string ElementName,
718 [OUT, IN(false), Description(
719 "Reference to the job (may be null if job completed).") ]
720 CIM_ConcreteJob REF Job,
721 [IN, Description (
722 "Reference to an instance of StorageSetting that defines "
723 "the desired capabilities of the StoragePool. If set to a "
724 "null value, the default configuration from the source "
725 "pool will be used. If not NULL, this parameter will supply "
726 "a new Goal setting when modifying an existing pool." ) ]
727 CIM_StorageSetting REF Goal,
728 [IN, OUT, Description(
729 "As an input parameter this specifies the desired pool "
730 "size in bytes. As an output parameter this specifies "
731 "the size achieved."), Units ("Bytes") ]
732 uint64 Size,
733 [IN, Description (
734 "Array of strings containing representations of "
735 "references to CIM_StoragePool instances, that are used "
736 tony 1.1 "to create the Pool or modify the source pools.") ]
737 string InPools[],
738 [IN, Description (
739 "Array of strings containing representations of "
740 "references to CIM_StorageExtent instances, that are used "
741 "to create the Pool or modify the source extents.") ]
742 string InExtents[],
743 [IN, OUT, Description (
744 "As an input parameter: if null, creates a new StoragePool. "
745 "If not null, modifies the referenced Pool. When returned, "
746 "it is a reference to the resulting StoragePool.") ]
747 CIM_StoragePool REF Pool);
748
749 [Description (
750 "Start a job to create (or modify) a specified element (for "
751 "example a StorageVolume or StorageExtent) from a "
752 "StoragePool. One of the parameters for this method is "
753 "Size. As an input parameter, Size specifies the desired "
754 "size of the element. As an output parameter, it specifies "
755 "the size achieved. Space is taken from the input "
756 "StoragePool. The desired settings for the element are "
757 tony 1.1 "specified by the Goal parameter. If the requested size "
758 "cannot be created, no action will be taken, and the Return "
759 "Value will be 4097/0x1001. Also, the output value of Size "
760 "is set to the nearest possible size. If 0 is returned, the "
761 "function completed successfully and no ConcreteJob instance "
762 "was required. If 4096/0x1000 is returned, a ConcreteJob "
763 "will be started to create the element. The Job's reference "
764 "will be returned in the output parameter Job."),
765 ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", "4096",
766 "4097", "4098..32767", "32768..65535"},
767 Values {"Job Completed with No Error", "Not Supported",
768 "Unknown", "Timeout", "Failed", "Invalid Parameter",
769 "In Use", "DMTF Reserved",
770 "Method Parameters Checked - Job Started",
771 "Size Not Supported", "Method Reserved", "Vendor Specific"} ]
772 uint32 CreateOrModifyElementFromStoragePool(
773 [IN, Description (
774 "A end user relevant name for the element being created. If "
775 "NULL, then a system supplied default name can be used. The "
776 "value will be stored in the 'ElementName' property for "
777 "the created element. If not NULL, this parameter will "
778 tony 1.1 "supply a new name when modifying an existing element.") ]
779 string ElementName,
780 [IN, Description (
781 "Enumeration indicating the type of element being created "
782 "or modified. If the input parameter TheElement is "
783 "specified when the operation is a 'modify', this type "
784 "value must match the type of that instance."),
785 ValueMap{"0", "1", "2", "3", "..", "32768..65535"},
786 Values {"Unknown", "Reserved", "StorageVolume",
787 "StorageExtent", "DMTF Reserved", "Vendor Specific"} ]
788 uint16 ElementType,
789 [OUT, IN(false), Description(
790 "Reference to the job (may be null if job completed).") ]
791 CIM_ConcreteJob REF Job,
792 [IN, Description(
793 "The requirements for the element to maintain. If set to "
794 "a null value, the default configuration from the source "
795 "pool will be used. This parameter should be a reference "
796 "to a Setting or Profile appropriate to the element being "
797 "created. If not NULL, this parameter will supply a new "
798 "Goal when modifying an existing element.") ]
799 tony 1.1 CIM_ManagedElement REF Goal,
800 [IN, OUT, Description (
801 "As an input parameter Size specifies the desired size. "
802 "If not NULL, this parameter will supply a new size when "
803 "modifying an existing element. As an output parameter "
804 "Size specifies the size achieved."),
805 Units ("Bytes") ]
806 uint64 Size,
807 [IN, Description(
808 "The Pool from which to create the element. This parameter "
809 "must be set to null if the input parameter TheElement is "
810 "specified (in the case of a 'modify' operation).") ]
811 CIM_StoragePool REF InPool,
812 [IN, OUT, Description (
813 "As an input parameter: if null, creates a new element. If "
814 "not null, then the method modifies the specified element. "
815 "As an output parameter, it is a reference to the "
816 "resulting element.") ]
817 CIM_LogicalElement REF TheElement);
818
819 [Description (
820 tony 1.1 "Start a job to delete a StoragePool. The freed space is "
821 "returned source StoragePools (indicated by AllocatedFrom "
822 "StoragePool) or back to underlying storage extents. If 0 "
823 "is returned, the function completed successfully, and no "
824 "ConcreteJob was required. If 4096/0x1000 is returned, a "
825 "ConcreteJob will be started to delete the StoragePool. A "
826 "reference to the Job is returned in the Job parameter."),
827 ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", "4096",
828 "4097..32767", "32768..65535"},
829 Values {"Job Completed with No Error", "Not Supported",
830 "Unknown", "Timeout", "Failed", "Invalid Parameter",
831 "In Use", "DMTF Reserved",
832 "Method Parameters Checked - Job Started",
833 "Method Reserved", "Vendor Specific"} ]
834 uint32 DeleteStoragePool (
835 [OUT, IN(false), Description(
836 "Reference to the job (may be null if job completed).") ]
837 CIM_ConcreteJob REF Job,
838 [IN, Description(
839 "Reference to the pool to delete.") ]
840 CIM_StoragePool REF Pool);
841 tony 1.1
842 [Description (
843 "Start a job to delete an element previously created from a "
844 "StoragePool. The freed space is returned to the source "
845 "StoragePool. If 0 is returned, the function completed "
846 "successfully and no ConcreteJob was required. If "
847 "4096/0x1000 is returned, a ConcreteJob will be started to "
848 "delete the element. A reference to the Job is returned in "
849 "the Job parameter."),
850 ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", "4096",
851 "4097..32767", "32768..65535"},
852 Values {"Job Completed with No Error", "Not Supported",
853 "Unknown", "Timeout", "Failed", "Invalid Parameter",
854 "In Use", "DMTF Reserved",
855 "Method Parameters Checked - Job Started",
856 "Method Reserved", "Vendor Specific"} ]
857 uint32 ReturnToStoragePool(
858 [OUT, IN(false), Description(
859 "Reference to the job (may be null if job completed).") ]
860 CIM_ConcreteJob REF Job,
861 [IN, Description(
862 tony 1.1 "Reference to the element to return to the StoragePool.") ]
863 CIM_LogicalElement REF TheElement);
864
865 [Description (
866 "Start a job to create a new storage object which is a "
867 "replica of the specified source storage object. "
868 "(SourceElement). Note that using the input paramter, "
869 "CopyType, this function can be used to instantiate the "
870 "replica, and to create an ongoing association between the "
871 "source and replica. If 0 is returned, the function "
872 "completed successfully and no ConcreteJob instance is "
873 "created. If 4096/0x1000 is returned, a ConcreteJob is "
874 "started, a reference to which is returned in the Job output "
875 "parameter."),
876 ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", "4096",
877 "4097..32767", "32768..65535"},
878 Values {"Job Completed with No Error", "Not Supported",
879 "Unknown", "Timeout", "Failed", "Invalid Parameter",
880 "In Use", "DMTF Reserved",
881 "Method Parameters Checked - Job Started",
882 "Method Reserved", "Vendor Specific"} ]
883 tony 1.1 uint32 CreateReplica(
884 [IN, Description (
885 "A end user relevant name for the element being created. "
886 "If NULL, then a system supplied default name can be used. "
887 "The value will be stored in the 'ElementName' property "
888 "for the created element.") ]
889 string ElementName,
890 [OUT, IN(false), Description(
891 "Reference to the job (may be null if job completed).") ]
892 CIM_ConcreteJob REF Job,
893 [IN, Required, Description(
894 "The source storage object which may be a StorageVolume or "
895 "storage object.") ]
896 CIM_LogicalElement REF SourceElement,
897 [OUT, IN(false), Description(
898 "Reference to the created target storage element "
899 "(i.e., the replica).") ]
900 CIM_LogicalElement REF TargetElement,
901 [IN, Description(
902 "The definition for the StorageSetting to be maintained "
903 "by the target storage object (the replica).") ]
904 tony 1.1 CIM_StorageSetting REF TargetSettingGoal,
905 [IN, Description(
906 "The underlying storage for the target element (the "
907 "replica) will be drawn from TargetPool if specified, "
908 "otherwise the allocation is implementation specific.") ]
909 CIM_StoragePool REF TargetPool,
910 [IN, Description(
911 "CopyType describes the type of copy that will be made. "
912 "Values are: \n "
913 " Async: Create and maintain an asynchronous "
914 "copy of the source. \n "
915 " Sync: Create and maintain a synchronized copy "
916 "of the source. \n"
917 " UnSyncAssoc: Create an unsynchronized copy and "
918 "maintain an association to the source. \n "
919 " UnSyncUnAssoc: Create unassociated copy of the "
920 "source element."),
921 ValueMap {"2", "3", "4", "5", "..", "32768..65535"},
922 Values {"Async", "Sync", "UnSyncAssoc", "UnSyncUnAssoc",
923 "DMTF Reserved", "Vendor Specific"} ]
924 uint16 CopyType);
925 tony 1.1
926 [Description (
927 "Modify (or start a job to modify) the synchronization "
928 "association between two storage objects. If 0 is returned, "
929 "the function completed successfully and no ConcreteJob "
930 "instance was created. If 0x1000 is returned, a ConcreteJob "
931 "was started and a reference to this Job is returned in the "
932 "Job output parameter. A return value of 1 indicates the "
933 "method is not supported. All other values indicate some "
934 "type of error condition."),
935 ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", "0x1000",
936 "0x1001..0x7FFF", "0x8000..0xFFFF"},
937 Values {"Job Completed with No Error", "Not Supported",
938 "Unspecified Error", "Timeout", "Failed",
939 "Invalid Parameter", "In Use", "DMTF Reserved",
940 "Method Parameters Checked - Job Started",
941 "Method Reserved", "Vendor Specific"} ]
942 uint32 ModifySynchronization(
943 [IN, Description(
944 "Operation describes the type of modification to be made "
945 "to the replica. Values are: \n "
946 tony 1.1 " Detach: 'Forget' the synchronization between two "
947 "storage objects. Start to treat the objects as "
948 "independent. \n "
949 " Fracture: Suspend the synchronization between two "
950 "storage objects. The association and (typically) changes "
951 "are remembered to allow a fast resynchronization. This "
952 "may be used during a backup cycle to allow one of the "
953 "objects to be copied while the other remains in "
954 "production. \n"
955 " Resync Replica: Re-establish the synchronization of "
956 "a replica. This will negate the action of a previous "
957 "Fracture operation. \n"
958 " Restore from Replica: Renew the contents of the "
959 "original storage object from a replica. \n"
960 " Prepare: Get the link ready for a Resync operation to "
961 "take place. Some implementations will require this "
962 "operation to be invoked to keep the Resync operation "
963 "as fast as possible.\n"
964 " Unprepare: Clear a prepared state if a Prepare is "
965 "not to be followed by a Resync operation. \n"
966 " Quiesce: Some applications require notification so "
967 tony 1.1 "that they can ready the link for an operation. For "
968 "example flush any cached data or buffered changes.\n"
969 " Unquiesce: Take the link from the quiesced state "
970 "(without executing the intended operation.\n"
971 " Reset To Sync: Change the CopyType of the association "
972 "to Sync (e.g., from the Async CopyType). \n"
973 " Reset To Async: Change the CopyType of the association "
974 "to Async (e.g., from the Sync CopyType)."),
975 ValueMap {"0","1","2", "3", "4", "5", "6", "7", "8", "9",
976 "10", "11", "..", "0x8000..0xFFFF"},
977 Values {"DMTF Reserved", "DMTF Reserved", "Detach",
978 "Fracture", "Resync Replica", "Restore from Replica",
979 "Prepare", "Unprepare", "Quiesce", "Unquiesce",
980 "Reset To Sync", "Reset To Async", "DMTF Reserved",
981 "Vendor Specific"} ]
982 uint16 Operation,
983 [OUT, IN(false), Description(
984 "Reference to the job (may be null if the task completed).") ]
985 CIM_ConcreteJob REF Job,
986 [IN, Description(
987 "The referenced to the StorageSynchronized association "
988 tony 1.1 "describing the storage source/replica relationship.") ]
989 CIM_StorageSynchronized REF Synchronization);
990
991 [Experimental, Description (
992 "Create (or start a job to create) a StorageSynchronized "
993 "relationship between two existing storage objects. Note "
994 "that using the input parameter, CopyType, this function can "
995 "be used to to create an ongoing association between the "
996 "source and replica. If 0 is returned, the function "
997 "completed successfully and no ConcreteJob instance is "
998 "created. If 0x1000 is returned, a ConcreteJob is started, "
999 "a reference to which is returned in the Job output "
1000 "parameter. A return value of 1 indicates the method is not "
1001 "supported. All other values indicate some type of error "
1002 "condition."),
1003 ValueMap {"0", "1", "2", "3", "4", "5", "6", "..", "0x1000",
1004 "0x1001..0x7FFF", "0x8000..0xFFFF"},
1005 Values {"Job Completed with No Error", "Not Supported",
1006 "Unspecified Error", "Timeout", "Failed",
1007 "Invalid Parameter", "In Use", "DMTF Reserved",
1008 "Method Parameters Checked - Job Started",
1009 tony 1.1 "Method Reserved", "Vendor Specific"} ]
1010 uint32 AttachReplica(
1011 [OUT, IN(false), Description(
1012 "Reference to the job (may be null if the task "
1013 "completed).") ]
1014 CIM_ConcreteJob REF Job,
1015 [IN, Required, Description(
1016 "The source storage object which may be a StorageVolume or "
1017 "other storage object") ]
1018 CIM_ManagedElement REF SourceElement,
1019 [IN, Description(
1020 "Reference to the target storage element "
1021 "(i.e., the replica).") ]
1022 CIM_ManagedElement REF TargetElement,
1023 [IN, Description(
1024 "CopyType describes the type of Synchronized relationship "
1025 "that will be created. "
1026 "Values are: \n "
1027 " Async: Create and maintain an asynchronous "
1028 "copy of the source. \n "
1029 " Sync: Create and maintain a synchronized copy "
1030 tony 1.1 "of the source. \n"
1031 " UnSyncAssoc: Create an unsynchronized copy and "
1032 "maintain an association to the source. \n "
1033 " UnSyncUnAssoc: Create unassociated copy of the "
1034 "source element."),
1035 ValueMap {"2", "3", "4", "5", "..", "0x8000..0xFFFF"},
1036 Values {"Async", "Sync", "UnSyncAssoc", "UnSyncUnAssoc",
1037 "DMTF Reserved", "Vendor Specific"} ]
1038 uint16 CopyType);
1039 };
1040
1041 // ==================================================================
1042 // StorageConfigurationCapabilities
1043 // ==================================================================
1044 [Experimental, Version ("2.7.1000"), Description (
1045 "A subclass of Capabilities that defines the Capabilities of a "
1046 "StorageConfigurationService. An instance of "
1047 "StorageConfigurationCapabilities is associated with a "
1048 "StorageConfigurationService using ElementCapabilities.") ]
1049 class CIM_StorageConfigurationCapabilities : CIM_Capabilities {
1050
1051 tony 1.1 [Description (
1052 "Enumeration indicating what operations will be executed as "
1053 "asynchronous jobs. If an operation is included in both "
1054 "this and SupportedSynchronousActions then the underlying "
1055 "implementation is indicating that it may or may not create "
1056 "a job."),
1057 ValueMap {"2", "3", "4", "5", "6", "7", "8", "9", "10"},
1058 Values {"Storage Pool Creation", "Storage Pool Deletion",
1059 "Storage Pool Modification", "Storage Element Creation",
1060 "Storage Element Return", "Storage Element Modification",
1061 "Replica Creation", "Replica Modification",
1062 "Replica Attachment"},
1063 ModelCorrespondence {
1064 "CIM_StorageConfigurationCapabilities.SupportedSynchronousActions"} ]
1065 uint16 SupportedAsynchronousActions[];
1066
1067 [Description (
1068 "Enumeration indicating what operations will be executed "
1069 "without the creation of a job. If an operation is included "
1070 "in both this and SupportedAsynchronousActions then the "
1071 "underlying instrumentation is indicating that it may or may "
1072 tony 1.1 "not create a job."),
1073 ValueMap {"2", "3", "4", "5", "6", "7", "8", "9", "10"},
1074 Values {"Storage Pool Creation", "Storage Pool Deletion",
1075 "Storage Pool Modification", "Storage Element Creation",
1076 "Storage Element Return", "Storage Element Modification",
1077 "Replica Creation", "Replica Modification",
1078 "Replica Attachment"},
1079 ModelCorrespondence { "CIM_StorageConfigurationCapabilities."
1080 "SupportedAsynchronousActions"} ]
1081 uint16 SupportedSynchronousActions[];
1082
1083 [Description (
1084 "Enumeration indicating the type of storage elements that "
1085 "are supported by the associated "
1086 "StorageConfigurationService."),
1087 ValueMap {"2", "3", "..", "0x8000..0xFFFF"},
1088 Values {"StorageVolume", "StorageExtent", "DMTF Reserved",
1089 "Vendor Specific"},
1090 ModelCorrespondence { "CIM_StorageConfigurationService."
1091 "CreateOrModifyElementFromStoragePool.ElementType"} ]
1092 uint16 SupportedStorageElementTypes[];
1093 tony 1.1
1094 [Description (
1095 "Enumeration indicating features supported by the "
1096 "StoragePool methods."),
1097 ValueMap {"2", "3", "4", "..", "0x8000..0xFFFF"},
1098 Values {"InExtents", "Single InPool", "Multiple InPools",
1099 "DMTF Reserved", "Vendor Specific"},
1100 ModelCorrespondence { "CIM_StorageConfigurationService."
1101 "CreateOrModifyStoragePool.InPools",
1102 "CIM_StorageConfigurationService."
1103 "CreateOrModifyStoragePool.InElements" } ]
1104 uint16 SupportedStoragePoolFeatures[];
1105
1106 [Description (
1107 "Enumeration indicating features supported by the Storage "
1108 "Element methods."),
1109 ValueMap {"2", "3", "4", "5", "6", "7", "..", "0x8000..0xFFFF"},
1110 Values {"StorageExtent Creation", "StorageVolume Creation",
1111 "StorageExtent Modification", "StorageVolume Modification",
1112 "Single InPool", "Multiple InPools", "DMTF Reserved",
1113 "Vendor Specific"},
1114 tony 1.1 ModelCorrespondence { "CIM_StorageConfigurationService."
1115 "CreateOrModifyElementFromStoragePool.ElementType",
1116 "CIM_StorageConfigurationService."
1117 "CreateOrModifyElementFromStoragePool.InPools"} ]
1118 uint16 SupportedStorageElementFeatures[];
1119
1120 [Description (
1121 "SupportedCopyTypes describes the replication capabilities "
1122 "supported by the associated StorageConfigurationServices. "
1123 "Values are:\n"
1124 "Async: asynchronous copies may be created and maintained.\n"
1125 "Sync: synchronous copies may be created and maintained.\n"
1126 "UnSyncAssoc: unsynchronized copies may be created and maintained.\n"
1127 "UnSyncUnAssoc: a 'straight copy' may be created."),
1128 ValueMap {"2", "3", "4", "5", "..", "0x8000..0xFFFF"},
1129 Values {"Async", "Sync", "UnSyncAssoc", "UnSyncUnAssoc",
1130 "DMTF Reserved", "Vendor Specific"},
1131 ModelCorrespondence {
1132 "CIM_StorageConfigurationService.CreateReplica.CopyType"} ]
1133 uint16 SupportedCopyTypes[];
1134
1135 tony 1.1 [Description (
1136 "InitialReplicationState specifies which initial "
1137 "ReplicationState is supported by a particular provider. "
1138 "Values are:\n"
1139 "Initialized: The replication relationship is known and "
1140 "unsynchronized, but time required to synchronize may be long.\n"
1141 "Prepared: The replication relationship is known and "
1142 "unsynchronized and the time required to synchronize will be short.\n"
1143 "Synchronized: The replicas are synchronized."),
1144 ValueMap {"2", "3", "4", "..", "0x8000..0xFFFF"},
1145 Values {"Initialized", "Prepared", "Synchronized",
1146 "DMTF Reserved", "Vendor Specific"},
1147 ModelCorrespondence {
1148 "CIM_StorageConfigurationService.AttachReplica",
1149 "CIM_StorageConfigurationService.CreateReplica"} ]
1150 uint16 InitialReplicationState;
1151 };
1152
1153 // ====================================================================
1154 // StorageSettingWithHints
1155 // ====================================================================
1156 tony 1.1 [Version ("2.7.1"), Description (
1157 "This subclass of StorageSetting allows a client to specify "
1158 "'hint's for optimization of the volume performance. The "
1159 "effect of these hints is implementation dependent.") ]
1160 class CIM_StorageSettingWithHints: CIM_StorageSetting {
1161
1162 [Description (
1163 "This hint is an indication from a client of the importance "
1164 "placed on data availability. Values are 0=Don't Care to "
1165 "10=Very Important."),
1166 MinValue (0), MaxValue (10) ]
1167 uint16 DataAvailabilityHint;
1168
1169 [Description (
1170 "This hint is an indication from a client of the randomness "
1171 "of accesses. Values are 0=Entirely Sequential to "
1172 "10=Entirely Random."),
1173 MinValue (0), MaxValue (10) ]
1174 uint16 AccessRandomnessHint;
1175
1176 [Description (
1177 tony 1.1 "This hint is an indication from a client of the direction "
1178 "of accesses. Values are 0=Entirely Read to 10=Entirely "
1179 "Write."),
1180 MinValue (0), MaxValue (10) ]
1181 uint16 AccessDirectionHint;
1182
1183 [Description (
1184 "This hint is an indication from a client of the optimal "
1185 "access sizes (in bytes). Since this property is an array, "
1186 "several sizes can be specified."),
1187 Units ("Bytes") ]
1188 uint16 AccessSizeHint[];
1189
1190 [Description (
1191 "This hint is an indication from a client how important "
1192 "access latency is. Values are 0=Don't Care to 10=Very "
1193 "Important."),
1194 MinValue (0), MaxValue (10) ]
1195 uint16 AccessLatencyHint;
1196
1197 [Description (
1198 tony 1.1 "This hint is an indication from a client of bandwidth "
1199 "prioritization. Values are 0=Don't Care to 10=Very "
1200 "Important."),
1201 MinValue (0), MaxValue (10) ]
1202 uint16 AccessBandwidthWeight;
1203
1204 [Description (
1205 "This hint is an indication of the importance the client "
1206 "places on the cost of storage. Values are 0=Don't Care to "
1207 "10=Very Important. A StorageVolume provider might choose "
1208 "to place data on low cost or high cost drives based on this "
1209 "parameter."),
1210 MinValue (0), MaxValue (10) ]
1211 uint16 StorageCostHint;
1212
1213 [Description (
1214 "This hint is an indication of the importance placed on "
1215 "storage space efficiency by the client. Values are 0=Don't "
1216 "Care to 10=Very Important. A StorageVolume provider might "
1217 "choose different RAID levels based on this hint."),
1218 MinValue (0), MaxValue (10) ]
1219 tony 1.1 uint16 StorageEfficiencyHint;
1220 };
1221
1222
1223 // ===================================================================
1224 // AllocatedFromStoragePool
1225 // ===================================================================
1226 [Association, Version ("2.7.0"), Description (
1227 "AllocatedFromStoragePool is an association describing how "
1228 "LogicalElements are allocated from underlying StoragePools. "
1229 "These elements typically would be subclasses of StorageExtents "
1230 "or StoragePools.") ]
1231 class CIM_AllocatedFromStoragePool : CIM_Dependency {
1232
1233 [Override ("Antecedent"), Description (
1234 "The StoragePool.") ]
1235 CIM_StoragePool REF Antecedent;
1236
1237 [Override ("Dependent"), Description (
1238 "The subsidiary element.") ]
1239 CIM_LogicalElement REF Dependent;
1240 tony 1.1
1241 [Description (
1242 "Space consumed from this Pool, in bytes."),
1243 Units ("Bytes") ]
1244 uint64 SpaceConsumed;
1245 };
1246
1247
1248 // ==================================================================
1249 // HostedStoragePool
1250 // ==================================================================
1251 [Association, Aggregation, Composition, Version ("2.7.0"),
1252 Description (
1253 "SystemStoragePool is a specialization of SystemComponent "
1254 "association that establishes that the StoragePool is defined "
1255 "in the context of the System.") ]
1256 class CIM_HostedStoragePool : CIM_SystemComponent {
1257
1258 [Aggregate, Override ("GroupComponent"), Min (1), Max (1),
1259 Description (
1260 "The parent system in the Association.") ]
1261 tony 1.1 CIM_System REF GroupComponent;
1262
1263 [Override ("PartComponent"), Description (
1264 "The StoragePool that is a component of a System.") ]
1265 CIM_StoragePool REF PartComponent;
1266 };
1267
1268
1269 // ===================================================================
1270 // ConfigurationReportingService
1271 // ===================================================================
1272 [Description (
1273 "Service to provide reports on current configuration and "
1274 "potential for growth. The service may be used in several circumstances:\n"
1275 "- To report growth potential (how many can I have)\n"
1276 "- To report information on objects not directly modeled for "
1277 "performance or other reasons.\n"
1278 "It can also report counts of 'things' or counts of 'units'. "
1279 "For example, the number of disk drives could be reported or "
1280 "the capacity that they would provide.") ]
1281 class CIM_ConfigurationReportingService : CIM_Service {
1282 tony 1.1
1283 [Description (
1284 "Returns a list of classes that the given Managed Element "
1285 "supports or has installed."),
1286 ValueMap {"0", "1", "2", "3", "4", "..", "32768..65535"},
1287 Values {"Success", "Not Supported", "Unknown", "Timeout",
1288 "Failed", "DMTF Reserved", "Vendor Specific"} ]
1289 uint32 GetClassTypes(
1290 [IN, ValueMap {"2", "3"},
1291 Values {"Supports", "Installed"},
1292 Description (
1293 "The type of inquiry to be performed.") ]
1294 uint16 InquiryType,
1295 [IN, Description(
1296 "False : Only report on elements directly contained "
1297 "in/attached to the given ManagedElement. \n"
1298 "True : Report on all objects contained in/attached "
1299 "to the given ManagedElement.") ]
1300 boolean Recursive,
1301 [IN, Description(
1302 "The target of query, for example a rack or a chassis.") ]
1303 tony 1.1 CIM_ManagedElement REF Target,
1304 [OUT, IN (false), Description(
1305 "Array containing the class names (typically the leaf "
1306 "classes) that the given ManagedElement can support or "
1307 "has installed.") ]
1308 string ClassTypes[]);
1309
1310 [Description (
1311 "Returns a list of UnitTypes that are installed for a given "
1312 "ClassType on a given ManagedElement."),
1313 ValueMap {"0", "1", "2", "3", "4", "..", "32768..65535"},
1314 Values {"Success", "Not Supported", "Unknown", "Timeout",
1315 "Failed", "DMTF Reserved", "Vendor Specific"} ]
1316 uint32 GetUnitTypes(
1317 [IN, ValueMap {"2", "3"},
1318 Values {"Supported", "Installed"},
1319 Description ("The type of inquiry to be performed.") ]
1320 uint16 InquiryType,
1321 [IN, Description(
1322 "False : Only report on elements directly contained "
1323 "in/attached to the given ManagedElement. \n"
1324 tony 1.1 "True : Report on all objects contained in/attached "
1325 "to the given ManagedElement.") ]
1326 boolean Recursive,
1327 [IN, Description(
1328 "The target of query, for example a rack or a chassis.") ]
1329 CIM_ManagedElement REF Target,
1330 [IN, Description(
1331 "The ClassType for the query. This should be a entry "
1332 "returned in the GetClassTypes.ClassTypes property.") ]
1333 string ClassType,
1334 [OUT, IN (false), Description(
1335 "A list of supported UnitTypes."),
1336 ValueMap{"2", "3", "4", "5", "6", "7", "8", "9",
1337 "10", "..", "32768..65535"},
1338 Values {"None", "Front Side", "Back Side", "Contained",
1339 "Connected", "I/O", "Memory", "StorageMediaLocation",
1340 "Megabytes", "DMTF Reserved", "Vendor Specific"},
1341 ModelCorrespondence {
1342 "CIM_ConfigurationReportingService."
1343 "ReportCapacity(UnitType)"} ]
1344 uint16 UnitTypes[]);
1345 tony 1.1
1346 [Description (
1347 "Returns the maximum number supported or the number of "
1348 "currently installed units for the given UnitType, for a "
1349 "given ClassType on a given ManagedElement."),
1350 ValueMap {"0", "1", "2", "3", "4", "..", "32768..65535"},
1351 Values {"Success", "Not Supported", "Unknown", "Timeout",
1352 "Failed", "DMTF Reserved", "Vendor Specific"} ]
1353 uint32 ReportCapacity(
1354 [IN, ValueMap {"2", "3"},
1355 Values {"Supported", "Installed"},
1356 Description ("The type of inquiry to be performed.") ]
1357 uint16 InquiryType,
1358 [IN, Description(
1359 "False : Only report on elements directly contained "
1360 "in/attached to the given ManagedElement. \n"
1361 "True : Report on all objects contained in/attached "
1362 "to the given ManagedElement.") ]
1363 boolean Recursive,
1364 [IN, Description(
1365 "The target of query, for example a rack or a chassis.") ]
1366 tony 1.1 CIM_ManagedElement REF Target,
1367 [IN, Description(
1368 "The ClassType for the query. This should be a entry "
1369 "returned in the GetClassTypes.ClassTypes property.") ]
1370 string ClassType,
1371 [IN, Description(
1372 "The UnitType for the query."),
1373 ValueMap{"2", "3", "4", "5", "6", "7", "8", "9",
1374 "10", "..", "32768..65535"},
1375 Values {"None", "Front Side", "Back Side", "Contained",
1376 "Connected", "I/O", "Memory", "StorageMediaLocation",
1377 "Megabytes", "DMTF Reserved", "Vendor Specific"},
1378 ModelCorrespondence {
1379 "CIM_ConfigurationReportingService."
1380 "GetUnitTypes(UnitTypes)"} ]
1381 uint16 UnitType,
1382 [OUT, IN (false), Description (
1383 "The maximum number of supported or the number of "
1384 "currently installed units.") ]
1385 uint64 NumberOfUnits);
1386 };
1387 tony 1.1
1388
1389 // ===================================================================
1390 // end of file
1391 // ===================================================================
|
Return to
Device28_StorageServices.mof
CVS log
Up to [Pegasus] / pegasus / Schemas / CIMPrelim28