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.
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.
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]
22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 2011, 2018 by Delphix. All rights reserved.
24 * Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
25 * Copyright 2016, Joyent, Inc.
26 * Copyright (c) 2019, Klara Inc.
27 * Copyright (c) 2019, Allan Jude
30 /* Portions Copyright 2010 Robert Milkowski */
34 #include <sys/u8_textprep.h>
35 #include <sys/zfs_acl.h>
36 #include <sys/zfs_ioctl.h>
37 #include <sys/zfs_znode.h>
38 #include <sys/dsl_crypt.h>
41 #include "zfs_deleg.h"
42 #include "zfs_fletcher.h"
50 static zprop_desc_t zfs_prop_table[ZFS_NUM_PROPS];
52 /* Note this is indexed by zfs_userquota_prop_t, keep the order the same */
53 const char *zfs_userquota_prop_prefixes[] = {
69 zfs_prop_get_table(void)
71 return (zfs_prop_table);
77 static zprop_index_t checksum_table[] = {
78 { "on", ZIO_CHECKSUM_ON },
79 { "off", ZIO_CHECKSUM_OFF },
80 { "fletcher2", ZIO_CHECKSUM_FLETCHER_2 },
81 { "fletcher4", ZIO_CHECKSUM_FLETCHER_4 },
82 { "sha256", ZIO_CHECKSUM_SHA256 },
83 { "noparity", ZIO_CHECKSUM_NOPARITY },
84 { "sha512", ZIO_CHECKSUM_SHA512 },
85 { "skein", ZIO_CHECKSUM_SKEIN },
86 #if !defined(__FreeBSD__)
88 { "edonr", ZIO_CHECKSUM_EDONR },
93 static zprop_index_t dedup_table[] = {
94 { "on", ZIO_CHECKSUM_ON },
95 { "off", ZIO_CHECKSUM_OFF },
96 { "verify", ZIO_CHECKSUM_ON | ZIO_CHECKSUM_VERIFY },
97 { "sha256", ZIO_CHECKSUM_SHA256 },
99 ZIO_CHECKSUM_SHA256 | ZIO_CHECKSUM_VERIFY },
100 { "sha512", ZIO_CHECKSUM_SHA512 },
102 ZIO_CHECKSUM_SHA512 | ZIO_CHECKSUM_VERIFY },
103 { "skein", ZIO_CHECKSUM_SKEIN },
105 ZIO_CHECKSUM_SKEIN | ZIO_CHECKSUM_VERIFY },
106 #if !defined(__FreeBSD__)
109 ZIO_CHECKSUM_EDONR | ZIO_CHECKSUM_VERIFY },
114 static zprop_index_t compress_table[] = {
115 { "on", ZIO_COMPRESS_ON },
116 { "off", ZIO_COMPRESS_OFF },
117 { "lzjb", ZIO_COMPRESS_LZJB },
118 { "gzip", ZIO_COMPRESS_GZIP_6 }, /* gzip default */
119 { "gzip-1", ZIO_COMPRESS_GZIP_1 },
120 { "gzip-2", ZIO_COMPRESS_GZIP_2 },
121 { "gzip-3", ZIO_COMPRESS_GZIP_3 },
122 { "gzip-4", ZIO_COMPRESS_GZIP_4 },
123 { "gzip-5", ZIO_COMPRESS_GZIP_5 },
124 { "gzip-6", ZIO_COMPRESS_GZIP_6 },
125 { "gzip-7", ZIO_COMPRESS_GZIP_7 },
126 { "gzip-8", ZIO_COMPRESS_GZIP_8 },
127 { "gzip-9", ZIO_COMPRESS_GZIP_9 },
128 { "zle", ZIO_COMPRESS_ZLE },
129 { "lz4", ZIO_COMPRESS_LZ4 },
130 { "zstd", ZIO_COMPRESS_ZSTD },
132 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_DEFAULT) },
135 * ZSTD 1-19 are synthetic. We store the compression level in a
136 * separate hidden property to avoid wasting a large amount of
137 * space in the ZIO_COMPRESS enum.
139 * The compression level is also stored within the header of the
140 * compressed block since we may need it for later recompression
141 * to avoid checksum errors (L2ARC).
143 * Note that the level here is defined as bit shifted mask on
146 { "zstd-1", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_1) },
147 { "zstd-2", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_2) },
148 { "zstd-3", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_3) },
149 { "zstd-4", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_4) },
150 { "zstd-5", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_5) },
151 { "zstd-6", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_6) },
152 { "zstd-7", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_7) },
153 { "zstd-8", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_8) },
154 { "zstd-9", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_9) },
155 { "zstd-10", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_10) },
156 { "zstd-11", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_11) },
157 { "zstd-12", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_12) },
158 { "zstd-13", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_13) },
159 { "zstd-14", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_14) },
160 { "zstd-15", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_15) },
161 { "zstd-16", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_16) },
162 { "zstd-17", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_17) },
163 { "zstd-18", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_18) },
164 { "zstd-19", ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_19) },
167 * The ZSTD-Fast levels are also synthetic.
170 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_1) },
172 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_2) },
174 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_3) },
176 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_4) },
178 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_5) },
180 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_6) },
182 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_7) },
184 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_8) },
186 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_9) },
188 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_10) },
190 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_20) },
192 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_30) },
194 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_40) },
196 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_50) },
198 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_60) },
200 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_70) },
202 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_80) },
204 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_90) },
206 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_100) },
208 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_500) },
210 ZIO_COMPLEVEL_ZSTD(ZIO_ZSTD_LEVEL_FAST_1000) },
214 static zprop_index_t crypto_table[] = {
215 { "on", ZIO_CRYPT_ON },
216 { "off", ZIO_CRYPT_OFF },
217 { "aes-128-ccm", ZIO_CRYPT_AES_128_CCM },
218 { "aes-192-ccm", ZIO_CRYPT_AES_192_CCM },
219 { "aes-256-ccm", ZIO_CRYPT_AES_256_CCM },
220 { "aes-128-gcm", ZIO_CRYPT_AES_128_GCM },
221 { "aes-192-gcm", ZIO_CRYPT_AES_192_GCM },
222 { "aes-256-gcm", ZIO_CRYPT_AES_256_GCM },
226 static zprop_index_t keyformat_table[] = {
227 { "none", ZFS_KEYFORMAT_NONE },
228 { "raw", ZFS_KEYFORMAT_RAW },
229 { "hex", ZFS_KEYFORMAT_HEX },
230 { "passphrase", ZFS_KEYFORMAT_PASSPHRASE },
234 static zprop_index_t snapdir_table[] = {
235 { "hidden", ZFS_SNAPDIR_HIDDEN },
236 { "visible", ZFS_SNAPDIR_VISIBLE },
240 static zprop_index_t snapdev_table[] = {
241 { "hidden", ZFS_SNAPDEV_HIDDEN },
242 { "visible", ZFS_SNAPDEV_VISIBLE },
246 static zprop_index_t acl_mode_table[] = {
247 { "discard", ZFS_ACL_DISCARD },
248 { "groupmask", ZFS_ACL_GROUPMASK },
249 { "passthrough", ZFS_ACL_PASSTHROUGH },
250 { "restricted", ZFS_ACL_RESTRICTED },
254 static zprop_index_t acltype_table[] = {
255 { "off", ZFS_ACLTYPE_OFF },
256 { "posix", ZFS_ACLTYPE_POSIX },
257 { "disabled", ZFS_ACLTYPE_OFF }, /* bkwrd compatibility */
258 { "noacl", ZFS_ACLTYPE_OFF }, /* bkwrd compatibility */
259 { "posixacl", ZFS_ACLTYPE_POSIX }, /* bkwrd compatibility */
263 static zprop_index_t acl_inherit_table[] = {
264 { "discard", ZFS_ACL_DISCARD },
265 { "noallow", ZFS_ACL_NOALLOW },
266 { "restricted", ZFS_ACL_RESTRICTED },
267 { "passthrough", ZFS_ACL_PASSTHROUGH },
268 { "secure", ZFS_ACL_RESTRICTED }, /* bkwrd compatibility */
269 { "passthrough-x", ZFS_ACL_PASSTHROUGH_X },
273 static zprop_index_t case_table[] = {
274 { "sensitive", ZFS_CASE_SENSITIVE },
275 { "insensitive", ZFS_CASE_INSENSITIVE },
276 { "mixed", ZFS_CASE_MIXED },
280 static zprop_index_t copies_table[] = {
288 * Use the unique flags we have to send to u8_strcmp() and/or
289 * u8_textprep() to represent the various normalization property
292 static zprop_index_t normalize_table[] = {
294 { "formD", U8_TEXTPREP_NFD },
295 { "formKC", U8_TEXTPREP_NFKC },
296 { "formC", U8_TEXTPREP_NFC },
297 { "formKD", U8_TEXTPREP_NFKD },
301 static zprop_index_t version_table[] = {
307 { "current", ZPL_VERSION },
311 static zprop_index_t boolean_table[] = {
317 static zprop_index_t keystatus_table[] = {
318 { "none", ZFS_KEYSTATUS_NONE},
319 { "unavailable", ZFS_KEYSTATUS_UNAVAILABLE},
320 { "available", ZFS_KEYSTATUS_AVAILABLE},
324 static zprop_index_t logbias_table[] = {
325 { "latency", ZFS_LOGBIAS_LATENCY },
326 { "throughput", ZFS_LOGBIAS_THROUGHPUT },
330 static zprop_index_t canmount_table[] = {
331 { "off", ZFS_CANMOUNT_OFF },
332 { "on", ZFS_CANMOUNT_ON },
333 { "noauto", ZFS_CANMOUNT_NOAUTO },
337 static zprop_index_t cache_table[] = {
338 { "none", ZFS_CACHE_NONE },
339 { "metadata", ZFS_CACHE_METADATA },
340 { "all", ZFS_CACHE_ALL },
344 static zprop_index_t sync_table[] = {
345 { "standard", ZFS_SYNC_STANDARD },
346 { "always", ZFS_SYNC_ALWAYS },
347 { "disabled", ZFS_SYNC_DISABLED },
351 static zprop_index_t xattr_table[] = {
352 { "off", ZFS_XATTR_OFF },
353 { "on", ZFS_XATTR_DIR },
354 { "sa", ZFS_XATTR_SA },
355 { "dir", ZFS_XATTR_DIR },
359 static zprop_index_t dnsize_table[] = {
360 { "legacy", ZFS_DNSIZE_LEGACY },
361 { "auto", ZFS_DNSIZE_AUTO },
362 { "1k", ZFS_DNSIZE_1K },
363 { "2k", ZFS_DNSIZE_2K },
364 { "4k", ZFS_DNSIZE_4K },
365 { "8k", ZFS_DNSIZE_8K },
366 { "16k", ZFS_DNSIZE_16K },
370 static zprop_index_t redundant_metadata_table[] = {
371 { "all", ZFS_REDUNDANT_METADATA_ALL },
372 { "most", ZFS_REDUNDANT_METADATA_MOST },
376 static zprop_index_t volmode_table[] = {
377 { "default", ZFS_VOLMODE_DEFAULT },
378 { "full", ZFS_VOLMODE_GEOM },
379 { "geom", ZFS_VOLMODE_GEOM },
380 { "dev", ZFS_VOLMODE_DEV },
381 { "none", ZFS_VOLMODE_NONE },
385 /* inherit index properties */
386 zprop_register_index(ZFS_PROP_REDUNDANT_METADATA, "redundant_metadata",
387 ZFS_REDUNDANT_METADATA_ALL,
388 PROP_INHERIT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
389 "all | most", "REDUND_MD",
390 redundant_metadata_table);
391 zprop_register_index(ZFS_PROP_SYNC, "sync", ZFS_SYNC_STANDARD,
392 PROP_INHERIT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
393 "standard | always | disabled", "SYNC",
395 zprop_register_index(ZFS_PROP_CHECKSUM, "checksum",
396 ZIO_CHECKSUM_DEFAULT, PROP_INHERIT, ZFS_TYPE_FILESYSTEM |
398 #if !defined(__FreeBSD__)
399 "on | off | fletcher2 | fletcher4 | sha256 | sha512 | skein"
402 "on | off | fletcher2 | fletcher4 | sha256 | sha512 | skein",
404 "CHECKSUM", checksum_table);
405 zprop_register_index(ZFS_PROP_DEDUP, "dedup", ZIO_CHECKSUM_OFF,
406 PROP_INHERIT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
407 "on | off | verify | sha256[,verify] | sha512[,verify] | "
408 #if !defined(__FreeBSD__)
409 "skein[,verify] | edonr,verify",
413 "DEDUP", dedup_table);
414 zprop_register_index(ZFS_PROP_COMPRESSION, "compression",
415 ZIO_COMPRESS_DEFAULT, PROP_INHERIT,
416 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
417 "on | off | lzjb | gzip | gzip-[1-9] | zle | lz4 | "
418 "zstd | zstd-[1-19] | "
419 "zstd-fast-[1-10,20,30,40,50,60,70,80,90,100,500,1000]",
420 "COMPRESS", compress_table);
421 zprop_register_index(ZFS_PROP_SNAPDIR, "snapdir", ZFS_SNAPDIR_HIDDEN,
422 PROP_INHERIT, ZFS_TYPE_FILESYSTEM,
423 "hidden | visible", "SNAPDIR", snapdir_table);
424 zprop_register_index(ZFS_PROP_SNAPDEV, "snapdev", ZFS_SNAPDEV_HIDDEN,
425 PROP_INHERIT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
426 "hidden | visible", "SNAPDEV", snapdev_table);
427 zprop_register_index(ZFS_PROP_ACLMODE, "aclmode", ZFS_ACL_DISCARD,
428 PROP_INHERIT, ZFS_TYPE_FILESYSTEM,
429 "discard | groupmask | passthrough | restricted", "ACLMODE",
432 zprop_register_index(ZFS_PROP_ACLTYPE, "acltype", ZFS_ACLTYPE_OFF,
433 PROP_INHERIT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT,
434 "off | posix", "ACLTYPE", acltype_table);
436 zprop_register_index(ZFS_PROP_ACLINHERIT, "aclinherit",
437 ZFS_ACL_RESTRICTED, PROP_INHERIT, ZFS_TYPE_FILESYSTEM,
438 "discard | noallow | restricted | passthrough | passthrough-x",
439 "ACLINHERIT", acl_inherit_table);
440 zprop_register_index(ZFS_PROP_COPIES, "copies", 1, PROP_INHERIT,
441 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
442 "1 | 2 | 3", "COPIES", copies_table);
443 zprop_register_index(ZFS_PROP_PRIMARYCACHE, "primarycache",
444 ZFS_CACHE_ALL, PROP_INHERIT,
445 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT | ZFS_TYPE_VOLUME,
446 "all | none | metadata", "PRIMARYCACHE", cache_table);
447 zprop_register_index(ZFS_PROP_SECONDARYCACHE, "secondarycache",
448 ZFS_CACHE_ALL, PROP_INHERIT,
449 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT | ZFS_TYPE_VOLUME,
450 "all | none | metadata", "SECONDARYCACHE", cache_table);
451 zprop_register_index(ZFS_PROP_LOGBIAS, "logbias", ZFS_LOGBIAS_LATENCY,
452 PROP_INHERIT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
453 "latency | throughput", "LOGBIAS", logbias_table);
454 zprop_register_index(ZFS_PROP_XATTR, "xattr", ZFS_XATTR_DIR,
455 PROP_INHERIT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT,
456 "on | off | dir | sa", "XATTR", xattr_table);
457 zprop_register_index(ZFS_PROP_DNODESIZE, "dnodesize",
458 ZFS_DNSIZE_LEGACY, PROP_INHERIT, ZFS_TYPE_FILESYSTEM,
459 "legacy | auto | 1k | 2k | 4k | 8k | 16k", "DNSIZE", dnsize_table);
460 zprop_register_index(ZFS_PROP_VOLMODE, "volmode",
461 ZFS_VOLMODE_DEFAULT, PROP_INHERIT,
462 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
463 "default | full | geom | dev | none", "VOLMODE", volmode_table);
465 /* inherit index (boolean) properties */
466 zprop_register_index(ZFS_PROP_ATIME, "atime", 1, PROP_INHERIT,
467 ZFS_TYPE_FILESYSTEM, "on | off", "ATIME", boolean_table);
468 zprop_register_index(ZFS_PROP_RELATIME, "relatime", 0, PROP_INHERIT,
469 ZFS_TYPE_FILESYSTEM, "on | off", "RELATIME", boolean_table);
470 zprop_register_index(ZFS_PROP_DEVICES, "devices", 1, PROP_INHERIT,
471 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT, "on | off", "DEVICES",
473 zprop_register_index(ZFS_PROP_EXEC, "exec", 1, PROP_INHERIT,
474 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT, "on | off", "EXEC",
476 zprop_register_index(ZFS_PROP_SETUID, "setuid", 1, PROP_INHERIT,
477 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT, "on | off", "SETUID",
479 zprop_register_index(ZFS_PROP_READONLY, "readonly", 0, PROP_INHERIT,
480 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "on | off", "RDONLY",
483 zprop_register_index(ZFS_PROP_ZONED, "jailed", 0, PROP_INHERIT,
484 ZFS_TYPE_FILESYSTEM, "on | off", "JAILED", boolean_table);
486 zprop_register_index(ZFS_PROP_ZONED, "zoned", 0, PROP_INHERIT,
487 ZFS_TYPE_FILESYSTEM, "on | off", "ZONED", boolean_table);
489 zprop_register_index(ZFS_PROP_VSCAN, "vscan", 0, PROP_INHERIT,
490 ZFS_TYPE_FILESYSTEM, "on | off", "VSCAN", boolean_table);
491 zprop_register_index(ZFS_PROP_NBMAND, "nbmand", 0, PROP_INHERIT,
492 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT, "on | off", "NBMAND",
494 zprop_register_index(ZFS_PROP_OVERLAY, "overlay", 1, PROP_INHERIT,
495 ZFS_TYPE_FILESYSTEM, "on | off", "OVERLAY", boolean_table);
497 /* default index properties */
498 zprop_register_index(ZFS_PROP_VERSION, "version", 0, PROP_DEFAULT,
499 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT,
500 "1 | 2 | 3 | 4 | 5 | current", "VERSION", version_table);
501 zprop_register_index(ZFS_PROP_CANMOUNT, "canmount", ZFS_CANMOUNT_ON,
502 PROP_DEFAULT, ZFS_TYPE_FILESYSTEM, "on | off | noauto",
503 "CANMOUNT", canmount_table);
505 /* readonly index properties */
506 zprop_register_index(ZFS_PROP_MOUNTED, "mounted", 0, PROP_READONLY,
507 ZFS_TYPE_FILESYSTEM, "yes | no", "MOUNTED", boolean_table);
508 zprop_register_index(ZFS_PROP_DEFER_DESTROY, "defer_destroy", 0,
509 PROP_READONLY, ZFS_TYPE_SNAPSHOT, "yes | no", "DEFER_DESTROY",
511 zprop_register_index(ZFS_PROP_KEYSTATUS, "keystatus",
512 ZFS_KEYSTATUS_NONE, PROP_READONLY, ZFS_TYPE_DATASET,
513 "none | unavailable | available",
514 "KEYSTATUS", keystatus_table);
516 /* set once index properties */
517 zprop_register_index(ZFS_PROP_NORMALIZE, "normalization", 0,
518 PROP_ONETIME, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT,
519 "none | formC | formD | formKC | formKD", "NORMALIZATION",
521 zprop_register_index(ZFS_PROP_CASE, "casesensitivity",
522 ZFS_CASE_SENSITIVE, PROP_ONETIME, ZFS_TYPE_FILESYSTEM |
524 "sensitive | insensitive | mixed", "CASE", case_table);
525 zprop_register_index(ZFS_PROP_KEYFORMAT, "keyformat",
526 ZFS_KEYFORMAT_NONE, PROP_ONETIME_DEFAULT,
527 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
528 "none | raw | hex | passphrase", "KEYFORMAT", keyformat_table);
529 zprop_register_index(ZFS_PROP_ENCRYPTION, "encryption",
530 ZIO_CRYPT_DEFAULT, PROP_ONETIME, ZFS_TYPE_DATASET,
531 "on | off | aes-128-ccm | aes-192-ccm | aes-256-ccm | "
532 "aes-128-gcm | aes-192-gcm | aes-256-gcm", "ENCRYPTION",
535 /* set once index (boolean) properties */
536 zprop_register_index(ZFS_PROP_UTF8ONLY, "utf8only", 0, PROP_ONETIME,
537 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT,
538 "on | off", "UTF8ONLY", boolean_table);
540 /* string properties */
541 zprop_register_string(ZFS_PROP_ORIGIN, "origin", NULL, PROP_READONLY,
542 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<snapshot>", "ORIGIN");
543 zprop_register_string(ZFS_PROP_CLONES, "clones", NULL, PROP_READONLY,
544 ZFS_TYPE_SNAPSHOT, "<dataset>[,...]", "CLONES");
545 zprop_register_string(ZFS_PROP_MOUNTPOINT, "mountpoint", "/",
546 PROP_INHERIT, ZFS_TYPE_FILESYSTEM, "<path> | legacy | none",
548 zprop_register_string(ZFS_PROP_SHARENFS, "sharenfs", "off",
549 PROP_INHERIT, ZFS_TYPE_FILESYSTEM, "on | off | share(1M) options",
551 zprop_register_string(ZFS_PROP_TYPE, "type", NULL, PROP_READONLY,
552 ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK,
553 "filesystem | volume | snapshot | bookmark", "TYPE");
554 zprop_register_string(ZFS_PROP_SHARESMB, "sharesmb", "off",
555 PROP_INHERIT, ZFS_TYPE_FILESYSTEM,
556 "on | off | sharemgr(1M) options", "SHARESMB");
557 zprop_register_string(ZFS_PROP_MLSLABEL, "mlslabel",
558 ZFS_MLSLABEL_DEFAULT, PROP_INHERIT, ZFS_TYPE_DATASET,
559 "<sensitivity label>", "MLSLABEL");
560 zprop_register_string(ZFS_PROP_SELINUX_CONTEXT, "context",
561 "none", PROP_DEFAULT, ZFS_TYPE_DATASET, "<selinux context>",
563 zprop_register_string(ZFS_PROP_SELINUX_FSCONTEXT, "fscontext",
564 "none", PROP_DEFAULT, ZFS_TYPE_DATASET, "<selinux fscontext>",
566 zprop_register_string(ZFS_PROP_SELINUX_DEFCONTEXT, "defcontext",
567 "none", PROP_DEFAULT, ZFS_TYPE_DATASET, "<selinux defcontext>",
569 zprop_register_string(ZFS_PROP_SELINUX_ROOTCONTEXT, "rootcontext",
570 "none", PROP_DEFAULT, ZFS_TYPE_DATASET, "<selinux rootcontext>",
572 zprop_register_string(ZFS_PROP_RECEIVE_RESUME_TOKEN,
573 "receive_resume_token",
574 NULL, PROP_READONLY, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
575 "<string token>", "RESUMETOK");
576 zprop_register_string(ZFS_PROP_ENCRYPTION_ROOT, "encryptionroot", NULL,
577 PROP_READONLY, ZFS_TYPE_DATASET, "<filesystem | volume>",
579 zprop_register_string(ZFS_PROP_KEYLOCATION, "keylocation",
580 "none", PROP_DEFAULT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
581 "prompt | <file URI>", "KEYLOCATION");
582 zprop_register_string(ZFS_PROP_REDACT_SNAPS,
583 "redact_snaps", NULL, PROP_READONLY,
584 ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK, "<snapshot>[,...]",
587 /* readonly number properties */
588 zprop_register_number(ZFS_PROP_USED, "used", 0, PROP_READONLY,
589 ZFS_TYPE_DATASET, "<size>", "USED");
590 zprop_register_number(ZFS_PROP_AVAILABLE, "available", 0, PROP_READONLY,
591 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<size>", "AVAIL");
592 zprop_register_number(ZFS_PROP_REFERENCED, "referenced", 0,
593 PROP_READONLY, ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK, "<size>",
595 zprop_register_number(ZFS_PROP_COMPRESSRATIO, "compressratio", 0,
596 PROP_READONLY, ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK,
597 "<1.00x or higher if compressed>", "RATIO");
598 zprop_register_number(ZFS_PROP_REFRATIO, "refcompressratio", 0,
599 PROP_READONLY, ZFS_TYPE_DATASET,
600 "<1.00x or higher if compressed>", "REFRATIO");
601 zprop_register_number(ZFS_PROP_VOLBLOCKSIZE, "volblocksize",
602 ZVOL_DEFAULT_BLOCKSIZE, PROP_ONETIME,
603 ZFS_TYPE_VOLUME, "512 to 128k, power of 2", "VOLBLOCK");
604 zprop_register_number(ZFS_PROP_USEDSNAP, "usedbysnapshots", 0,
605 PROP_READONLY, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<size>",
607 zprop_register_number(ZFS_PROP_USEDDS, "usedbydataset", 0,
608 PROP_READONLY, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<size>",
610 zprop_register_number(ZFS_PROP_USEDCHILD, "usedbychildren", 0,
611 PROP_READONLY, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<size>",
613 zprop_register_number(ZFS_PROP_USEDREFRESERV, "usedbyrefreservation", 0,
615 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<size>", "USEDREFRESERV");
616 zprop_register_number(ZFS_PROP_USERREFS, "userrefs", 0, PROP_READONLY,
617 ZFS_TYPE_SNAPSHOT, "<count>", "USERREFS");
618 zprop_register_number(ZFS_PROP_WRITTEN, "written", 0, PROP_READONLY,
619 ZFS_TYPE_DATASET, "<size>", "WRITTEN");
620 zprop_register_number(ZFS_PROP_LOGICALUSED, "logicalused", 0,
621 PROP_READONLY, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<size>",
623 zprop_register_number(ZFS_PROP_LOGICALREFERENCED, "logicalreferenced",
624 0, PROP_READONLY, ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK, "<size>",
626 zprop_register_number(ZFS_PROP_FILESYSTEM_COUNT, "filesystem_count",
627 UINT64_MAX, PROP_READONLY, ZFS_TYPE_FILESYSTEM,
628 "<count>", "FSCOUNT");
629 zprop_register_number(ZFS_PROP_SNAPSHOT_COUNT, "snapshot_count",
630 UINT64_MAX, PROP_READONLY, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
631 "<count>", "SSCOUNT");
632 zprop_register_number(ZFS_PROP_GUID, "guid", 0, PROP_READONLY,
633 ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK, "<uint64>", "GUID");
634 zprop_register_number(ZFS_PROP_CREATETXG, "createtxg", 0, PROP_READONLY,
635 ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK, "<uint64>", "CREATETXG");
636 zprop_register_number(ZFS_PROP_PBKDF2_ITERS, "pbkdf2iters",
637 0, PROP_ONETIME_DEFAULT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
638 "<iters>", "PBKDF2ITERS");
639 zprop_register_number(ZFS_PROP_OBJSETID, "objsetid", 0,
640 PROP_READONLY, ZFS_TYPE_DATASET, "<uint64>", "OBJSETID");
642 /* default number properties */
643 zprop_register_number(ZFS_PROP_QUOTA, "quota", 0, PROP_DEFAULT,
644 ZFS_TYPE_FILESYSTEM, "<size> | none", "QUOTA");
645 zprop_register_number(ZFS_PROP_RESERVATION, "reservation", 0,
646 PROP_DEFAULT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
647 "<size> | none", "RESERV");
648 zprop_register_number(ZFS_PROP_VOLSIZE, "volsize", 0, PROP_DEFAULT,
649 ZFS_TYPE_SNAPSHOT | ZFS_TYPE_VOLUME, "<size>", "VOLSIZE");
650 zprop_register_number(ZFS_PROP_REFQUOTA, "refquota", 0, PROP_DEFAULT,
651 ZFS_TYPE_FILESYSTEM, "<size> | none", "REFQUOTA");
652 zprop_register_number(ZFS_PROP_REFRESERVATION, "refreservation", 0,
653 PROP_DEFAULT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
654 "<size> | none", "REFRESERV");
655 zprop_register_number(ZFS_PROP_FILESYSTEM_LIMIT, "filesystem_limit",
656 UINT64_MAX, PROP_DEFAULT, ZFS_TYPE_FILESYSTEM,
657 "<count> | none", "FSLIMIT");
658 zprop_register_number(ZFS_PROP_SNAPSHOT_LIMIT, "snapshot_limit",
659 UINT64_MAX, PROP_DEFAULT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
660 "<count> | none", "SSLIMIT");
662 /* inherit number properties */
663 zprop_register_number(ZFS_PROP_RECORDSIZE, "recordsize",
664 SPA_OLD_MAXBLOCKSIZE, PROP_INHERIT,
665 ZFS_TYPE_FILESYSTEM, "512 to 1M, power of 2", "RECSIZE");
666 zprop_register_number(ZFS_PROP_SPECIAL_SMALL_BLOCKS,
667 "special_small_blocks", 0, PROP_INHERIT, ZFS_TYPE_FILESYSTEM,
668 "zero or 512 to 1M, power of 2", "SPECIAL_SMALL_BLOCKS");
670 /* hidden properties */
671 zprop_register_hidden(ZFS_PROP_NUMCLONES, "numclones", PROP_TYPE_NUMBER,
672 PROP_READONLY, ZFS_TYPE_SNAPSHOT, "NUMCLONES");
673 zprop_register_hidden(ZFS_PROP_NAME, "name", PROP_TYPE_STRING,
674 PROP_READONLY, ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK, "NAME");
675 zprop_register_hidden(ZFS_PROP_ISCSIOPTIONS, "iscsioptions",
676 PROP_TYPE_STRING, PROP_INHERIT, ZFS_TYPE_VOLUME, "ISCSIOPTIONS");
677 zprop_register_hidden(ZFS_PROP_STMF_SHAREINFO, "stmf_sbd_lu",
678 PROP_TYPE_STRING, PROP_INHERIT, ZFS_TYPE_VOLUME,
680 zprop_register_hidden(ZFS_PROP_USERACCOUNTING, "useraccounting",
681 PROP_TYPE_NUMBER, PROP_READONLY, ZFS_TYPE_DATASET,
683 zprop_register_hidden(ZFS_PROP_UNIQUE, "unique", PROP_TYPE_NUMBER,
684 PROP_READONLY, ZFS_TYPE_DATASET, "UNIQUE");
685 zprop_register_hidden(ZFS_PROP_INCONSISTENT, "inconsistent",
686 PROP_TYPE_NUMBER, PROP_READONLY, ZFS_TYPE_DATASET, "INCONSISTENT");
687 zprop_register_hidden(ZFS_PROP_IVSET_GUID, "ivsetguid",
688 PROP_TYPE_NUMBER, PROP_READONLY,
689 ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK, "IVSETGUID");
690 zprop_register_hidden(ZFS_PROP_PREV_SNAP, "prevsnap", PROP_TYPE_STRING,
691 PROP_READONLY, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "PREVSNAP");
692 zprop_register_hidden(ZFS_PROP_PBKDF2_SALT, "pbkdf2salt",
693 PROP_TYPE_NUMBER, PROP_ONETIME_DEFAULT,
694 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "PBKDF2SALT");
695 zprop_register_hidden(ZFS_PROP_KEY_GUID, "keyguid", PROP_TYPE_NUMBER,
696 PROP_READONLY, ZFS_TYPE_DATASET, "KEYGUID");
697 zprop_register_hidden(ZFS_PROP_REDACTED, "redacted", PROP_TYPE_NUMBER,
698 PROP_READONLY, ZFS_TYPE_DATASET, "REDACTED");
701 * Properties that are obsolete and not used. These are retained so
702 * that we don't have to change the values of the zfs_prop_t enum, or
703 * have NULL pointers in the zfs_prop_table[].
706 zprop_register_impl(ZFS_PROP_ACLTYPE, "acltype", PROP_TYPE_INDEX,
707 ZFS_ACLTYPE_OFF, NULL, PROP_INHERIT,
708 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT,
709 "off | posix", "ACLTYPE", B_FALSE, B_FALSE, acltype_table);
711 zprop_register_hidden(ZFS_PROP_REMAPTXG, "remaptxg", PROP_TYPE_NUMBER,
712 PROP_READONLY, ZFS_TYPE_DATASET, "REMAPTXG");
714 /* oddball properties */
715 zprop_register_impl(ZFS_PROP_CREATION, "creation", PROP_TYPE_NUMBER, 0,
716 NULL, PROP_READONLY, ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK,
717 "<date>", "CREATION", B_FALSE, B_TRUE, NULL);
721 zfs_prop_delegatable(zfs_prop_t prop)
723 zprop_desc_t *pd = &zfs_prop_table[prop];
725 /* The mlslabel property is never delegatable. */
726 if (prop == ZFS_PROP_MLSLABEL)
729 return (pd->pd_attr != PROP_READONLY);
733 * Given a zfs dataset property name, returns the corresponding property ID.
736 zfs_name_to_prop(const char *propname)
738 return (zprop_name_to_prop(propname, ZFS_TYPE_DATASET));
742 * For user property names, we allow all lowercase alphanumeric characters, plus
743 * a few useful punctuation characters.
748 return ((c >= 'a' && c <= 'z') ||
749 (c >= '0' && c <= '9') ||
750 c == '-' || c == '_' || c == '.' || c == ':');
754 * Returns true if this is a valid user-defined property (one with a ':').
757 zfs_prop_user(const char *name)
761 boolean_t foundsep = B_FALSE;
763 for (i = 0; i < strlen(name); i++) {
778 * Returns true if this is a valid userspace-type property (one with a '@').
779 * Note that after the @, any character is valid (eg, another @, for SID
783 zfs_prop_userquota(const char *name)
785 zfs_userquota_prop_t prop;
787 for (prop = 0; prop < ZFS_NUM_USERQUOTA_PROPS; prop++) {
788 if (strncmp(name, zfs_userquota_prop_prefixes[prop],
789 strlen(zfs_userquota_prop_prefixes[prop])) == 0) {
798 * Returns true if this is a valid written@ property.
799 * Note that after the @, any character is valid (eg, another @, for
800 * written@pool/fs@origin).
803 zfs_prop_written(const char *name)
805 static const char *prop_prefix = "written@";
806 static const char *book_prefix = "written#";
807 return (strncmp(name, prop_prefix, strlen(prop_prefix)) == 0 ||
808 strncmp(name, book_prefix, strlen(book_prefix)) == 0);
812 * Tables of index types, plus functions to convert between the user view
813 * (strings) and internal representation (uint64_t).
816 zfs_prop_string_to_index(zfs_prop_t prop, const char *string, uint64_t *index)
818 return (zprop_string_to_index(prop, string, index, ZFS_TYPE_DATASET));
822 zfs_prop_index_to_string(zfs_prop_t prop, uint64_t index, const char **string)
824 return (zprop_index_to_string(prop, index, string, ZFS_TYPE_DATASET));
828 zfs_prop_random_value(zfs_prop_t prop, uint64_t seed)
830 return (zprop_random_value(prop, seed, ZFS_TYPE_DATASET));
834 * Returns TRUE if the property applies to any of the given dataset types.
837 zfs_prop_valid_for_type(int prop, zfs_type_t types, boolean_t headcheck)
839 return (zprop_valid_for_type(prop, types, headcheck));
843 zfs_prop_get_type(zfs_prop_t prop)
845 return (zfs_prop_table[prop].pd_proptype);
849 * Returns TRUE if the property is readonly.
852 zfs_prop_readonly(zfs_prop_t prop)
854 return (zfs_prop_table[prop].pd_attr == PROP_READONLY ||
855 zfs_prop_table[prop].pd_attr == PROP_ONETIME ||
856 zfs_prop_table[prop].pd_attr == PROP_ONETIME_DEFAULT);
860 * Returns TRUE if the property is visible (not hidden).
863 zfs_prop_visible(zfs_prop_t prop)
865 return (zfs_prop_table[prop].pd_visible &&
866 zfs_prop_table[prop].pd_zfs_mod_supported);
870 * Returns TRUE if the property is only allowed to be set once.
873 zfs_prop_setonce(zfs_prop_t prop)
875 return (zfs_prop_table[prop].pd_attr == PROP_ONETIME ||
876 zfs_prop_table[prop].pd_attr == PROP_ONETIME_DEFAULT);
880 zfs_prop_default_string(zfs_prop_t prop)
882 return (zfs_prop_table[prop].pd_strdefault);
886 zfs_prop_default_numeric(zfs_prop_t prop)
888 return (zfs_prop_table[prop].pd_numdefault);
892 * Given a dataset property ID, returns the corresponding name.
893 * Assuming the zfs dataset property ID is valid.
896 zfs_prop_to_name(zfs_prop_t prop)
898 return (zfs_prop_table[prop].pd_name);
902 * Returns TRUE if the property is inheritable.
905 zfs_prop_inheritable(zfs_prop_t prop)
907 return (zfs_prop_table[prop].pd_attr == PROP_INHERIT ||
908 zfs_prop_table[prop].pd_attr == PROP_ONETIME);
912 * Returns TRUE if property is one of the encryption properties that requires
913 * a loaded encryption key to modify.
916 zfs_prop_encryption_key_param(zfs_prop_t prop)
919 * keylocation does not count as an encryption property. It can be
920 * changed at will without needing the master keys.
922 return (prop == ZFS_PROP_PBKDF2_SALT || prop == ZFS_PROP_PBKDF2_ITERS ||
923 prop == ZFS_PROP_KEYFORMAT);
927 * Helper function used by both kernelspace and userspace to check the
928 * keylocation property. If encrypted is set, the keylocation must be valid
929 * for an encrypted dataset.
932 zfs_prop_valid_keylocation(const char *str, boolean_t encrypted)
934 if (strcmp("none", str) == 0)
936 else if (strcmp("prompt", str) == 0)
938 else if (strlen(str) > 8 && strncmp("file:///", str, 8) == 0)
949 * Returns a string describing the set of acceptable values for the given
950 * zfs property, or NULL if it cannot be set.
953 zfs_prop_values(zfs_prop_t prop)
955 return (zfs_prop_table[prop].pd_values);
959 * Returns TRUE if this property is a string type. Note that index types
960 * (compression, checksum) are treated as strings in userland, even though they
961 * are stored numerically on disk.
964 zfs_prop_is_string(zfs_prop_t prop)
966 return (zfs_prop_table[prop].pd_proptype == PROP_TYPE_STRING ||
967 zfs_prop_table[prop].pd_proptype == PROP_TYPE_INDEX);
971 * Returns the column header for the given property. Used only in
972 * 'zfs list -o', but centralized here with the other property information.
975 zfs_prop_column_name(zfs_prop_t prop)
977 return (zfs_prop_table[prop].pd_colname);
981 * Returns whether the given property should be displayed right-justified for
985 zfs_prop_align_right(zfs_prop_t prop)
987 return (zfs_prop_table[prop].pd_rightalign);
994 #include <sys/simd.h>
996 #if defined(HAVE_KERNEL_FPU_INTERNAL)
997 union fpregs_state **zfs_kfpu_fpregs;
998 EXPORT_SYMBOL(zfs_kfpu_fpregs);
999 #endif /* HAVE_KERNEL_FPU_INTERNAL */
1004 int error = kfpu_init();
1020 module_init(zcommon_init);
1021 module_exit(zcommon_fini);
1025 ZFS_MODULE_DESCRIPTION("Generic ZFS support");
1026 ZFS_MODULE_AUTHOR(ZFS_META_AUTHOR);
1027 ZFS_MODULE_LICENSE(ZFS_META_LICENSE);
1028 ZFS_MODULE_VERSION(ZFS_META_VERSION "-" ZFS_META_RELEASE);
1030 /* zfs dataset property functions */
1031 EXPORT_SYMBOL(zfs_userquota_prop_prefixes);
1032 EXPORT_SYMBOL(zfs_prop_init);
1033 EXPORT_SYMBOL(zfs_prop_get_type);
1034 EXPORT_SYMBOL(zfs_prop_get_table);
1035 EXPORT_SYMBOL(zfs_prop_delegatable);
1036 EXPORT_SYMBOL(zfs_prop_visible);
1038 /* Dataset property functions shared between libzfs and kernel. */
1039 EXPORT_SYMBOL(zfs_prop_default_string);
1040 EXPORT_SYMBOL(zfs_prop_default_numeric);
1041 EXPORT_SYMBOL(zfs_prop_readonly);
1042 EXPORT_SYMBOL(zfs_prop_inheritable);
1043 EXPORT_SYMBOL(zfs_prop_encryption_key_param);
1044 EXPORT_SYMBOL(zfs_prop_valid_keylocation);
1045 EXPORT_SYMBOL(zfs_prop_setonce);
1046 EXPORT_SYMBOL(zfs_prop_to_name);
1047 EXPORT_SYMBOL(zfs_name_to_prop);
1048 EXPORT_SYMBOL(zfs_prop_user);
1049 EXPORT_SYMBOL(zfs_prop_userquota);
1050 EXPORT_SYMBOL(zfs_prop_index_to_string);
1051 EXPORT_SYMBOL(zfs_prop_string_to_index);
1052 EXPORT_SYMBOL(zfs_prop_valid_for_type);
1053 EXPORT_SYMBOL(zfs_prop_written);