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_inherit_table[] = {
378 { "off", 0},
379 { "on", 1},
380 { "inherit", ZPROP_BOOLEAN_INHERIT},
381 { NULL }
382 };
383 static const zprop_index_t boolean_na_table[] = {
384 { "off", 0},
385 { "on", 1},
386 { "-", ZPROP_BOOLEAN_NA},
387 { NULL }
388 };
389
390 static const zprop_index_t vdevschedulertype_table[] = {
391 { "auto", VDEV_SCHEDULER_AUTO },
392 { "on", VDEV_SCHEDULER_ON },
393 { "off", VDEV_SCHEDULER_OFF },
394 { NULL }
395 };
396
397 static const zprop_index_t vdev_alloc_bias_table[] = {
398 { "none", VDEV_BIAS_NONE },
399 { "log", VDEV_BIAS_LOG },
400 { "special", VDEV_BIAS_SPECIAL },
401 { "dedup", VDEV_BIAS_DEDUP },
402 { NULL }
403 };
404
405 struct zfs_mod_supported_features *sfeatures =
406 zfs_mod_list_supported(ZFS_SYSFS_VDEV_PROPERTIES);
407
408 /* string properties */
409 zprop_register_string(VDEV_PROP_COMMENT, "comment", NULL,
410 PROP_DEFAULT, ZFS_TYPE_VDEV, "<comment-string>", "COMMENT",
411 sfeatures);
412 zprop_register_string(VDEV_PROP_PATH, "path", NULL,
413 PROP_DEFAULT, ZFS_TYPE_VDEV, "<device-path>", "PATH", sfeatures);
414 zprop_register_string(VDEV_PROP_DEVID, "devid", NULL,
415 PROP_READONLY, ZFS_TYPE_VDEV, "<devid>", "DEVID", sfeatures);
416 zprop_register_string(VDEV_PROP_PHYS_PATH, "physpath", NULL,
417 PROP_READONLY, ZFS_TYPE_VDEV, "<physpath>", "PHYSPATH", sfeatures);
418 zprop_register_string(VDEV_PROP_ENC_PATH, "encpath", NULL,
419 PROP_READONLY, ZFS_TYPE_VDEV, "<encpath>", "ENCPATH", sfeatures);
420 zprop_register_string(VDEV_PROP_FRU, "fru", NULL,
421 PROP_READONLY, ZFS_TYPE_VDEV, "<fru>", "FRU", sfeatures);
422 zprop_register_string(VDEV_PROP_PARENT, "parent", NULL,
423 PROP_READONLY, ZFS_TYPE_VDEV, "<parent>", "PARENT", sfeatures);
424 zprop_register_string(VDEV_PROP_CHILDREN, "children", NULL,
425 PROP_READONLY, ZFS_TYPE_VDEV, "<child[,...]>", "CHILDREN",
426 sfeatures);
427
428 /* readonly number properties */
429 zprop_register_number(VDEV_PROP_SIZE, "size", 0, PROP_READONLY,
430 ZFS_TYPE_VDEV, "<size>", "SIZE", B_FALSE, sfeatures);
431 zprop_register_number(VDEV_PROP_FREE, "free", 0, PROP_READONLY,
432 ZFS_TYPE_VDEV, "<size>", "FREE", B_FALSE, sfeatures);
433 zprop_register_number(VDEV_PROP_ALLOCATED, "allocated", 0,
434 PROP_READONLY, ZFS_TYPE_VDEV, "<size>", "ALLOC", B_FALSE,
435 sfeatures);
436 zprop_register_number(VDEV_PROP_EXPANDSZ, "expandsize", 0,
437 PROP_READONLY, ZFS_TYPE_VDEV, "<size>", "EXPANDSZ", B_FALSE,
438 sfeatures);
439 zprop_register_number(VDEV_PROP_FRAGMENTATION, "fragmentation", 0,
440 PROP_READONLY, ZFS_TYPE_VDEV, "<percent>", "FRAG", B_FALSE,
441 sfeatures);
442 zprop_register_number(VDEV_PROP_CAPACITY, "capacity", 0, PROP_READONLY,
443 ZFS_TYPE_VDEV, "<percent>", "CAP", B_FALSE, sfeatures);
444 zprop_register_number(VDEV_PROP_GUID, "guid", 0, PROP_READONLY,
445 ZFS_TYPE_VDEV, "<guid>", "GUID", B_TRUE, sfeatures);
446 zprop_register_number(VDEV_PROP_STATE, "state", 0, PROP_READONLY,
447 ZFS_TYPE_VDEV, "<state>", "STATE", B_FALSE, sfeatures);
448 zprop_register_number(VDEV_PROP_BOOTSIZE, "bootsize", 0, PROP_READONLY,
449 ZFS_TYPE_VDEV, "<size>", "BOOTSIZE", B_FALSE, sfeatures);
450 zprop_register_number(VDEV_PROP_ASIZE, "asize", 0, PROP_READONLY,
451 ZFS_TYPE_VDEV, "<asize>", "ASIZE", B_FALSE, sfeatures);
452 zprop_register_number(VDEV_PROP_PSIZE, "psize", 0, PROP_READONLY,
453 ZFS_TYPE_VDEV, "<psize>", "PSIZE", B_FALSE, sfeatures);
454 zprop_register_number(VDEV_PROP_ASHIFT, "ashift", 0, PROP_READONLY,
455 ZFS_TYPE_VDEV, "<ashift>", "ASHIFT", B_FALSE, sfeatures);
456 zprop_register_number(VDEV_PROP_PARITY, "parity", 0, PROP_READONLY,
457 ZFS_TYPE_VDEV, "<parity>", "PARITY", B_FALSE, sfeatures);
458 zprop_register_number(VDEV_PROP_FDOMAIN, "failure_domain", UINT64_MAX,
459 PROP_READONLY, ZFS_TYPE_VDEV, "<fdomain>", "FDOM", B_FALSE,
460 sfeatures);
461 zprop_register_number(VDEV_PROP_FGROUP, "failure_group", UINT64_MAX,
462 PROP_READONLY, ZFS_TYPE_VDEV, "<fgroup>", "FGRP", B_FALSE,
463 sfeatures);
464 zprop_register_number(VDEV_PROP_NUMCHILDREN, "numchildren", 0,
465 PROP_READONLY, ZFS_TYPE_VDEV, "<number-of-children>", "NUMCHILD",
466 B_FALSE, sfeatures);
467 zprop_register_number(VDEV_PROP_READ_ERRORS, "read_errors", 0,
468 PROP_READONLY, ZFS_TYPE_VDEV, "<errors>", "RDERR", B_FALSE,
469 sfeatures);
470 zprop_register_number(VDEV_PROP_WRITE_ERRORS, "write_errors", 0,
471 PROP_READONLY, ZFS_TYPE_VDEV, "<errors>", "WRERR", B_FALSE,
472 sfeatures);
473 zprop_register_number(VDEV_PROP_CHECKSUM_ERRORS, "checksum_errors", 0,
474 PROP_READONLY, ZFS_TYPE_VDEV, "<errors>", "CKERR", B_FALSE,
475 sfeatures);
476 zprop_register_number(VDEV_PROP_INITIALIZE_ERRORS,
477 "initialize_errors", 0, PROP_READONLY, ZFS_TYPE_VDEV, "<errors>",
478 "INITERR", B_FALSE, sfeatures);
479 zprop_register_number(VDEV_PROP_TRIM_ERRORS, "trim_errors", 0,
480 PROP_READONLY, ZFS_TYPE_VDEV, "<errors>", "TRIMERR", B_FALSE,
481 sfeatures);
482 zprop_register_number(VDEV_PROP_SLOW_IOS, "slow_ios", 0,
483 PROP_READONLY, ZFS_TYPE_VDEV, "<slowios>", "SLOW", B_FALSE,
484 sfeatures);
485 zprop_register_number(VDEV_PROP_OPS_NULL, "null_ops", 0,
486 PROP_READONLY, ZFS_TYPE_VDEV, "<operations>", "NULLOP", B_FALSE,
487 sfeatures);
488 zprop_register_number(VDEV_PROP_OPS_READ, "read_ops", 0,
489 PROP_READONLY, ZFS_TYPE_VDEV, "<operations>", "READOP", B_FALSE,
490 sfeatures);
491 zprop_register_number(VDEV_PROP_OPS_WRITE, "write_ops", 0,
492 PROP_READONLY, ZFS_TYPE_VDEV, "<operations>", "WRITEOP", B_FALSE,
493 sfeatures);
494 zprop_register_number(VDEV_PROP_OPS_FREE, "free_ops", 0,
495 PROP_READONLY, ZFS_TYPE_VDEV, "<operations>", "FREEOP", B_FALSE,
496 sfeatures);
497 zprop_register_number(VDEV_PROP_OPS_CLAIM, "claim_ops", 0,
498 PROP_READONLY, ZFS_TYPE_VDEV, "<operations>", "CLAIMOP", B_FALSE,
499 sfeatures);
500 zprop_register_number(VDEV_PROP_OPS_TRIM, "trim_ops", 0,
501 PROP_READONLY, ZFS_TYPE_VDEV, "<operations>", "TRIMOP", B_FALSE,
502 sfeatures);
503 zprop_register_number(VDEV_PROP_BYTES_NULL, "null_bytes", 0,
504 PROP_READONLY, ZFS_TYPE_VDEV, "<bytes>", "NULLBYTE", B_FALSE,
505 sfeatures);
506 zprop_register_number(VDEV_PROP_BYTES_READ, "read_bytes", 0,
507 PROP_READONLY, ZFS_TYPE_VDEV, "<bytes>", "READBYTE", B_FALSE,
508 sfeatures);
509 zprop_register_number(VDEV_PROP_BYTES_WRITE, "write_bytes", 0,
510 PROP_READONLY, ZFS_TYPE_VDEV, "<bytes>", "WRITEBYTE", B_FALSE,
511 sfeatures);
512 zprop_register_number(VDEV_PROP_BYTES_FREE, "free_bytes", 0,
513 PROP_READONLY, ZFS_TYPE_VDEV, "<bytes>", "FREEBYTE", B_FALSE,
514 sfeatures);
515 zprop_register_number(VDEV_PROP_BYTES_CLAIM, "claim_bytes", 0,
516 PROP_READONLY, ZFS_TYPE_VDEV, "<bytes>", "CLAIMBYTE", B_FALSE,
517 sfeatures);
518 zprop_register_number(VDEV_PROP_BYTES_TRIM, "trim_bytes", 0,
519 PROP_READONLY, ZFS_TYPE_VDEV, "<bytes>", "TRIMBYTE", B_FALSE,
520 sfeatures);
521
522 /* default numeric properties */
523 zprop_register_number(VDEV_PROP_CHECKSUM_N, "checksum_n", UINT64_MAX,
524 PROP_DEFAULT, ZFS_TYPE_VDEV, "<events>", "CKSUM_N", B_FALSE,
525 sfeatures);
526 zprop_register_number(VDEV_PROP_CHECKSUM_T, "checksum_t", UINT64_MAX,
527 PROP_DEFAULT, ZFS_TYPE_VDEV, "<seconds>", "CKSUM_T", B_FALSE,
528 sfeatures);
529 zprop_register_number(VDEV_PROP_IO_N, "io_n", UINT64_MAX,
530 PROP_DEFAULT, ZFS_TYPE_VDEV, "<events>", "IO_N", B_FALSE,
531 sfeatures);
532 zprop_register_number(VDEV_PROP_IO_T, "io_t", UINT64_MAX,
533 PROP_DEFAULT, ZFS_TYPE_VDEV, "<seconds>", "IO_T", B_FALSE,
534 sfeatures);
535 zprop_register_number(VDEV_PROP_SLOW_IO_N, "slow_io_n", UINT64_MAX,
536 PROP_DEFAULT, ZFS_TYPE_VDEV, "<events>", "SLOW_IO_N", B_FALSE,
537 sfeatures);
538 zprop_register_number(VDEV_PROP_SLOW_IO_T, "slow_io_t", UINT64_MAX,
539 PROP_DEFAULT, ZFS_TYPE_VDEV, "<seconds>", "SLOW_IO_T", B_FALSE,
540 sfeatures);
541
542 /* default index (boolean) properties */
543 zprop_register_index(VDEV_PROP_REMOVING, "removing", 0,
544 PROP_READONLY, ZFS_TYPE_VDEV, "on | off", "REMOVING",
545 boolean_table, sfeatures);
546 zprop_register_index(VDEV_PROP_ALLOCATING, "allocating", 1,
547 PROP_DEFAULT, ZFS_TYPE_VDEV, "on | off", "ALLOCATING",
548 boolean_na_table, sfeatures);
549 zprop_register_index(VDEV_PROP_RAIDZ_EXPANDING, "raidz_expanding", 0,
550 PROP_READONLY, ZFS_TYPE_VDEV, "on | off", "RAIDZ_EXPANDING",
551 boolean_table, sfeatures);
552 zprop_register_index(VDEV_PROP_SIT_OUT, "sit_out", 0,
553 PROP_DEFAULT, ZFS_TYPE_VDEV, "on | off", "SIT_OUT", boolean_table,
554 sfeatures);
555 zprop_register_index(VDEV_PROP_TRIM_SUPPORT, "trim_support", 0,
556 PROP_READONLY, ZFS_TYPE_VDEV, "on | off", "TRIMSUP",
557 boolean_table, sfeatures);
558 zprop_register_index(VDEV_PROP_AUTOSIT, "autosit", 0,
559 PROP_DEFAULT, ZFS_TYPE_VDEV, "on | off", "AUTOSIT", boolean_table,
560 sfeatures);
561
562 /* default index properties */
563 zprop_register_index(VDEV_PROP_FAILFAST, "failfast", B_TRUE,
564 PROP_DEFAULT, ZFS_TYPE_VDEV, "on | off | inherit", "FAILFAST",
565 boolean_inherit_table, sfeatures);
566 zprop_register_index(VDEV_PROP_SLOW_IO_EVENTS, "slow_io_events",
567 B_TRUE, PROP_DEFAULT, ZFS_TYPE_VDEV, "on | off",
568 "SLOW_IO_EVENTS", boolean_table, sfeatures);
569 zprop_register_index(VDEV_PROP_SCHEDULER, "scheduler",
570 VDEV_SCHEDULER_AUTO, PROP_DEFAULT, ZFS_TYPE_VDEV,
571 "auto | on | off", "IO_SCHEDULER",
572 vdevschedulertype_table, sfeatures);
573 zprop_register_index(VDEV_PROP_ALLOC_BIAS, "alloc_bias",
574 VDEV_BIAS_NONE, PROP_DEFAULT, ZFS_TYPE_VDEV,
575 "none | log | special | dedup", "ALLOC_BIAS",
576 vdev_alloc_bias_table, sfeatures);
577 zprop_register_index(VDEV_PROP_ROTATIONAL, "rotational", 0,
578 PROP_READONLY, ZFS_TYPE_VDEV, "on | off", "ROTATIONAL",
579 boolean_table, sfeatures);
580
581 /* hidden properties */
582 zprop_register_hidden(VDEV_PROP_NAME, "name", PROP_TYPE_STRING,
583 PROP_READONLY, ZFS_TYPE_VDEV, "NAME", B_TRUE, sfeatures);
584
585 zfs_mod_list_supported_free(sfeatures);
586 }
587
588 /*
589 * Given a property name and its type, returns the corresponding property ID.
590 */
591 vdev_prop_t
vdev_name_to_prop(const char * propname)592 vdev_name_to_prop(const char *propname)
593 {
594 return (zprop_name_to_prop(propname, ZFS_TYPE_VDEV));
595 }
596
597 /*
598 * Returns true if this is a valid user-defined property (one with a ':').
599 */
600 boolean_t
vdev_prop_user(const char * name)601 vdev_prop_user(const char *name)
602 {
603 int i, len;
604 char c;
605 boolean_t foundsep = B_FALSE;
606
607 len = strlen(name);
608 for (i = 0; i < len; i++) {
609 c = name[i];
610 if (!zprop_valid_char(c))
611 return (B_FALSE);
612 if (c == ':')
613 foundsep = B_TRUE;
614 }
615
616 return (foundsep);
617 }
618
619 /*
620 * Given a pool property ID, returns the corresponding name.
621 * Assuming the pool property ID is valid.
622 */
623 const char *
vdev_prop_to_name(vdev_prop_t prop)624 vdev_prop_to_name(vdev_prop_t prop)
625 {
626 return (vdev_prop_table[prop].pd_name);
627 }
628
629 zprop_type_t
vdev_prop_get_type(vdev_prop_t prop)630 vdev_prop_get_type(vdev_prop_t prop)
631 {
632 return (vdev_prop_table[prop].pd_proptype);
633 }
634
635 boolean_t
vdev_prop_readonly(vdev_prop_t prop)636 vdev_prop_readonly(vdev_prop_t prop)
637 {
638 return (vdev_prop_table[prop].pd_attr == PROP_READONLY);
639 }
640
641 const char *
vdev_prop_default_string(vdev_prop_t prop)642 vdev_prop_default_string(vdev_prop_t prop)
643 {
644 return (vdev_prop_table[prop].pd_strdefault);
645 }
646
647 uint64_t
vdev_prop_default_numeric(vdev_prop_t prop)648 vdev_prop_default_numeric(vdev_prop_t prop)
649 {
650 return (vdev_prop_table[prop].pd_numdefault);
651 }
652
653 int
vdev_prop_string_to_index(vdev_prop_t prop,const char * string,uint64_t * index)654 vdev_prop_string_to_index(vdev_prop_t prop, const char *string,
655 uint64_t *index)
656 {
657 return (zprop_string_to_index(prop, string, index, ZFS_TYPE_VDEV));
658 }
659
660 int
vdev_prop_index_to_string(vdev_prop_t prop,uint64_t index,const char ** string)661 vdev_prop_index_to_string(vdev_prop_t prop, uint64_t index,
662 const char **string)
663 {
664 return (zprop_index_to_string(prop, index, string, ZFS_TYPE_VDEV));
665 }
666
667 /*
668 * Returns true if this is a valid vdev property.
669 */
670 boolean_t
zpool_prop_vdev(const char * name)671 zpool_prop_vdev(const char *name)
672 {
673 return (vdev_name_to_prop(name) != VDEV_PROP_INVAL);
674 }
675
676 uint64_t
vdev_prop_random_value(vdev_prop_t prop,uint64_t seed)677 vdev_prop_random_value(vdev_prop_t prop, uint64_t seed)
678 {
679 return (zprop_random_value(prop, seed, ZFS_TYPE_VDEV));
680 }
681
682 #ifndef _KERNEL
683 const char *
vdev_prop_values(vdev_prop_t prop)684 vdev_prop_values(vdev_prop_t prop)
685 {
686 return (vdev_prop_table[prop].pd_values);
687 }
688
689 const char *
vdev_prop_column_name(vdev_prop_t prop)690 vdev_prop_column_name(vdev_prop_t prop)
691 {
692 return (vdev_prop_table[prop].pd_colname);
693 }
694
695 boolean_t
vdev_prop_align_right(vdev_prop_t prop)696 vdev_prop_align_right(vdev_prop_t prop)
697 {
698 return (vdev_prop_table[prop].pd_rightalign);
699 }
700 #endif
701
702 #if defined(_KERNEL)
703 /* zpool property functions */
704 EXPORT_SYMBOL(zpool_prop_init);
705 EXPORT_SYMBOL(zpool_prop_get_type);
706 EXPORT_SYMBOL(zpool_prop_get_table);
707
708 /* vdev property functions */
709 EXPORT_SYMBOL(vdev_prop_init);
710 EXPORT_SYMBOL(vdev_prop_get_type);
711 EXPORT_SYMBOL(vdev_prop_get_table);
712
713 /* Pool property functions shared between libzfs and kernel. */
714 EXPORT_SYMBOL(zpool_name_to_prop);
715 EXPORT_SYMBOL(zpool_prop_to_name);
716 EXPORT_SYMBOL(zpool_prop_default_string);
717 EXPORT_SYMBOL(zpool_prop_default_numeric);
718 EXPORT_SYMBOL(zpool_prop_readonly);
719 EXPORT_SYMBOL(zpool_prop_feature);
720 EXPORT_SYMBOL(zpool_prop_unsupported);
721 EXPORT_SYMBOL(zpool_prop_index_to_string);
722 EXPORT_SYMBOL(zpool_prop_string_to_index);
723 EXPORT_SYMBOL(zpool_prop_vdev);
724
725 /* vdev property functions shared between libzfs and kernel. */
726 EXPORT_SYMBOL(vdev_name_to_prop);
727 EXPORT_SYMBOL(vdev_prop_user);
728 EXPORT_SYMBOL(vdev_prop_to_name);
729 EXPORT_SYMBOL(vdev_prop_default_string);
730 EXPORT_SYMBOL(vdev_prop_default_numeric);
731 EXPORT_SYMBOL(vdev_prop_readonly);
732 EXPORT_SYMBOL(vdev_prop_index_to_string);
733 EXPORT_SYMBOL(vdev_prop_string_to_index);
734 #endif
735