]>
Commit | Line | Data |
---|---|---|
9ae529ec CS |
1 | /* |
2 | * CDDL HEADER START | |
3 | * | |
4 | * The contents of this file are subject to the terms of the | |
5 | * Common Development and Distribution License (the "License"). | |
6 | * You may not use this file except in compliance with the License. | |
7 | * | |
8 | * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE | |
9 | * or http://www.opensolaris.org/os/licensing. | |
10 | * See the License for the specific language governing permissions | |
11 | * and limitations under the License. | |
12 | * | |
13 | * When distributing Covered Code, include this CDDL HEADER in each | |
14 | * file and include the License file at usr/src/OPENSOLARIS.LICENSE. | |
15 | * If applicable, add the following below this CDDL HEADER, with the | |
16 | * fields enclosed by brackets "[]" replaced with your own identifying | |
17 | * information: Portions Copyright [yyyy] [name of copyright owner] | |
18 | * | |
19 | * CDDL HEADER END | |
20 | */ | |
21 | ||
22 | /* | |
241b5415 | 23 | * Copyright (c) 2011, 2015 by Delphix. All rights reserved. |
9ae529ec CS |
24 | */ |
25 | ||
26 | #include <sys/zfs_context.h> | |
27 | #include <sys/zfeature.h> | |
28 | #include <sys/dmu.h> | |
29 | #include <sys/nvpair.h> | |
30 | #include <sys/zap.h> | |
31 | #include <sys/dmu_tx.h> | |
32 | #include "zfeature_common.h" | |
33 | #include <sys/spa_impl.h> | |
34 | ||
35 | /* | |
36 | * ZFS Feature Flags | |
37 | * ----------------- | |
38 | * | |
39 | * ZFS feature flags are used to provide fine-grained versioning to the ZFS | |
40 | * on-disk format. Once enabled on a pool feature flags replace the old | |
41 | * spa_version() number. | |
42 | * | |
43 | * Each new on-disk format change will be given a uniquely identifying string | |
44 | * guid rather than a version number. This avoids the problem of different | |
45 | * organizations creating new on-disk formats with the same version number. To | |
46 | * keep feature guids unique they should consist of the reverse dns name of the | |
47 | * organization which implemented the feature and a short name for the feature, | |
48 | * separated by a colon (e.g. com.delphix:async_destroy). | |
49 | * | |
50 | * Reference Counts | |
51 | * ---------------- | |
52 | * | |
53 | * Within each pool features can be in one of three states: disabled, enabled, | |
54 | * or active. These states are differentiated by a reference count stored on | |
55 | * disk for each feature: | |
56 | * | |
57 | * 1) If there is no reference count stored on disk the feature is disabled. | |
58 | * 2) If the reference count is 0 a system administrator has enabled the | |
59 | * feature, but the feature has not been used yet, so no on-disk | |
60 | * format changes have been made. | |
61 | * 3) If the reference count is greater than 0 the feature is active. | |
62 | * The format changes required by the feature are currently on disk. | |
63 | * Note that if the feature's format changes are reversed the feature | |
64 | * may choose to set its reference count back to 0. | |
65 | * | |
66 | * Feature flags makes no differentiation between non-zero reference counts | |
67 | * for an active feature (e.g. a reference count of 1 means the same thing as a | |
68 | * reference count of 27834721), but feature implementations may choose to use | |
69 | * the reference count to store meaningful information. For example, a new RAID | |
70 | * implementation might set the reference count to the number of vdevs using | |
71 | * it. If all those disks are removed from the pool the feature goes back to | |
72 | * having a reference count of 0. | |
73 | * | |
74 | * It is the responsibility of the individual features to maintain a non-zero | |
75 | * reference count as long as the feature's format changes are present on disk. | |
76 | * | |
77 | * Dependencies | |
78 | * ------------ | |
79 | * | |
80 | * Each feature may depend on other features. The only effect of this | |
81 | * relationship is that when a feature is enabled all of its dependencies are | |
82 | * automatically enabled as well. Any future work to support disabling of | |
83 | * features would need to ensure that features cannot be disabled if other | |
84 | * enabled features depend on them. | |
85 | * | |
86 | * On-disk Format | |
87 | * -------------- | |
88 | * | |
89 | * When feature flags are enabled spa_version() is set to SPA_VERSION_FEATURES | |
90 | * (5000). In order for this to work the pool is automatically upgraded to | |
91 | * SPA_VERSION_BEFORE_FEATURES (28) first, so all pre-feature flags on disk | |
92 | * format changes will be in use. | |
93 | * | |
94 | * Information about features is stored in 3 ZAP objects in the pool's MOS. | |
95 | * These objects are linked to by the following names in the pool directory | |
96 | * object: | |
97 | * | |
98 | * 1) features_for_read: feature guid -> reference count | |
99 | * Features needed to open the pool for reading. | |
100 | * 2) features_for_write: feature guid -> reference count | |
101 | * Features needed to open the pool for writing. | |
102 | * 3) feature_descriptions: feature guid -> descriptive string | |
103 | * A human readable string. | |
104 | * | |
105 | * All enabled features appear in either features_for_read or | |
106 | * features_for_write, but not both. | |
107 | * | |
108 | * To open a pool in read-only mode only the features listed in | |
109 | * features_for_read need to be supported. | |
110 | * | |
111 | * To open the pool in read-write mode features in both features_for_read and | |
112 | * features_for_write need to be supported. | |
113 | * | |
114 | * Some features may be required to read the ZAP objects containing feature | |
115 | * information. To allow software to check for compatibility with these features | |
116 | * before the pool is opened their names must be stored in the label in a | |
117 | * new "features_for_read" entry (note that features that are only required | |
118 | * to write to a pool never need to be stored in the label since the | |
119 | * features_for_write ZAP object can be read before the pool is written to). | |
120 | * To save space in the label features must be explicitly marked as needing to | |
121 | * be written to the label. Also, reference counts are not stored in the label, | |
122 | * instead any feature whose reference count drops to 0 is removed from the | |
123 | * label. | |
124 | * | |
125 | * Adding New Features | |
126 | * ------------------- | |
127 | * | |
128 | * Features must be registered in zpool_feature_init() function in | |
129 | * zfeature_common.c using the zfeature_register() function. This function | |
130 | * has arguments to specify if the feature should be stored in the | |
131 | * features_for_read or features_for_write ZAP object and if it needs to be | |
132 | * written to the label when active. | |
133 | * | |
134 | * Once a feature is registered it will appear as a "feature@<feature name>" | |
135 | * property which can be set by an administrator. Feature implementors should | |
136 | * use the spa_feature_is_enabled() and spa_feature_is_active() functions to | |
137 | * query the state of a feature and the spa_feature_incr() and | |
138 | * spa_feature_decr() functions to change an enabled feature's reference count. | |
139 | * Reference counts may only be updated in the syncing context. | |
140 | * | |
141 | * Features may not perform enable-time initialization. Instead, any such | |
142 | * initialization should occur when the feature is first used. This design | |
143 | * enforces that on-disk changes be made only when features are used. Code | |
144 | * should only check if a feature is enabled using spa_feature_is_enabled(), | |
145 | * not by relying on any feature specific metadata existing. If a feature is | |
146 | * enabled, but the feature's metadata is not on disk yet then it should be | |
147 | * created as needed. | |
148 | * | |
149 | * As an example, consider the com.delphix:async_destroy feature. This feature | |
150 | * relies on the existence of a bptree in the MOS that store blocks for | |
151 | * asynchronous freeing. This bptree is not created when async_destroy is | |
152 | * enabled. Instead, when a dataset is destroyed spa_feature_is_enabled() is | |
153 | * called to check if async_destroy is enabled. If it is and the bptree object | |
154 | * does not exist yet, the bptree object is created as part of the dataset | |
155 | * destroy and async_destroy's reference count is incremented to indicate it | |
156 | * has made an on-disk format change. Later, after the destroyed dataset's | |
157 | * blocks have all been asynchronously freed there is no longer any use for the | |
158 | * bptree object, so it is destroyed and async_destroy's reference count is | |
159 | * decremented back to 0 to indicate that it has undone its on-disk format | |
160 | * changes. | |
161 | */ | |
162 | ||
163 | typedef enum { | |
9ae529ec CS |
164 | FEATURE_ACTION_INCR, |
165 | FEATURE_ACTION_DECR, | |
166 | } feature_action_t; | |
167 | ||
168 | /* | |
fa86b5db | 169 | * Checks that the active features in the pool are supported by |
9ae529ec CS |
170 | * this software. Adds each unsupported feature (name -> description) to |
171 | * the supplied nvlist. | |
172 | */ | |
173 | boolean_t | |
fa86b5db | 174 | spa_features_check(spa_t *spa, boolean_t for_write, |
b9b24bb4 | 175 | nvlist_t *unsup_feat, nvlist_t *enabled_feat) |
9ae529ec | 176 | { |
fa86b5db | 177 | objset_t *os = spa->spa_meta_objset; |
9ae529ec CS |
178 | boolean_t supported; |
179 | zap_cursor_t *zc; | |
180 | zap_attribute_t *za; | |
fa86b5db MA |
181 | uint64_t obj = for_write ? |
182 | spa->spa_feat_for_write_obj : spa->spa_feat_for_read_obj; | |
9ae529ec CS |
183 | char *buf; |
184 | ||
d1d7e268 MK |
185 | zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP); |
186 | za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); | |
9ae529ec CS |
187 | buf = kmem_alloc(MAXPATHLEN, KM_SLEEP); |
188 | ||
189 | supported = B_TRUE; | |
190 | for (zap_cursor_init(zc, os, obj); | |
191 | zap_cursor_retrieve(zc, za) == 0; | |
192 | zap_cursor_advance(zc)) { | |
193 | ASSERT(za->za_integer_length == sizeof (uint64_t) && | |
194 | za->za_num_integers == 1); | |
195 | ||
b9b24bb4 CS |
196 | if (NULL != enabled_feat) { |
197 | fnvlist_add_uint64(enabled_feat, za->za_name, | |
198 | za->za_first_integer); | |
199 | } | |
200 | ||
9ae529ec CS |
201 | if (za->za_first_integer != 0 && |
202 | !zfeature_is_supported(za->za_name)) { | |
203 | supported = B_FALSE; | |
204 | ||
b9b24bb4 | 205 | if (NULL != unsup_feat) { |
9ae529ec CS |
206 | char *desc = ""; |
207 | ||
fa86b5db MA |
208 | if (zap_lookup(os, spa->spa_feat_desc_obj, |
209 | za->za_name, 1, MAXPATHLEN, buf) == 0) | |
9ae529ec CS |
210 | desc = buf; |
211 | ||
212 | VERIFY(nvlist_add_string(unsup_feat, | |
213 | za->za_name, desc) == 0); | |
214 | } | |
215 | } | |
216 | } | |
217 | zap_cursor_fini(zc); | |
218 | ||
219 | kmem_free(buf, MAXPATHLEN); | |
d1d7e268 MK |
220 | kmem_free(za, sizeof (zap_attribute_t)); |
221 | kmem_free(zc, sizeof (zap_cursor_t)); | |
9ae529ec CS |
222 | |
223 | return (supported); | |
224 | } | |
225 | ||
fa86b5db | 226 | /* |
b0bc7a84 MG |
227 | * Use an in-memory cache of feature refcounts for quick retrieval. |
228 | * | |
fa86b5db MA |
229 | * Note: well-designed features will not need to use this; they should |
230 | * use spa_feature_is_enabled() and spa_feature_is_active() instead. | |
417104bd | 231 | * However, this is non-static for zdb, zhack, and spa_add_feature_stats(). |
fa86b5db MA |
232 | */ |
233 | int | |
234 | feature_get_refcount(spa_t *spa, zfeature_info_t *feature, uint64_t *res) | |
b0bc7a84 MG |
235 | { |
236 | ASSERT(VALID_FEATURE_FID(feature->fi_feature)); | |
237 | if (spa->spa_feat_refcount_cache[feature->fi_feature] == | |
238 | SPA_FEATURE_DISABLED) { | |
239 | return (SET_ERROR(ENOTSUP)); | |
240 | } | |
241 | *res = spa->spa_feat_refcount_cache[feature->fi_feature]; | |
242 | return (0); | |
243 | } | |
244 | ||
245 | /* | |
246 | * Note: well-designed features will not need to use this; they should | |
247 | * use spa_feature_is_enabled() and spa_feature_is_active() instead. | |
248 | * However, this is non-static for zdb and zhack. | |
249 | */ | |
250 | int | |
251 | feature_get_refcount_from_disk(spa_t *spa, zfeature_info_t *feature, | |
252 | uint64_t *res) | |
9ae529ec CS |
253 | { |
254 | int err; | |
255 | uint64_t refcount; | |
241b5415 | 256 | uint64_t zapobj = (feature->fi_flags & ZFEATURE_FLAG_READONLY_COMPAT) ? |
fa86b5db | 257 | spa->spa_feat_for_write_obj : spa->spa_feat_for_read_obj; |
9ae529ec | 258 | |
753c3839 MA |
259 | /* |
260 | * If the pool is currently being created, the feature objects may not | |
261 | * have been allocated yet. Act as though all features are disabled. | |
262 | */ | |
263 | if (zapobj == 0) | |
2e528b49 | 264 | return (SET_ERROR(ENOTSUP)); |
9ae529ec | 265 | |
fa86b5db MA |
266 | err = zap_lookup(spa->spa_meta_objset, zapobj, |
267 | feature->fi_guid, sizeof (uint64_t), 1, &refcount); | |
9ae529ec CS |
268 | if (err != 0) { |
269 | if (err == ENOENT) | |
2e528b49 | 270 | return (SET_ERROR(ENOTSUP)); |
9ae529ec CS |
271 | else |
272 | return (err); | |
273 | } | |
274 | *res = refcount; | |
275 | return (0); | |
276 | } | |
277 | ||
b0bc7a84 MG |
278 | |
279 | static int | |
e9aa730c GM |
280 | feature_get_enabled_txg(spa_t *spa, zfeature_info_t *feature, uint64_t *res) |
281 | { | |
b0bc7a84 MG |
282 | ASSERTV(uint64_t enabled_txg_obj = spa->spa_feat_enabled_txg_obj); |
283 | ||
284 | ASSERT(zfeature_depends_on(feature->fi_feature, | |
285 | SPA_FEATURE_ENABLED_TXG)); | |
286 | ||
287 | if (!spa_feature_is_enabled(spa, feature->fi_feature)) { | |
288 | return (SET_ERROR(ENOTSUP)); | |
289 | } | |
290 | ||
291 | ASSERT(enabled_txg_obj != 0); | |
292 | ||
293 | VERIFY0(zap_lookup(spa->spa_meta_objset, spa->spa_feat_enabled_txg_obj, | |
294 | feature->fi_guid, sizeof (uint64_t), 1, res)); | |
295 | ||
296 | return (0); | |
297 | } | |
298 | ||
fa86b5db MA |
299 | /* |
300 | * This function is non-static for zhack; it should otherwise not be used | |
301 | * outside this file. | |
302 | */ | |
303 | void | |
304 | feature_sync(spa_t *spa, zfeature_info_t *feature, uint64_t refcount, | |
9ae529ec CS |
305 | dmu_tx_t *tx) |
306 | { | |
b0bc7a84 | 307 | uint64_t zapobj; |
fa86b5db | 308 | |
b0bc7a84 | 309 | ASSERT(VALID_FEATURE_OR_NONE(feature->fi_feature)); |
241b5415 | 310 | zapobj = (feature->fi_flags & ZFEATURE_FLAG_READONLY_COMPAT) ? |
b0bc7a84 | 311 | spa->spa_feat_for_write_obj : spa->spa_feat_for_read_obj; |
fa86b5db MA |
312 | VERIFY0(zap_update(spa->spa_meta_objset, zapobj, feature->fi_guid, |
313 | sizeof (uint64_t), 1, &refcount, tx)); | |
314 | ||
b0bc7a84 MG |
315 | /* |
316 | * feature_sync is called directly from zhack, allowing the | |
317 | * creation of arbitrary features whose fi_feature field may | |
318 | * be greater than SPA_FEATURES. When called from zhack, the | |
319 | * zfeature_info_t object's fi_feature field will be set to | |
320 | * SPA_FEATURE_NONE. | |
321 | */ | |
322 | if (feature->fi_feature != SPA_FEATURE_NONE) { | |
323 | uint64_t *refcount_cache = | |
324 | &spa->spa_feat_refcount_cache[feature->fi_feature]; | |
325 | VERIFY3U(*refcount_cache, ==, | |
326 | atomic_swap_64(refcount_cache, refcount)); | |
327 | } | |
328 | ||
fa86b5db MA |
329 | if (refcount == 0) |
330 | spa_deactivate_mos_feature(spa, feature->fi_guid); | |
241b5415 | 331 | else if (feature->fi_flags & ZFEATURE_FLAG_MOS) |
b0bc7a84 | 332 | spa_activate_mos_feature(spa, feature->fi_guid, tx); |
fa86b5db MA |
333 | } |
334 | ||
335 | /* | |
336 | * This function is non-static for zhack; it should otherwise not be used | |
337 | * outside this file. | |
338 | */ | |
339 | void | |
340 | feature_enable_sync(spa_t *spa, zfeature_info_t *feature, dmu_tx_t *tx) | |
341 | { | |
241b5415 MA |
342 | uint64_t initial_refcount = |
343 | (feature->fi_flags & ZFEATURE_FLAG_ACTIVATE_ON_ENABLE) ? 1 : 0; | |
344 | uint64_t zapobj = (feature->fi_flags & ZFEATURE_FLAG_READONLY_COMPAT) ? | |
fa86b5db MA |
345 | spa->spa_feat_for_write_obj : spa->spa_feat_for_read_obj; |
346 | int i; | |
9ae529ec CS |
347 | |
348 | ASSERT(0 != zapobj); | |
349 | ASSERT(zfeature_is_valid_guid(feature->fi_guid)); | |
fa86b5db | 350 | ASSERT3U(spa_version(spa), >=, SPA_VERSION_FEATURES); |
9ae529ec CS |
351 | |
352 | /* | |
fa86b5db | 353 | * If the feature is already enabled, ignore the request. |
9ae529ec | 354 | */ |
fa86b5db MA |
355 | if (zap_contains(spa->spa_meta_objset, zapobj, feature->fi_guid) == 0) |
356 | return; | |
357 | ||
358 | for (i = 0; feature->fi_depends[i] != SPA_FEATURE_NONE; i++) | |
359 | spa_feature_enable(spa, feature->fi_depends[i], tx); | |
360 | ||
361 | VERIFY0(zap_update(spa->spa_meta_objset, spa->spa_feat_desc_obj, | |
362 | feature->fi_guid, 1, strlen(feature->fi_desc) + 1, | |
363 | feature->fi_desc, tx)); | |
b0bc7a84 MG |
364 | |
365 | feature_sync(spa, feature, initial_refcount, tx); | |
366 | ||
367 | if (spa_feature_is_enabled(spa, SPA_FEATURE_ENABLED_TXG)) { | |
368 | uint64_t enabling_txg = dmu_tx_get_txg(tx); | |
369 | ||
370 | if (spa->spa_feat_enabled_txg_obj == 0ULL) { | |
371 | spa->spa_feat_enabled_txg_obj = | |
372 | zap_create_link(spa->spa_meta_objset, | |
373 | DMU_OTN_ZAP_METADATA, DMU_POOL_DIRECTORY_OBJECT, | |
374 | DMU_POOL_FEATURE_ENABLED_TXG, tx); | |
375 | } | |
376 | spa_feature_incr(spa, SPA_FEATURE_ENABLED_TXG, tx); | |
377 | ||
378 | VERIFY0(zap_add(spa->spa_meta_objset, | |
379 | spa->spa_feat_enabled_txg_obj, feature->fi_guid, | |
380 | sizeof (uint64_t), 1, &enabling_txg, tx)); | |
381 | } | |
fa86b5db MA |
382 | } |
383 | ||
384 | static void | |
385 | feature_do_action(spa_t *spa, spa_feature_t fid, feature_action_t action, | |
386 | dmu_tx_t *tx) | |
387 | { | |
b0bc7a84 | 388 | uint64_t refcount = 0; |
fa86b5db | 389 | zfeature_info_t *feature = &spa_feature_table[fid]; |
241b5415 MA |
390 | ASSERTV(uint64_t zapobj = |
391 | (feature->fi_flags & ZFEATURE_FLAG_READONLY_COMPAT) ? | |
b0bc7a84 | 392 | spa->spa_feat_for_write_obj : spa->spa_feat_for_read_obj); |
fa86b5db | 393 | |
b0bc7a84 | 394 | ASSERT(VALID_FEATURE_FID(fid)); |
fa86b5db MA |
395 | ASSERT(0 != zapobj); |
396 | ASSERT(zfeature_is_valid_guid(feature->fi_guid)); | |
397 | ||
398 | ASSERT(dmu_tx_is_syncing(tx)); | |
399 | ASSERT3U(spa_version(spa), >=, SPA_VERSION_FEATURES); | |
400 | ||
b0bc7a84 | 401 | VERIFY3U(feature_get_refcount(spa, feature, &refcount), !=, ENOTSUP); |
9ae529ec CS |
402 | |
403 | switch (action) { | |
9ae529ec | 404 | case FEATURE_ACTION_INCR: |
fa86b5db | 405 | VERIFY3U(refcount, !=, UINT64_MAX); |
9ae529ec CS |
406 | refcount++; |
407 | break; | |
408 | case FEATURE_ACTION_DECR: | |
fa86b5db | 409 | VERIFY3U(refcount, !=, 0); |
9ae529ec CS |
410 | refcount--; |
411 | break; | |
412 | default: | |
413 | ASSERT(0); | |
414 | break; | |
415 | } | |
416 | ||
fa86b5db | 417 | feature_sync(spa, feature, refcount, tx); |
9ae529ec CS |
418 | } |
419 | ||
420 | void | |
421 | spa_feature_create_zap_objects(spa_t *spa, dmu_tx_t *tx) | |
422 | { | |
423 | /* | |
424 | * We create feature flags ZAP objects in two instances: during pool | |
425 | * creation and during pool upgrade. | |
426 | */ | |
b5256303 TC |
427 | ASSERT((!spa->spa_sync_on && tx->tx_txg == TXG_INITIAL) || |
428 | dsl_pool_sync_context(spa_get_dsl(spa))); | |
9ae529ec CS |
429 | |
430 | spa->spa_feat_for_read_obj = zap_create_link(spa->spa_meta_objset, | |
431 | DMU_OTN_ZAP_METADATA, DMU_POOL_DIRECTORY_OBJECT, | |
432 | DMU_POOL_FEATURES_FOR_READ, tx); | |
433 | spa->spa_feat_for_write_obj = zap_create_link(spa->spa_meta_objset, | |
434 | DMU_OTN_ZAP_METADATA, DMU_POOL_DIRECTORY_OBJECT, | |
435 | DMU_POOL_FEATURES_FOR_WRITE, tx); | |
436 | spa->spa_feat_desc_obj = zap_create_link(spa->spa_meta_objset, | |
437 | DMU_OTN_ZAP_METADATA, DMU_POOL_DIRECTORY_OBJECT, | |
438 | DMU_POOL_FEATURE_DESCRIPTIONS, tx); | |
439 | } | |
440 | ||
441 | /* | |
442 | * Enable any required dependencies, then enable the requested feature. | |
443 | */ | |
444 | void | |
fa86b5db | 445 | spa_feature_enable(spa_t *spa, spa_feature_t fid, dmu_tx_t *tx) |
9ae529ec CS |
446 | { |
447 | ASSERT3U(spa_version(spa), >=, SPA_VERSION_FEATURES); | |
b0bc7a84 | 448 | ASSERT(VALID_FEATURE_FID(fid)); |
fa86b5db | 449 | feature_enable_sync(spa, &spa_feature_table[fid], tx); |
9ae529ec CS |
450 | } |
451 | ||
9ae529ec | 452 | void |
fa86b5db | 453 | spa_feature_incr(spa_t *spa, spa_feature_t fid, dmu_tx_t *tx) |
9ae529ec | 454 | { |
fa86b5db | 455 | feature_do_action(spa, fid, FEATURE_ACTION_INCR, tx); |
9ae529ec CS |
456 | } |
457 | ||
9ae529ec | 458 | void |
fa86b5db | 459 | spa_feature_decr(spa_t *spa, spa_feature_t fid, dmu_tx_t *tx) |
9ae529ec | 460 | { |
fa86b5db | 461 | feature_do_action(spa, fid, FEATURE_ACTION_DECR, tx); |
93cf2076 GW |
462 | } |
463 | ||
9ae529ec | 464 | boolean_t |
fa86b5db | 465 | spa_feature_is_enabled(spa_t *spa, spa_feature_t fid) |
9ae529ec CS |
466 | { |
467 | int err; | |
468 | uint64_t refcount = 0; | |
469 | ||
b0bc7a84 | 470 | ASSERT(VALID_FEATURE_FID(fid)); |
9ae529ec CS |
471 | if (spa_version(spa) < SPA_VERSION_FEATURES) |
472 | return (B_FALSE); | |
473 | ||
fa86b5db | 474 | err = feature_get_refcount(spa, &spa_feature_table[fid], &refcount); |
9ae529ec CS |
475 | ASSERT(err == 0 || err == ENOTSUP); |
476 | return (err == 0); | |
477 | } | |
478 | ||
479 | boolean_t | |
fa86b5db | 480 | spa_feature_is_active(spa_t *spa, spa_feature_t fid) |
9ae529ec CS |
481 | { |
482 | int err; | |
483 | uint64_t refcount = 0; | |
484 | ||
b0bc7a84 | 485 | ASSERT(VALID_FEATURE_FID(fid)); |
9ae529ec CS |
486 | if (spa_version(spa) < SPA_VERSION_FEATURES) |
487 | return (B_FALSE); | |
488 | ||
fa86b5db | 489 | err = feature_get_refcount(spa, &spa_feature_table[fid], &refcount); |
9ae529ec CS |
490 | ASSERT(err == 0 || err == ENOTSUP); |
491 | return (err == 0 && refcount > 0); | |
492 | } | |
b0bc7a84 MG |
493 | |
494 | /* | |
495 | * For the feature specified by fid (which must depend on | |
496 | * SPA_FEATURE_ENABLED_TXG), return the TXG at which it was enabled in the | |
497 | * OUT txg argument. | |
498 | * | |
499 | * Returns B_TRUE if the feature is enabled, in which case txg will be filled | |
500 | * with the transaction group in which the specified feature was enabled. | |
501 | * Returns B_FALSE otherwise (i.e. if the feature is not enabled). | |
502 | */ | |
503 | boolean_t | |
e9aa730c GM |
504 | spa_feature_enabled_txg(spa_t *spa, spa_feature_t fid, uint64_t *txg) |
505 | { | |
b0bc7a84 MG |
506 | int err; |
507 | ||
508 | ASSERT(VALID_FEATURE_FID(fid)); | |
509 | if (spa_version(spa) < SPA_VERSION_FEATURES) | |
510 | return (B_FALSE); | |
511 | ||
512 | err = feature_get_enabled_txg(spa, &spa_feature_table[fid], txg); | |
513 | ASSERT(err == 0 || err == ENOTSUP); | |
514 | ||
515 | return (err == 0); | |
516 | } |