xref: /titanic_41/usr/src/common/zfs/zfs_prop.c (revision 0b8f054691a3974b7c86dd2700ecbf6108a2d55e)
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  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #include <sys/zio.h>
27 #include <sys/spa.h>
28 #include <sys/u8_textprep.h>
29 #include <sys/zfs_acl.h>
30 #include <sys/zfs_ioctl.h>
31 #include <sys/zfs_znode.h>
32 
33 #include "zfs_prop.h"
34 #include "zfs_deleg.h"
35 
36 #if defined(_KERNEL)
37 #include <sys/systm.h>
38 #else
39 #include <stdlib.h>
40 #include <string.h>
41 #include <ctype.h>
42 #endif
43 
44 static zprop_desc_t zfs_prop_table[ZFS_NUM_PROPS];
45 
46 /* Note this is indexed by zfs_userquota_prop_t, keep the order the same */
47 const char *zfs_userquota_prop_prefixes[] = {
48 	"userused@",
49 	"userquota@",
50 	"groupused@",
51 	"groupquota@"
52 };
53 
54 zprop_desc_t *
55 zfs_prop_get_table(void)
56 {
57 	return (zfs_prop_table);
58 }
59 
60 void
61 zfs_prop_init(void)
62 {
63 	static zprop_index_t checksum_table[] = {
64 		{ "on",		ZIO_CHECKSUM_ON },
65 		{ "off",	ZIO_CHECKSUM_OFF },
66 		{ "fletcher2",	ZIO_CHECKSUM_FLETCHER_2 },
67 		{ "fletcher4",	ZIO_CHECKSUM_FLETCHER_4 },
68 		{ "sha256",	ZIO_CHECKSUM_SHA256 },
69 		{ NULL }
70 	};
71 
72 	static zprop_index_t compress_table[] = {
73 		{ "on",		ZIO_COMPRESS_ON },
74 		{ "off",	ZIO_COMPRESS_OFF },
75 		{ "lzjb",	ZIO_COMPRESS_LZJB },
76 		{ "gzip",	ZIO_COMPRESS_GZIP_6 },	/* gzip default */
77 		{ "gzip-1",	ZIO_COMPRESS_GZIP_1 },
78 		{ "gzip-2",	ZIO_COMPRESS_GZIP_2 },
79 		{ "gzip-3",	ZIO_COMPRESS_GZIP_3 },
80 		{ "gzip-4",	ZIO_COMPRESS_GZIP_4 },
81 		{ "gzip-5",	ZIO_COMPRESS_GZIP_5 },
82 		{ "gzip-6",	ZIO_COMPRESS_GZIP_6 },
83 		{ "gzip-7",	ZIO_COMPRESS_GZIP_7 },
84 		{ "gzip-8",	ZIO_COMPRESS_GZIP_8 },
85 		{ "gzip-9",	ZIO_COMPRESS_GZIP_9 },
86 		{ NULL }
87 	};
88 
89 	static zprop_index_t snapdir_table[] = {
90 		{ "hidden",	ZFS_SNAPDIR_HIDDEN },
91 		{ "visible",	ZFS_SNAPDIR_VISIBLE },
92 		{ NULL }
93 	};
94 
95 	static zprop_index_t acl_mode_table[] = {
96 		{ "discard",	ZFS_ACL_DISCARD },
97 		{ "groupmask",	ZFS_ACL_GROUPMASK },
98 		{ "passthrough", ZFS_ACL_PASSTHROUGH },
99 		{ NULL }
100 	};
101 
102 	static zprop_index_t acl_inherit_table[] = {
103 		{ "discard",	ZFS_ACL_DISCARD },
104 		{ "noallow",	ZFS_ACL_NOALLOW },
105 		{ "restricted",	ZFS_ACL_RESTRICTED },
106 		{ "passthrough", ZFS_ACL_PASSTHROUGH },
107 		{ "secure",	ZFS_ACL_RESTRICTED }, /* bkwrd compatability */
108 		{ "passthrough-x", ZFS_ACL_PASSTHROUGH_X },
109 		{ NULL }
110 	};
111 
112 	static zprop_index_t case_table[] = {
113 		{ "sensitive",		ZFS_CASE_SENSITIVE },
114 		{ "insensitive",	ZFS_CASE_INSENSITIVE },
115 		{ "mixed",		ZFS_CASE_MIXED },
116 		{ NULL }
117 	};
118 
119 	static zprop_index_t copies_table[] = {
120 		{ "1",		1 },
121 		{ "2",		2 },
122 		{ "3",		3 },
123 		{ NULL }
124 	};
125 
126 	/*
127 	 * Use the unique flags we have to send to u8_strcmp() and/or
128 	 * u8_textprep() to represent the various normalization property
129 	 * values.
130 	 */
131 	static zprop_index_t normalize_table[] = {
132 		{ "none",	0 },
133 		{ "formD",	U8_TEXTPREP_NFD },
134 		{ "formKC",	U8_TEXTPREP_NFKC },
135 		{ "formC",	U8_TEXTPREP_NFC },
136 		{ "formKD",	U8_TEXTPREP_NFKD },
137 		{ NULL }
138 	};
139 
140 	static zprop_index_t version_table[] = {
141 		{ "1",		1 },
142 		{ "2",		2 },
143 		{ "3",		3 },
144 		{ "4",		4 },
145 		{ "current",	ZPL_VERSION },
146 		{ NULL }
147 	};
148 
149 	static zprop_index_t boolean_table[] = {
150 		{ "off",	0 },
151 		{ "on",		1 },
152 		{ NULL }
153 	};
154 
155 	static zprop_index_t canmount_table[] = {
156 		{ "off",	ZFS_CANMOUNT_OFF },
157 		{ "on",		ZFS_CANMOUNT_ON },
158 		{ "noauto",	ZFS_CANMOUNT_NOAUTO },
159 		{ NULL }
160 	};
161 
162 	static zprop_index_t cache_table[] = {
163 		{ "none",	ZFS_CACHE_NONE },
164 		{ "metadata",	ZFS_CACHE_METADATA },
165 		{ "all",	ZFS_CACHE_ALL },
166 		{ NULL }
167 	};
168 
169 	/* inherit index properties */
170 	register_index(ZFS_PROP_CHECKSUM, "checksum", ZIO_CHECKSUM_DEFAULT,
171 	    PROP_INHERIT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
172 	    "on | off | fletcher2 | fletcher4 | sha256", "CHECKSUM",
173 	    checksum_table);
174 	register_index(ZFS_PROP_COMPRESSION, "compression",
175 	    ZIO_COMPRESS_DEFAULT, PROP_INHERIT,
176 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
177 	    "on | off | lzjb | gzip | gzip-[1-9]", "COMPRESS", compress_table);
178 	register_index(ZFS_PROP_SNAPDIR, "snapdir", ZFS_SNAPDIR_HIDDEN,
179 	    PROP_INHERIT, ZFS_TYPE_FILESYSTEM,
180 	    "hidden | visible", "SNAPDIR", snapdir_table);
181 	register_index(ZFS_PROP_ACLMODE, "aclmode", ZFS_ACL_GROUPMASK,
182 	    PROP_INHERIT, ZFS_TYPE_FILESYSTEM,
183 	    "discard | groupmask | passthrough", "ACLMODE", acl_mode_table);
184 	register_index(ZFS_PROP_ACLINHERIT, "aclinherit", ZFS_ACL_RESTRICTED,
185 	    PROP_INHERIT, ZFS_TYPE_FILESYSTEM,
186 	    "discard | noallow | restricted | passthrough | passthrough-x",
187 	    "ACLINHERIT", acl_inherit_table);
188 	register_index(ZFS_PROP_COPIES, "copies", 1,
189 	    PROP_INHERIT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
190 	    "1 | 2 | 3", "COPIES", copies_table);
191 	register_index(ZFS_PROP_PRIMARYCACHE, "primarycache",
192 	    ZFS_CACHE_ALL, PROP_INHERIT,
193 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT | ZFS_TYPE_VOLUME,
194 	    "all | none | metadata", "PRIMARYCACHE", cache_table);
195 	register_index(ZFS_PROP_SECONDARYCACHE, "secondarycache",
196 	    ZFS_CACHE_ALL, PROP_INHERIT,
197 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT | ZFS_TYPE_VOLUME,
198 	    "all | none | metadata", "SECONDARYCACHE", cache_table);
199 
200 	/* inherit index (boolean) properties */
201 	register_index(ZFS_PROP_ATIME, "atime", 1, PROP_INHERIT,
202 	    ZFS_TYPE_FILESYSTEM, "on | off", "ATIME", boolean_table);
203 	register_index(ZFS_PROP_DEVICES, "devices", 1, PROP_INHERIT,
204 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT, "on | off", "DEVICES",
205 	    boolean_table);
206 	register_index(ZFS_PROP_EXEC, "exec", 1, PROP_INHERIT,
207 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT, "on | off", "EXEC",
208 	    boolean_table);
209 	register_index(ZFS_PROP_SETUID, "setuid", 1, PROP_INHERIT,
210 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT, "on | off", "SETUID",
211 	    boolean_table);
212 	register_index(ZFS_PROP_READONLY, "readonly", 0, PROP_INHERIT,
213 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "on | off", "RDONLY",
214 	    boolean_table);
215 	register_index(ZFS_PROP_ZONED, "zoned", 0, PROP_INHERIT,
216 	    ZFS_TYPE_FILESYSTEM, "on | off", "ZONED", boolean_table);
217 	register_index(ZFS_PROP_XATTR, "xattr", 1, PROP_INHERIT,
218 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT, "on | off", "XATTR",
219 	    boolean_table);
220 	register_index(ZFS_PROP_VSCAN, "vscan", 0, PROP_INHERIT,
221 	    ZFS_TYPE_FILESYSTEM, "on | off", "VSCAN",
222 	    boolean_table);
223 	register_index(ZFS_PROP_NBMAND, "nbmand", 0, PROP_INHERIT,
224 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT, "on | off", "NBMAND",
225 	    boolean_table);
226 
227 	/* default index properties */
228 	register_index(ZFS_PROP_VERSION, "version", 0, PROP_DEFAULT,
229 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT,
230 	    "1 | 2 | 3 | 4 | current", "VERSION", version_table);
231 	register_index(ZFS_PROP_CANMOUNT, "canmount", ZFS_CANMOUNT_ON,
232 	    PROP_DEFAULT, ZFS_TYPE_FILESYSTEM, "on | off | noauto",
233 	    "CANMOUNT", canmount_table);
234 
235 	/* readonly index (boolean) properties */
236 	register_index(ZFS_PROP_MOUNTED, "mounted", 0, PROP_READONLY,
237 	    ZFS_TYPE_FILESYSTEM, "yes | no", "MOUNTED", boolean_table);
238 
239 	/* set once index properties */
240 	register_index(ZFS_PROP_NORMALIZE, "normalization", 0,
241 	    PROP_ONETIME, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT,
242 	    "none | formC | formD | formKC | formKD", "NORMALIZATION",
243 	    normalize_table);
244 	register_index(ZFS_PROP_CASE, "casesensitivity", ZFS_CASE_SENSITIVE,
245 	    PROP_ONETIME, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT,
246 	    "sensitive | insensitive | mixed", "CASE", case_table);
247 
248 	/* set once index (boolean) properties */
249 	register_index(ZFS_PROP_UTF8ONLY, "utf8only", 0, PROP_ONETIME,
250 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT,
251 	    "on | off", "UTF8ONLY", boolean_table);
252 
253 	/* string properties */
254 	register_string(ZFS_PROP_ORIGIN, "origin", NULL, PROP_READONLY,
255 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<snapshot>", "ORIGIN");
256 	register_string(ZFS_PROP_MOUNTPOINT, "mountpoint", "/", PROP_INHERIT,
257 	    ZFS_TYPE_FILESYSTEM, "<path> | legacy | none", "MOUNTPOINT");
258 	register_string(ZFS_PROP_SHARENFS, "sharenfs", "off", PROP_INHERIT,
259 	    ZFS_TYPE_FILESYSTEM, "on | off | share(1M) options", "SHARENFS");
260 	register_string(ZFS_PROP_SHAREISCSI, "shareiscsi", "off", PROP_INHERIT,
261 	    ZFS_TYPE_DATASET, "on | off | type=<type>", "SHAREISCSI");
262 	register_string(ZFS_PROP_TYPE, "type", NULL, PROP_READONLY,
263 	    ZFS_TYPE_DATASET, "filesystem | volume | snapshot", "TYPE");
264 	register_string(ZFS_PROP_SHARESMB, "sharesmb", "off", PROP_INHERIT,
265 	    ZFS_TYPE_FILESYSTEM, "on | off | sharemgr(1M) options", "SHARESMB");
266 
267 	/* readonly number properties */
268 	register_number(ZFS_PROP_USED, "used", 0, PROP_READONLY,
269 	    ZFS_TYPE_DATASET, "<size>", "USED");
270 	register_number(ZFS_PROP_AVAILABLE, "available", 0, PROP_READONLY,
271 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<size>", "AVAIL");
272 	register_number(ZFS_PROP_REFERENCED, "referenced", 0, PROP_READONLY,
273 	    ZFS_TYPE_DATASET, "<size>", "REFER");
274 	register_number(ZFS_PROP_COMPRESSRATIO, "compressratio", 0,
275 	    PROP_READONLY, ZFS_TYPE_DATASET,
276 	    "<1.00x or higher if compressed>", "RATIO");
277 	register_number(ZFS_PROP_VOLBLOCKSIZE, "volblocksize", 8192,
278 	    PROP_ONETIME,
279 	    ZFS_TYPE_VOLUME, "512 to 128k, power of 2",	"VOLBLOCK");
280 	register_number(ZFS_PROP_USEDSNAP, "usedbysnapshots", 0, PROP_READONLY,
281 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<size>", "USEDSNAP");
282 	register_number(ZFS_PROP_USEDDS, "usedbydataset", 0, PROP_READONLY,
283 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<size>", "USEDDS");
284 	register_number(ZFS_PROP_USEDCHILD, "usedbychildren", 0, PROP_READONLY,
285 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<size>", "USEDCHILD");
286 	register_number(ZFS_PROP_USEDREFRESERV, "usedbyrefreservation", 0,
287 	    PROP_READONLY,
288 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<size>", "USEDREFRESERV");
289 
290 	/* default number properties */
291 	register_number(ZFS_PROP_QUOTA, "quota", 0, PROP_DEFAULT,
292 	    ZFS_TYPE_FILESYSTEM, "<size> | none", "QUOTA");
293 	register_number(ZFS_PROP_RESERVATION, "reservation", 0, PROP_DEFAULT,
294 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<size> | none", "RESERV");
295 	register_number(ZFS_PROP_VOLSIZE, "volsize", 0, PROP_DEFAULT,
296 	    ZFS_TYPE_VOLUME, "<size>", "VOLSIZE");
297 	register_number(ZFS_PROP_REFQUOTA, "refquota", 0, PROP_DEFAULT,
298 	    ZFS_TYPE_FILESYSTEM, "<size> | none", "REFQUOTA");
299 	register_number(ZFS_PROP_REFRESERVATION, "refreservation", 0,
300 	    PROP_DEFAULT, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
301 	    "<size> | none", "REFRESERV");
302 
303 	/* inherit number properties */
304 	register_number(ZFS_PROP_RECORDSIZE, "recordsize", SPA_MAXBLOCKSIZE,
305 	    PROP_INHERIT,
306 	    ZFS_TYPE_FILESYSTEM, "512 to 128k, power of 2", "RECSIZE");
307 
308 	/* hidden properties */
309 	register_hidden(ZFS_PROP_CREATETXG, "createtxg", PROP_TYPE_NUMBER,
310 	    PROP_READONLY, ZFS_TYPE_DATASET, NULL);
311 	register_hidden(ZFS_PROP_NUMCLONES, "numclones", PROP_TYPE_NUMBER,
312 	    PROP_READONLY, ZFS_TYPE_SNAPSHOT, NULL);
313 	register_hidden(ZFS_PROP_NAME, "name", PROP_TYPE_STRING,
314 	    PROP_READONLY, ZFS_TYPE_DATASET, "NAME");
315 	register_hidden(ZFS_PROP_ISCSIOPTIONS, "iscsioptions", PROP_TYPE_STRING,
316 	    PROP_INHERIT, ZFS_TYPE_VOLUME, "ISCSIOPTIONS");
317 	register_hidden(ZFS_PROP_STMF_SHAREINFO, "stmf_sbd_lu",
318 	    PROP_TYPE_STRING, PROP_INHERIT, ZFS_TYPE_VOLUME,
319 	    "STMF_SBD_LU");
320 	register_hidden(ZFS_PROP_GUID, "guid", PROP_TYPE_NUMBER, PROP_READONLY,
321 	    ZFS_TYPE_DATASET, "GUID");
322 	register_hidden(ZFS_PROP_USERACCOUNTING, "useraccounting",
323 	    PROP_TYPE_NUMBER, PROP_READONLY, ZFS_TYPE_DATASET, NULL);
324 
325 	/* oddball properties */
326 	register_impl(ZFS_PROP_CREATION, "creation", PROP_TYPE_NUMBER, 0, NULL,
327 	    PROP_READONLY, ZFS_TYPE_DATASET,
328 	    "<date>", "CREATION", B_FALSE, B_TRUE, NULL);
329 }
330 
331 boolean_t
332 zfs_prop_delegatable(zfs_prop_t prop)
333 {
334 	zprop_desc_t *pd = &zfs_prop_table[prop];
335 	return (pd->pd_attr != PROP_READONLY);
336 }
337 
338 /*
339  * Given a zfs dataset property name, returns the corresponding property ID.
340  */
341 zfs_prop_t
342 zfs_name_to_prop(const char *propname)
343 {
344 	return (zprop_name_to_prop(propname, ZFS_TYPE_DATASET));
345 }
346 
347 /*
348  * For user property names, we allow all lowercase alphanumeric characters, plus
349  * a few useful punctuation characters.
350  */
351 static int
352 valid_char(char c)
353 {
354 	return ((c >= 'a' && c <= 'z') ||
355 	    (c >= '0' && c <= '9') ||
356 	    c == '-' || c == '_' || c == '.' || c == ':');
357 }
358 
359 /*
360  * Returns true if this is a valid user-defined property (one with a ':').
361  */
362 boolean_t
363 zfs_prop_user(const char *name)
364 {
365 	int i;
366 	char c;
367 	boolean_t foundsep = B_FALSE;
368 
369 	for (i = 0; i < strlen(name); i++) {
370 		c = name[i];
371 		if (!valid_char(c))
372 			return (B_FALSE);
373 		if (c == ':')
374 			foundsep = B_TRUE;
375 	}
376 
377 	if (!foundsep)
378 		return (B_FALSE);
379 
380 	return (B_TRUE);
381 }
382 
383 /*
384  * Returns true if this is a valid userspace-type property (one with a '@').
385  * Note that after the @, any character is valid (eg, another @, for SID
386  * user@domain).
387  */
388 boolean_t
389 zfs_prop_userquota(const char *name)
390 {
391 	zfs_userquota_prop_t prop;
392 
393 	for (prop = 0; prop < ZFS_NUM_USERQUOTA_PROPS; prop++) {
394 		if (strncmp(name, zfs_userquota_prop_prefixes[prop],
395 		    strlen(zfs_userquota_prop_prefixes[prop])) == 0) {
396 			return (B_TRUE);
397 		}
398 	}
399 
400 	return (B_FALSE);
401 }
402 
403 /*
404  * Tables of index types, plus functions to convert between the user view
405  * (strings) and internal representation (uint64_t).
406  */
407 int
408 zfs_prop_string_to_index(zfs_prop_t prop, const char *string, uint64_t *index)
409 {
410 	return (zprop_string_to_index(prop, string, index, ZFS_TYPE_DATASET));
411 }
412 
413 int
414 zfs_prop_index_to_string(zfs_prop_t prop, uint64_t index, const char **string)
415 {
416 	return (zprop_index_to_string(prop, index, string, ZFS_TYPE_DATASET));
417 }
418 
419 /*
420  * Returns TRUE if the property applies to any of the given dataset types.
421  */
422 boolean_t
423 zfs_prop_valid_for_type(int prop, zfs_type_t types)
424 {
425 	return (zprop_valid_for_type(prop, types));
426 }
427 
428 zprop_type_t
429 zfs_prop_get_type(zfs_prop_t prop)
430 {
431 	return (zfs_prop_table[prop].pd_proptype);
432 }
433 
434 /*
435  * Returns TRUE if the property is readonly.
436  */
437 boolean_t
438 zfs_prop_readonly(zfs_prop_t prop)
439 {
440 	return (zfs_prop_table[prop].pd_attr == PROP_READONLY ||
441 	    zfs_prop_table[prop].pd_attr == PROP_ONETIME);
442 }
443 
444 /*
445  * Returns TRUE if the property is only allowed to be set once.
446  */
447 boolean_t
448 zfs_prop_setonce(zfs_prop_t prop)
449 {
450 	return (zfs_prop_table[prop].pd_attr == PROP_ONETIME);
451 }
452 
453 const char *
454 zfs_prop_default_string(zfs_prop_t prop)
455 {
456 	return (zfs_prop_table[prop].pd_strdefault);
457 }
458 
459 uint64_t
460 zfs_prop_default_numeric(zfs_prop_t prop)
461 {
462 	return (zfs_prop_table[prop].pd_numdefault);
463 }
464 
465 /*
466  * Given a dataset property ID, returns the corresponding name.
467  * Assuming the zfs dataset property ID is valid.
468  */
469 const char *
470 zfs_prop_to_name(zfs_prop_t prop)
471 {
472 	return (zfs_prop_table[prop].pd_name);
473 }
474 
475 /*
476  * Returns TRUE if the property is inheritable.
477  */
478 boolean_t
479 zfs_prop_inheritable(zfs_prop_t prop)
480 {
481 	return (zfs_prop_table[prop].pd_attr == PROP_INHERIT ||
482 	    zfs_prop_table[prop].pd_attr == PROP_ONETIME);
483 }
484 
485 #ifndef _KERNEL
486 
487 /*
488  * Returns a string describing the set of acceptable values for the given
489  * zfs property, or NULL if it cannot be set.
490  */
491 const char *
492 zfs_prop_values(zfs_prop_t prop)
493 {
494 	return (zfs_prop_table[prop].pd_values);
495 }
496 
497 /*
498  * Returns TRUE if this property is a string type.  Note that index types
499  * (compression, checksum) are treated as strings in userland, even though they
500  * are stored numerically on disk.
501  */
502 int
503 zfs_prop_is_string(zfs_prop_t prop)
504 {
505 	return (zfs_prop_table[prop].pd_proptype == PROP_TYPE_STRING ||
506 	    zfs_prop_table[prop].pd_proptype == PROP_TYPE_INDEX);
507 }
508 
509 /*
510  * Returns the column header for the given property.  Used only in
511  * 'zfs list -o', but centralized here with the other property information.
512  */
513 const char *
514 zfs_prop_column_name(zfs_prop_t prop)
515 {
516 	return (zfs_prop_table[prop].pd_colname);
517 }
518 
519 /*
520  * Returns whether the given property should be displayed right-justified for
521  * 'zfs list'.
522  */
523 boolean_t
524 zfs_prop_align_right(zfs_prop_t prop)
525 {
526 	return (zfs_prop_table[prop].pd_rightalign);
527 }
528 
529 #endif
530