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