1 // SPDX-License-Identifier: CDDL-1.0
2 /*
3 * CDDL HEADER START
4 *
5 * The contents of this file are subject to the terms of the
6 * Common Development and Distribution License (the "License").
7 * You may not use this file except in compliance with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or https://opensource.org/licenses/CDDL-1.0.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
25 * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
26 * Copyright (c) 2021, Colm Buckley <colm@tuatha.org>
27 * Copyright (c) 2021, 2023, Klara Inc.
28 */
29
30 #include <sys/zio.h>
31 #include <sys/spa.h>
32 #include <sys/zfs_acl.h>
33 #include <sys/zfs_ioctl.h>
34 #include <sys/fs/zfs.h>
35
36 #include "zfs_prop.h"
37
38 #if !defined(_KERNEL)
39 #include <stdlib.h>
40 #include <string.h>
41 #include <ctype.h>
42 #endif
43
44 static zprop_desc_t zpool_prop_table[ZPOOL_NUM_PROPS];
45 static zprop_desc_t vdev_prop_table[VDEV_NUM_PROPS];
46
47 zprop_desc_t *
zpool_prop_get_table(void)48 zpool_prop_get_table(void)
49 {
50 return (zpool_prop_table);
51 }
52
53 /* BEGIN CSTYLED */
54 #define zprop_register_mc_props_impl(mcp, uprefix, lprefix, sfeatures) ({ \
55 zprop_register_number(mcp + ZPOOL_MC_PROP_SIZE, \
56 #lprefix "_size", 0, PROP_READONLY, ZFS_TYPE_POOL, "<size>", \
57 #uprefix "_SIZE", B_FALSE, sfeatures); \
58 zprop_register_number(mcp + ZPOOL_MC_PROP_CAPACITY, \
59 #lprefix "_capacity", 0, PROP_READONLY, ZFS_TYPE_POOL, \
60 "<percent>", #uprefix "_CAP", B_FALSE, sfeatures); \
61 zprop_register_number(mcp + ZPOOL_MC_PROP_FREE, \
62 #lprefix "_free", 0, PROP_READONLY, ZFS_TYPE_POOL, "<size>", \
63 #uprefix "_FREE", B_FALSE, sfeatures); \
64 zprop_register_number(mcp + ZPOOL_MC_PROP_ALLOCATED, \
65 #lprefix "_allocated", 0, PROP_READONLY, ZFS_TYPE_POOL, "<size>", \
66 #uprefix "_ALLOC", B_FALSE, sfeatures); \
67 zprop_register_number(mcp + ZPOOL_MC_PROP_AVAILABLE, \
68 #lprefix "_available", 0, PROP_READONLY, ZFS_TYPE_POOL, "<size>", \
69 #uprefix "_AVAIL", B_FALSE, sfeatures); \
70 zprop_register_number(mcp + ZPOOL_MC_PROP_USABLE, \
71 #lprefix "_usable", 0, PROP_READONLY, ZFS_TYPE_POOL, "<size>", \
72 #uprefix "_USABLE", B_FALSE, sfeatures); \
73 zprop_register_number(mcp + ZPOOL_MC_PROP_USED, \
74 #lprefix "_used", 0, PROP_READONLY, ZFS_TYPE_POOL, "<size>", \
75 #uprefix "_USED", B_FALSE, sfeatures); \
76 zprop_register_number(mcp + ZPOOL_MC_PROP_EXPANDSZ, \
77 #lprefix "_expandsize", 0, PROP_READONLY, ZFS_TYPE_POOL, "<size>", \
78 #uprefix "_EXPANDSZ", B_FALSE, sfeatures); \
79 zprop_register_number(mcp + ZPOOL_MC_PROP_FRAGMENTATION, \
80 #lprefix "_fragmentation", 0, PROP_READONLY, ZFS_TYPE_POOL, \
81 "<percent>", #uprefix "_FRAG", B_FALSE, sfeatures); \
82 })
83 #define zprop_register_mc_props(uclass, lclass, sfeatures) \
84 zprop_register_mc_props_impl(ZPOOL_MC_PROPS_##uclass, \
85 CLASS_##uclass, class_##lclass, sfeatures)
86 /* END CSTYLED */
87
88 void
zpool_prop_init(void)89 zpool_prop_init(void)
90 {
91 static const zprop_index_t boolean_table[] = {
92 { "off", 0},
93 { "on", 1},
94 { NULL }
95 };
96
97 static const zprop_index_t failuremode_table[] = {
98 { "wait", ZIO_FAILURE_MODE_WAIT },
99 { "continue", ZIO_FAILURE_MODE_CONTINUE },
100 { "panic", ZIO_FAILURE_MODE_PANIC },
101 { NULL }
102 };
103
104 struct zfs_mod_supported_features *sfeatures =
105 zfs_mod_list_supported(ZFS_SYSFS_POOL_PROPERTIES);
106
107 /* string properties */
108 zprop_register_string(ZPOOL_PROP_ALTROOT, "altroot", NULL, PROP_DEFAULT,
109 ZFS_TYPE_POOL, "<path>", "ALTROOT", sfeatures);
110 zprop_register_string(ZPOOL_PROP_BOOTFS, "bootfs", NULL, PROP_DEFAULT,
111 ZFS_TYPE_POOL, "<filesystem>", "BOOTFS", sfeatures);
112 zprop_register_string(ZPOOL_PROP_CACHEFILE, "cachefile", NULL,
113 PROP_DEFAULT, ZFS_TYPE_POOL, "<file> | none", "CACHEFILE",
114 sfeatures);
115 zprop_register_string(ZPOOL_PROP_COMMENT, "comment", NULL,
116 PROP_DEFAULT, ZFS_TYPE_POOL, "<comment-string>", "COMMENT",
117 sfeatures);
118 zprop_register_string(ZPOOL_PROP_COMPATIBILITY, "compatibility",
119 "off", PROP_DEFAULT, ZFS_TYPE_POOL,
120 "<file[,file...]> | off | legacy", "COMPATIBILITY", sfeatures);
121
122 /* readonly number properties */
123 zprop_register_number(ZPOOL_PROP_SIZE, "size", 0, PROP_READONLY,
124 ZFS_TYPE_POOL, "<size>", "SIZE", B_FALSE, sfeatures);
125 zprop_register_number(ZPOOL_PROP_FREE, "free", 0, PROP_READONLY,
126 ZFS_TYPE_POOL, "<size>", "FREE", B_FALSE, sfeatures);
127 zprop_register_number(ZPOOL_PROP_FREEING, "freeing", 0, PROP_READONLY,
128 ZFS_TYPE_POOL, "<size>", "FREEING", B_FALSE, sfeatures);
129 zprop_register_number(ZPOOL_PROP_CHECKPOINT, "checkpoint", 0,
130 PROP_READONLY, ZFS_TYPE_POOL, "<size>", "CKPOINT", B_FALSE,
131 sfeatures);
132 zprop_register_number(ZPOOL_PROP_LEAKED, "leaked", 0, PROP_READONLY,
133 ZFS_TYPE_POOL, "<size>", "LEAKED", B_FALSE, sfeatures);
134 zprop_register_number(ZPOOL_PROP_ALLOCATED, "allocated", 0,
135 PROP_READONLY, ZFS_TYPE_POOL, "<size>", "ALLOC", B_FALSE,
136 sfeatures);
137 zprop_register_number(ZPOOL_PROP_EXPANDSZ, "expandsize", 0,
138 PROP_READONLY, ZFS_TYPE_POOL, "<size>", "EXPANDSZ", B_FALSE,
139 sfeatures);
140 zprop_register_number(ZPOOL_PROP_FRAGMENTATION, "fragmentation", 0,
141 PROP_READONLY, ZFS_TYPE_POOL, "<percent>", "FRAG", B_FALSE,
142 sfeatures);
143 zprop_register_number(ZPOOL_PROP_CAPACITY, "capacity", 0, PROP_READONLY,
144 ZFS_TYPE_POOL, "<percent>", "CAP", B_FALSE, sfeatures);
145 zprop_register_number(ZPOOL_PROP_GUID, "guid", 0, PROP_READONLY,
146 ZFS_TYPE_POOL, "<guid>", "GUID", B_TRUE, sfeatures);
147 zprop_register_number(ZPOOL_PROP_LOAD_GUID, "load_guid", 0,
148 PROP_READONLY, ZFS_TYPE_POOL, "<load_guid>", "LOAD_GUID",
149 B_TRUE, sfeatures);
150 zprop_register_number(ZPOOL_PROP_HEALTH, "health", 0, PROP_READONLY,
151 ZFS_TYPE_POOL, "<state>", "HEALTH", B_FALSE, sfeatures);
152 zprop_register_number(ZPOOL_PROP_DEDUPRATIO, "dedupratio", 0,
153 PROP_READONLY, ZFS_TYPE_POOL, "<1.00x or higher if deduped>",
154 "DEDUP", B_FALSE, sfeatures);
155 zprop_register_number(ZPOOL_PROP_DEDUPUSED, "dedupused", 0,
156 PROP_READONLY, ZFS_TYPE_POOL, "<size>",
157 "DEDUP_USED", B_FALSE, sfeatures);
158 zprop_register_number(ZPOOL_PROP_DEDUPSAVED, "dedupsaved", 0,
159 PROP_READONLY, ZFS_TYPE_POOL, "<size>",
160 "DEDUP_SAVED", B_FALSE, sfeatures);
161 zprop_register_number(ZPOOL_PROP_BCLONEUSED, "bcloneused", 0,
162 PROP_READONLY, ZFS_TYPE_POOL, "<size>",
163 "BCLONE_USED", B_FALSE, sfeatures);
164 zprop_register_number(ZPOOL_PROP_BCLONESAVED, "bclonesaved", 0,
165 PROP_READONLY, ZFS_TYPE_POOL, "<size>",
166 "BCLONE_SAVED", B_FALSE, sfeatures);
167 zprop_register_number(ZPOOL_PROP_BCLONERATIO, "bcloneratio", 0,
168 PROP_READONLY, ZFS_TYPE_POOL, "<1.00x or higher if cloned>",
169 "BCLONE_RATIO", B_FALSE, sfeatures);
170 zprop_register_number(ZPOOL_PROP_DEDUP_TABLE_SIZE, "dedup_table_size",
171 0, PROP_READONLY, ZFS_TYPE_POOL, "<size>", "DDTSIZE", B_FALSE,
172 sfeatures);
173 zprop_register_number(ZPOOL_PROP_LAST_SCRUBBED_TXG,
174 "last_scrubbed_txg", 0, PROP_READONLY, ZFS_TYPE_POOL, "<txg>",
175 "LAST_SCRUBBED_TXG", B_FALSE, sfeatures);
176 zprop_register_number(ZPOOL_PROP_AVAILABLE, "available", 0,
177 PROP_READONLY, ZFS_TYPE_POOL, "<size>", "AVAIL", B_FALSE,
178 sfeatures);
179 zprop_register_number(ZPOOL_PROP_USABLE, "usable", 0, PROP_READONLY,
180 ZFS_TYPE_POOL, "<size>", "USABLE", B_FALSE, sfeatures);
181 zprop_register_number(ZPOOL_PROP_USED, "used", 0, PROP_READONLY,
182 ZFS_TYPE_POOL, "<size>", "USED", B_FALSE, sfeatures);
183
184 zprop_register_mc_props(NORMAL, normal, sfeatures);
185 zprop_register_mc_props(SPECIAL, special, sfeatures);
186 zprop_register_mc_props(DEDUP, dedup, sfeatures);
187 zprop_register_mc_props(LOG, log, sfeatures);
188 zprop_register_mc_props(ELOG, elog, sfeatures);
189 zprop_register_mc_props(SELOG, special_elog, sfeatures);
190
191 /* default number properties */
192 zprop_register_number(ZPOOL_PROP_VERSION, "version", SPA_VERSION,
193 PROP_DEFAULT, ZFS_TYPE_POOL, "<version>", "VERSION", B_FALSE,
194 sfeatures);
195 zprop_register_number(ZPOOL_PROP_ASHIFT, "ashift", 0, PROP_DEFAULT,
196 ZFS_TYPE_POOL, "<ashift, 9-16, or 0=default>", "ASHIFT", B_FALSE,
197 sfeatures);
198 zprop_register_number(ZPOOL_PROP_DEDUP_TABLE_QUOTA, "dedup_table_quota",
199 UINT64_MAX, PROP_DEFAULT, ZFS_TYPE_POOL, "<size>", "DDTQUOTA",
200 B_FALSE, sfeatures);
201
202 /* default index (boolean) properties */
203 zprop_register_index(ZPOOL_PROP_DELEGATION, "delegation", 1,
204 PROP_DEFAULT, ZFS_TYPE_POOL, "on | off", "DELEGATION",
205 boolean_table, sfeatures);
206 zprop_register_index(ZPOOL_PROP_AUTOREPLACE, "autoreplace", 0,
207 PROP_DEFAULT, ZFS_TYPE_POOL, "on | off", "REPLACE", boolean_table,
208 sfeatures);
209 zprop_register_index(ZPOOL_PROP_LISTSNAPS, "listsnapshots", 0,
210 PROP_DEFAULT, ZFS_TYPE_POOL, "on | off", "LISTSNAPS",
211 boolean_table, sfeatures);
212 zprop_register_index(ZPOOL_PROP_AUTOEXPAND, "autoexpand", 0,
213 PROP_DEFAULT, ZFS_TYPE_POOL, "on | off", "EXPAND", boolean_table,
214 sfeatures);
215 zprop_register_index(ZPOOL_PROP_READONLY, "readonly", 0,
216 PROP_DEFAULT, ZFS_TYPE_POOL, "on | off", "RDONLY", boolean_table,
217 sfeatures);
218 zprop_register_index(ZPOOL_PROP_MULTIHOST, "multihost", 0,
219 PROP_DEFAULT, ZFS_TYPE_POOL, "on | off", "MULTIHOST",
220 boolean_table, sfeatures);
221
222 /* default index properties */
223 zprop_register_index(ZPOOL_PROP_FAILUREMODE, "failmode",
224 ZIO_FAILURE_MODE_WAIT, PROP_DEFAULT, ZFS_TYPE_POOL,
225 "wait | continue | panic", "FAILMODE", failuremode_table,
226 sfeatures);
227 zprop_register_index(ZPOOL_PROP_AUTOTRIM, "autotrim",
228 SPA_AUTOTRIM_OFF, PROP_DEFAULT, ZFS_TYPE_POOL,
229 "on | off", "AUTOTRIM", boolean_table, sfeatures);
230
231 /* hidden properties */
232 zprop_register_hidden(ZPOOL_PROP_NAME, "name", PROP_TYPE_STRING,
233 PROP_READONLY, ZFS_TYPE_POOL, "NAME", B_TRUE, sfeatures);
234 zprop_register_hidden(ZPOOL_PROP_MAXBLOCKSIZE, "maxblocksize",
235 PROP_TYPE_NUMBER, PROP_READONLY, ZFS_TYPE_POOL, "MAXBLOCKSIZE",
236 B_FALSE, sfeatures);
237 zprop_register_hidden(ZPOOL_PROP_TNAME, "tname", PROP_TYPE_STRING,
238 PROP_ONETIME, ZFS_TYPE_POOL, "TNAME", B_TRUE, sfeatures);
239 zprop_register_hidden(ZPOOL_PROP_MAXDNODESIZE, "maxdnodesize",
240 PROP_TYPE_NUMBER, PROP_READONLY, ZFS_TYPE_POOL, "MAXDNODESIZE",
241 B_FALSE, sfeatures);
242 zprop_register_hidden(ZPOOL_PROP_DEDUPDITTO, "dedupditto",
243 PROP_TYPE_NUMBER, PROP_DEFAULT, ZFS_TYPE_POOL, "DEDUPDITTO",
244 B_FALSE, sfeatures);
245 zprop_register_hidden(ZPOOL_PROP_DEDUPCACHED,
246 ZPOOL_DEDUPCACHED_PROP_NAME, PROP_TYPE_NUMBER, PROP_READONLY,
247 ZFS_TYPE_POOL, "DEDUPCACHED", B_FALSE, sfeatures);
248
249 zfs_mod_list_supported_free(sfeatures);
250 }
251
252 /*
253 * Given a property name and its type, returns the corresponding property ID.
254 */
255 zpool_prop_t
zpool_name_to_prop(const char * propname)256 zpool_name_to_prop(const char *propname)
257 {
258 return (zprop_name_to_prop(propname, ZFS_TYPE_POOL));
259 }
260
261 /*
262 * Given a pool property ID, returns the corresponding name.
263 * Assuming the pool property ID is valid.
264 */
265 const char *
zpool_prop_to_name(zpool_prop_t prop)266 zpool_prop_to_name(zpool_prop_t prop)
267 {
268 return (zpool_prop_table[prop].pd_name);
269 }
270
271 zprop_type_t
zpool_prop_get_type(zpool_prop_t prop)272 zpool_prop_get_type(zpool_prop_t prop)
273 {
274 return (zpool_prop_table[prop].pd_proptype);
275 }
276
277 boolean_t
zpool_prop_readonly(zpool_prop_t prop)278 zpool_prop_readonly(zpool_prop_t prop)
279 {
280 return (zpool_prop_table[prop].pd_attr == PROP_READONLY);
281 }
282
283 boolean_t
zpool_prop_setonce(zpool_prop_t prop)284 zpool_prop_setonce(zpool_prop_t prop)
285 {
286 return (zpool_prop_table[prop].pd_attr == PROP_ONETIME);
287 }
288
289 const char *
zpool_prop_default_string(zpool_prop_t prop)290 zpool_prop_default_string(zpool_prop_t prop)
291 {
292 return (zpool_prop_table[prop].pd_strdefault);
293 }
294
295 uint64_t
zpool_prop_default_numeric(zpool_prop_t prop)296 zpool_prop_default_numeric(zpool_prop_t prop)
297 {
298 return (zpool_prop_table[prop].pd_numdefault);
299 }
300
301 /*
302 * Returns true if this is a valid feature@ property.
303 */
304 boolean_t
zpool_prop_feature(const char * name)305 zpool_prop_feature(const char *name)
306 {
307 static const char *prefix = "feature@";
308 return (strncmp(name, prefix, strlen(prefix)) == 0);
309 }
310
311 /*
312 * Returns true if this is a valid unsupported@ property.
313 */
314 boolean_t
zpool_prop_unsupported(const char * name)315 zpool_prop_unsupported(const char *name)
316 {
317 static const char *prefix = "unsupported@";
318 return (strncmp(name, prefix, strlen(prefix)) == 0);
319 }
320
321 int
zpool_prop_string_to_index(zpool_prop_t prop,const char * string,uint64_t * index)322 zpool_prop_string_to_index(zpool_prop_t prop, const char *string,
323 uint64_t *index)
324 {
325 return (zprop_string_to_index(prop, string, index, ZFS_TYPE_POOL));
326 }
327
328 int
zpool_prop_index_to_string(zpool_prop_t prop,uint64_t index,const char ** string)329 zpool_prop_index_to_string(zpool_prop_t prop, uint64_t index,
330 const char **string)
331 {
332 return (zprop_index_to_string(prop, index, string, ZFS_TYPE_POOL));
333 }
334
335 uint64_t
zpool_prop_random_value(zpool_prop_t prop,uint64_t seed)336 zpool_prop_random_value(zpool_prop_t prop, uint64_t seed)
337 {
338 return (zprop_random_value(prop, seed, ZFS_TYPE_POOL));
339 }
340
341 #ifndef _KERNEL
342 #include <libzfs.h>
343
344 const char *
zpool_prop_values(zpool_prop_t prop)345 zpool_prop_values(zpool_prop_t prop)
346 {
347 return (zpool_prop_table[prop].pd_values);
348 }
349
350 const char *
zpool_prop_column_name(zpool_prop_t prop)351 zpool_prop_column_name(zpool_prop_t prop)
352 {
353 return (zpool_prop_table[prop].pd_colname);
354 }
355
356 boolean_t
zpool_prop_align_right(zpool_prop_t prop)357 zpool_prop_align_right(zpool_prop_t prop)
358 {
359 return (zpool_prop_table[prop].pd_rightalign);
360 }
361 #endif
362
363 zprop_desc_t *
vdev_prop_get_table(void)364 vdev_prop_get_table(void)
365 {
366 return (vdev_prop_table);
367 }
368
369 void
vdev_prop_init(void)370 vdev_prop_init(void)
371 {
372 static const zprop_index_t boolean_table[] = {
373 { "off", 0},
374 { "on", 1},
375 { NULL }
376 };
377 static const zprop_index_t boolean_na_table[] = {
378 { "off", 0},
379 { "on", 1},
380 { "-", 2}, /* ZPROP_BOOLEAN_NA */
381 { NULL }
382 };
383
384 static const zprop_index_t vdevschedulertype_table[] = {
385 { "auto", VDEV_SCHEDULER_AUTO },
386 { "on", VDEV_SCHEDULER_ON },
387 { "off", VDEV_SCHEDULER_OFF },
388 { NULL }
389 };
390
391 struct zfs_mod_supported_features *sfeatures =
392 zfs_mod_list_supported(ZFS_SYSFS_VDEV_PROPERTIES);
393
394 /* string properties */
395 zprop_register_string(VDEV_PROP_COMMENT, "comment", NULL,
396 PROP_DEFAULT, ZFS_TYPE_VDEV, "<comment-string>", "COMMENT",
397 sfeatures);
398 zprop_register_string(VDEV_PROP_PATH, "path", NULL,
399 PROP_DEFAULT, ZFS_TYPE_VDEV, "<device-path>", "PATH", sfeatures);
400 zprop_register_string(VDEV_PROP_DEVID, "devid", NULL,
401 PROP_READONLY, ZFS_TYPE_VDEV, "<devid>", "DEVID", sfeatures);
402 zprop_register_string(VDEV_PROP_PHYS_PATH, "physpath", NULL,
403 PROP_READONLY, ZFS_TYPE_VDEV, "<physpath>", "PHYSPATH", sfeatures);
404 zprop_register_string(VDEV_PROP_ENC_PATH, "encpath", NULL,
405 PROP_READONLY, ZFS_TYPE_VDEV, "<encpath>", "ENCPATH", sfeatures);
406 zprop_register_string(VDEV_PROP_FRU, "fru", NULL,
407 PROP_READONLY, ZFS_TYPE_VDEV, "<fru>", "FRU", sfeatures);
408 zprop_register_string(VDEV_PROP_PARENT, "parent", NULL,
409 PROP_READONLY, ZFS_TYPE_VDEV, "<parent>", "PARENT", sfeatures);
410 zprop_register_string(VDEV_PROP_CHILDREN, "children", NULL,
411 PROP_READONLY, ZFS_TYPE_VDEV, "<child[,...]>", "CHILDREN",
412 sfeatures);
413
414 /* readonly number properties */
415 zprop_register_number(VDEV_PROP_SIZE, "size", 0, PROP_READONLY,
416 ZFS_TYPE_VDEV, "<size>", "SIZE", B_FALSE, sfeatures);
417 zprop_register_number(VDEV_PROP_FREE, "free", 0, PROP_READONLY,
418 ZFS_TYPE_VDEV, "<size>", "FREE", B_FALSE, sfeatures);
419 zprop_register_number(VDEV_PROP_ALLOCATED, "allocated", 0,
420 PROP_READONLY, ZFS_TYPE_VDEV, "<size>", "ALLOC", B_FALSE,
421 sfeatures);
422 zprop_register_number(VDEV_PROP_EXPANDSZ, "expandsize", 0,
423 PROP_READONLY, ZFS_TYPE_VDEV, "<size>", "EXPANDSZ", B_FALSE,
424 sfeatures);
425 zprop_register_number(VDEV_PROP_FRAGMENTATION, "fragmentation", 0,
426 PROP_READONLY, ZFS_TYPE_VDEV, "<percent>", "FRAG", B_FALSE,
427 sfeatures);
428 zprop_register_number(VDEV_PROP_CAPACITY, "capacity", 0, PROP_READONLY,
429 ZFS_TYPE_VDEV, "<percent>", "CAP", B_FALSE, sfeatures);
430 zprop_register_number(VDEV_PROP_GUID, "guid", 0, PROP_READONLY,
431 ZFS_TYPE_VDEV, "<guid>", "GUID", B_TRUE, sfeatures);
432 zprop_register_number(VDEV_PROP_STATE, "state", 0, PROP_READONLY,
433 ZFS_TYPE_VDEV, "<state>", "STATE", B_FALSE, sfeatures);
434 zprop_register_number(VDEV_PROP_BOOTSIZE, "bootsize", 0, PROP_READONLY,
435 ZFS_TYPE_VDEV, "<size>", "BOOTSIZE", B_FALSE, sfeatures);
436 zprop_register_number(VDEV_PROP_ASIZE, "asize", 0, PROP_READONLY,
437 ZFS_TYPE_VDEV, "<asize>", "ASIZE", B_FALSE, sfeatures);
438 zprop_register_number(VDEV_PROP_PSIZE, "psize", 0, PROP_READONLY,
439 ZFS_TYPE_VDEV, "<psize>", "PSIZE", B_FALSE, sfeatures);
440 zprop_register_number(VDEV_PROP_ASHIFT, "ashift", 0, PROP_READONLY,
441 ZFS_TYPE_VDEV, "<ashift>", "ASHIFT", B_FALSE, sfeatures);
442 zprop_register_number(VDEV_PROP_PARITY, "parity", 0, PROP_READONLY,
443 ZFS_TYPE_VDEV, "<parity>", "PARITY", B_FALSE, sfeatures);
444 zprop_register_number(VDEV_PROP_NUMCHILDREN, "numchildren", 0,
445 PROP_READONLY, ZFS_TYPE_VDEV, "<number-of-children>", "NUMCHILD",
446 B_FALSE, sfeatures);
447 zprop_register_number(VDEV_PROP_READ_ERRORS, "read_errors", 0,
448 PROP_READONLY, ZFS_TYPE_VDEV, "<errors>", "RDERR", B_FALSE,
449 sfeatures);
450 zprop_register_number(VDEV_PROP_WRITE_ERRORS, "write_errors", 0,
451 PROP_READONLY, ZFS_TYPE_VDEV, "<errors>", "WRERR", B_FALSE,
452 sfeatures);
453 zprop_register_number(VDEV_PROP_CHECKSUM_ERRORS, "checksum_errors", 0,
454 PROP_READONLY, ZFS_TYPE_VDEV, "<errors>", "CKERR", B_FALSE,
455 sfeatures);
456 zprop_register_number(VDEV_PROP_INITIALIZE_ERRORS,
457 "initialize_errors", 0, PROP_READONLY, ZFS_TYPE_VDEV, "<errors>",
458 "INITERR", B_FALSE, sfeatures);
459 zprop_register_number(VDEV_PROP_TRIM_ERRORS, "trim_errors", 0,
460 PROP_READONLY, ZFS_TYPE_VDEV, "<errors>", "TRIMERR", B_FALSE,
461 sfeatures);
462 zprop_register_number(VDEV_PROP_SLOW_IOS, "slow_ios", 0,
463 PROP_READONLY, ZFS_TYPE_VDEV, "<slowios>", "SLOW", B_FALSE,
464 sfeatures);
465 zprop_register_number(VDEV_PROP_OPS_NULL, "null_ops", 0,
466 PROP_READONLY, ZFS_TYPE_VDEV, "<operations>", "NULLOP", B_FALSE,
467 sfeatures);
468 zprop_register_number(VDEV_PROP_OPS_READ, "read_ops", 0,
469 PROP_READONLY, ZFS_TYPE_VDEV, "<operations>", "READOP", B_FALSE,
470 sfeatures);
471 zprop_register_number(VDEV_PROP_OPS_WRITE, "write_ops", 0,
472 PROP_READONLY, ZFS_TYPE_VDEV, "<operations>", "WRITEOP", B_FALSE,
473 sfeatures);
474 zprop_register_number(VDEV_PROP_OPS_FREE, "free_ops", 0,
475 PROP_READONLY, ZFS_TYPE_VDEV, "<operations>", "FREEOP", B_FALSE,
476 sfeatures);
477 zprop_register_number(VDEV_PROP_OPS_CLAIM, "claim_ops", 0,
478 PROP_READONLY, ZFS_TYPE_VDEV, "<operations>", "CLAIMOP", B_FALSE,
479 sfeatures);
480 zprop_register_number(VDEV_PROP_OPS_TRIM, "trim_ops", 0,
481 PROP_READONLY, ZFS_TYPE_VDEV, "<operations>", "TRIMOP", B_FALSE,
482 sfeatures);
483 zprop_register_number(VDEV_PROP_BYTES_NULL, "null_bytes", 0,
484 PROP_READONLY, ZFS_TYPE_VDEV, "<bytes>", "NULLBYTE", B_FALSE,
485 sfeatures);
486 zprop_register_number(VDEV_PROP_BYTES_READ, "read_bytes", 0,
487 PROP_READONLY, ZFS_TYPE_VDEV, "<bytes>", "READBYTE", B_FALSE,
488 sfeatures);
489 zprop_register_number(VDEV_PROP_BYTES_WRITE, "write_bytes", 0,
490 PROP_READONLY, ZFS_TYPE_VDEV, "<bytes>", "WRITEBYTE", B_FALSE,
491 sfeatures);
492 zprop_register_number(VDEV_PROP_BYTES_FREE, "free_bytes", 0,
493 PROP_READONLY, ZFS_TYPE_VDEV, "<bytes>", "FREEBYTE", B_FALSE,
494 sfeatures);
495 zprop_register_number(VDEV_PROP_BYTES_CLAIM, "claim_bytes", 0,
496 PROP_READONLY, ZFS_TYPE_VDEV, "<bytes>", "CLAIMBYTE", B_FALSE,
497 sfeatures);
498 zprop_register_number(VDEV_PROP_BYTES_TRIM, "trim_bytes", 0,
499 PROP_READONLY, ZFS_TYPE_VDEV, "<bytes>", "TRIMBYTE", B_FALSE,
500 sfeatures);
501
502 /* default numeric properties */
503 zprop_register_number(VDEV_PROP_CHECKSUM_N, "checksum_n", UINT64_MAX,
504 PROP_DEFAULT, ZFS_TYPE_VDEV, "<events>", "CKSUM_N", B_FALSE,
505 sfeatures);
506 zprop_register_number(VDEV_PROP_CHECKSUM_T, "checksum_t", UINT64_MAX,
507 PROP_DEFAULT, ZFS_TYPE_VDEV, "<seconds>", "CKSUM_T", B_FALSE,
508 sfeatures);
509 zprop_register_number(VDEV_PROP_IO_N, "io_n", UINT64_MAX,
510 PROP_DEFAULT, ZFS_TYPE_VDEV, "<events>", "IO_N", B_FALSE,
511 sfeatures);
512 zprop_register_number(VDEV_PROP_IO_T, "io_t", UINT64_MAX,
513 PROP_DEFAULT, ZFS_TYPE_VDEV, "<seconds>", "IO_T", B_FALSE,
514 sfeatures);
515 zprop_register_number(VDEV_PROP_SLOW_IO_N, "slow_io_n", UINT64_MAX,
516 PROP_DEFAULT, ZFS_TYPE_VDEV, "<events>", "SLOW_IO_N", B_FALSE,
517 sfeatures);
518 zprop_register_number(VDEV_PROP_SLOW_IO_T, "slow_io_t", UINT64_MAX,
519 PROP_DEFAULT, ZFS_TYPE_VDEV, "<seconds>", "SLOW_IO_T", B_FALSE,
520 sfeatures);
521
522 /* default index (boolean) properties */
523 zprop_register_index(VDEV_PROP_REMOVING, "removing", 0,
524 PROP_READONLY, ZFS_TYPE_VDEV, "on | off", "REMOVING",
525 boolean_table, sfeatures);
526 zprop_register_index(VDEV_PROP_ALLOCATING, "allocating", 1,
527 PROP_DEFAULT, ZFS_TYPE_VDEV, "on | off", "ALLOCATING",
528 boolean_na_table, sfeatures);
529 zprop_register_index(VDEV_PROP_RAIDZ_EXPANDING, "raidz_expanding", 0,
530 PROP_READONLY, ZFS_TYPE_VDEV, "on | off", "RAIDZ_EXPANDING",
531 boolean_table, sfeatures);
532 zprop_register_index(VDEV_PROP_SIT_OUT, "sit_out", 0,
533 PROP_DEFAULT, ZFS_TYPE_VDEV, "on | off", "SIT_OUT", boolean_table,
534 sfeatures);
535 zprop_register_index(VDEV_PROP_TRIM_SUPPORT, "trim_support", 0,
536 PROP_READONLY, ZFS_TYPE_VDEV, "on | off", "TRIMSUP",
537 boolean_table, sfeatures);
538 zprop_register_index(VDEV_PROP_AUTOSIT, "autosit", 0,
539 PROP_DEFAULT, ZFS_TYPE_VDEV, "on | off", "AUTOSIT", boolean_table,
540 sfeatures);
541
542 /* default index properties */
543 zprop_register_index(VDEV_PROP_FAILFAST, "failfast", B_TRUE,
544 PROP_DEFAULT, ZFS_TYPE_VDEV, "on | off", "FAILFAST", boolean_table,
545 sfeatures);
546 zprop_register_index(VDEV_PROP_SLOW_IO_EVENTS, "slow_io_events",
547 B_TRUE, PROP_DEFAULT, ZFS_TYPE_VDEV, "on | off",
548 "SLOW_IO_EVENTS", boolean_table, sfeatures);
549 zprop_register_index(VDEV_PROP_SCHEDULER, "scheduler",
550 VDEV_SCHEDULER_AUTO, PROP_DEFAULT, ZFS_TYPE_VDEV,
551 "auto | on | off", "IO_SCHEDULER",
552 vdevschedulertype_table, sfeatures);
553
554 /* hidden properties */
555 zprop_register_hidden(VDEV_PROP_NAME, "name", PROP_TYPE_STRING,
556 PROP_READONLY, ZFS_TYPE_VDEV, "NAME", B_TRUE, sfeatures);
557
558 zfs_mod_list_supported_free(sfeatures);
559 }
560
561 /*
562 * Given a property name and its type, returns the corresponding property ID.
563 */
564 vdev_prop_t
vdev_name_to_prop(const char * propname)565 vdev_name_to_prop(const char *propname)
566 {
567 return (zprop_name_to_prop(propname, ZFS_TYPE_VDEV));
568 }
569
570 /*
571 * Returns true if this is a valid user-defined property (one with a ':').
572 */
573 boolean_t
vdev_prop_user(const char * name)574 vdev_prop_user(const char *name)
575 {
576 int i, len;
577 char c;
578 boolean_t foundsep = B_FALSE;
579
580 len = strlen(name);
581 for (i = 0; i < len; i++) {
582 c = name[i];
583 if (!zprop_valid_char(c))
584 return (B_FALSE);
585 if (c == ':')
586 foundsep = B_TRUE;
587 }
588
589 return (foundsep);
590 }
591
592 /*
593 * Given a pool property ID, returns the corresponding name.
594 * Assuming the pool property ID is valid.
595 */
596 const char *
vdev_prop_to_name(vdev_prop_t prop)597 vdev_prop_to_name(vdev_prop_t prop)
598 {
599 return (vdev_prop_table[prop].pd_name);
600 }
601
602 zprop_type_t
vdev_prop_get_type(vdev_prop_t prop)603 vdev_prop_get_type(vdev_prop_t prop)
604 {
605 return (vdev_prop_table[prop].pd_proptype);
606 }
607
608 boolean_t
vdev_prop_readonly(vdev_prop_t prop)609 vdev_prop_readonly(vdev_prop_t prop)
610 {
611 return (vdev_prop_table[prop].pd_attr == PROP_READONLY);
612 }
613
614 const char *
vdev_prop_default_string(vdev_prop_t prop)615 vdev_prop_default_string(vdev_prop_t prop)
616 {
617 return (vdev_prop_table[prop].pd_strdefault);
618 }
619
620 uint64_t
vdev_prop_default_numeric(vdev_prop_t prop)621 vdev_prop_default_numeric(vdev_prop_t prop)
622 {
623 return (vdev_prop_table[prop].pd_numdefault);
624 }
625
626 int
vdev_prop_string_to_index(vdev_prop_t prop,const char * string,uint64_t * index)627 vdev_prop_string_to_index(vdev_prop_t prop, const char *string,
628 uint64_t *index)
629 {
630 return (zprop_string_to_index(prop, string, index, ZFS_TYPE_VDEV));
631 }
632
633 int
vdev_prop_index_to_string(vdev_prop_t prop,uint64_t index,const char ** string)634 vdev_prop_index_to_string(vdev_prop_t prop, uint64_t index,
635 const char **string)
636 {
637 return (zprop_index_to_string(prop, index, string, ZFS_TYPE_VDEV));
638 }
639
640 /*
641 * Returns true if this is a valid vdev property.
642 */
643 boolean_t
zpool_prop_vdev(const char * name)644 zpool_prop_vdev(const char *name)
645 {
646 return (vdev_name_to_prop(name) != VDEV_PROP_INVAL);
647 }
648
649 uint64_t
vdev_prop_random_value(vdev_prop_t prop,uint64_t seed)650 vdev_prop_random_value(vdev_prop_t prop, uint64_t seed)
651 {
652 return (zprop_random_value(prop, seed, ZFS_TYPE_VDEV));
653 }
654
655 #ifndef _KERNEL
656 const char *
vdev_prop_values(vdev_prop_t prop)657 vdev_prop_values(vdev_prop_t prop)
658 {
659 return (vdev_prop_table[prop].pd_values);
660 }
661
662 const char *
vdev_prop_column_name(vdev_prop_t prop)663 vdev_prop_column_name(vdev_prop_t prop)
664 {
665 return (vdev_prop_table[prop].pd_colname);
666 }
667
668 boolean_t
vdev_prop_align_right(vdev_prop_t prop)669 vdev_prop_align_right(vdev_prop_t prop)
670 {
671 return (vdev_prop_table[prop].pd_rightalign);
672 }
673 #endif
674
675 #if defined(_KERNEL)
676 /* zpool property functions */
677 EXPORT_SYMBOL(zpool_prop_init);
678 EXPORT_SYMBOL(zpool_prop_get_type);
679 EXPORT_SYMBOL(zpool_prop_get_table);
680
681 /* vdev property functions */
682 EXPORT_SYMBOL(vdev_prop_init);
683 EXPORT_SYMBOL(vdev_prop_get_type);
684 EXPORT_SYMBOL(vdev_prop_get_table);
685
686 /* Pool property functions shared between libzfs and kernel. */
687 EXPORT_SYMBOL(zpool_name_to_prop);
688 EXPORT_SYMBOL(zpool_prop_to_name);
689 EXPORT_SYMBOL(zpool_prop_default_string);
690 EXPORT_SYMBOL(zpool_prop_default_numeric);
691 EXPORT_SYMBOL(zpool_prop_readonly);
692 EXPORT_SYMBOL(zpool_prop_feature);
693 EXPORT_SYMBOL(zpool_prop_unsupported);
694 EXPORT_SYMBOL(zpool_prop_index_to_string);
695 EXPORT_SYMBOL(zpool_prop_string_to_index);
696 EXPORT_SYMBOL(zpool_prop_vdev);
697
698 /* vdev property functions shared between libzfs and kernel. */
699 EXPORT_SYMBOL(vdev_name_to_prop);
700 EXPORT_SYMBOL(vdev_prop_user);
701 EXPORT_SYMBOL(vdev_prop_to_name);
702 EXPORT_SYMBOL(vdev_prop_default_string);
703 EXPORT_SYMBOL(vdev_prop_default_numeric);
704 EXPORT_SYMBOL(vdev_prop_readonly);
705 EXPORT_SYMBOL(vdev_prop_index_to_string);
706 EXPORT_SYMBOL(vdev_prop_string_to_index);
707 #endif
708