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 2007 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 /* 29 * Master property table. 30 * 31 * This table keeps track of all the properties supported by ZFS, and their 32 * various attributes. Not all of these are needed by the kernel, and several 33 * are only used by a single libzfs client. But having them here centralizes 34 * all property information in one location. 35 * 36 * name The human-readable string representing this property 37 * proptype Basic type (string, boolean, number) 38 * default Default value for the property. Sadly, C only allows 39 * you to initialize the first member of a union, so we 40 * have two default members for each property. 41 * attr Attributes (readonly, inheritable) for the property 42 * types Valid dataset types to which this applies 43 * values String describing acceptable values for the property 44 * colname The column header for 'zfs list' 45 * colfmt The column formatting for 'zfs list' 46 * 47 * This table must match the order of property types in libzfs.h. 48 */ 49 50 #include <sys/zio.h> 51 #include <sys/spa.h> 52 #include <sys/zfs_acl.h> 53 #include <sys/zfs_ioctl.h> 54 55 #include "zfs_prop.h" 56 57 #if defined(_KERNEL) 58 #include <sys/systm.h> 59 #else 60 #include <stdlib.h> 61 #include <string.h> 62 #include <ctype.h> 63 #endif 64 65 typedef enum { 66 prop_default, 67 prop_readonly, 68 prop_inherit 69 } prop_attr_t; 70 71 typedef struct { 72 const char *pd_name; 73 zfs_proptype_t pd_proptype; 74 uint64_t pd_numdefault; 75 const char *pd_strdefault; 76 prop_attr_t pd_attr; 77 int pd_types; 78 const char *pd_values; 79 const char *pd_colname; 80 boolean_t pd_rightalign; 81 } prop_desc_t; 82 83 static prop_desc_t zfs_prop_table[ZFS_NPROP_ALL] = { 84 { "type", prop_type_string, 0, NULL, prop_readonly, 85 ZFS_TYPE_ANY, "filesystem | volume | snapshot", "TYPE", B_TRUE }, 86 { "creation", prop_type_number, 0, NULL, prop_readonly, 87 ZFS_TYPE_ANY, "<date>", "CREATION", B_FALSE }, 88 { "used", prop_type_number, 0, NULL, prop_readonly, 89 ZFS_TYPE_ANY, "<size>", "USED", B_TRUE }, 90 { "available", prop_type_number, 0, NULL, prop_readonly, 91 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<size>", "AVAIL", B_TRUE }, 92 { "referenced", prop_type_number, 0, NULL, prop_readonly, 93 ZFS_TYPE_ANY, 94 "<size>", "REFER", B_TRUE }, 95 { "compressratio", prop_type_number, 0, NULL, prop_readonly, 96 ZFS_TYPE_ANY, "<1.00x or higher if compressed>", "RATIO", B_TRUE }, 97 { "mounted", prop_type_boolean, 0, NULL, prop_readonly, 98 ZFS_TYPE_FILESYSTEM, "yes | no | -", "MOUNTED", B_TRUE }, 99 { "origin", prop_type_string, 0, NULL, prop_readonly, 100 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, "<snapshot>", "ORIGIN", 101 B_FALSE }, 102 { "quota", prop_type_number, 0, NULL, prop_default, 103 ZFS_TYPE_FILESYSTEM, "<size> | none", "QUOTA", B_TRUE }, 104 { "reservation", prop_type_number, 0, NULL, prop_default, 105 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, 106 "<size> | none", "RESERV", B_TRUE }, 107 { "volsize", prop_type_number, 0, NULL, prop_default, 108 ZFS_TYPE_VOLUME, "<size>", "VOLSIZE", B_TRUE }, 109 { "volblocksize", prop_type_number, 8192, NULL, prop_readonly, 110 ZFS_TYPE_VOLUME, "512 to 128k, power of 2", "VOLBLOCK", B_TRUE }, 111 { "recordsize", prop_type_number, SPA_MAXBLOCKSIZE, NULL, 112 prop_inherit, 113 ZFS_TYPE_FILESYSTEM, 114 "512 to 128k, power of 2", "RECSIZE", B_TRUE }, 115 { "mountpoint", prop_type_string, 0, "/", prop_inherit, 116 ZFS_TYPE_FILESYSTEM, 117 "<path> | legacy | none", "MOUNTPOINT", B_FALSE }, 118 { "sharenfs", prop_type_string, 0, "off", prop_inherit, 119 ZFS_TYPE_FILESYSTEM, 120 "on | off | share(1M) options", "SHARENFS", B_FALSE }, 121 { "shareiscsi", prop_type_string, 0, "off", prop_inherit, 122 ZFS_TYPE_ANY, 123 "on | off | type=<type>", "SHAREISCSI", B_FALSE }, 124 { "checksum", prop_type_index, ZIO_CHECKSUM_DEFAULT, "on", 125 prop_inherit, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, 126 "on | off | fletcher2 | fletcher4 | sha256", "CHECKSUM", B_TRUE }, 127 { "compression", prop_type_index, ZIO_COMPRESS_DEFAULT, "off", 128 prop_inherit, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, 129 "on | off | lzjb", "COMPRESS", B_TRUE }, 130 { "atime", prop_type_boolean, 1, NULL, prop_inherit, 131 ZFS_TYPE_FILESYSTEM, 132 "on | off", "ATIME", B_TRUE }, 133 { "devices", prop_type_boolean, 1, NULL, prop_inherit, 134 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT, 135 "on | off", "DEVICES", B_TRUE }, 136 { "exec", prop_type_boolean, 1, NULL, prop_inherit, 137 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT, 138 "on | off", "EXEC", B_TRUE }, 139 { "setuid", prop_type_boolean, 1, NULL, prop_inherit, 140 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT, "on | off", "SETUID", 141 B_TRUE }, 142 { "readonly", prop_type_boolean, 0, NULL, prop_inherit, 143 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, 144 "on | off", "RDONLY", B_TRUE }, 145 { "zoned", prop_type_boolean, 0, NULL, prop_inherit, 146 ZFS_TYPE_FILESYSTEM, 147 "on | off", "ZONED", B_TRUE }, 148 { "snapdir", prop_type_index, ZFS_SNAPDIR_HIDDEN, "hidden", 149 prop_inherit, 150 ZFS_TYPE_FILESYSTEM, 151 "hidden | visible", "SNAPDIR", B_TRUE }, 152 { "aclmode", prop_type_index, ZFS_ACL_GROUPMASK, "groupmask", 153 prop_inherit, ZFS_TYPE_FILESYSTEM, 154 "discard | groupmask | passthrough", "ACLMODE", B_TRUE }, 155 { "aclinherit", prop_type_index, ZFS_ACL_SECURE, "secure", 156 prop_inherit, ZFS_TYPE_FILESYSTEM, 157 "discard | noallow | secure | passthrough", "ACLINHERIT", B_TRUE }, 158 { "canmount", prop_type_boolean, 1, NULL, prop_default, 159 ZFS_TYPE_FILESYSTEM, 160 "on | off", "CANMOUNT", B_TRUE }, 161 { "xattr", prop_type_boolean, 1, NULL, prop_inherit, 162 ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT, 163 "on | off", "XATTR", B_TRUE }, 164 { "createtxg", prop_type_number, 0, NULL, prop_readonly, 165 ZFS_TYPE_ANY, NULL, NULL, B_FALSE}, 166 { "name", prop_type_string, 0, NULL, prop_readonly, 167 ZFS_TYPE_ANY, NULL, "NAME", B_FALSE }, 168 { "iscsioptions", prop_type_string, 0, NULL, prop_inherit, 169 ZFS_TYPE_VOLUME, NULL, "ISCSIOPTIONS", B_FALSE }, 170 { "numclones", prop_type_number, 0, NULL, prop_readonly, 171 ZFS_TYPE_SNAPSHOT, NULL, NULL, B_FALSE }, 172 }; 173 174 zfs_proptype_t 175 zfs_prop_get_type(zfs_prop_t prop) 176 { 177 return (zfs_prop_table[prop].pd_proptype); 178 } 179 180 static boolean_t 181 propname_match(const char *p, zfs_prop_t prop, size_t len) 182 { 183 const char *propname = zfs_prop_table[prop].pd_name; 184 #ifndef _KERNEL 185 const char *colname = zfs_prop_table[prop].pd_colname; 186 int c; 187 #endif 188 189 #ifndef _KERNEL 190 if (colname == NULL) 191 return (B_FALSE); 192 #endif 193 194 if (len == strlen(propname) && 195 strncmp(p, propname, len) == 0) 196 return (B_TRUE); 197 198 #ifndef _KERNEL 199 if (len != strlen(colname)) 200 return (B_FALSE); 201 202 for (c = 0; c < len; c++) 203 if (p[c] != tolower(colname[c])) 204 break; 205 206 return (colname[c] == '\0'); 207 #else 208 return (B_FALSE); 209 #endif 210 } 211 212 213 /* 214 * Given a property name, returns the corresponding property ID. 215 */ 216 zfs_prop_t 217 zfs_name_to_prop(const char *propname) 218 { 219 int i; 220 221 for (i = 0; i < ZFS_NPROP_ALL; i++) { 222 if (propname_match(propname, i, strlen(propname))) 223 return (i); 224 } 225 226 return (ZFS_PROP_INVAL); 227 } 228 229 /* 230 * For user property names, we allow all lowercase alphanumeric characters, plus 231 * a few useful punctuation characters. 232 */ 233 static int 234 valid_char(char c) 235 { 236 return ((c >= 'a' && c <= 'z') || 237 (c >= '0' && c <= '9') || 238 c == '-' || c == '_' || c == '.' || c == ':'); 239 } 240 241 /* 242 * Returns true if this is a valid user-defined property (one with a ':'). 243 */ 244 boolean_t 245 zfs_prop_user(const char *name) 246 { 247 int i; 248 char c; 249 boolean_t foundsep = B_FALSE; 250 251 for (i = 0; i < strlen(name); i++) { 252 c = name[i]; 253 if (!valid_char(c)) 254 return (B_FALSE); 255 if (c == ':') 256 foundsep = B_TRUE; 257 } 258 259 if (!foundsep) 260 return (B_FALSE); 261 262 return (B_TRUE); 263 } 264 265 /* 266 * Return the default value for the given property. 267 */ 268 const char * 269 zfs_prop_default_string(zfs_prop_t prop) 270 { 271 return (zfs_prop_table[prop].pd_strdefault); 272 } 273 274 uint64_t 275 zfs_prop_default_numeric(zfs_prop_t prop) 276 { 277 return (zfs_prop_table[prop].pd_numdefault); 278 } 279 280 /* 281 * Returns TRUE if the property is readonly. 282 */ 283 int 284 zfs_prop_readonly(zfs_prop_t prop) 285 { 286 return (zfs_prop_table[prop].pd_attr == prop_readonly); 287 } 288 289 /* 290 * Given a property ID, returns the corresponding name. 291 */ 292 const char * 293 zfs_prop_to_name(zfs_prop_t prop) 294 { 295 return (zfs_prop_table[prop].pd_name); 296 } 297 298 /* 299 * Returns TRUE if the property is inheritable. 300 */ 301 int 302 zfs_prop_inheritable(zfs_prop_t prop) 303 { 304 return (zfs_prop_table[prop].pd_attr == prop_inherit); 305 } 306 307 typedef struct zfs_index { 308 const char *name; 309 uint64_t index; 310 } zfs_index_t; 311 312 static zfs_index_t checksum_table[] = { 313 { "on", ZIO_CHECKSUM_ON }, 314 { "off", ZIO_CHECKSUM_OFF }, 315 { "fletcher2", ZIO_CHECKSUM_FLETCHER_2 }, 316 { "fletcher4", ZIO_CHECKSUM_FLETCHER_4 }, 317 { "sha256", ZIO_CHECKSUM_SHA256 }, 318 { NULL } 319 }; 320 321 static zfs_index_t compress_table[] = { 322 { "on", ZIO_COMPRESS_ON }, 323 { "off", ZIO_COMPRESS_OFF }, 324 { "lzjb", ZIO_COMPRESS_LZJB }, 325 { NULL } 326 }; 327 328 static zfs_index_t snapdir_table[] = { 329 { "hidden", ZFS_SNAPDIR_HIDDEN }, 330 { "visible", ZFS_SNAPDIR_VISIBLE }, 331 { NULL } 332 }; 333 334 static zfs_index_t acl_mode_table[] = { 335 { "discard", ZFS_ACL_DISCARD }, 336 { "groupmask", ZFS_ACL_GROUPMASK }, 337 { "passthrough", ZFS_ACL_PASSTHROUGH }, 338 { NULL } 339 }; 340 341 static zfs_index_t acl_inherit_table[] = { 342 { "discard", ZFS_ACL_DISCARD }, 343 { "noallow", ZFS_ACL_NOALLOW }, 344 { "secure", ZFS_ACL_SECURE }, 345 { "passthrough", ZFS_ACL_PASSTHROUGH }, 346 { NULL } 347 }; 348 349 static zfs_index_t * 350 zfs_prop_index_table(zfs_prop_t prop) 351 { 352 switch (prop) { 353 case ZFS_PROP_CHECKSUM: 354 return (checksum_table); 355 case ZFS_PROP_COMPRESSION: 356 return (compress_table); 357 case ZFS_PROP_SNAPDIR: 358 return (snapdir_table); 359 case ZFS_PROP_ACLMODE: 360 return (acl_mode_table); 361 case ZFS_PROP_ACLINHERIT: 362 return (acl_inherit_table); 363 default: 364 return (NULL); 365 } 366 } 367 368 369 /* 370 * Tables of index types, plus functions to convert between the user view 371 * (strings) and internal representation (uint64_t). 372 */ 373 int 374 zfs_prop_string_to_index(zfs_prop_t prop, const char *string, uint64_t *index) 375 { 376 zfs_index_t *table; 377 int i; 378 379 if ((table = zfs_prop_index_table(prop)) == NULL) 380 return (-1); 381 382 for (i = 0; table[i].name != NULL; i++) { 383 if (strcmp(string, table[i].name) == 0) { 384 *index = table[i].index; 385 return (0); 386 } 387 } 388 389 return (-1); 390 } 391 392 int 393 zfs_prop_index_to_string(zfs_prop_t prop, uint64_t index, const char **string) 394 { 395 zfs_index_t *table; 396 int i; 397 398 if ((table = zfs_prop_index_table(prop)) == NULL) 399 return (-1); 400 401 for (i = 0; table[i].name != NULL; i++) { 402 if (table[i].index == index) { 403 *string = table[i].name; 404 return (0); 405 } 406 } 407 408 return (-1); 409 } 410 411 #ifndef _KERNEL 412 413 /* 414 * Returns TRUE if the property applies to the given dataset types. 415 */ 416 int 417 zfs_prop_valid_for_type(zfs_prop_t prop, int types) 418 { 419 return ((zfs_prop_table[prop].pd_types & types) != 0); 420 } 421 422 /* 423 * Returns a string describing the set of acceptable values for the given 424 * property, or NULL if it cannot be set. 425 */ 426 const char * 427 zfs_prop_values(zfs_prop_t prop) 428 { 429 return (zfs_prop_table[prop].pd_values); 430 } 431 432 /* 433 * Returns TRUE if this property is a string type. Note that index types 434 * (compression, checksum) are treated as strings in userland, even though they 435 * are stored numerically on disk. 436 */ 437 int 438 zfs_prop_is_string(zfs_prop_t prop) 439 { 440 return (zfs_prop_table[prop].pd_proptype == prop_type_string || 441 zfs_prop_table[prop].pd_proptype == prop_type_index); 442 } 443 444 /* 445 * Returns the column header for the given property. Used only in 446 * 'zfs list -o', but centralized here with the other property information. 447 */ 448 const char * 449 zfs_prop_column_name(zfs_prop_t prop) 450 { 451 return (zfs_prop_table[prop].pd_colname); 452 } 453 454 /* 455 * Returns whether the given property should be displayed right-justified for 456 * 'zfs list'. 457 */ 458 boolean_t 459 zfs_prop_align_right(zfs_prop_t prop) 460 { 461 return (zfs_prop_table[prop].pd_rightalign); 462 } 463 464 /* 465 * Determines the minimum width for the column, and indicates whether it's fixed 466 * or not. Only string columns are non-fixed. 467 */ 468 size_t 469 zfs_prop_width(zfs_prop_t prop, boolean_t *fixed) 470 { 471 prop_desc_t *pd = &zfs_prop_table[prop]; 472 zfs_index_t *idx; 473 size_t ret; 474 int i; 475 476 *fixed = B_TRUE; 477 478 /* 479 * Start with the width of the column name. 480 */ 481 ret = strlen(pd->pd_colname); 482 483 /* 484 * For fixed-width values, make sure the width is large enough to hold 485 * any possible value. 486 */ 487 switch (pd->pd_proptype) { 488 case prop_type_number: 489 /* 490 * The maximum length of a human-readable number is 5 characters 491 * ("20.4M", for example). 492 */ 493 if (ret < 5) 494 ret = 5; 495 /* 496 * 'creation' is handled specially because it's a number 497 * internally, but displayed as a date string. 498 */ 499 if (prop == ZFS_PROP_CREATION) 500 *fixed = B_FALSE; 501 break; 502 case prop_type_boolean: 503 /* 504 * The maximum length of a boolean value is 3 characters, for 505 * "off". 506 */ 507 if (ret < 3) 508 ret = 3; 509 break; 510 case prop_type_index: 511 idx = zfs_prop_index_table(prop); 512 for (i = 0; idx[i].name != NULL; i++) { 513 if (strlen(idx[i].name) > ret) 514 ret = strlen(idx[i].name); 515 } 516 break; 517 518 case prop_type_string: 519 *fixed = B_FALSE; 520 break; 521 } 522 523 return (ret); 524 } 525 526 #endif 527