1 karl 1.1 // ===================================================================
2 // Title: Device Storage Services
3 // $State: Preliminary $
4 // $Date: 2004/07/21 17:37:54 $
5 // $Source: /home/dmtf2/dotorg/var/cvs/repositories/dev/Schema/MOF/Device_StorageServices.mof,v $
6 // $Revision: 1.14 $
7 // ===================================================================
8 //#pragma inLine ("Includes/copyright.inc")
9 // Copyright 1998-2004 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 karl 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 karl 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.9 Preliminary Company Review
55 // CR1449 - Missing other element types from GetSupported* methods
56 // on StoragePool
57 // CR1427 - Add a method to scan for SCSI configuration changes.
58 //
59 // Change Log for v2.9 Preliminary
60 // CR1293 - Add GetAvailableExtents to StoragePool
61 // CR1331 - Add CreateOrModifyElementFromElements to Storage
62 // Configuration Service.
63 // CR1376 - Add "InExtents" to Values of
64 karl 1.1 // StorageConfigurationCapabilities.
65 // SupportedStorageElementFeatures for support of
66 // CreateOrModifyStoragePool method.
67 // CR1328 - StorageCapabilities and StorageSettings: Settings
68 // not associated
69 // CR1329 - Incorporate additional properties in StorageConfiguration
70 // (and Settings) to better describe RAID levels.
71 //
72 // Change Log for v2.8 Final
73 // CR1279 - Add LogicalDisk to supported element types in
74 // StorageServices
75 //
76 // Change Log for v2.8 Final
77 // CR1171 - Add WRITE qualifiers to StorageSetting.x
78 // CR1151 - Clarify description of
79 // AllocatedFromStoragePool.SpaceConsummed
80 // CR1227 - Missing commas in ModelCorrespondences in StorageSetting
81 // CR1202 - Remove Experimental to Final for Device
82 // CR1223 - Omnibus SysDev Cr - minor MOF corrections
83 //
84 // Change Log for v2.8 Preliminary
85 karl 1.1 // CR997 - clarify StorageEfficiencyHint
86 // CR1028 - Add CreateSetting to StorageCapabilities
87 // CR1033 - Extent copy services.
88 // CR1044 - Add:
89 // StoragePool.TotalManagedSpace
90 // StoragePool.TotalAvailableSpace
91 // StoragePool.Primordial
92 // - Remove TotalAvailableSpace
93 // CR1046 - Add StorageConfigurationCapabilities
94 // CR1141 - Correction of StorageSynchronized.SyncState.
95 //
96 // Change Log for v2.7.1
97 // - Fix MaxValue declarations in StorageSettingWithHints - the
98 // properties, AccessDirectionHint and AccessBandwidthWeight
99 //
100 // Change Log for v2.7 Final
101 // CR970 - Removal of the Experimental qualifier
102 // - Remove StoragePool.GetSupportedSize and StoragePool.
103 // GetSupportedSizeRange so they can remain experimental in 2.8
104 // CR978 - Clarify the use of settings and capabilities
105 // - Change 'spindle' to 'package'
106 karl 1.1 // - Add ElementType in StoragePool methods
107 // - Add ElementName to creation methods
108 // - Fix ValueMap issues
109 // - Generalize the "goal" parameter in CreateOrModifyElement
110 // - Change units from megabytes to bytes.
111 // CR994 - Update description for InstanceID
112 //
113 // Change Log for v2.7
114 // CR775 - Add StorageSetting, StoragePool, StorageCapabilities,
115 // StorageConfigurationService, StorageSettingsWithHints,
116 // HostedStoragePool, and AllocatedStoragePool
117 // CR759 - Add ConfigurationReportingService
118 // CR777 - Add StorageSynchrononized
119 // Add StorageSetting.DeltaReservation,
120 // StorageCpabilities.DeltaReservationMin,
121 // StorageCpabilities.DeltaReservationMax,
122 // StorageCpabilities.DeltaReservationDefault,
123 // StorageConfigurationService.CreateReplica() and
124 // StorageConfigurationService.ModifySynchronization()
125 // CR895 - Correct the method return Values/ValueMaps for all the
126 // methods in the ConfigurationReportingService.
127 karl 1.1 // ==================================================================
128
129 #pragma locale ("en_US")
130
131
132 // ==================================================================
133 // StorageSynchronized
134 // ==================================================================
135 [Association, Version ( "2.8.0" ), Description (
136 "Indicates that two Storage objects were replicated at the "
137 "specified point in time. If the CopyType property is set to "
138 "'Sync' (=3), then synchronization of the Storage objects is "
139 "preserved.")]
140 class CIM_StorageSynchronized : CIM_Synchronized {
141
142 [Override ( "SystemElement" ), Description (
143 "SystemElement represents the Storage that is the source of "
144 "the replication.")]
145 CIM_ManagedElement REF SystemElement;
146
147 [Override ( "SyncedElement" ), Description (
148 karl 1.1 "SyncedElement represents the Storage that is the target of "
149 "the replication.")]
150 CIM_ManagedElement REF SyncedElement;
151
152 [Description (
153 "CopyType describes the Replication Policy. Values are: \n"
154 "Async: create and maintain an asynchronous copy of the "
155 "source. \n"
156 "Sync: create and maintain a synchronized copy of the "
157 "source. \n"
158 "UnSyncAssoc: create an unsynchronized copy and maintain an "
159 "association to the source."),
160 ValueMap { "2", "3", "4", "..", "0x8000.." },
161 Values { "Async", "Sync", "UnSyncAssoc", "DMTF Reserved",
162 "Vendor Specific" }]
163 uint16 CopyType;
164
165 [Description (
166 "ReplicaType provides information on how the Replica is "
167 "being maintained. Values are: \n"
168 "Full Copy: This indicates that a full copy of the source "
169 karl 1.1 "object is (or will be) generated . \n"
170 "Before Delta: This indicates that the source object will be "
171 "maintained as a delta data from the replica. \n"
172 "After Delta: This indicates that the replica will be "
173 "maintained as delta data from the source object. \n"
174 "Log: This indicates that the replica object is being "
175 "maintained as a log of changes to the source. \n"
176 "Not Specified: The method of maintaining the copy is not "
177 "specified."),
178 ValueMap { "0", "2", "3", "4", "5","..", "0x8000.." },
179 Values { "Not Specified", "Full Copy", "Before Delta",
180 "After Delta", "Log","DMTF Reserved", "Vendor Specific" }]
181 uint16 ReplicaType;
182
183 [Description (
184 "SyncState describes the state of the association with "
185 "respect to Replication activity. Values are: \n"
186 "Initialized: The link to enable replication is established. "
187 "\nPrepareInProgress: Preparation for Replication is in "
188 "progress. \n"
189 "Prepared: All necessary preparation has completed. \n"
190 karl 1.1 "ResyncInProgress: Synchronization or Resynchronization is "
191 "in progress. \n"
192 "This may be the initial 'copy' or subsequent changes being "
193 "copied. \n"
194 "Synchronized: An Async or Sync replication is currently "
195 "synchronized. When this value is set, SyncMaintained will "
196 "be true. \n"
197 "FractureInProgress: An operation to fracture an Async or "
198 "Sync replication is in progress. \n"
199 "Fractured: An Async or Sync replication is fractured. \n"
200 "QuiesceInProgress: A quiesce operation is in progress. \n"
201 "Quiesced: The replication has been quiesced and is ready "
202 "for a change. \n"
203 "RestoreInProgress: An operation is in progress to copy the "
204 "Synced object to the System object. \n"
205 "Idle: The 'normal' state for an UnSyncAssoc replica. \n"
206 "Broken: The relationship is non-functional due to errors in "
207 "the source, the target, the path between the two or space "
208 "constraints."),
209 ValueMap { "2", "3", "4", "5", "6", "7", "8", "9", "10", "11",
210 "12", "13", "..", "0x8000.." },
211 karl 1.1 Values { "Initialized", "PrepareInProgress", "Prepared",
212 "ResyncInProgress", "Synchronized", "Fracture In Progress",
213 "QuiesceInProgress", "Quiesced", "Restore In Progresss",
214 "Idle", "Broken", "Fractured", "DMTF Reserved",
215 "Vendor Specific" }]
216 uint16 SyncState;
217 };
218
219
220 // ==================================================================
221 // StorageSetting
222 // ==================================================================
223 [Version ( "2.8.1000" ), Description (
224 "StorageSetting is roughly equivalent to a Service Level "
225 "Agreement (SLA) It defines the characteristics, qualities of "
226 "service and goals when used in a CreateOrModifyElement "
227 "FromStoragePool or CreateOrModifyStoragePool method in the "
228 "StorageConfigurationService. It specifies a series of "
229 "properties with Maximum and Minimum values that define the "
230 "(inclusive) bounds that the object should maintain. Note that "
231 "the setting is associated to a StorageVolume or LogicalDisk, "
232 karl 1.1 "using ElementSetting. \n"
233 "The use of these properties differs depending on whether the "
234 "StorageSetting instance is being used as a goal for a "
235 "configuration operation or being used as a Service Level "
236 "Agreement for a created Volume. In addition the properties "
237 "fall into two categories: The QOS "
238 "properties(PackageRedundancy, Data Redundancy, & "
239 "NoSinglePointOfFailure) and the Detailed RAID "
240 "properties(ExtentStripeLength, ParityLayout, and "
241 "UserDataStripeDepth). In a Setting used as a goal, the QOS "
242 "properties are required as a set; The Detailed RAID "
243 "properties(if supported as indicated by the scoping "
244 "StorageCapabilities instance) may be used optionally in any "
245 "combination. The implementation MUST supply it's own best "
246 "practice in the case where one or more supported RAID "
247 "properties are not supplied. In this situation the use of "
248 "StorageSettingWithHints can be useful to provide direction to "
249 "the implementation. \n"
250 "In a Setting used as a service agreement for a Volume, the QOS "
251 "properties reflect the Service Level Agreement, with goal, "
252 "min, & max. The actual current service level is exposed by "
253 karl 1.1 "corresponding values in StorageExtent. \n"
254 "The Detailed RAID properties, by contrast, reflect specific "
255 "values that reflect the RAID construction of the Volume. Only "
256 "the primary values are meaningful; Min and Max are set to "
257 "match. \n"
258 "Certain StorageSetting instances may be classed as \"Fixed\", "
259 "by using the \"ChangeableType\" property, indicating the "
260 "setting is preset. Such settings are used when the possible "
261 "setting variations are low enough to be instantiated in their "
262 "entirety. The StorageCapabilities \"CreateSetting\" method MAY "
263 "NOT be used to return settings that are not changeable. \n"
264 "Other StorageSetting instances are created using the "
265 "\"CreateSetting\" method. If the capabilities specifies "
266 "ranges, then the setting can be used by a client to narrow the "
267 "range to particular values within the range. In other words, "
268 "the capabilities MAY be broad, but the related setting MUST be "
269 "as capable or less capable, that is more narrowly defined, "
270 "before it is used to create or modify resources. \n"
271 "These created StorageSetting instances MUST have their "
272 "\"ChangeableType\" property = 1, \"Changeable - Transient\". \n"
273 "GeneratedSettings MAY not remain after the restart or reset of "
274 karl 1.1 "the implementation. They may be deleted by implementation at "
275 "any time. A reasonable minimal time to retain the generated "
276 "transient settings is five minutes, although there is no "
277 "minimal retention time.")]
278 class CIM_StorageSetting : CIM_SettingData {
279
280 [Write, Description (
281 "Indicates the desired value for No Single Point of Failure. "
282 "Possible values are false = single point of failure, and "
283 "true = no single point of failure.")]
284 boolean NoSinglePointOfFailure;
285
286 [Write, Description (
287 "DataRedundancyMax describes the maximum number of complete "
288 "copies of data to be maintained. Examples would be RAID 5 "
289 "where 1 copy is maintained and RAID 1 where 2 or more "
290 "copies are maintained. Possible values are 1 to n. The "
291 "desired redundancy is specified using DataRedundancyGoal, "
292 "while the minimum is defined by DataRedundancyMin."),
293 MinValue ( 1 ),
294 ModelCorrespondence { "CIM_StorageSetting.DataRedundancyMin",
295 karl 1.1 "CIM_StorageSetting.DataRedundancyGoal" }]
296 uint16 DataRedundancyMax;
297
298 [Write, Description (
299 "DataRedundancyMin describes the minimum number of complete "
300 "copies of data to be maintained. Examples would be RAID 5 "
301 "where 1 copy is maintained and RAID 1 where 2 or more "
302 "copies are maintained. Possible values are 1 to n. The "
303 "desired redundancy is specified using DataRedundancyGoal, "
304 "while the maximum is defined by DataRedundancyMax."),
305 MinValue ( 1 ),
306 ModelCorrespondence { "CIM_StorageSetting.DataRedundancyMax",
307 "CIM_StorageSetting.DataRedundancyGoal" }]
308 uint16 DataRedundancyMin;
309
310 [Write, Description (
311 "DataRedundancyGoal describes the desired number of complete "
312 "copies of data to be maintained. Examples would be RAID 5 "
313 "where 1 copy is maintained and RAID 1 where 2 or more "
314 "copies are maintained. Possible values are 1 to n. The "
315 "bounds (max and min) for redundancy are defined using the "
316 karl 1.1 "properties, DataRedundancyMax and DataRedundancyMin."),
317 MinValue ( 1 ),
318 ModelCorrespondence { "CIM_StorageSetting.DataRedundancyMax",
319 "CIM_StorageSetting.DataRedundancyMin" }]
320 uint16 DataRedundancyGoal;
321
322 [Write, Description (
323 "PackageRedundancyMax describes the maximum number of "
324 "redundant packages to be used. For example, in the storage "
325 "domain, package redundancy describes how many disk spindles "
326 "can fail without data loss including, at most, one spare. "
327 "An example would be RAID5 with a spare disk which would "
328 "have a PackageRedundancy of 2. Possible values are 0 to n. "
329 "The desired redundancy is specified using "
330 "PackageRedundancyGoal, while the minimum is defined by "
331 "PackageRedundancyMin."),
332 ModelCorrespondence { "CIM_StorageSetting.PackageRedundancyMin",
333 "CIM_StorageSetting.PackageRedundancyGoal" }]
334 uint16 PackageRedundancyMax;
335
336 [Write, Description (
337 karl 1.1 "PackageRedundancyMin describes the minimum number of "
338 "redundant packages to be used. For example, in the storage "
339 "domain, package redundancy describes how many disk spindles "
340 "can fail without data loss including, at most, one spare. "
341 "An example would be RAID5 with a spare disk which would "
342 "have a PackageRedundancy of 2. Possible values are 0 to n. "
343 "The desired redundancy is specified using "
344 "PackageRedundancyGoal, while the maximum is defined by "
345 "PackageRedundancyMax."),
346 ModelCorrespondence { "CIM_StorageSetting.PackageRedundancyMax",
347 "CIM_StorageSetting.PackageRedundancyGoal" }]
348 uint16 PackageRedundancyMin;
349
350 [Write, Description (
351 "PackageRedundancyGoal describes the desired number of "
352 "redundant packages to be used. For example, in the storage "
353 "domain, package redundancy describes how many disk spindles "
354 "can fail without data loss including, at most, one spare. "
355 "An example would be RAID5 with a spare disk which would "
356 "have a PackageRedundancy of 2. Possible values are 0 to n. "
357 "The bounds (max and min) for redundancy are defined using "
358 karl 1.1 "the properties, PackageRedundancyMax and "
359 "PackageRedundancyMin."),
360 ModelCorrespondence { "CIM_StorageSetting.PackageRedundancyMax",
361 "CIM_StorageSetting.PackageRedundancyMin" }]
362 uint16 PackageRedundancyGoal;
363
364 [Write, Description (
365 "DeltaReservationMax is a number between 1 (1%) and a 100 "
366 "(100%) which specifies the maximum amount of space that "
367 "should be reserved in a replica for caching changes. For a "
368 "complete copy this would be 100%. The desired reservation "
369 "is specified using DeltaReservationGoal, while the minimum "
370 "is defined by DeltaReservationMin."),
371 Units ( "Percentage" ), MinValue ( 1 ), MaxValue ( 100 ),
372 ModelCorrespondence { "CIM_StorageSetting.DeltaReservationMin",
373 "CIM_StorageSetting.DeltaReservationGoal" }]
374 uint8 DeltaReservationMax;
375
376 [Write, Description (
377 "DeltaReservationMin is a number between 1 (1%) and a 100 "
378 "(100%) which specifies the minimum amount of space that "
379 karl 1.1 "should be reserved in a replica for caching changes. For a "
380 "complete copy this would be 100%. The desired reservation "
381 "is specified using DeltaReservationGoal, while the maximum "
382 "is defined by DeltaReservationMax."),
383 Units ( "Percentage" ), MinValue ( 1 ), MaxValue ( 100 ),
384 ModelCorrespondence { "CIM_StorageSetting.DeltaReservationMax",
385 "CIM_StorageSetting.DeltaReservationGoal" }]
386 uint8 DeltaReservationMin;
387
388 [Write, Description (
389 "DeltaReservationGoal is a number between 1 (1%) and a 100 "
390 "(100%) which specifies the desired amount of space that "
391 "should be reserved in a replica for caching changes. For a "
392 "complete copy this would be 100%. The bounds (max and min) "
393 "for the reservation are defined using the properties, "
394 "DeltaReservationMax and DeltaReservationMin."),
395 Units ( "Percentage" ), MinValue ( 1 ), MaxValue ( 100 ),
396 ModelCorrespondence { "CIM_StorageSetting.DeltaReservationMin",
397 "CIM_StorageSetting.DeltaReservationMax" }]
398 uint8 DeltaReservationGoal;
399
400 karl 1.1 [Experimental, Description (
401 "Enumeration indicating the type of setting. \"Fixed - Not "
402 "Changeable\" settings are primordial. These setting are "
403 "defined at the implementor of the class. \"Changeable - "
404 "Transient\" is the type of setting produced by the "
405 "\"CreateSetting\" method. A client can subsequently request "
406 "that the implementation persist the generated and "
407 "potentially modified setting indefinately. Only a "
408 "\"Changeable - Transient\" setting SHALL be converted to a "
409 "\"Changeable = Persistent\" setting; the setting SHALL NOT "
410 "be changed back."),
411 ValueMap { "0", "1", "2" },
412 Values { "Fixed - Not Changeable", "Changeable - Transient",
413 "Changeable - Persistent" }]
414 uint16 ChangeableType;
415
416 [Experimental, Write, Description (
417 "ExtentStripeLength describes the number of underlying "
418 "StorageExtents across which data is striped in the common "
419 "striping-based storage organizations. This is also known as "
420 "the number of 'members' or 'columns'. When used in a goal "
421 karl 1.1 "setting instance, ExtentStripeLength is the optimal desired "
422 "value. The bounds (max and min) for Stripe Length are "
423 "defined using the properties ExtentStripeLengthMax and "
424 "ExtentStripeLengthMin. ExtentStripeLength MUST be set to "
425 "NULL if the scoping StorageCapablities indicates that it is "
426 "not supported in this context. ExtentStripeLength can be "
427 "used in conjunction with CreateOrModifyElementFromELements "
428 "to explicitly configure storage. An example would be RAID "
429 "0+1 with mirroring two stripe sets, each set being three "
430 "wide. In this case CreateOrModifyElementFromElements would "
431 "be passed a goal setting with DataRedundancy = 2 and "
432 "ExtentStripeLength = 3. The size of the InElements array "
433 "would be 6 and would contain the StorageExtents to be used "
434 "to construct the StorageElement as a RAID 0+1. "
435 "ExtentStripeLengthMin and ExtentStripeLengthMax are "
436 "meaningless and wouldbe set to NULL. If the property is "
437 "supported, and is part of StorageSettingWithHints it MAY be "
438 "set to NULL. If used it will constrain the effects of Hint "
439 "selections. When used in a Setting instance associated to a "
440 "Volume, this property indicates the specific value that the "
441 "Volume was created with, and ExtentStripeLengthMin and "
442 karl 1.1 "ExtentStripeLengthMax will be set to the same specific "
443 "value."),
444 MinValue ( 1 ),
445 ModelCorrespondence {
446 "CIM_StorageSetting.ExtentStripeLengthMax",
447 "CIM_StorageSetting.ExtentStripeLengthMin" }]
448 uint16 ExtentStripeLength;
449
450 [Experimental, Write, Description (
451 "ExtentStripeLength describes the number of underlying "
452 "StorageExtents across which data is striped in the common "
453 "striping-based storage organizations. This is also known as "
454 "the number of 'members' or 'columns'. When used in a goal "
455 "setting instance, ExtentStripeLengthMin is the minimum "
456 "acceptable value. The desired Stripe Length is specified "
457 "using ExtentStripeLength, while the maximum is defined by "
458 "ExtentStripeLengthMax. ExtentStripeLengthMin MUST be set to "
459 "NULL if the scoping StorageCapablities indicates that it is "
460 "not supported in this context. If the property is "
461 "supported, and is part of StorageSettingWithHints it MAY be "
462 "set to NULL. If used it will constrain the effects of Hint "
463 karl 1.1 "selections. When used in a Setting instance associated to a "
464 "Volume, this property is set to the specific value of "
465 "ExtentStripeLength."),
466 MinValue ( 1 ),
467 ModelCorrespondence {
468 "CIM_StorageSetting.ExtentStripeLengthMax",
469 "CIM_StorageSetting.ExtentStripeLength" }]
470 uint16 ExtentStripeLengthMin;
471
472 [Experimental, Write, Description (
473 "ExtentStripeLength describes the number of underlying "
474 "StorageExtents across which data is striped in the common "
475 "striping-based storage organizations. This is also known as "
476 "the number of 'members' or 'columns'. When used in a goal "
477 "setting instance, ExtentStripeLengthMax is the maximum "
478 "acceptable value. The desired Stripe Length is specified "
479 "using ExtentStripeLength, while the minimum is defined by "
480 "ExtentStripeLengthMin. ExtentStripeLengthMax MUST be set to "
481 "NULL if the scoping StorageCapablities indicates that it is "
482 "not supported in this context. If the property is "
483 "supported, and is part of StorageSettingWithHints it MAY be "
484 karl 1.1 "set to NULL. If used it will constrain the effects of Hint "
485 "selections. When used in a Setting instance associated to a "
486 "Volume, this property is set to the specific value of "
487 "ExtentStripeLength."),
488 MinValue ( 1 ),
489 ModelCorrespondence {
490 "CIM_StorageSetting.ExtentStripeLengthMin",
491 "CIM_StorageSetting.ExtentStripeLength" }]
492 uint16 ExtentStripeLengthMax;
493
494 [Experimental, Write, Description (
495 "ParityLayout specifies whether a parity-based storage "
496 "organization is using rotated or non-rotated parity. When "
497 "used in a goal setting instance, ParityLayout is the "
498 "desired value. It MUST be set to NULL if the scoping "
499 "StorageCapablities indicates that it is not supported in "
500 "this context. If the property is supported, and is part of "
501 "StorageSettingWithHints it MAY be set to NULL. If used it "
502 "will constrain the effects of Hint selections. When used in "
503 "a Setting instance associated to a Volume, this property "
504 "indicates the specific value that the Volume was created "
505 karl 1.1 "with."),
506 ValueMap { "1", "2" },
507 Values { "Non-rotated Parity", "Rotated Parity" }]
508 uint16 ParityLayout;
509
510 [Experimental, Write, Description (
511 "UserDataStripeDepth describes the number of bytes forming a "
512 "strip in common striping-based storage organizations. The "
513 "strip is defined as the size of the portion of a stripe "
514 "that lies on one extent. Thus, ExtentStripeLength * "
515 "UserDataStripeDepth will yield the size of one stripe of "
516 "user data. When used in a goal setting instance, "
517 "UserDataStripeDepth is the optimal desired value. The "
518 "bounds (max and min) for Stripe Depth are defined using the "
519 "properties UserDataStripeDepthMax and "
520 "UserDataStripeDepthMin. UserDataStripeDepth MUST be set to "
521 "NULL if the scoping StorageCapablities indicates that it is "
522 "not supported in this context. If the property is "
523 "supported, and is part of StorageSettingWithHints it MAY be "
524 "set to NULL. If used it will constrain the effects of Hint "
525 "selections. When used in a Setting instance associated to a "
526 karl 1.1 "Volume, this property indicates the specific value that the "
527 "Volume was created with, and UserDataStripeDepthMin and "
528 "UserDataStripeDepthMax will be set to the same specific "
529 "value."),
530 Units ( "Bytes" ), MinValue ( 1 ),
531 ModelCorrespondence {
532 "CIM_StorageSetting.UserDataStripeDepthMax",
533 "CIM_StorageSetting.UserDataStripeDepthMin" }]
534 uint64 UserDataStripeDepth;
535
536 [Experimental, Write, Description (
537 "UserDataStripeDepth describes the number of bytes forming a "
538 "strip in common striping-based storage organizations. The "
539 "strip is defined as the size of the portion of a stripe "
540 "that lies on one extent. Thus, ExtentStripeLength * "
541 "UserDataStripeDepth will yield the size of one stripe of "
542 "user data. When used in a goal setting instance, "
543 "UserDataStripeDepthMin is the minimum acceptable value. The "
544 "desired Stripe Depth is specified using "
545 "UserDataStripeDepth, while the maximum is defined by "
546 "UserDataStripeDepthMax. UserDataStripeDepthMin MUST be set "
547 karl 1.1 "to NULL if the scoping StorageCapablities indicates that it "
548 "is not supported in this context. If the property is "
549 "supported, and is part of StorageSettingWithHints it MAY be "
550 "set to NULL. If used it will constrain the effects of Hint "
551 "selections. When used in a Setting instance associated to a "
552 "Volume, this property is set to the specific value of "
553 "UserDataStripeDepth."),
554 Units ( "Bytes" ), MinValue ( 1 ),
555 ModelCorrespondence {
556 "CIM_StorageSetting.UserDataStripeDepthMax",
557 "CIM_StorageSetting.UserDataStripeDepth" }]
558 uint64 UserDataStripeDepthMin;
559
560 [Experimental, Write, Description (
561 "UserDataStripeDepth describes the number of bytes forming a "
562 "strip in common striping-based storage organizations. The "
563 "strip is defined as the size of the portion of a stripe "
564 "that lies on one extent. Thus, ExtentStripeLength * "
565 "UserDataStripeDepth will yield the size of one stripe of "
566 "user data. When used in a goal setting instance, "
567 "UserDataStripeDepthMax is the maximum acceptable value. The "
568 karl 1.1 "desired Stripe Depth is specified using "
569 "UserDataStripeDepthGoal, while the minimum is defined by "
570 "UserDataStripeDepthMin. UserDataStripeDepthMax MUST be set "
571 "to NULL if the scoping StorageCapablities indicates that it "
572 "is not supported in this context. If the property is "
573 "supported, and is part of StorageSettingwWithHints it MAY "
574 "be set to NULL. If used it will constrain the effects of "
575 "Hint selections. When used in a Setting instance associated "
576 "to a Volume, this property is set to the specific value of "
577 "UserDataStripeDepth."),
578 Units ( "Bytes" ), MinValue ( 1 ),
579 ModelCorrespondence {
580 "CIM_StorageSetting.UserDataStripeDepthMin",
581 "CIM_StorageSetting.UserDataStripeDepth" }]
582 uint64 UserDataStripeDepthMax;
583 };
584
585
586 // ==================================================================
587 // StoragePool
588 // ==================================================================
589 karl 1.1 [Version ( "2.8.1000" ), Description (
590 "A pool of Storage that is managed within the scope of a "
591 "particular System. StoragePools may consist of component "
592 "StoragePools or StorageExtents. StorageExtents that belong to "
593 "the StoragePool have a Component relationship to the "
594 "StoragePool. StorageExtents/StoragePools that are elements of "
595 "a pool have their available space aggregated into the pool. "
596 "StoragePools, StorageVolumes and LogicalDisks may be created "
597 "from StoragePools. This is indicated by the "
598 "AllocatedFromStoragePool association. StoragePool is scoped to "
599 "a system by the HostedStoragePool association.")]
600 class CIM_StoragePool : CIM_LogicalElement {
601
602 [Key, Description (
603 "Within the scope of the instantiating Namespace, InstanceID "
604 "opaquely and uniquely identifies an instance of this class. "
605 "In order to ensure uniqueness within the NameSpace, the "
606 "value of InstanceID SHOULD be constructed using the "
607 "following 'preferred' algorithm: \n"
608 "<OrgID>:<LocalID> \n"
609 "Where <OrgID> and <LocalID> are separated by a colon ':', "
610 karl 1.1 "and where <OrgID> MUST include a copyrighted, trademarked "
611 "or otherwise unique name that is owned by the business "
612 "entity creating/defining the InstanceID, or is a registered "
613 "ID that is assigned to the business entity by a recognized "
614 "global authority (This is similar to the <Schema "
615 "Name>_<Class Name> structure of Schema class names.) In "
616 "addition, to ensure uniqueness <OrgID> MUST NOT contain a "
617 "colon (':'). When using this algorithm, the first colon to "
618 "appear in InstanceID MUST appear between <OrgID> and "
619 "<LocalID>. \n"
620 "<LocalID> is chosen by the business entity and SHOULD not "
621 "be re-used to identify different underlying (real-world) "
622 "elements. If the above 'preferred' algorithm is not used, "
623 "the defining entity MUST assure that the resultant "
624 "InstanceID is not re-used across any InstanceIDs produced "
625 "by this or other providers for this instance's NameSpace. \n"
626 "For DMTF defined instances, the 'preferred' algorithm MUST "
627 "be used with the <OrgID> set to 'CIM'.")]
628 string InstanceID;
629
630 [Required, Description (
631 karl 1.1 "A unique name in the context of the System that identifies "
632 "this pool."),
633 MaxLen ( 256 )]
634 string PoolID;
635
636 [Description (
637 "If true, \"Primordial\" indicates that the containing "
638 "System does not have the ability to create or delete this "
639 "operational element. This is important because higher-level "
640 "StoragePools may be assembled using the Component or "
641 "AllocatedFromStoragePool associations. Although the "
642 "higher-level abstractions can be created and deleted, the "
643 "most basic, (i.e. primordial), hardware-based StoragePools "
644 "cannot. They are physically realized as part of the System, "
645 "or are actually managed by some other System and imported "
646 "as if they were physically realized.")]
647 boolean Primordial=false;
648
649 [Description (
650 "The total amount of raw storage (in bytes) managed by this "
651 "StoragePool. This includes all of the bytes consumed to "
652 karl 1.1 "create the storage surfaced by this StoragePool, including "
653 "all of the overhead bytes that are not reflected in the "
654 "size of the logical storage allocated from this "
655 "StoragePool. \n"
656 "Conceptually TotalManagedSpace reflects all storage known "
657 "via Component associations to underlying StorageExtents or "
658 "via AllocatedFromStoragePool associations to underlying "
659 "StoragePools. However, note that this underlying storage "
660 "may not be surfaced by the instrumentation."),
661 Units ( "Bytes" ),
662 ModelCorrespondence { "CIM_StoragePool.RemainingManagedSpace" }]
663 uint64 TotalManagedSpace;
664
665 [Required, Description (
666 "The remaining amount of raw storage (in bytes) from the "
667 "TotalManagedSpace of this StoragePool. This property is "
668 "maintained here to provide efficient access to this "
669 "information. However, note that it is possible to compute "
670 "RemainingManagedSpace as (TotalManagedSpace minus the sum "
671 "of SpaceConsumed from all of the AllocatedFromStoragePool "
672 "references from this StoragePool). Note that SpaceConsumed "
673 karl 1.1 "remains useful to determine the amount of raw storage "
674 "consumed by a particular allocated element."),
675 Units ( "Bytes" ),
676 ModelCorrespondence { "CIM_StoragePool.TotalManagedSpace",
677 "CIM_AllocatedFromStoragePool.SpaceConsumed" }]
678 uint64 RemainingManagedSpace;
679
680 [Description (
681 "For pools that support discrete sizes for volume or pool "
682 "creation, this method can be used to retrieve a list of "
683 "supported sizes. Note that different pool implementations "
684 "may support either or both the GetSupportedSizes and "
685 "GetSupportedSizeRanges methods at different times, "
686 "depending on Pool configuration. Also note that the "
687 "advertised sizes may change after the call due to requests "
688 "from other clients. If the pool currently only supports a "
689 "range of sizes, then the return value will be set to 1."),
690 ValueMap { "0", "1", "2" },
691 Values { "Method completed OK", "Method not supported",
692 "Use GetSupportedSizeRange instead" }]
693 uint32 GetSupportedSizes (
694 karl 1.1 [IN, Description (
695 "The type of element for which supported sizes are "
696 "reported for."),
697 ValueMap { "2", "3", "4" },
698 Values { "Storage Pool", "Storage Volume", "Logical Disk" }]
699 uint16 ElementType,
700 [IN, Description (
701 "The StorageSetting for which supported sizes should be "
702 "reported for.")]
703 CIM_StorageSetting REF Goal,
704 [IN ( false ), OUT, Description (
705 "List of supported sizes for a Volume/Pool creation or "
706 "modification."),
707 Units ( "Bytes" )]
708 uint64 Sizes[] );
709
710 [Description (
711 "For pools that that support a range of sizes for volume or "
712 "pool creation, this method can be used to retrieve the "
713 "supported range. Note that different pool implementations "
714 "may support either or both the GetSupportedSizes and "
715 karl 1.1 "GetSupportedSizeRanges methods at different times, "
716 "depending on Pool configuration. Also note that the "
717 "advertised sizes may change after the call due to requests "
718 "from other clients. If the pool currently only supports "
719 "discrete sizes, then the return value will be set to 1."),
720 ValueMap { "0", "1", "2" },
721 Values { "Method completed OK", "Method not supported",
722 "Use GetSupportedSizes instead" }]
723 uint32 GetSupportedSizeRange (
724 [IN, Description (
725 "The type of element for which supported size ranges are "
726 "reported for."),
727 ValueMap { "2", "3", "4" },
728 Values { "Storage Pool", "Storage Volume", "Logical Disk" }]
729 uint16 ElementType,
730 [IN, Description (
731 "The StorageSetting for which supported size ranges "
732 "should be reported for.")]
733 CIM_StorageSetting REF Goal,
734 [IN ( false ), OUT, Description (
735 "The minimum size for a volume/pool in bytes."),
736 karl 1.1 Units ( "Bytes" )]
737 uint64 MinimumVolumeSize,
738 [IN ( false ), OUT, Description (
739 "The maximum size for a volume/pool in bytes."),
740 Units ( "Bytes" )]
741 uint64 MaximumVolumeSize,
742 [IN ( false ), OUT, Description (
743 "A volume/pool size must be a multiple of this value "
744 "which is specified in bytes."),
745 Units ( "Bytes" )]
746 uint64 VolumeSizeDivisor);
747
748 [Experimental, Description (
749 "This method can be used to retrieve a list of available "
750 "Extents that may be used in the creation or modification of "
751 "a StoragePool, StorageVolume, or LogicalDisk. The "
752 "GetAvailableExtents method MUST return the Extents from the "
753 "set of Component Extents of the Pool on which the method is "
754 "being invoked. The returned Extents are available at the "
755 "time the method returns. There is no guarantee that the "
756 "same Extents will be available later. This method MUST "
757 karl 1.1 "return the Extents that are not being used as supporting "
758 "capacity for any other Pools, Volumes, or LogicalDisks that "
759 "have been allocated from this Pool. The Extent returned "
760 "MUST be a component Extent of the Pool or subdivisions of a "
761 "component Extent, the subdivisions themselves represented "
762 "as Extents."),
763 ValueMap { "0", "1", "2", "3", "4", "5", "6", "..",
764 "4098..32767", "32768..65535" },
765 Values { "Completed with No Error", "Not Supported", "Unknown",
766 "Timeout", "Failed", "Invalid Parameter", "In Use",
767 "DMTF Reserved", "Method Reserved", "Vendor Specific" }]
768 uint32 GetAvailableExtents (
769 [IN, Description (
770 "The StorageSetting (Goal) for which supported extents "
771 "should be retrieved as available. \n"
772 "If a NULL is passed for the Goal, the method will return "
773 "all available extents, regardless of the goal. There "
774 "exists a possibility of error in creating a Pool, "
775 "Volume, or LogicalDisk retrieved in this manner.")]
776 CIM_StorageSetting REF Goal,
777 [OUT, Description (
778 karl 1.1 "List of references to available StorageExtents, or "
779 "subclass instances.")]
780 CIM_StorageExtent REF AvailableExtents[] );
781 };
782
783
784 // ==================================================================
785 // StorageCapabilities
786 // ==================================================================
787 [Version ( "2.8.1000" ), Description (
788 "A subclass of Capabilities that defines the Capabilities of a "
789 "StorageService or StoragePool. For example, an instance of "
790 "StorageCapabilities could be associated with either a "
791 "StorageConfigurationService or StoragePool by using "
792 "ElementCapabilities.")]
793 class CIM_StorageCapabilities : CIM_Capabilities {
794
795 [Description (
796 "Enumeration indicating the type of element to which this "
797 "StorageCapabilities applies."),
798 ValueMap { "0", "1", "2", "3", "4", "5", "6", "7" },
799 karl 1.1 Values { "Unknown", "Reserved", "Any Type", "StorageVolume",
800 "StorageExtent", "StoragePool",
801 "StorageConfigurationService", "LogicalDisk" }]
802 uint16 ElementType;
803
804 [Description (
805 "Indicates whether or not the associated element supports no "
806 "single point of failure. Values are: FALSE = does not "
807 "support no single point of failure, and TRUE = supports no "
808 "single point of failure."),
809 ModelCorrespondence {
810 "CIM_StorageCapabilities.NoSinglePointOfFailureDefault" }]
811 boolean NoSinglePointOfFailure;
812
813 [Description (
814 "Indicates the default value for the NoSinglePointOfFailure "
815 "property."),
816 ModelCorrespondence {
817 "CIM_StorageCapabilities.NoSinglePointOfFailure" }]
818 boolean NoSinglePointOfFailureDefault;
819
820 karl 1.1 [Description (
821 "DataRedundancyMax describes the maximum number of complete "
822 "copies of data that can be maintained. Examples would be "
823 "RAID 5 (where 1 copy is maintained) and RAID 1 (where 2 or "
824 "more copies are maintained). Possible values are 1 to n. "
825 "The default redundancy is specified using "
826 "DataRedundancyDefault, while the minimum is defined by "
827 "DataRedundancyMin."),
828 MinValue ( 1 ),
829 ModelCorrespondence {
830 "CIM_StorageCapabilities.DataRedundancyMin",
831 "CIM_StorageCapabilities.DataRedundancyDefault" }]
832 uint16 DataRedundancyMax;
833
834 [Description (
835 "DataRedundancyMin describes the minimum number of complete "
836 "copies of data that can be maintained. Examples would be "
837 "RAID 5 where 1 copy is maintained and RAID 1 where 2 or "
838 "more copies are maintained). Possible values are 1 to n. "
839 "The default redundancy is specified using "
840 "DataRedundancyDefault, while the maximum is defined by "
841 karl 1.1 "DataRedundancyMax."),
842 MinValue ( 1 ),
843 ModelCorrespondence {
844 "CIM_StorageCapabilities.DataRedundancyMax",
845 "CIM_StorageCapabilities.DataRedundancyDefault" }]
846 uint16 DataRedundancyMin;
847
848 [Description (
849 "DataRedundancyDefault describes the default number of "
850 "complete copies of data that can be maintained. Examples "
851 "would be RAID 5 where 1 copy is maintained and RAID 1 where "
852 "2 or more copies are maintained. Possible values are 1 to "
853 "n. The bounds for the redundancy (max and min) are defined "
854 "by DataRedundancyMax and DataRedundancyMin."),
855 MinValue ( 1 ),
856 ModelCorrespondence {
857 "CIM_StorageCapabilities.DataRedundancyMax",
858 "CIM_StorageCapabilities.DataRedundancyMin" }]
859 uint16 DataRedundancyDefault;
860
861 [Description (
862 karl 1.1 "PackageRedundancyMax describes the maximum number of "
863 "redundant packages that can be used. For example, in the "
864 "storage domain, package redundancy describes how many disk "
865 "spindles can fail without data loss including, at most, one "
866 "spare. An example would be RAID5 with a spare disk which "
867 "would have a PackageRedundancy of 2. Possible values are 0 "
868 "to n. The default redundancy is specified using "
869 "PackageRedundancyDefault, while the maximum is defined by "
870 "PackageRedundancyMax."),
871 ModelCorrespondence {
872 "CIM_StorageCapabilities.PackageRedundancyMin",
873 "CIM_StorageCapabilities.PackageRedundancyDefault" }]
874 uint16 PackageRedundancyMax;
875
876 [Description (
877 "PackageRedundancyMin describes the minimum number of "
878 "redundant packages that can be used. For example, in the "
879 "storage domain, package redundancy describes how many disk "
880 "spindles can fail without data loss including, at most, one "
881 "spare. An example would be RAID5 with a spare disk which "
882 "would have a PackageRedundancy of 2. Possible values are 0 "
883 karl 1.1 "to n. The default redundancy is specified using "
884 "PackageRedundancyDefault, while the minimum is defined by "
885 "PackageRedundancyMin."),
886 ModelCorrespondence {
887 "CIM_StorageCapabilities.PackageRedundancyMax",
888 "CIM_StorageCapabilities.PackageRedundancyDefault" }]
889 uint16 PackageRedundancyMin;
890
891 [Description (
892 "PackageRedundancyDefault describes the default number of "
893 "redundant packages that will be used. For example, in the "
894 "storage domain, package redundancy describes how many disk "
895 "spindles can fail without data loss including, at most, one "
896 "spare. An example would be RAID5 with a spare disk which "
897 "would have a PackageRedundancy of 2. Possible values are 0 "
898 "to n. The bounds for redundancy are specified using the "
899 "properties, PackageRedundancyMax and PackageRedundancyMin."),
900 ModelCorrespondence {
901 "CIM_StorageCapabilities.PackageRedundancyMin",
902 "CIM_StorageCapabilities.PackageRedundancyMax" }]
903 uint16 PackageRedundancyDefault;
904 karl 1.1
905 [Description (
906 "DeltaReservatioMax is a number between 1 (1%) and a 100 "
907 "(100%) that specifies the maximum amount of space reserved "
908 "in a replica for caching changes. For a complete copy this "
909 "would be 100%, but it can be lower in some implementations. "
910 "This parameter sets the upper limit, while "
911 "DeltaReservationMin sets the lower limit."),
912 Units ( "Percentage" ), MinValue ( 0 ), MaxValue ( 100 ),
913 ModelCorrespondence {
914 "CIM_StorageCapabilities.DeltaReservationMin",
915 "CIM_StorageCapabilities.DeltaReservationDefault" }]
916 uint16 DeltaReservationMax;
917
918 [Description (
919 "DeltaReservationMin is a number between 1 (1%) and a 100 "
920 "(100%) that specifies the minimum amount of space that "
921 "should be reserved in a replica for caching changes. For a "
922 "complete copy this would be 100%, but it can be lower in "
923 "some implementations. This parameter sets the lower limit, "
924 "while DeltaReservationMax sets the upper limit."),
925 karl 1.1 Units ( "Percentage" ), MinValue ( 0 ), MaxValue ( 100 ),
926 ModelCorrespondence {
927 "CIM_StorageCapabilities.DeltaReservationMax",
928 "CIM_StorageCapabilities.DeltaReservationDefault" }]
929 uint16 DeltaReservationMin;
930
931 [Description (
932 "Delta reservation is a number between 1 (1%) and a 100 "
933 "(100%) that specifies how much space should be reserved by "
934 "default in a replica for caching changes. For a complete "
935 "copy this would be 100%, but it can be lower in some "
936 "implementations. This parameter sets the default value, "
937 "while DeletaReservationMax and DeltReservationMin set the "
938 "upper and lower bounds."),
939 Units ( "Percentage" ), MinValue ( 0 ), MaxValue ( 100 ),
940 ModelCorrespondence {
941 "CIM_StorageCapabilities.DeltaReservationMax",
942 "CIM_StorageCapabilities.DeltaReservationMin" }]
943 uint16 DeltaReservationDefault;
944
945 [Description (
946 karl 1.1 "Method to create and populate a StorageSetting instance "
947 "from a StorageCapability instance. This removes the need to "
948 "populate default settings and other settings in the context "
949 "of each StorageCapabilities (which could be numerous). If "
950 "the underlying instrumentation supports the "
951 "StorageSettingWithHints subclass, then an instance of that "
952 "class will be created instead."),
953 ValueMap { "0", "1", "2", "3", "4", "5", "..", "32768..65535" },
954 Values { "Success", "Not Supported", "Unspecified Error",
955 "Timeout", "Failed", "Invalid Parameter", "DMTF Reserved",
956 "Vendor Specific" }]
957 uint32 CreateSetting (
958 [IN, Description (
959 "If 'Default' is passed for the CreateDefault parameter, "
960 "the Max, Goal, and Min setting attributes are set to the "
961 "Default values of the parent StorageCapabilities when "
962 "the instance is created. \n"
963 "If set to 'Goal' the new StorageSetting attributes are "
964 "set to the related attributes of the parent "
965 "StorageCapabilities, e.g. Min to Min, Goal to Default, "
966 "and Max to Max. \n"
967 karl 1.1 "\n"
968 "This method maybe deprecated in lieu of intrinsics once "
969 "limitations in the CIM Operations are addressed."),
970 ValueMap { "2", "3" },
971 Values { "Default", "Goal" }]
972 uint16 SettingType,
973 [IN ( False ), OUT, Description (
974 "Reference to the created StorageSetting instance.")]
975 CIM_StorageSetting REF NewSetting );
976
977 [Experimental, Description (
978 "Extent Stripe Length describes the number of underlying "
979 "StorageExtents across which data is striped in the common "
980 "striping-based storage organizations. This is also known as "
981 "the number of 'members' or 'columns'. \n"
982 "A NULL value for ExtentStripeLengthDefault indicates that "
983 "the system does not support configuration of storage by "
984 "specifying Stripe Length. \n"
985 "If Extent Stripe Length is supported, and this Capabilities "
986 "instance is associated with a pool that was created with a "
987 "range of QOS then ExtentStripeLengthDefault represents the "
988 karl 1.1 "default value. Other available values(such as min, max, and "
989 "discrete values) can be determined by using the "
990 "'GetSupportedStripeLengths' and "
991 "'GetSupportedStripeLengthRange' methods. \n"
992 "If Extent Stripe Length is supported and the pool was "
993 "created with a single specific QOS, representing a Raid "
994 "group, set, or rank, then this property represents the "
995 "current/fixed value for the pool, and Extent Stripe Length "
996 "is not supported in subsequent creation of elements from "
997 "this pool. Consequently, the 'GetSupportedStripeLength' "
998 "methods cannot be used, and in a StorageSetting instance "
999 "used as a goal when creating or modifying a child element "
1000 "of the pool, ExtentStripeLengthGoal, ExtentStripeLengthMin, "
1001 "and ExtentStripeLengthMax MUST be set to NULL."),
1002 MinValue ( 1 )]
1003 uint16 ExtentStripeLengthDefault;
1004
1005 [Experimental, Description (
1006 "ParityLayout specifies whether a parity-based storage "
1007 "organization is using rotated or non-rotated parity. If "
1008 "this capabilities instance is associated with a pool that "
1009 karl 1.1 "was created with a range of QOS then ParityLayoutDefault "
1010 "represents the default value. Other available values can be "
1011 "determined by using the 'GetSupportedParityLayouts' method. "
1012 "If the pool was created with a single specific QOS, "
1013 "representing a Raid group, set, or rank, then this property "
1014 "represents the current/fixed value for the pool, and "
1015 "ParityLayout is not supported in subsequent creation of "
1016 "elements from this pool. Consequently, the "
1017 "'GetSupportedParityLayouts' method cannot be used, and the "
1018 "ParityLayoutGoal property in StorageSetting instances used "
1019 "in child element operations on this pool MUST be set to "
1020 "NULL. A NULL value for ParityLayoutDefault indicates that "
1021 "the system does not support configuration of storage by "
1022 "specifying ParityLayout."),
1023 ValueMap { "2", "3" },
1024 Values { "Non-Rotated Parity", "Rotated Parity" }]
1025 uint16 ParityLayoutDefault;
1026
1027 [Experimental, Description (
1028 "User Data Stripe Depth describes the number of bytes "
1029 "forming a strip in common striping-based storage "
1030 karl 1.1 "organizations. The strip is defined as the size of the "
1031 "portion of a stripe that lies on one extent. Thus, "
1032 "ExtentStripeLength * UserDataStripeDepth will yield the "
1033 "size of one stripe of user data. A NULL value for "
1034 "UserDataStripeDepthDefault indicates that the system does "
1035 "not support configuration of storage by specifying Stripe "
1036 "Depth. \n"
1037 "If User Data Stripe Depth is supported, and this "
1038 "Capabilities instance is associated with a pool that was "
1039 "created with a range of QOS then UserDataStripeDepthDefault "
1040 "represents the default value. Other available values(such "
1041 "as min, max, and discrete values) can be determined by "
1042 "using the 'GetSupportedStripeDepths' and "
1043 "'GetSupportedStripeDepthRange' methods. \n"
1044 "If User Data Stripe Depth is supported and the pool was "
1045 "created with a single specific QOS, representing a Raid "
1046 "group, set, or rank, then this property represents the "
1047 "current/fixed value for the pool, and User Data Stripe "
1048 "Depth is not supported in subsequent creation of elements "
1049 "from this pool. Consequently, the 'GetSupportedStripeDepth' "
1050 "methods cannot be used, and in a StorageSetting instance "
1051 karl 1.1 "used as a goal when creating or modifying a child element "
1052 "of the pool, UserDataStripeDepthGoal, UserStripeDepthMin, "
1053 "and UserDataStripeDepthMax MUST be set to NULL."),
1054 Units ( "Bytes" ), MinValue ( 1 )]
1055 uint64 UserDataStripeDepthDefault;
1056
1057
1058 [Experimental, Description (
1059 "For systems that support discrete ExtentStripeLengths for "
1060 "volume or pool creation, this method can be used to "
1061 "retrieve a list of supported values. Note that different "
1062 "implementations may support either the "
1063 "GetSupportedStripeLengths or the "
1064 "GetSupportedStripeLengthRange method. Also note that the "
1065 "advertised sizes may change after the call due to requests "
1066 "from other clients. If the system only supports a range of "
1067 "sizes, then the return value will be set to 3."),
1068 ValueMap { "0", "1", "2", "3" },
1069 Values { "Method completed OK", "Method not supported",
1070 "Choices not available for this Capability",
1071 "Use GetSupportedStripeLengthRange instead" }]
1072 karl 1.1 uint32 GetSupportedStripeLengths (
1073 [IN ( false ), OUT, Description (
1074 "List of supported ExtentStripeLengths for a Volume/Pool "
1075 "creation or modification."),
1076 ArrayType ( "Indexed" )]
1077 uint16 StripeLengths[] );
1078
1079 [Experimental, Description (
1080 "For systems that support a range of ExtentStripeLengths for "
1081 "volume or pool creation, this method can be used to "
1082 "retrieve the supported range. Note that different "
1083 "implementations may support either the "
1084 "GetSupportedExtentLengths or the "
1085 "GetSupportedExtentLengthRange method. Also note that the "
1086 "advertised sizes may change after the call due to requests "
1087 "from other clients. If the system only supports discrete "
1088 "values, then the return value will be set to 3."),
1089 ValueMap { "0", "1", "2", "3" },
1090 Values { "Method completed OK", "Method not supported",
1091 "Choices not available for this Capability",
1092 "Use GetSupportedStripeLengths instead" }]
1093 karl 1.1 uint32 GetSupportedStripeLengthRange (
1094 [IN ( false ), OUT, Description (
1095 "The minimum ExtentStripeDepth for a volume/pool in "
1096 "bytes.")]
1097 uint16 MinimumStripeLength,
1098 [IN ( false ), OUT, Description (
1099 "The maximum ExtentStripeLength for a volume/pool in "
1100 "bytes.")]
1101 uint16 MaximumStripeLength,
1102 [IN ( false ), OUT, Description (
1103 "A volume/pool ExtentStripeLength must be a multiple of "
1104 "this value which is specified in bytes.")]
1105 uint32 StripeLengthDivisor );
1106
1107 [Description (
1108 "For systems that support Parity-based storage organizations "
1109 "for volume or pool creation, this method can be used to the "
1110 "supported parity layouts."),
1111 ValueMap { "0", "1", "2" },
1112 Values { "Method completed OK", "Method not supported",
1113 "Choice not aavailable for this capability" }]
1114 karl 1.1 uint32 GetSupportedParityLayouts (
1115 [IN ( false ), OUT, Description (
1116 "List of supported Parity for a Volume/Pool creation or "
1117 "modification."),
1118 ValueMap { "2", "3" },
1119 Values { "Non-Rotated Parity", "Rotated Parity" },
1120 ArrayType ( "Indexed" )]
1121 uint16 ParityLayout[] );
1122
1123
1124 [Experimental, Description (
1125 "For systems that support discrete UserDataStripeDepths for "
1126 "volume or pool creation, this method can be used to "
1127 "retrieve a list of supported values. Note that different "
1128 "implementations may support either the "
1129 "GetSupportedStripeDepths or the "
1130 "GetSupportedStripeDepthRange method. If the system only "
1131 "supports a range of sizes, then the return value will be "
1132 "set to 2."),
1133 ValueMap { "0", "1", "2" },
1134 Values { "Method completed OK", "Method not supported",
1135 karl 1.1 "Use GetSupportedStripeDepthRange instead" }]
1136 uint32 GetSupportedStripeDepths (
1137 [IN ( false ), OUT, Description (
1138 "List of supported UserDataStripeDepths for a Volume/Pool "
1139 "creation or modification."),
1140 Units ( "Bytes" ), ArrayType ( "Indexed" )]
1141 uint64 StripeDepths[] );
1142
1143 [Experimental, Description (
1144 "For systems that support a range of UserDataStripeDepths "
1145 "for volume or pool creation, this method can be used to "
1146 "retrieve the supported range. Note that different "
1147 "implementations may support either the "
1148 "GetSupportedStripeDepths or the "
1149 "GetSupportedStripeDepthRange method. If the system only "
1150 "supports discrete values, then the return value will be set "
1151 "to 2."),
1152 ValueMap { "0", "1", "2" },
1153 Values { "Method completed OK", "Method not supported",
1154 "Use GetSupportedStripeDepths instead" }]
1155 uint32 GetSupportedStripeDepthRange (
1156 karl 1.1 [IN ( false ), OUT, Description (
1157 "The minimum UserDataStripeDepth for a volume/pool in "
1158 "bytes."),
1159 Units ( "Bytes" )]
1160 uint64 MinimumStripeDepth,
1161 [IN ( false ), OUT, Description (
1162 "The maximum UserDataStripeDepth for a volume/pool in "
1163 "bytes."),
1164 Units ( "Bytes" )]
1165 uint64 MaximumStripeDepth,
1166 [IN ( false ), OUT, Description (
1167 "A volume/pool UserDataStripeDepth must be a multiple of "
1168 "this value which is specified in bytes."),
1169 Units ( "Bytes" )]
1170 uint64 StripeDepthDivisor );
1171
1172 };
1173
1174 // ==================================================================
1175 // StorageConfigurationService
1176 // ==================================================================
1177 karl 1.1 [Version ( "2.8.1000" ), Description (
1178 "This service allows the active management of a Storage Server. "
1179 "It allows jobs to be started for the creation, modification "
1180 "and deletion of storage objects (StoragePools, StorageVolumes "
1181 "and LogicalDisks).")]
1182 class CIM_StorageConfigurationService : CIM_Service {
1183
1184 [Description (
1185 "Starts a job to create (or modify) a StoragePool. The "
1186 "StoragePool will be (or must be) scoped to the same System "
1187 "as this Service. One of the parameters for this method is "
1188 "Size. As an input parameter, Size specifies the desired "
1189 "size of the pool. As an output parameter, it specifies the "
1190 "size achieved. Space is taken from either or both of the "
1191 "specified input StoragePools and StorageExtents (InPools "
1192 "and InExtents). The capability requirements that the Pool "
1193 "must support are defined using the Goal parameter. If the "
1194 "requested pool size cannot be created, no action will be "
1195 "taken, the Return Value will be 4097/0x1001, and the output "
1196 "value of Size will be set to the nearest possible size. If "
1197 "0 is returned, then the task completed successfully and the "
1198 karl 1.1 "use of ConcreteJob was not required. If the task will take "
1199 "some time to complete, a ConcreteJob will be created and "
1200 "its reference returned in the output parameter Job."),
1201 ValueMap { "0", "1", "2", "3", "4", "5", "6", "..", "4096",
1202 "4097", "4098..32767", "32768..65535" },
1203 Values { "Job Completed with No Error", "Not Supported",
1204 "Unknown", "Timeout", "Failed", "Invalid Parameter",
1205 "In Use", "DMTF Reserved",
1206 "Method Parameters Checked - Job Started",
1207 "Size Not Supported", "Method Reserved", "Vendor Specific" }]
1208 uint32 CreateOrModifyStoragePool (
1209 [IN, Description (
1210 "A end user relevant name for the pool being created. If "
1211 "NULL, then a system supplied default name can be used. "
1212 "The value will be stored in the 'ElementName' property "
1213 "for the created pool. If not NULL, this parameter will "
1214 "supply a new name when modifying an existing pool.")]
1215 string ElementName,
1216 [IN ( false ), OUT, Description (
1217 "Reference to the job (may be null if job completed).")]
1218 CIM_ConcreteJob REF Job,
1219 karl 1.1 [IN, Description (
1220 "Reference to an instance of StorageSetting that defines "
1221 "the desired capabilities of the StoragePool. If set to a "
1222 "null value, the default configuration from the source "
1223 "pool will be used. If not NULL, this parameter will "
1224 "supply a new Goal setting when modifying an existing "
1225 "pool.")]
1226 CIM_StorageSetting REF Goal,
1227 [IN, OUT, Description (
1228 "As an input parameter this specifies the desired pool "
1229 "size in bytes. As an output parameter this specifies the "
1230 "size achieved."),
1231 Units ( "Bytes" )]
1232 uint64 Size,
1233 [IN, Description (
1234 "Array of strings containing representations of "
1235 "references to CIM_StoragePool instances, that are used "
1236 "to create the Pool or modify the source pools.")]
1237 string InPools[],
1238 [IN, Description (
1239 "Array of strings containing representations of "
1240 karl 1.1 "references to CIM_StorageExtent instances, that are used "
1241 "to create the Pool or modify the source extents.")]
1242 string InExtents[],
1243 [IN, OUT, Description (
1244 "As an input parameter: if null, creates a new "
1245 "StoragePool. If not null, modifies the referenced Pool. "
1246 "When returned, it is a reference to the resulting "
1247 "StoragePool.")]
1248 CIM_StoragePool REF Pool);
1249
1250 [Description (
1251 "Start a job to create (or modify) a specified element (for "
1252 "example a StorageVolume or StorageExtent) from a "
1253 "StoragePool. One of the parameters for this method is Size. "
1254 "As an input parameter, Size specifies the desired size of "
1255 "the element. As an output parameter, it specifies the size "
1256 "achieved. Space is taken from the input StoragePool. The "
1257 "desired settings for the element are specified by the Goal "
1258 "parameter. If the requested size cannot be created, no "
1259 "action will be taken, and the Return Value will be "
1260 "4097/0x1001. Also, the output value of Size is set to the "
1261 karl 1.1 "nearest possible size. If 0 is returned, the function "
1262 "completed successfully and no ConcreteJob instance was "
1263 "required. If 4096/0x1000 is returned, a ConcreteJob will be "
1264 "started to create the element. The Job's reference will be "
1265 "returned in the output parameter Job."),
1266 ValueMap { "0", "1", "2", "3", "4", "5", "6", "..", "4096",
1267 "4097", "4098..32767", "32768..65535" },
1268 Values { "Job Completed with No Error", "Not Supported",
1269 "Unknown", "Timeout", "Failed", "Invalid Parameter",
1270 "In Use", "DMTF Reserved",
1271 "Method Parameters Checked - Job Started",
1272 "Size Not Supported", "Method Reserved", "Vendor Specific" }]
1273 uint32 CreateOrModifyElementFromStoragePool(
1274 [IN, Description (
1275 "A end user relevant name for the element being created. "
1276 "If NULL, then a system supplied default name can be "
1277 "used. The value will be stored in the 'ElementName' "
1278 "property for the created element. If not NULL, this "
1279 "parameter will supply a new name when modifying an "
1280 "existing element.")]
1281 string ElementName,
1282 karl 1.1 [IN, Description (
1283 "Enumeration indicating the type of element being created "
1284 "or modified. If the input parameter TheElement is "
1285 "specified when the operation is a 'modify', this type "
1286 "value must match the type of that instance."),
1287 ValueMap { "0", "1", "2", "3", "4", "..", "32768..65535" },
1288 Values { "Unknown", "Reserved", "StorageVolume",
1289 "StorageExtent", "LogicalDisk", "DMTF Reserved",
1290 "Vendor Specific" }]
1291 uint16 ElementType,
1292 [IN ( false ), OUT, Description (
1293 "Reference to the job (may be null if job completed).")]
1294 CIM_ConcreteJob REF Job,
1295 [IN, Description (
1296 "The requirements for the element to maintain. If set to "
1297 "a null value, the default configuration from the source "
1298 "pool will be used. This parameter should be a reference "
1299 "to a Setting or Profile appropriate to the element being "
1300 "created. If not NULL, this parameter will supply a new "
1301 "Goal when modifying an existing element.")]
1302 CIM_ManagedElement REF Goal,
1303 karl 1.1 [IN, OUT, Description (
1304 "As an input parameter Size specifies the desired size. "
1305 "If not NULL, this parameter will supply a new size when "
1306 "modifying an existing element. As an output parameter "
1307 "Size specifies the size achieved."),
1308 Units ( "Bytes" )]
1309 uint64 Size,
1310 [IN, Description (
1311 "The Pool from which to create the element. This "
1312 "parameter must be set to null if the input parameter "
1313 "TheElement is specified (in the case of a 'modify' "
1314 "operation).")]
1315 CIM_StoragePool REF InPool,
1316 [IN, OUT, Description (
1317 "As an input parameter: if null, creates a new element. "
1318 "If not null, then the method modifies the specified "
1319 "element. As an output parameter, it is a reference to "
1320 "the resulting element.")]
1321 CIM_LogicalElement REF TheElement);
1322
1323 [Description (
1324 karl 1.1 "Start a job to delete a StoragePool. The freed space is "
1325 "returned source StoragePools (indicated by AllocatedFrom "
1326 "StoragePool) or back to underlying storage extents. If 0 is "
1327 "returned, the function completed successfully, and no "
1328 "ConcreteJob was required. If 4096/0x1000 is returned, a "
1329 "ConcreteJob will be started to delete the StoragePool. A "
1330 "reference to the Job is returned in the Job parameter."),
1331 ValueMap { "0", "1", "2", "3", "4", "5", "6", "..", "4096",
1332 "4097..32767", "32768..65535" },
1333 Values { "Job Completed with No Error", "Not Supported",
1334 "Unknown", "Timeout", "Failed", "Invalid Parameter",
1335 "In Use", "DMTF Reserved",
1336 "Method Parameters Checked - Job Started", "Method Reserved",
1337 "Vendor Specific" }]
1338 uint32 DeleteStoragePool (
1339 [IN ( false ), OUT, Description (
1340 "Reference to the job (may be null if job completed).")]
1341 CIM_ConcreteJob REF Job,
1342 [IN, Description (
1343 "Reference to the pool to delete.")]
1344 CIM_StoragePool REF Pool);
1345 karl 1.1
1346 [Description (
1347 "Start a job to delete an element previously created from a "
1348 "StoragePool. The freed space is returned to the source "
1349 "StoragePool. If 0 is returned, the function completed "
1350 "successfully and no ConcreteJob was required. If "
1351 "4096/0x1000 is returned, a ConcreteJob will be started to "
1352 "delete the element. A reference to the Job is returned in "
1353 "the Job parameter."),
1354 ValueMap { "0", "1", "2", "3", "4", "5", "6", "..", "4096",
1355 "4097..32767", "32768..65535" },
1356 Values { "Job Completed with No Error", "Not Supported",
1357 "Unknown", "Timeout", "Failed", "Invalid Parameter",
1358 "In Use", "DMTF Reserved",
1359 "Method Parameters Checked - Job Started", "Method Reserved",
1360 "Vendor Specific" }]
1361 uint32 ReturnToStoragePool(
1362 [IN ( false ), OUT, Description (
1363 "Reference to the job (may be null if job completed).")]
1364 CIM_ConcreteJob REF Job,
1365 [IN, Description (
1366 karl 1.1 "Reference to the element to return to the StoragePool.")]
1367 CIM_LogicalElement REF TheElement);
1368
1369 [Description (
1370 "Start a job to create a new storage object which is a "
1371 "replica of the specified source storage object. "
1372 "(SourceElement). Note that using the input paramter, "
1373 "CopyType, this function can be used to instantiate the "
1374 "replica, and to create an ongoing association between the "
1375 "source and replica. If 0 is returned, the function "
1376 "completed successfully and no ConcreteJob instance is "
1377 "created. If 4096/0x1000 is returned, a ConcreteJob is "
1378 "started, a reference to which is returned in the Job output "
1379 "parameter."),
1380 ValueMap { "0", "1", "2", "3", "4", "5", "6", "..", "4096",
1381 "4097..32767", "32768..65535" },
1382 Values { "Job Completed with No Error", "Not Supported",
1383 "Unknown", "Timeout", "Failed", "Invalid Parameter",
1384 "In Use", "DMTF Reserved",
1385 "Method Parameters Checked - Job Started", "Method Reserved",
1386 "Vendor Specific" }]
1387 karl 1.1 uint32 CreateReplica(
1388 [IN, Description (
1389 "A end user relevant name for the element being created. "
1390 "If NULL, then a system supplied default name can be "
1391 "used. The value will be stored in the 'ElementName' "
1392 "property for the created element.")]
1393 string ElementName,
1394 [IN ( false ), OUT, Description (
1395 "Reference to the job (may be null if job completed).")]
1396 CIM_ConcreteJob REF Job,
1397 [Required, IN, Description (
1398 "The source storage object which may be a StorageVolume "
1399 "or storage object.")]
1400 CIM_LogicalElement REF SourceElement,
1401 [IN ( false ), OUT, Description (
1402 "Reference to the created target storage element (i.e., "
1403 "the replica).")]
1404 CIM_LogicalElement REF TargetElement,
1405 [IN, Description (
1406 "The definition for the StorageSetting to be maintained "
1407 "by the target storage object (the replica).")]
1408 karl 1.1 CIM_StorageSetting REF TargetSettingGoal,
1409 [IN, Description (
1410 "The underlying storage for the target element (the "
1411 "replica) will be drawn from TargetPool if specified, "
1412 "otherwise the allocation is implementation specific.")]
1413 CIM_StoragePool REF TargetPool,
1414 [IN, Description (
1415 "CopyType describes the type of copy that will be made. "
1416 "Values are: \n"
1417 "Async: Create and maintain an asynchronous copy of the "
1418 "source. \n"
1419 "Sync: Create and maintain a synchronized copy of the "
1420 "source. \n"
1421 "UnSyncAssoc: Create an unsynchronized copy and maintain "
1422 "an association to the source. \n"
1423 "UnSyncUnAssoc: Create unassociated copy of the source "
1424 "element."),
1425 ValueMap { "2", "3", "4", "5", "..", "32768..65535" },
1426 Values { "Async", "Sync", "UnSyncAssoc", "UnSyncUnAssoc",
1427 "DMTF Reserved", "Vendor Specific" }]
1428 uint16 CopyType);
1429 karl 1.1
1430 [Description (
1431 "Modify (or start a job to modify) the synchronization "
1432 "association between two storage objects. If 0 is returned, "
1433 "the function completed successfully and no ConcreteJob "
1434 "instance was created. If 0x1000 is returned, a ConcreteJob "
1435 "was started and a reference to this Job is returned in the "
1436 "Job output parameter. A return value of 1 indicates the "
1437 "method is not supported. All other values indicate some "
1438 "type of error condition."),
1439 ValueMap { "0", "1", "2", "3", "4", "5", "6", "..", "0x1000",
1440 "0x1001..0x7FFF", "0x8000..0xFFFF" },
1441 Values { "Job Completed with No Error", "Not Supported",
1442 "Unspecified Error", "Timeout", "Failed",
1443 "Invalid Parameter", "In Use", "DMTF Reserved",
1444 "Method Parameters Checked - Job Started", "Method Reserved",
1445 "Vendor Specific" }]
1446 uint32 ModifySynchronization(
1447 [IN, Description (
1448 "Operation describes the type of modification to be made "
1449 "to the replica. Values are: \n"
1450 karl 1.1 "Detach: 'Forget' the synchronization between two storage "
1451 "objects. Start to treat the objects as independent. \n"
1452 "Fracture: Suspend the synchronization between two "
1453 "storage objects. The association and (typically) changes "
1454 "are remembered to allow a fast resynchronization. This "
1455 "may be used during a backup cycle to allow one of the "
1456 "objects to be copied while the other remains in "
1457 "production. \n"
1458 "Resync Replica: Re-establish the synchronization of a "
1459 "replica. This will negate the action of a previous "
1460 "Fracture operation. \n"
1461 "Restore from Replica: Renew the contents of the original "
1462 "storage object from a replica. \n"
1463 "Prepare: Get the link ready for a Resync operation to "
1464 "take place. Some implementations will require this "
1465 "operation to be invoked to keep the Resync operation as "
1466 "fast as possible. \n"
1467 "Unprepare: Clear a prepared state if a Prepare is not to "
1468 "be followed by a Resync operation. \n"
1469 "Quiesce: Some applications require notification so that "
1470 "they can ready the link for an operation. For example "
1471 karl 1.1 "flush any cached data or buffered changes. \n"
1472 "Unquiesce: Take the link from the quiesced state "
1473 "(without executing the intended operation. \n"
1474 "Reset To Sync: Change the CopyType of the association to "
1475 "Sync (e.g., from the Async CopyType). \n"
1476 "Reset To Async: Change the CopyType of the association "
1477 "to Async (e.g., from the Sync CopyType)."),
1478 ValueMap { "0","1","2", "3", "4", "5", "6", "7", "8", "9",
1479 "10", "11", "..", "0x8000..0xFFFF" },
1480 Values { "DMTF Reserved", "DMTF Reserved", "Detach",
1481 "Fracture", "Resync Replica", "Restore from Replica",
1482 "Prepare", "Unprepare", "Quiesce", "Unquiesce",
1483 "Reset To Sync", "Reset To Async", "DMTF Reserved",
1484 "Vendor Specific" }]
1485 uint16 Operation,
1486 [IN ( false ), OUT, Description (
1487 "Reference to the job (may be null if the task "
1488 "completed).")]
1489 CIM_ConcreteJob REF Job,
1490 [IN, Description (
1491 "The referenced to the StorageSynchronized association "
1492 karl 1.1 "describing the storage source/replica relationship.")]
1493 CIM_StorageSynchronized REF Synchronization);
1494
1495 [Description (
1496 "Create (or start a job to create) a StorageSynchronized "
1497 "relationship between two existing storage objects. Note "
1498 "that using the input parameter, CopyType, this function can "
1499 "be used to to create an ongoing association between the "
1500 "source and replica. If 0 is returned, the function "
1501 "completed successfully and no ConcreteJob instance is "
1502 "created. If 0x1000 is returned, a ConcreteJob is started, a "
1503 "reference to which is returned in the Job output parameter. "
1504 "A return value of 1 indicates the method is not supported. "
1505 "All other values indicate some type of error condition."),
1506 ValueMap { "0", "1", "2", "3", "4", "5", "6", "..", "0x1000",
1507 "0x1001..0x7FFF", "0x8000..0xFFFF" },
1508 Values { "Job Completed with No Error", "Not Supported",
1509 "Unspecified Error", "Timeout", "Failed",
1510 "Invalid Parameter", "In Use", "DMTF Reserved",
1511 "Method Parameters Checked - Job Started", "Method Reserved",
1512 "Vendor Specific" }]
1513 karl 1.1 uint32 AttachReplica(
1514 [IN ( false ), OUT, Description (
1515 "Reference to the job (may be null if the task "
1516 "completed).")]
1517 CIM_ConcreteJob REF Job,
1518 [Required, IN, Description (
1519 "The source storage object which may be a StorageVolume "
1520 "or other storage object.")]
1521 CIM_ManagedElement REF SourceElement,
1522 [IN, Description (
1523 "Reference to the target storage element (i.e., the "
1524 "replica).")]
1525 CIM_ManagedElement REF TargetElement,
1526 [IN, Description (
1527 "CopyType describes the type of Synchronized relationship "
1528 "that will be created. Values are: \n"
1529 "Async: Create and maintain an asynchronous copy of the "
1530 "source. \n"
1531 "Sync: Create and maintain a synchronized copy of the "
1532 "source. \n"
1533 "UnSyncAssoc: Create an unsynchronized copy and maintain "
1534 karl 1.1 "an association to the source. \n"
1535 "UnSyncUnAssoc: Create unassociated copy of the source "
1536 "element."),
1537 ValueMap { "2", "3", "4", "5", "..", "0x8000..0xFFFF" },
1538 Values { "Async", "Sync", "UnSyncAssoc", "UnSyncUnAssoc",
1539 "DMTF Reserved", "Vendor Specific" }]
1540 uint16 CopyType);
1541
1542 [Experimental, Description (
1543 "Start a job to create (or modify) a specified storage "
1544 "element from specified input StorageExtents. The created or "
1545 "modified storage element can be a StorageExtent, "
1546 "StorageVolume, LogicalDisk, or StoragePool. An input list "
1547 "of InElements must be specified. The GetAvailableExtents "
1548 "method can be used to get a list of valid extents that can "
1549 "be used to achieve a desired goal. Validity of the extents "
1550 "is determined by the implementation. As an input parameter, "
1551 "Size specifies the desired size of the element. As an "
1552 "output parameter, it specifies the size achieved. Space is "
1553 "taken from the input InElements. The desired Settings for "
1554 "the element are specified by the Goal parameter. If the "
1555 karl 1.1 "size of Extents passed is less than the size requested, "
1556 "then the capacity is drawn from the extents in the order, "
1557 "left to right, that the Extents were specified. The partial "
1558 "consumption of an Extent is represented by an Extent for "
1559 "the capacity used and an Extent for the capacity not used. "
1560 "If the Size is NULL, then a configuration using all Extents "
1561 "passed will be attempted. If the requested size cannot be "
1562 "created, no action will be taken, and the Return Value will "
1563 "be 4097/0x1001. Also, the output value of Size is set to "
1564 "the nearest possible size. If 0 is returned, the function "
1565 "completed successfully and no ConcreteJob instance was "
1566 "required. If 4096/0x1000 is returned, a ConcreteJob will be "
1567 "started to create the element. The Job's reference will be "
1568 "returned in the output parameter Job."),
1569 ValueMap { "0", "1", "2", "3", "4", "5", "6", "..", "4096",
1570 "4097", "4098..32767", "32768..65535" },
1571 Values { "Completed with No Error", "Not Supported", "Unknown",
1572 "Timeout", "Failed", "Invalid Parameter", "In Use",
1573 "DMTF Reserved", "Method Parameters Checked - Job Started",
1574 "Size Not Supported", "Method Reserved", "Vendor Specific" }]
1575 uint32 CreateOrModifyElementFromElements(
1576 karl 1.1 [IN, Description (
1577 "A end user relevant name for the element being created. "
1578 "If NULL, then a system-supplied default name can be "
1579 "used. The value will be stored in the 'ElementName' "
1580 "property for the created element. If not NULL, this "
1581 "parameter will supply a new name when modifying an "
1582 "existing element.")]
1583 string ElementName,
1584 [Required, IN, Description (
1585 "Enumeration indicating the type of element being created "
1586 "or modified. If the input parameter TheElement is "
1587 "specified when the operation is a 'modify', this type "
1588 "value must match the type of that instance. The actual "
1589 "CIM class of the created TheElement can be "
1590 "vendor-specific, but it must be a derived class of the "
1591 "appropriate CIM class -- i.e., CIM_StorageVolume, "
1592 "CIM_StorageExtent, CIM_LogicalDisk, or CIM_StoragePool."),
1593 ValueMap { "0", "1", "2", "3", "4", "5", "..",
1594 "32768..65535" },
1595 Values { "Unknown", "Reserved", "Storage Volume",
1596 "Storage Extent", "Storage Pool", "Logical Disk",
1597 karl 1.1 "DMTF Reserved", "Vendor Specific" }]
1598 uint16 ElementType,
1599 [IN ( false ), OUT, Description (
1600 "Reference to the job (may be null if job completed).")]
1601 CIM_ConcreteJob REF Job,
1602 [Required, IN, Description (
1603 "The requirements for the element to maintain. If set to "
1604 "a null value, the default configuration associated with "
1605 "the Service will be used. This parameter should be a "
1606 "reference to a Setting, SettingData, or Profile "
1607 "appropriate to the element being created. If not NULL, "
1608 "this parameter will supply a new Goal when modifying an "
1609 "existing element.")]
1610 CIM_ManagedElement REF Goal,
1611 [IN, OUT, Description (
1612 "As an input parameter Size specifies the desired size. "
1613 "If not NULL, this parameter will supply a new size when "
1614 "modifying an existing element. As an output parameter "
1615 "Size specifies the size achieved."),
1616 Units ( "Bytes" )]
1617 uint64 Size,
1618 karl 1.1 [Required, IN, Description (
1619 "Array of references to storage element instances that "
1620 "are used to create or modify TheElement.")]
1621 CIM_StorageExtent REF InElements[],
1622 [IN, OUT, Description (
1623 "As an input parameter: if null, creates a new element. "
1624 "If not null, then the method modifies the specified "
1625 "element. As an output parameter, it is a reference to "
1626 "the resulting element.")]
1627 CIM_LogicalElement REF TheElement);
1628
1629 [Experimental, Description (
1630 "This method requests that the system rescan SCSI devices "
1631 "for changes in their configuration. If called on a "
1632 "general-purpose host, the changes are reflected in the list "
1633 "of devices available to applications (for example, the UNIX "
1634 "'device tree'. This method may also be used on a storage "
1635 "appliance to force rescanning of attached SCSI devices. \n"
1636 "\n"
1637 "This operation can be disruptive; optional parameters allow "
1638 "the caller to limit the scan to a single or set of SCSI "
1639 karl 1.1 "device elements. All parameters are optional; if parameters "
1640 "other Job are passed in as null, a full scan is invoked."),
1641 ValueMap { "0", "1", "2", "3", "4", "5", "6..4095", "4096",
1642 "4097", "4098", "4099", "4100", "..", "32768..65535" },
1643 Values { "Success", "Not Supported", "Unknown", "Timeout",
1644 "Failed", "Invalid Parameter", "DMTF Reserved",
1645 "Invalid connection type", "Invalid Initiator",
1646 "No matching target found", "No matching LUs found",
1647 "Prohibited by name binding configuration", "DMTF Reserved",
1648 "Vendor Specific" }]
1649 uint32 ScsiScan (
1650 [IN, OUT, Description (
1651 "Reference to the job (may be null if job completed).")]
1652 CIM_ConcreteJob REF Job,
1653
1654 [Description (
1655 "The type of connection, constrains the scan to initiator "
1656 "ports of this type. Only used if the Initiators "
1657 "parameter is null."),
1658 ValueMap { "1", "2", "3", "4", "5", "6", "7", "8", "9" },
1659 Values { "Other", "Fibre Channel", "Parallel SCSI", "SSA",
1660 karl 1.1 "IEEE 1394", "RDMA", "iSCSI", "SAS", "ADT" },
1661 ModelCorrespondence {
1662 "CIM_SCSIProtocolEndpoint.ConnectionType" }]
1663 uint16 ConnectionType,
1664
1665 [Description (
1666 "The connection type, if the ConnectionType parameter is "
1667 "\"Other\".")]
1668 string OtherConnectionType,
1669
1670 [Description (
1671 "A list of references to initiators. Scanning will be "
1672 "limited to SCSI targets attached to these initiators. If "
1673 "this parameter is null and connection is specified, all "
1674 "initiators of that connection type are scanned. If this "
1675 "parameter and ConnectionType are null, all targets on "
1676 "all system initiators are probed.")]
1677 CIM_SCSIProtocolEndpoint REF Initiators[],
1678
1679 [Description (
1680 "A list of names or numbers for targets. These should be "
1681 karl 1.1 "formatted to match the appropriate connection type, For "
1682 "example, PortWWNs would be specified for Fibre Channel "
1683 "targets.")]
1684 string Targets[],
1685
1686 [Description (
1687 "A list of SCSI logical unit numbers representing logical "
1688 "units hosted on the targets specified in the Targets "
1689 "argument.")]
1690 string LogicalUnits[]);
1691 };
1692
1693 // ==================================================================
1694 // StorageConfigurationCapabilities
1695 // ==================================================================
1696 [Version ( "2.8.1000" ), Description (
1697 "A subclass of Capabilities that defines the Capabilities of a "
1698 "StorageConfigurationService. An instance of "
1699 "StorageConfigurationCapabilities is associated with a "
1700 "StorageConfigurationService using ElementCapabilities. The "
1701 "properties in this class specify the envelope of capabilites "
1702 karl 1.1 "for storage configuration in the context of the Service or "
1703 "Pool with which the instance is associated. These properties "
1704 "correspond to the properties of the same base names in "
1705 "StorageSetting and StorageSettingWithHints when either is used "
1706 "as a goal parameter to the StorageConfigurationService methods "
1707 "(CreateOrModifyStoragePool, "
1708 "CreateOrModifyElementFromStoragePool, or "
1709 "CreateOrModifyElementFromElements).")]
1710 class CIM_StorageConfigurationCapabilities : CIM_Capabilities {
1711
1712 [Description (
1713 "Enumeration indicating what operations will be executed as "
1714 "asynchronous jobs. If an operation is included in both this "
1715 "and SupportedSynchronousActions then the underlying "
1716 "implementation is indicating that it may or may not create "
1717 "a job."),
1718 ValueMap { "2", "3", "4", "5", "6", "7", "8", "9", "10" },
1719 Values { "Storage Pool Creation", "Storage Pool Deletion",
1720 "Storage Pool Modification", "Storage Element Creation",
1721 "Storage Element Return", "Storage Element Modification",
1722 "Replica Creation", "Replica Modification",
1723 karl 1.1 "Replica Attachment" },
1724 ModelCorrespondence {
1725 "CIM_StorageConfigurationCapabilities.SupportedSynchronousActions"
1726 }]
1727 uint16 SupportedAsynchronousActions[];
1728
1729 [Description (
1730 "Enumeration indicating what operations will be executed "
1731 "without the creation of a job. If an operation is included "
1732 "in both this and SupportedAsynchronousActions then the "
1733 "underlying instrumentation is indicating that it may or may "
1734 "not create a job."),
1735 ValueMap { "2", "3", "4", "5", "6", "7", "8", "9", "10" },
1736 Values { "Storage Pool Creation", "Storage Pool Deletion",
1737 "Storage Pool Modification", "Storage Element Creation",
1738 "Storage Element Return", "Storage Element Modification",
1739 "Replica Creation", "Replica Modification",
1740 "Replica Attachment" },
1741 ModelCorrespondence { "CIM_StorageConfigurationCapabilities."
1742 "SupportedAsynchronousActions" }]
1743 uint16 SupportedSynchronousActions[];
1744 karl 1.1
1745 [Description (
1746 "Enumeration indicating the type of storage elements that "
1747 "are supported by the associated "
1748 "StorageConfigurationService."),
1749 ValueMap { "2", "3", "4", "..", "0x8000..0xFFFF" },
1750 Values { "StorageVolume", "StorageExtent", "LogicalDisk",
1751 "DMTF Reserved", "Vendor Specific" },
1752 ModelCorrespondence { "CIM_StorageConfigurationService."
1753 "CreateOrModifyElementFromStoragePool.ElementType" }]
1754 uint16 SupportedStorageElementTypes[];
1755
1756 [Description (
1757 "Enumeration indicating features supported by the "
1758 "StoragePool methods."),
1759 ValueMap { "2", "3", "4", "..", "0x8000..0xFFFF" },
1760 Values { "InExtents", "Single InPool", "Multiple InPools",
1761 "DMTF Reserved", "Vendor Specific" },
1762 ModelCorrespondence { "CIM_StorageConfigurationService."
1763 "CreateOrModifyStoragePool.InPools",
1764 "CIM_StorageConfigurationService."
1765 karl 1.1 "CreateOrModifyStoragePool.InExtents" }]
1766 uint16 SupportedStoragePoolFeatures[];
1767
1768 [Description (
1769 "Enumeration indicating features supported by the Storage "
1770 "Element methods."),
1771 ValueMap { "2", "3", "4", "5", "6", "7", "8", "9", "10", "..",
1772 "0x8000..0xFFFF" },
1773 Values { "StorageExtent Creation", "StorageVolume Creation",
1774 "StorageExtent Modification", "StorageVolume Modification",
1775 "Single InPool", "Multiple InPools", "LogicalDisk Creation",
1776 "LogicalDisk Modification", "InExtents", "DMTF Reserved",
1777 "Vendor Specific" },
1778 ModelCorrespondence { "CIM_StorageConfigurationService."
1779 "CreateOrModifyElementFromStoragePool.ElementType",
1780 "CIM_StorageConfigurationService."
1781 "CreateOrModifyElementFromStoragePool.InPool",
1782 "CIM_StorageConfigurationService."
1783 "CreateOrModifyElementFromElements.InElements" }]
1784 uint16 SupportedStorageElementFeatures[];
1785
1786 karl 1.1 [Description (
1787 "SupportedCopyTypes describes the replication capabilities "
1788 "supported by the associated StorageConfigurationServices. "
1789 "Values are: \n"
1790 "Async: asynchronous copies may be created and maintained. \n"
1791 "Sync: synchronous copies may be created and maintained. \n"
1792 "UnSyncAssoc: unsynchronized copies may be created and "
1793 "maintained. \n"
1794 "UnSyncUnAssoc: a 'straight copy' may be created."),
1795 ValueMap { "2", "3", "4", "5", "..", "0x8000..0xFFFF" },
1796 Values { "Async", "Sync", "UnSyncAssoc", "UnSyncUnAssoc",
1797 "DMTF Reserved", "Vendor Specific" },
1798 ModelCorrespondence {
1799 "CIM_StorageConfigurationService.CreateReplica.CopyType" }]
1800 uint16 SupportedCopyTypes[];
1801
1802 [Description (
1803 "InitialReplicationState specifies which initial "
1804 "ReplicationState is supported by a particular provider. "
1805 "Values are: \n"
1806 "Initialized: The replication relationship is known and "
1807 karl 1.1 "unsynchronized, but time required to synchronize may be "
1808 "long. \n"
1809 "Prepared: The replication relationship is known and "
1810 "unsynchronized and the time required to synchronize will be "
1811 "short. \n"
1812 "Synchronized: The replicas are synchronized."),
1813 ValueMap { "2", "3", "4", "..", "0x8000..0xFFFF" },
1814 Values { "Initialized", "Prepared", "Synchronized",
1815 "DMTF Reserved", "Vendor Specific" },
1816 ModelCorrespondence {
1817 "CIM_StorageConfigurationService.AttachReplica",
1818 "CIM_StorageConfigurationService.CreateReplica" }]
1819 uint16 InitialReplicationState;
1820
1821 };
1822
1823 // ====================================================================
1824 // StorageSettingWithHints
1825 // ====================================================================
1826 [Version ( "2.7.1" ), Description (
1827 "This subclass of StorageSetting allows a client to specify "
1828 karl 1.1 "'hint's for optimization of the volume performance. The effect "
1829 "of these hints is implementation dependent.")]
1830 class CIM_StorageSettingWithHints : CIM_StorageSetting {
1831
1832 [Write, Description (
1833 "This hint is an indication from a client of the importance "
1834 "placed on data availability. Values are 0=Don't Care to "
1835 "10=Very Important."),
1836 MinValue ( 0 ), MaxValue ( 10 )]
1837 uint16 DataAvailabilityHint;
1838
1839 [Write, Description (
1840 "This hint is an indication from a client of the randomness "
1841 "of accesses. Values are 0=Entirely Sequential to "
1842 "10=Entirely Random."),
1843 MinValue ( 0 ), MaxValue ( 10 )]
1844 uint16 AccessRandomnessHint;
1845
1846 [Write, Description (
1847 "This hint is an indication from a client of the direction "
1848 "of accesses. Values are 0=Entirely Read to 10=Entirely "
1849 karl 1.1 "Write."),
1850 MinValue ( 0 ), MaxValue ( 10 )]
1851 uint16 AccessDirectionHint;
1852
1853 [Write, Description (
1854 "This hint is an indication from a client of the optimal "
1855 "access sizes (in bytes). Since this property is an array, "
1856 "several sizes can be specified."),
1857 Units ( "Bytes" )]
1858 uint16 AccessSizeHint[];
1859
1860 [Write, Description (
1861 "This hint is an indication from a client how important "
1862 "access latency is. Values are 0=Don't Care to 10=Very "
1863 "Important."),
1864 MinValue ( 0 ), MaxValue ( 10 )]
1865 uint16 AccessLatencyHint;
1866
1867 [Write, Description (
1868 "This hint is an indication from a client of bandwidth "
1869 "prioritization. Values are 0=Don't Care to 10=Very "
1870 karl 1.1 "Important."),
1871 MinValue ( 0 ), MaxValue ( 10 )]
1872 uint16 AccessBandwidthWeight;
1873
1874 [Write, Description (
1875 "This hint is an indication of the importance the client "
1876 "places on the cost of storage. Values are 0=Don't Care to "
1877 "10=Very Important. A StorageVolume provider might choose to "
1878 "place data on low cost or high cost drives based on this "
1879 "parameter."),
1880 MinValue ( 0 ), MaxValue ( 10 )]
1881 uint16 StorageCostHint;
1882
1883 [Write, Description (
1884 "This hint is an indication of the importance placed on "
1885 "storage space efficiency by the client. Values are 0=Don't "
1886 "Care to 10=Very Important. A StorageVolume provider might "
1887 "choose different RAID levels based on this hint."),
1888 MinValue ( 0 ), MaxValue ( 10 )]
1889 uint16 StorageEfficiencyHint;
1890 };
1891 karl 1.1
1892
1893 // ===================================================================
1894 // AllocatedFromStoragePool
1895 // ===================================================================
1896 [Association, Version ( "2.8.0" ), Description (
1897 "AllocatedFromStoragePool is an association describing how "
1898 "LogicalElements are allocated from underlying StoragePools. "
1899 "These elements typically would be subclasses of StorageExtents "
1900 "or StoragePools.")]
1901 class CIM_AllocatedFromStoragePool : CIM_Dependency {
1902
1903 [Override ( "Antecedent" ), Description (
1904 "The StoragePool.")]
1905 CIM_StoragePool REF Antecedent;
1906
1907 [Override ( "Dependent" ), Description (
1908 "The subsidiary element.")]
1909 CIM_LogicalElement REF Dependent;
1910
1911 [Required, Description (
1912 karl 1.1 "Space consumed from this Pool, in bytes. This value MUST be "
1913 "maintained so that, relative to the Antecedent StoragePool, "
1914 "it is possible to compute TotalManagedSpace as "
1915 "StoragePool.RemainingManagedSpace plus the sum of "
1916 "SpaceConsumed from all of the AllocatedFromStoragePool "
1917 "references from the antecedent StoragePool."),
1918 Units ( "Bytes" ),
1919 ModelCorrespondence { "CIM_StoragePool.TotalManagedSpace",
1920 "CIM_StoragePool.RemainingManagedSpace" }]
1921 uint64 SpaceConsumed;
1922
1923 };
1924
1925
1926 // ==================================================================
1927 // HostedStoragePool
1928 // ==================================================================
1929 [Association, Aggregation, Composition, Version ( "2.7.0" ),
1930 Description (
1931 "SystemStoragePool is a specialization of SystemComponent "
1932 "association that establishes that the StoragePool is defined "
1933 karl 1.1 "in the context of the System.")]
1934 class CIM_HostedStoragePool : CIM_SystemComponent {
1935
1936 [Aggregate, Override ( "GroupComponent" ), Min ( 1 ), Max ( 1 ),
1937 Description (
1938 "The parent system in the Association.")]
1939 CIM_System REF GroupComponent;
1940
1941 [Override ( "PartComponent" ), Description (
1942 "The StoragePool that is a component of a System.")]
1943 CIM_StoragePool REF PartComponent;
1944 };
1945
1946
1947 // ===================================================================
1948 // ConfigurationReportingService
1949 // ===================================================================
1950 [Version ( "2.7.0" ), Description (
1951 "Service to provide reports on current configuration and "
1952 "potential for growth. The service may be used in several "
1953 "circumstances: \n"
1954 karl 1.1 "- To report growth potential (how many can I have) \n"
1955 "- To report information on objects not directly modeled for "
1956 "performance or other reasons. \n"
1957 "It can also report counts of 'things' or counts of 'units'. "
1958 "For example, the number of disk drives could be reported or "
1959 "the capacity that they would provide.")]
1960 class CIM_ConfigurationReportingService : CIM_Service {
1961
1962 [Description (
1963 "Returns a list of classes that the given Managed Element "
1964 "supports or has installed."),
1965 ValueMap { "0", "1", "2", "3", "4", "..", "32768..65535" },
1966 Values { "Success", "Not Supported", "Unknown", "Timeout",
1967 "Failed", "DMTF Reserved", "Vendor Specific" }]
1968 uint32 GetClassTypes(
1969 [IN, Description (
1970 "The type of inquiry to be performed."),
1971 ValueMap { "2", "3" },
1972 Values { "Supports", "Installed" }]
1973 uint16 InquiryType,
1974 [IN, Description (
1975 karl 1.1 "False : Only report on elements directly contained "
1976 "in/attached to the given ManagedElement. \n"
1977 "True : Report on all objects contained in/attached to "
1978 "the given ManagedElement.")]
1979 boolean Recursive,
1980 [IN, Description (
1981 "The target of query, for example a rack or a chassis.")]
1982 CIM_ManagedElement REF Target,
1983 [IN ( false ), OUT, Description (
1984 "Array containing the class names (typically the leaf "
1985 "classes) that the given ManagedElement can support or "
1986 "has installed.")]
1987 string ClassTypes[]);
1988
1989 [Description (
1990 "Returns a list of UnitTypes that are installed for a given "
1991 "ClassType on a given ManagedElement."),
1992 ValueMap { "0", "1", "2", "3", "4", "..", "32768..65535" },
1993 Values { "Success", "Not Supported", "Unknown", "Timeout",
1994 "Failed", "DMTF Reserved", "Vendor Specific" }]
1995 uint32 GetUnitTypes(
1996 karl 1.1 [IN, Description (
1997 "The type of inquiry to be performed."),
1998 ValueMap { "2", "3" },
1999 Values { "Supported", "Installed" }]
2000 uint16 InquiryType,
2001 [IN, Description (
2002 "False : Only report on elements directly contained "
2003 "in/attached to the given ManagedElement. \n"
2004 "True : Report on all objects contained in/attached to "
2005 "the given ManagedElement.")]
2006 boolean Recursive,
2007 [IN, Description (
2008 "The target of query, for example a rack or a chassis.")]
2009 CIM_ManagedElement REF Target,
2010 [IN, Description (
2011 "The ClassType for the query. This should be a entry "
2012 "returned in the GetClassTypes.ClassTypes property.")]
2013 string ClassType,
2014 [IN ( false ), OUT, Description (
2015 "A list of supported UnitTypes."),
2016 ValueMap { "2", "3", "4", "5", "6", "7", "8", "9", "10",
2017 karl 1.1 "..", "32768..65535" },
2018 Values { "None", "Front Side", "Back Side", "Contained",
2019 "Connected", "I/O", "Memory", "StorageMediaLocation",
2020 "Megabytes", "DMTF Reserved", "Vendor Specific" },
2021 ModelCorrespondence { "CIM_ConfigurationReportingService."
2022 "ReportCapacity(UnitType)" }]
2023 uint16 UnitTypes[]);
2024
2025 [Description (
2026 "Returns the maximum number supported or the number of "
2027 "currently installed units for the given UnitType, for a "
2028 "given ClassType on a given ManagedElement."),
2029 ValueMap { "0", "1", "2", "3", "4", "..", "32768..65535" },
2030 Values { "Success", "Not Supported", "Unknown", "Timeout",
2031 "Failed", "DMTF Reserved", "Vendor Specific" }]
2032 uint32 ReportCapacity(
2033 [IN, Description (
2034 "The type of inquiry to be performed."),
2035 ValueMap { "2", "3" },
2036 Values { "Supported", "Installed" }]
2037 uint16 InquiryType,
2038 karl 1.1 [IN, Description (
2039 "False : Only report on elements directly contained "
2040 "in/attached to the given ManagedElement. \n"
2041 "True : Report on all objects contained in/attached to "
2042 "the given ManagedElement.")]
2043 boolean Recursive,
2044 [IN, Description (
2045 "The target of query, for example a rack or a chassis.")]
2046 CIM_ManagedElement REF Target,
2047 [IN, Description (
2048 "The ClassType for the query. This should be a entry "
2049 "returned in the GetClassTypes.ClassTypes property.")]
2050 string ClassType,
2051 [IN, Description (
2052 "The UnitType for the query."),
2053 ValueMap { "2", "3", "4", "5", "6", "7", "8", "9", "10",
2054 "..", "32768..65535" },
2055 Values { "None", "Front Side", "Back Side", "Contained",
2056 "Connected", "I/O", "Memory", "StorageMediaLocation",
2057 "Megabytes", "DMTF Reserved", "Vendor Specific" },
2058 ModelCorrespondence { "CIM_ConfigurationReportingService."
2059 karl 1.1 "GetUnitTypes(UnitTypes)" }]
2060 uint16 UnitType,
2061 [IN ( false ), OUT, Description (
2062 "The maximum number of supported or the number of "
2063 "currently installed units.")]
2064 uint64 NumberOfUnits);
2065 };
2066
2067 // ===================================================================
2068 // StorageSettingsAssociatedToCapabilities
2069 // ===================================================================
2070 [Association, Experimental, Version ( "2.8.1000" ), Description (
2071 "This association define StorageSettings that reflect the "
2072 "capabilities of the associated StorageCapabilities. The "
2073 "associated StorageSetting MAY NOT define the operational "
2074 "characteristics (through settings properties) of any storage "
2075 "element. Certain StorageSetting instances can be defined as "
2076 "\"Fixed = Not Changeable\" by using the \"ChangeableType\" "
2077 "attribute. \"Fixed\" settings have this special association. "
2078 "This association SHALL be defined between \"Fixed - Not "
2079 "Changeable\" instances of StorageSetting with the "
2080 karl 1.1 "StorageCapabilities instances that are associated with the "
2081 "StoragePools which support the storage characteristics "
2082 "described by the StorageSetting instance. \n"
2083 "Fixed settings MAY be associated to many StorageCapabilities.")]
2084 class CIM_StorageSettingsAssociatedToCapabilities : CIM_Dependency {
2085
2086 [Override ( "Antecedent" ), Description (
2087 "The StorageCapabilities.")]
2088 CIM_StorageCapabilities REF Antecedent;
2089
2090 [Override ( "Dependent" ), Description (
2091 "The StorageSetting.")]
2092 CIM_StorageSetting REF Dependent;
2093
2094 [Required, Description (
2095 "The default association associates the setting that will be "
2096 "used to create or modify a Storage Element if a no setting "
2097 "is passed as a Goal. \n"
2098 "There MUST be only one default Setting per pool.")]
2099 boolean DefaultSetting = FALSE;
2100
2101 karl 1.1 };
2102
2103
2104 // ===================================================================
2105 // StorageSettingsGeneratedFromCapabilities
2106 // ===================================================================
2107 [Association, Experimental, Version ( "2.8.1000" ), Description (
2108 "This association define StorageSettings that reflect the "
2109 "capabilities of the associated StorageCapabilities. The "
2110 "associated StorageSetting MAY NOT define the operational "
2111 "characteristics (through settings properties) of any storage "
2112 "element. StorageSettingsGeneratedFromCapabilities is the "
2113 "association between instances of StorageCapabilities and those "
2114 "instances of StorageSetting that have been created from the "
2115 "StorageCapabilities instance using the StorageCapabilities "
2116 "\"CreateSetting\" method. These settings are either "
2117 "\"Changeable - Transient\" or \"Changeable - Persistent\" The "
2118 "settings associated by this class reflect the capabilities "
2119 "from which they are generated. These setting SHALL be "
2120 "associated with one StorageCapabilities. \n"
2121 "A generated setting can be deleted by the implementation at "
2122 karl 1.1 "any time if the it is a \"Changed - Transient\" setting. \n"
2123 "A client SHOULD not use this association to find transient "
2124 "Settings to subsequently modify and/or use because that would "
2125 "increase the likelihood of setting contention across clients. "
2126 "Instead the implementation uses this association to define "
2127 "transient settings, which can be located through any means, "
2128 "that have special temporal based life cycle.")]
2129 class CIM_StorageSettingsGeneratedFromCapabilities : CIM_Dependency {
2130
2131 [Override ( "Antecedent" ), Max ( 1 ), Description (
2132 "The StorageCapabilities.")]
2133 CIM_StorageCapabilities REF Antecedent;
2134
2135 [Override ( "Dependent" ), Description (
2136 "The StorageSetting.")]
2137 CIM_StorageSetting REF Dependent;
2138 };
2139
2140 // ===================================================================
2141 // end of file
2142 // ===================================================================
|
Return to
Device_StorageServices.mof
CVS log
Up to [Pegasus] / pegasus / Schemas / CIMPrelim29