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