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 /* 27 * Internal utility routines for the ZFS library. 28 */ 29 30 #include <errno.h> 31 #include <fcntl.h> 32 #include <libintl.h> 33 #include <stdarg.h> 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <strings.h> 37 #include <unistd.h> 38 #include <ctype.h> 39 #include <math.h> 40 #include <sys/mnttab.h> 41 #include <sys/mntent.h> 42 #include <sys/types.h> 43 44 #include <libzfs.h> 45 46 #include "libzfs_impl.h" 47 #include "zfs_prop.h" 48 49 int 50 libzfs_errno(libzfs_handle_t *hdl) 51 { 52 return (hdl->libzfs_error); 53 } 54 55 const char * 56 libzfs_error_action(libzfs_handle_t *hdl) 57 { 58 return (hdl->libzfs_action); 59 } 60 61 const char * 62 libzfs_error_description(libzfs_handle_t *hdl) 63 { 64 if (hdl->libzfs_desc[0] != '\0') 65 return (hdl->libzfs_desc); 66 67 switch (hdl->libzfs_error) { 68 case EZFS_NOMEM: 69 return (dgettext(TEXT_DOMAIN, "out of memory")); 70 case EZFS_BADPROP: 71 return (dgettext(TEXT_DOMAIN, "invalid property value")); 72 case EZFS_PROPREADONLY: 73 return (dgettext(TEXT_DOMAIN, "read only property")); 74 case EZFS_PROPTYPE: 75 return (dgettext(TEXT_DOMAIN, "property doesn't apply to " 76 "datasets of this type")); 77 case EZFS_PROPNONINHERIT: 78 return (dgettext(TEXT_DOMAIN, "property cannot be inherited")); 79 case EZFS_PROPSPACE: 80 return (dgettext(TEXT_DOMAIN, "invalid quota or reservation")); 81 case EZFS_BADTYPE: 82 return (dgettext(TEXT_DOMAIN, "operation not applicable to " 83 "datasets of this type")); 84 case EZFS_BUSY: 85 return (dgettext(TEXT_DOMAIN, "pool or dataset is busy")); 86 case EZFS_EXISTS: 87 return (dgettext(TEXT_DOMAIN, "pool or dataset exists")); 88 case EZFS_NOENT: 89 return (dgettext(TEXT_DOMAIN, "no such pool or dataset")); 90 case EZFS_BADSTREAM: 91 return (dgettext(TEXT_DOMAIN, "invalid backup stream")); 92 case EZFS_DSREADONLY: 93 return (dgettext(TEXT_DOMAIN, "dataset is read only")); 94 case EZFS_VOLTOOBIG: 95 return (dgettext(TEXT_DOMAIN, "volume size exceeds limit for " 96 "this system")); 97 case EZFS_INVALIDNAME: 98 return (dgettext(TEXT_DOMAIN, "invalid name")); 99 case EZFS_BADRESTORE: 100 return (dgettext(TEXT_DOMAIN, "unable to restore to " 101 "destination")); 102 case EZFS_BADBACKUP: 103 return (dgettext(TEXT_DOMAIN, "backup failed")); 104 case EZFS_BADTARGET: 105 return (dgettext(TEXT_DOMAIN, "invalid target vdev")); 106 case EZFS_NODEVICE: 107 return (dgettext(TEXT_DOMAIN, "no such device in pool")); 108 case EZFS_BADDEV: 109 return (dgettext(TEXT_DOMAIN, "invalid device")); 110 case EZFS_NOREPLICAS: 111 return (dgettext(TEXT_DOMAIN, "no valid replicas")); 112 case EZFS_RESILVERING: 113 return (dgettext(TEXT_DOMAIN, "currently resilvering")); 114 case EZFS_BADVERSION: 115 return (dgettext(TEXT_DOMAIN, "unsupported version")); 116 case EZFS_POOLUNAVAIL: 117 return (dgettext(TEXT_DOMAIN, "pool is unavailable")); 118 case EZFS_DEVOVERFLOW: 119 return (dgettext(TEXT_DOMAIN, "too many devices in one vdev")); 120 case EZFS_BADPATH: 121 return (dgettext(TEXT_DOMAIN, "must be an absolute path")); 122 case EZFS_CROSSTARGET: 123 return (dgettext(TEXT_DOMAIN, "operation crosses datasets or " 124 "pools")); 125 case EZFS_ZONED: 126 return (dgettext(TEXT_DOMAIN, "dataset in use by local zone")); 127 case EZFS_MOUNTFAILED: 128 return (dgettext(TEXT_DOMAIN, "mount failed")); 129 case EZFS_UMOUNTFAILED: 130 return (dgettext(TEXT_DOMAIN, "umount failed")); 131 case EZFS_UNSHARENFSFAILED: 132 return (dgettext(TEXT_DOMAIN, "unshare(1M) failed")); 133 case EZFS_SHARENFSFAILED: 134 return (dgettext(TEXT_DOMAIN, "share(1M) failed")); 135 case EZFS_UNSHARESMBFAILED: 136 return (dgettext(TEXT_DOMAIN, "smb remove share failed")); 137 case EZFS_SHARESMBFAILED: 138 return (dgettext(TEXT_DOMAIN, "smb add share failed")); 139 case EZFS_ISCSISVCUNAVAIL: 140 return (dgettext(TEXT_DOMAIN, 141 "iscsitgt service need to be enabled by " 142 "a privileged user")); 143 case EZFS_PERM: 144 return (dgettext(TEXT_DOMAIN, "permission denied")); 145 case EZFS_NOSPC: 146 return (dgettext(TEXT_DOMAIN, "out of space")); 147 case EZFS_IO: 148 return (dgettext(TEXT_DOMAIN, "I/O error")); 149 case EZFS_INTR: 150 return (dgettext(TEXT_DOMAIN, "signal received")); 151 case EZFS_ISSPARE: 152 return (dgettext(TEXT_DOMAIN, "device is reserved as a hot " 153 "spare")); 154 case EZFS_INVALCONFIG: 155 return (dgettext(TEXT_DOMAIN, "invalid vdev configuration")); 156 case EZFS_RECURSIVE: 157 return (dgettext(TEXT_DOMAIN, "recursive dataset dependency")); 158 case EZFS_NOHISTORY: 159 return (dgettext(TEXT_DOMAIN, "no history available")); 160 case EZFS_UNSHAREISCSIFAILED: 161 return (dgettext(TEXT_DOMAIN, 162 "iscsitgtd failed request to unshare")); 163 case EZFS_SHAREISCSIFAILED: 164 return (dgettext(TEXT_DOMAIN, 165 "iscsitgtd failed request to share")); 166 case EZFS_POOLPROPS: 167 return (dgettext(TEXT_DOMAIN, "failed to retrieve " 168 "pool properties")); 169 case EZFS_POOL_NOTSUP: 170 return (dgettext(TEXT_DOMAIN, "operation not supported " 171 "on this type of pool")); 172 case EZFS_POOL_INVALARG: 173 return (dgettext(TEXT_DOMAIN, "invalid argument for " 174 "this pool operation")); 175 case EZFS_NAMETOOLONG: 176 return (dgettext(TEXT_DOMAIN, "dataset name is too long")); 177 case EZFS_OPENFAILED: 178 return (dgettext(TEXT_DOMAIN, "open failed")); 179 case EZFS_NOCAP: 180 return (dgettext(TEXT_DOMAIN, 181 "disk capacity information could not be retrieved")); 182 case EZFS_LABELFAILED: 183 return (dgettext(TEXT_DOMAIN, "write of label failed")); 184 case EZFS_BADWHO: 185 return (dgettext(TEXT_DOMAIN, "invalid user/group")); 186 case EZFS_BADPERM: 187 return (dgettext(TEXT_DOMAIN, "invalid permission")); 188 case EZFS_BADPERMSET: 189 return (dgettext(TEXT_DOMAIN, "invalid permission set name")); 190 case EZFS_NODELEGATION: 191 return (dgettext(TEXT_DOMAIN, "delegated administration is " 192 "disabled on pool")); 193 case EZFS_PERMRDONLY: 194 return (dgettext(TEXT_DOMAIN, "snapshot permissions cannot be" 195 " modified")); 196 case EZFS_BADCACHE: 197 return (dgettext(TEXT_DOMAIN, "invalid or missing cache file")); 198 case EZFS_ISL2CACHE: 199 return (dgettext(TEXT_DOMAIN, "device is in use as a cache")); 200 case EZFS_VDEVNOTSUP: 201 return (dgettext(TEXT_DOMAIN, "vdev specification is not " 202 "supported")); 203 case EZFS_NOTSUP: 204 return (dgettext(TEXT_DOMAIN, "operation not supported " 205 "on this dataset")); 206 case EZFS_ACTIVE_SPARE: 207 return (dgettext(TEXT_DOMAIN, "pool has active shared spare " 208 "device")); 209 case EZFS_UNPLAYED_LOGS: 210 return (dgettext(TEXT_DOMAIN, "log device has unplayed intent " 211 "logs")); 212 case EZFS_REFTAG_RELE: 213 return (dgettext(TEXT_DOMAIN, "no such tag on this dataset")); 214 case EZFS_REFTAG_HOLD: 215 return (dgettext(TEXT_DOMAIN, "tag already exists on this " 216 "dataset")); 217 case EZFS_TAGTOOLONG: 218 return (dgettext(TEXT_DOMAIN, "tag too long")); 219 case EZFS_UNKNOWN: 220 return (dgettext(TEXT_DOMAIN, "unknown error")); 221 default: 222 assert(hdl->libzfs_error == 0); 223 return (dgettext(TEXT_DOMAIN, "no error")); 224 } 225 } 226 227 /*PRINTFLIKE2*/ 228 void 229 zfs_error_aux(libzfs_handle_t *hdl, const char *fmt, ...) 230 { 231 va_list ap; 232 233 va_start(ap, fmt); 234 235 (void) vsnprintf(hdl->libzfs_desc, sizeof (hdl->libzfs_desc), 236 fmt, ap); 237 hdl->libzfs_desc_active = 1; 238 239 va_end(ap); 240 } 241 242 static void 243 zfs_verror(libzfs_handle_t *hdl, int error, const char *fmt, va_list ap) 244 { 245 (void) vsnprintf(hdl->libzfs_action, sizeof (hdl->libzfs_action), 246 fmt, ap); 247 hdl->libzfs_error = error; 248 249 if (hdl->libzfs_desc_active) 250 hdl->libzfs_desc_active = 0; 251 else 252 hdl->libzfs_desc[0] = '\0'; 253 254 if (hdl->libzfs_printerr) { 255 if (error == EZFS_UNKNOWN) { 256 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, "internal " 257 "error: %s\n"), libzfs_error_description(hdl)); 258 abort(); 259 } 260 261 (void) fprintf(stderr, "%s: %s\n", hdl->libzfs_action, 262 libzfs_error_description(hdl)); 263 if (error == EZFS_NOMEM) 264 exit(1); 265 } 266 } 267 268 int 269 zfs_error(libzfs_handle_t *hdl, int error, const char *msg) 270 { 271 return (zfs_error_fmt(hdl, error, "%s", msg)); 272 } 273 274 /*PRINTFLIKE3*/ 275 int 276 zfs_error_fmt(libzfs_handle_t *hdl, int error, const char *fmt, ...) 277 { 278 va_list ap; 279 280 va_start(ap, fmt); 281 282 zfs_verror(hdl, error, fmt, ap); 283 284 va_end(ap); 285 286 return (-1); 287 } 288 289 static int 290 zfs_common_error(libzfs_handle_t *hdl, int error, const char *fmt, 291 va_list ap) 292 { 293 switch (error) { 294 case EPERM: 295 case EACCES: 296 zfs_verror(hdl, EZFS_PERM, fmt, ap); 297 return (-1); 298 299 case ECANCELED: 300 zfs_verror(hdl, EZFS_NODELEGATION, fmt, ap); 301 return (-1); 302 303 case EIO: 304 zfs_verror(hdl, EZFS_IO, fmt, ap); 305 return (-1); 306 307 case EINTR: 308 zfs_verror(hdl, EZFS_INTR, fmt, ap); 309 return (-1); 310 } 311 312 return (0); 313 } 314 315 int 316 zfs_standard_error(libzfs_handle_t *hdl, int error, const char *msg) 317 { 318 return (zfs_standard_error_fmt(hdl, error, "%s", msg)); 319 } 320 321 /*PRINTFLIKE3*/ 322 int 323 zfs_standard_error_fmt(libzfs_handle_t *hdl, int error, const char *fmt, ...) 324 { 325 va_list ap; 326 327 va_start(ap, fmt); 328 329 if (zfs_common_error(hdl, error, fmt, ap) != 0) { 330 va_end(ap); 331 return (-1); 332 } 333 334 switch (error) { 335 case ENXIO: 336 case ENODEV: 337 zfs_verror(hdl, EZFS_IO, fmt, ap); 338 break; 339 340 case ENOENT: 341 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 342 "dataset does not exist")); 343 zfs_verror(hdl, EZFS_NOENT, fmt, ap); 344 break; 345 346 case ENOSPC: 347 case EDQUOT: 348 zfs_verror(hdl, EZFS_NOSPC, fmt, ap); 349 return (-1); 350 351 case EEXIST: 352 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 353 "dataset already exists")); 354 zfs_verror(hdl, EZFS_EXISTS, fmt, ap); 355 break; 356 357 case EBUSY: 358 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 359 "dataset is busy")); 360 zfs_verror(hdl, EZFS_BUSY, fmt, ap); 361 break; 362 case EROFS: 363 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 364 "snapshot permissions cannot be modified")); 365 zfs_verror(hdl, EZFS_PERMRDONLY, fmt, ap); 366 break; 367 case ENAMETOOLONG: 368 zfs_verror(hdl, EZFS_NAMETOOLONG, fmt, ap); 369 break; 370 case ENOTSUP: 371 zfs_verror(hdl, EZFS_BADVERSION, fmt, ap); 372 break; 373 case EAGAIN: 374 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 375 "pool I/O is currently suspended")); 376 zfs_verror(hdl, EZFS_POOLUNAVAIL, fmt, ap); 377 break; 378 default: 379 zfs_error_aux(hdl, strerror(errno)); 380 zfs_verror(hdl, EZFS_UNKNOWN, fmt, ap); 381 break; 382 } 383 384 va_end(ap); 385 return (-1); 386 } 387 388 int 389 zpool_standard_error(libzfs_handle_t *hdl, int error, const char *msg) 390 { 391 return (zpool_standard_error_fmt(hdl, error, "%s", msg)); 392 } 393 394 /*PRINTFLIKE3*/ 395 int 396 zpool_standard_error_fmt(libzfs_handle_t *hdl, int error, const char *fmt, ...) 397 { 398 va_list ap; 399 400 va_start(ap, fmt); 401 402 if (zfs_common_error(hdl, error, fmt, ap) != 0) { 403 va_end(ap); 404 return (-1); 405 } 406 407 switch (error) { 408 case ENODEV: 409 zfs_verror(hdl, EZFS_NODEVICE, fmt, ap); 410 break; 411 412 case ENOENT: 413 zfs_error_aux(hdl, 414 dgettext(TEXT_DOMAIN, "no such pool or dataset")); 415 zfs_verror(hdl, EZFS_NOENT, fmt, ap); 416 break; 417 418 case EEXIST: 419 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 420 "pool already exists")); 421 zfs_verror(hdl, EZFS_EXISTS, fmt, ap); 422 break; 423 424 case EBUSY: 425 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "pool is busy")); 426 zfs_verror(hdl, EZFS_BUSY, fmt, ap); 427 break; 428 429 case ENXIO: 430 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 431 "one or more devices is currently unavailable")); 432 zfs_verror(hdl, EZFS_BADDEV, fmt, ap); 433 break; 434 435 case ENAMETOOLONG: 436 zfs_verror(hdl, EZFS_DEVOVERFLOW, fmt, ap); 437 break; 438 439 case ENOTSUP: 440 zfs_verror(hdl, EZFS_POOL_NOTSUP, fmt, ap); 441 break; 442 443 case EINVAL: 444 zfs_verror(hdl, EZFS_POOL_INVALARG, fmt, ap); 445 break; 446 447 case ENOSPC: 448 case EDQUOT: 449 zfs_verror(hdl, EZFS_NOSPC, fmt, ap); 450 return (-1); 451 case EAGAIN: 452 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 453 "pool I/O is currently suspended")); 454 zfs_verror(hdl, EZFS_POOLUNAVAIL, fmt, ap); 455 break; 456 457 default: 458 zfs_error_aux(hdl, strerror(error)); 459 zfs_verror(hdl, EZFS_UNKNOWN, fmt, ap); 460 } 461 462 va_end(ap); 463 return (-1); 464 } 465 466 /* 467 * Display an out of memory error message and abort the current program. 468 */ 469 int 470 no_memory(libzfs_handle_t *hdl) 471 { 472 return (zfs_error(hdl, EZFS_NOMEM, "internal error")); 473 } 474 475 /* 476 * A safe form of malloc() which will die if the allocation fails. 477 */ 478 void * 479 zfs_alloc(libzfs_handle_t *hdl, size_t size) 480 { 481 void *data; 482 483 if ((data = calloc(1, size)) == NULL) 484 (void) no_memory(hdl); 485 486 return (data); 487 } 488 489 /* 490 * A safe form of realloc(), which also zeroes newly allocated space. 491 */ 492 void * 493 zfs_realloc(libzfs_handle_t *hdl, void *ptr, size_t oldsize, size_t newsize) 494 { 495 void *ret; 496 497 if ((ret = realloc(ptr, newsize)) == NULL) { 498 (void) no_memory(hdl); 499 return (NULL); 500 } 501 502 bzero((char *)ret + oldsize, (newsize - oldsize)); 503 return (ret); 504 } 505 506 /* 507 * A safe form of strdup() which will die if the allocation fails. 508 */ 509 char * 510 zfs_strdup(libzfs_handle_t *hdl, const char *str) 511 { 512 char *ret; 513 514 if ((ret = strdup(str)) == NULL) 515 (void) no_memory(hdl); 516 517 return (ret); 518 } 519 520 /* 521 * Convert a number to an appropriately human-readable output. 522 */ 523 void 524 zfs_nicenum(uint64_t num, char *buf, size_t buflen) 525 { 526 uint64_t n = num; 527 int index = 0; 528 char u; 529 530 while (n >= 1024) { 531 n /= 1024; 532 index++; 533 } 534 535 u = " KMGTPE"[index]; 536 537 if (index == 0) { 538 (void) snprintf(buf, buflen, "%llu", n); 539 } else if ((num & ((1ULL << 10 * index) - 1)) == 0) { 540 /* 541 * If this is an even multiple of the base, always display 542 * without any decimal precision. 543 */ 544 (void) snprintf(buf, buflen, "%llu%c", n, u); 545 } else { 546 /* 547 * We want to choose a precision that reflects the best choice 548 * for fitting in 5 characters. This can get rather tricky when 549 * we have numbers that are very close to an order of magnitude. 550 * For example, when displaying 10239 (which is really 9.999K), 551 * we want only a single place of precision for 10.0K. We could 552 * develop some complex heuristics for this, but it's much 553 * easier just to try each combination in turn. 554 */ 555 int i; 556 for (i = 2; i >= 0; i--) { 557 if (snprintf(buf, buflen, "%.*f%c", i, 558 (double)num / (1ULL << 10 * index), u) <= 5) 559 break; 560 } 561 } 562 } 563 564 void 565 libzfs_print_on_error(libzfs_handle_t *hdl, boolean_t printerr) 566 { 567 hdl->libzfs_printerr = printerr; 568 } 569 570 libzfs_handle_t * 571 libzfs_init(void) 572 { 573 libzfs_handle_t *hdl; 574 575 if ((hdl = calloc(sizeof (libzfs_handle_t), 1)) == NULL) { 576 return (NULL); 577 } 578 579 if ((hdl->libzfs_fd = open(ZFS_DEV, O_RDWR)) < 0) { 580 free(hdl); 581 return (NULL); 582 } 583 584 if ((hdl->libzfs_mnttab = fopen(MNTTAB, "r")) == NULL) { 585 (void) close(hdl->libzfs_fd); 586 free(hdl); 587 return (NULL); 588 } 589 590 hdl->libzfs_sharetab = fopen("/etc/dfs/sharetab", "r"); 591 592 zfs_prop_init(); 593 zpool_prop_init(); 594 libzfs_mnttab_init(hdl); 595 596 return (hdl); 597 } 598 599 void 600 libzfs_fini(libzfs_handle_t *hdl) 601 { 602 (void) close(hdl->libzfs_fd); 603 if (hdl->libzfs_mnttab) 604 (void) fclose(hdl->libzfs_mnttab); 605 if (hdl->libzfs_sharetab) 606 (void) fclose(hdl->libzfs_sharetab); 607 zfs_uninit_libshare(hdl); 608 if (hdl->libzfs_log_str) 609 (void) free(hdl->libzfs_log_str); 610 zpool_free_handles(hdl); 611 namespace_clear(hdl); 612 libzfs_mnttab_fini(hdl); 613 free(hdl); 614 } 615 616 libzfs_handle_t * 617 zpool_get_handle(zpool_handle_t *zhp) 618 { 619 return (zhp->zpool_hdl); 620 } 621 622 libzfs_handle_t * 623 zfs_get_handle(zfs_handle_t *zhp) 624 { 625 return (zhp->zfs_hdl); 626 } 627 628 zpool_handle_t * 629 zfs_get_pool_handle(const zfs_handle_t *zhp) 630 { 631 return (zhp->zpool_hdl); 632 } 633 634 /* 635 * Given a name, determine whether or not it's a valid path 636 * (starts with '/' or "./"). If so, walk the mnttab trying 637 * to match the device number. If not, treat the path as an 638 * fs/vol/snap name. 639 */ 640 zfs_handle_t * 641 zfs_path_to_zhandle(libzfs_handle_t *hdl, char *path, zfs_type_t argtype) 642 { 643 struct stat64 statbuf; 644 struct extmnttab entry; 645 int ret; 646 647 if (path[0] != '/' && strncmp(path, "./", strlen("./")) != 0) { 648 /* 649 * It's not a valid path, assume it's a name of type 'argtype'. 650 */ 651 return (zfs_open(hdl, path, argtype)); 652 } 653 654 if (stat64(path, &statbuf) != 0) { 655 (void) fprintf(stderr, "%s: %s\n", path, strerror(errno)); 656 return (NULL); 657 } 658 659 rewind(hdl->libzfs_mnttab); 660 while ((ret = getextmntent(hdl->libzfs_mnttab, &entry, 0)) == 0) { 661 if (makedevice(entry.mnt_major, entry.mnt_minor) == 662 statbuf.st_dev) { 663 break; 664 } 665 } 666 if (ret != 0) { 667 return (NULL); 668 } 669 670 if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) { 671 (void) fprintf(stderr, gettext("'%s': not a ZFS filesystem\n"), 672 path); 673 return (NULL); 674 } 675 676 return (zfs_open(hdl, entry.mnt_special, ZFS_TYPE_FILESYSTEM)); 677 } 678 679 /* 680 * Initialize the zc_nvlist_dst member to prepare for receiving an nvlist from 681 * an ioctl(). 682 */ 683 int 684 zcmd_alloc_dst_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc, size_t len) 685 { 686 if (len == 0) 687 len = 4*1024; 688 zc->zc_nvlist_dst_size = len; 689 if ((zc->zc_nvlist_dst = (uint64_t)(uintptr_t) 690 zfs_alloc(hdl, zc->zc_nvlist_dst_size)) == NULL) 691 return (-1); 692 693 return (0); 694 } 695 696 /* 697 * Called when an ioctl() which returns an nvlist fails with ENOMEM. This will 698 * expand the nvlist to the size specified in 'zc_nvlist_dst_size', which was 699 * filled in by the kernel to indicate the actual required size. 700 */ 701 int 702 zcmd_expand_dst_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc) 703 { 704 free((void *)(uintptr_t)zc->zc_nvlist_dst); 705 if ((zc->zc_nvlist_dst = (uint64_t)(uintptr_t) 706 zfs_alloc(hdl, zc->zc_nvlist_dst_size)) 707 == NULL) 708 return (-1); 709 710 return (0); 711 } 712 713 /* 714 * Called to free the src and dst nvlists stored in the command structure. 715 */ 716 void 717 zcmd_free_nvlists(zfs_cmd_t *zc) 718 { 719 free((void *)(uintptr_t)zc->zc_nvlist_conf); 720 free((void *)(uintptr_t)zc->zc_nvlist_src); 721 free((void *)(uintptr_t)zc->zc_nvlist_dst); 722 } 723 724 static int 725 zcmd_write_nvlist_com(libzfs_handle_t *hdl, uint64_t *outnv, uint64_t *outlen, 726 nvlist_t *nvl) 727 { 728 char *packed; 729 size_t len; 730 731 verify(nvlist_size(nvl, &len, NV_ENCODE_NATIVE) == 0); 732 733 if ((packed = zfs_alloc(hdl, len)) == NULL) 734 return (-1); 735 736 verify(nvlist_pack(nvl, &packed, &len, NV_ENCODE_NATIVE, 0) == 0); 737 738 *outnv = (uint64_t)(uintptr_t)packed; 739 *outlen = len; 740 741 return (0); 742 } 743 744 int 745 zcmd_write_conf_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc, nvlist_t *nvl) 746 { 747 return (zcmd_write_nvlist_com(hdl, &zc->zc_nvlist_conf, 748 &zc->zc_nvlist_conf_size, nvl)); 749 } 750 751 int 752 zcmd_write_src_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc, nvlist_t *nvl) 753 { 754 return (zcmd_write_nvlist_com(hdl, &zc->zc_nvlist_src, 755 &zc->zc_nvlist_src_size, nvl)); 756 } 757 758 /* 759 * Unpacks an nvlist from the ZFS ioctl command structure. 760 */ 761 int 762 zcmd_read_dst_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc, nvlist_t **nvlp) 763 { 764 if (nvlist_unpack((void *)(uintptr_t)zc->zc_nvlist_dst, 765 zc->zc_nvlist_dst_size, nvlp, 0) != 0) 766 return (no_memory(hdl)); 767 768 return (0); 769 } 770 771 int 772 zfs_ioctl(libzfs_handle_t *hdl, int request, zfs_cmd_t *zc) 773 { 774 int error; 775 776 zc->zc_history = (uint64_t)(uintptr_t)hdl->libzfs_log_str; 777 error = ioctl(hdl->libzfs_fd, request, zc); 778 if (hdl->libzfs_log_str) { 779 free(hdl->libzfs_log_str); 780 hdl->libzfs_log_str = NULL; 781 } 782 zc->zc_history = 0; 783 784 return (error); 785 } 786 787 /* 788 * ================================================================ 789 * API shared by zfs and zpool property management 790 * ================================================================ 791 */ 792 793 static void 794 zprop_print_headers(zprop_get_cbdata_t *cbp, zfs_type_t type) 795 { 796 zprop_list_t *pl = cbp->cb_proplist; 797 int i; 798 char *title; 799 size_t len; 800 801 cbp->cb_first = B_FALSE; 802 if (cbp->cb_scripted) 803 return; 804 805 /* 806 * Start with the length of the column headers. 807 */ 808 cbp->cb_colwidths[GET_COL_NAME] = strlen(dgettext(TEXT_DOMAIN, "NAME")); 809 cbp->cb_colwidths[GET_COL_PROPERTY] = strlen(dgettext(TEXT_DOMAIN, 810 "PROPERTY")); 811 cbp->cb_colwidths[GET_COL_VALUE] = strlen(dgettext(TEXT_DOMAIN, 812 "VALUE")); 813 cbp->cb_colwidths[GET_COL_SOURCE] = strlen(dgettext(TEXT_DOMAIN, 814 "SOURCE")); 815 816 /* first property is always NAME */ 817 assert(cbp->cb_proplist->pl_prop == 818 ((type == ZFS_TYPE_POOL) ? ZPOOL_PROP_NAME : ZFS_PROP_NAME)); 819 820 /* 821 * Go through and calculate the widths for each column. For the 822 * 'source' column, we kludge it up by taking the worst-case scenario of 823 * inheriting from the longest name. This is acceptable because in the 824 * majority of cases 'SOURCE' is the last column displayed, and we don't 825 * use the width anyway. Note that the 'VALUE' column can be oversized, 826 * if the name of the property is much longer the any values we find. 827 */ 828 for (pl = cbp->cb_proplist; pl != NULL; pl = pl->pl_next) { 829 /* 830 * 'PROPERTY' column 831 */ 832 if (pl->pl_prop != ZPROP_INVAL) { 833 const char *propname = (type == ZFS_TYPE_POOL) ? 834 zpool_prop_to_name(pl->pl_prop) : 835 zfs_prop_to_name(pl->pl_prop); 836 837 len = strlen(propname); 838 if (len > cbp->cb_colwidths[GET_COL_PROPERTY]) 839 cbp->cb_colwidths[GET_COL_PROPERTY] = len; 840 } else { 841 len = strlen(pl->pl_user_prop); 842 if (len > cbp->cb_colwidths[GET_COL_PROPERTY]) 843 cbp->cb_colwidths[GET_COL_PROPERTY] = len; 844 } 845 846 /* 847 * 'VALUE' column. The first property is always the 'name' 848 * property that was tacked on either by /sbin/zfs's 849 * zfs_do_get() or when calling zprop_expand_list(), so we 850 * ignore its width. If the user specified the name property 851 * to display, then it will be later in the list in any case. 852 */ 853 if (pl != cbp->cb_proplist && 854 pl->pl_width > cbp->cb_colwidths[GET_COL_VALUE]) 855 cbp->cb_colwidths[GET_COL_VALUE] = pl->pl_width; 856 857 /* 858 * 'NAME' and 'SOURCE' columns 859 */ 860 if (pl->pl_prop == (type == ZFS_TYPE_POOL ? ZPOOL_PROP_NAME : 861 ZFS_PROP_NAME) && 862 pl->pl_width > cbp->cb_colwidths[GET_COL_NAME]) { 863 cbp->cb_colwidths[GET_COL_NAME] = pl->pl_width; 864 cbp->cb_colwidths[GET_COL_SOURCE] = pl->pl_width + 865 strlen(dgettext(TEXT_DOMAIN, "inherited from")); 866 } 867 } 868 869 /* 870 * Now go through and print the headers. 871 */ 872 for (i = 0; i < 4; i++) { 873 switch (cbp->cb_columns[i]) { 874 case GET_COL_NAME: 875 title = dgettext(TEXT_DOMAIN, "NAME"); 876 break; 877 case GET_COL_PROPERTY: 878 title = dgettext(TEXT_DOMAIN, "PROPERTY"); 879 break; 880 case GET_COL_VALUE: 881 title = dgettext(TEXT_DOMAIN, "VALUE"); 882 break; 883 case GET_COL_SOURCE: 884 title = dgettext(TEXT_DOMAIN, "SOURCE"); 885 break; 886 default: 887 title = NULL; 888 } 889 890 if (title != NULL) { 891 if (i == 3 || cbp->cb_columns[i + 1] == 0) 892 (void) printf("%s", title); 893 else 894 (void) printf("%-*s ", 895 cbp->cb_colwidths[cbp->cb_columns[i]], 896 title); 897 } 898 } 899 (void) printf("\n"); 900 } 901 902 /* 903 * Display a single line of output, according to the settings in the callback 904 * structure. 905 */ 906 void 907 zprop_print_one_property(const char *name, zprop_get_cbdata_t *cbp, 908 const char *propname, const char *value, zprop_source_t sourcetype, 909 const char *source) 910 { 911 int i; 912 const char *str; 913 char buf[128]; 914 915 /* 916 * Ignore those source types that the user has chosen to ignore. 917 */ 918 if ((sourcetype & cbp->cb_sources) == 0) 919 return; 920 921 if (cbp->cb_first) 922 zprop_print_headers(cbp, cbp->cb_type); 923 924 for (i = 0; i < 4; i++) { 925 switch (cbp->cb_columns[i]) { 926 case GET_COL_NAME: 927 str = name; 928 break; 929 930 case GET_COL_PROPERTY: 931 str = propname; 932 break; 933 934 case GET_COL_VALUE: 935 str = value; 936 break; 937 938 case GET_COL_SOURCE: 939 switch (sourcetype) { 940 case ZPROP_SRC_NONE: 941 str = "-"; 942 break; 943 944 case ZPROP_SRC_DEFAULT: 945 str = "default"; 946 break; 947 948 case ZPROP_SRC_LOCAL: 949 str = "local"; 950 break; 951 952 case ZPROP_SRC_TEMPORARY: 953 str = "temporary"; 954 break; 955 956 case ZPROP_SRC_INHERITED: 957 (void) snprintf(buf, sizeof (buf), 958 "inherited from %s", source); 959 str = buf; 960 break; 961 } 962 break; 963 964 default: 965 continue; 966 } 967 968 if (cbp->cb_columns[i + 1] == 0) 969 (void) printf("%s", str); 970 else if (cbp->cb_scripted) 971 (void) printf("%s\t", str); 972 else 973 (void) printf("%-*s ", 974 cbp->cb_colwidths[cbp->cb_columns[i]], 975 str); 976 977 } 978 979 (void) printf("\n"); 980 } 981 982 /* 983 * Given a numeric suffix, convert the value into a number of bits that the 984 * resulting value must be shifted. 985 */ 986 static int 987 str2shift(libzfs_handle_t *hdl, const char *buf) 988 { 989 const char *ends = "BKMGTPEZ"; 990 int i; 991 992 if (buf[0] == '\0') 993 return (0); 994 for (i = 0; i < strlen(ends); i++) { 995 if (toupper(buf[0]) == ends[i]) 996 break; 997 } 998 if (i == strlen(ends)) { 999 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1000 "invalid numeric suffix '%s'"), buf); 1001 return (-1); 1002 } 1003 1004 /* 1005 * We want to allow trailing 'b' characters for 'GB' or 'Mb'. But don't 1006 * allow 'BB' - that's just weird. 1007 */ 1008 if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0' && 1009 toupper(buf[0]) != 'B')) 1010 return (10*i); 1011 1012 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1013 "invalid numeric suffix '%s'"), buf); 1014 return (-1); 1015 } 1016 1017 /* 1018 * Convert a string of the form '100G' into a real number. Used when setting 1019 * properties or creating a volume. 'buf' is used to place an extended error 1020 * message for the caller to use. 1021 */ 1022 int 1023 zfs_nicestrtonum(libzfs_handle_t *hdl, const char *value, uint64_t *num) 1024 { 1025 char *end; 1026 int shift; 1027 1028 *num = 0; 1029 1030 /* Check to see if this looks like a number. */ 1031 if ((value[0] < '0' || value[0] > '9') && value[0] != '.') { 1032 if (hdl) 1033 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1034 "bad numeric value '%s'"), value); 1035 return (-1); 1036 } 1037 1038 /* Rely on stroull() to process the numeric portion. */ 1039 errno = 0; 1040 *num = strtoull(value, &end, 10); 1041 1042 /* 1043 * Check for ERANGE, which indicates that the value is too large to fit 1044 * in a 64-bit value. 1045 */ 1046 if (errno == ERANGE) { 1047 if (hdl) 1048 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1049 "numeric value is too large")); 1050 return (-1); 1051 } 1052 1053 /* 1054 * If we have a decimal value, then do the computation with floating 1055 * point arithmetic. Otherwise, use standard arithmetic. 1056 */ 1057 if (*end == '.') { 1058 double fval = strtod(value, &end); 1059 1060 if ((shift = str2shift(hdl, end)) == -1) 1061 return (-1); 1062 1063 fval *= pow(2, shift); 1064 1065 if (fval > UINT64_MAX) { 1066 if (hdl) 1067 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1068 "numeric value is too large")); 1069 return (-1); 1070 } 1071 1072 *num = (uint64_t)fval; 1073 } else { 1074 if ((shift = str2shift(hdl, end)) == -1) 1075 return (-1); 1076 1077 /* Check for overflow */ 1078 if (shift >= 64 || (*num << shift) >> shift != *num) { 1079 if (hdl) 1080 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1081 "numeric value is too large")); 1082 return (-1); 1083 } 1084 1085 *num <<= shift; 1086 } 1087 1088 return (0); 1089 } 1090 1091 /* 1092 * Given a propname=value nvpair to set, parse any numeric properties 1093 * (index, boolean, etc) if they are specified as strings and add the 1094 * resulting nvpair to the returned nvlist. 1095 * 1096 * At the DSL layer, all properties are either 64-bit numbers or strings. 1097 * We want the user to be able to ignore this fact and specify properties 1098 * as native values (numbers, for example) or as strings (to simplify 1099 * command line utilities). This also handles converting index types 1100 * (compression, checksum, etc) from strings to their on-disk index. 1101 */ 1102 int 1103 zprop_parse_value(libzfs_handle_t *hdl, nvpair_t *elem, int prop, 1104 zfs_type_t type, nvlist_t *ret, char **svalp, uint64_t *ivalp, 1105 const char *errbuf) 1106 { 1107 data_type_t datatype = nvpair_type(elem); 1108 zprop_type_t proptype; 1109 const char *propname; 1110 char *value; 1111 boolean_t isnone = B_FALSE; 1112 1113 if (type == ZFS_TYPE_POOL) { 1114 proptype = zpool_prop_get_type(prop); 1115 propname = zpool_prop_to_name(prop); 1116 } else { 1117 proptype = zfs_prop_get_type(prop); 1118 propname = zfs_prop_to_name(prop); 1119 } 1120 1121 /* 1122 * Convert any properties to the internal DSL value types. 1123 */ 1124 *svalp = NULL; 1125 *ivalp = 0; 1126 1127 switch (proptype) { 1128 case PROP_TYPE_STRING: 1129 if (datatype != DATA_TYPE_STRING) { 1130 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1131 "'%s' must be a string"), nvpair_name(elem)); 1132 goto error; 1133 } 1134 (void) nvpair_value_string(elem, svalp); 1135 if (strlen(*svalp) >= ZFS_MAXPROPLEN) { 1136 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1137 "'%s' is too long"), nvpair_name(elem)); 1138 goto error; 1139 } 1140 break; 1141 1142 case PROP_TYPE_NUMBER: 1143 if (datatype == DATA_TYPE_STRING) { 1144 (void) nvpair_value_string(elem, &value); 1145 if (strcmp(value, "none") == 0) { 1146 isnone = B_TRUE; 1147 } else if (zfs_nicestrtonum(hdl, value, ivalp) 1148 != 0) { 1149 goto error; 1150 } 1151 } else if (datatype == DATA_TYPE_UINT64) { 1152 (void) nvpair_value_uint64(elem, ivalp); 1153 } else { 1154 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1155 "'%s' must be a number"), nvpair_name(elem)); 1156 goto error; 1157 } 1158 1159 /* 1160 * Quota special: force 'none' and don't allow 0. 1161 */ 1162 if ((type & ZFS_TYPE_DATASET) && *ivalp == 0 && !isnone && 1163 (prop == ZFS_PROP_QUOTA || prop == ZFS_PROP_REFQUOTA)) { 1164 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1165 "use 'none' to disable quota/refquota")); 1166 goto error; 1167 } 1168 break; 1169 1170 case PROP_TYPE_INDEX: 1171 if (datatype != DATA_TYPE_STRING) { 1172 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1173 "'%s' must be a string"), nvpair_name(elem)); 1174 goto error; 1175 } 1176 1177 (void) nvpair_value_string(elem, &value); 1178 1179 if (zprop_string_to_index(prop, value, ivalp, type) != 0) { 1180 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1181 "'%s' must be one of '%s'"), propname, 1182 zprop_values(prop, type)); 1183 goto error; 1184 } 1185 break; 1186 1187 default: 1188 abort(); 1189 } 1190 1191 /* 1192 * Add the result to our return set of properties. 1193 */ 1194 if (*svalp != NULL) { 1195 if (nvlist_add_string(ret, propname, *svalp) != 0) { 1196 (void) no_memory(hdl); 1197 return (-1); 1198 } 1199 } else { 1200 if (nvlist_add_uint64(ret, propname, *ivalp) != 0) { 1201 (void) no_memory(hdl); 1202 return (-1); 1203 } 1204 } 1205 1206 return (0); 1207 error: 1208 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1209 return (-1); 1210 } 1211 1212 static int 1213 addlist(libzfs_handle_t *hdl, char *propname, zprop_list_t **listp, 1214 zfs_type_t type) 1215 { 1216 int prop; 1217 zprop_list_t *entry; 1218 1219 prop = zprop_name_to_prop(propname, type); 1220 1221 if (prop != ZPROP_INVAL && !zprop_valid_for_type(prop, type)) 1222 prop = ZPROP_INVAL; 1223 1224 /* 1225 * When no property table entry can be found, return failure if 1226 * this is a pool property or if this isn't a user-defined 1227 * dataset property, 1228 */ 1229 if (prop == ZPROP_INVAL && (type == ZFS_TYPE_POOL || 1230 (!zfs_prop_user(propname) && !zfs_prop_userquota(propname)))) { 1231 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1232 "invalid property '%s'"), propname); 1233 return (zfs_error(hdl, EZFS_BADPROP, 1234 dgettext(TEXT_DOMAIN, "bad property list"))); 1235 } 1236 1237 if ((entry = zfs_alloc(hdl, sizeof (zprop_list_t))) == NULL) 1238 return (-1); 1239 1240 entry->pl_prop = prop; 1241 if (prop == ZPROP_INVAL) { 1242 if ((entry->pl_user_prop = zfs_strdup(hdl, propname)) == NULL) { 1243 free(entry); 1244 return (-1); 1245 } 1246 entry->pl_width = strlen(propname); 1247 } else { 1248 entry->pl_width = zprop_width(prop, &entry->pl_fixed, 1249 type); 1250 } 1251 1252 *listp = entry; 1253 1254 return (0); 1255 } 1256 1257 /* 1258 * Given a comma-separated list of properties, construct a property list 1259 * containing both user-defined and native properties. This function will 1260 * return a NULL list if 'all' is specified, which can later be expanded 1261 * by zprop_expand_list(). 1262 */ 1263 int 1264 zprop_get_list(libzfs_handle_t *hdl, char *props, zprop_list_t **listp, 1265 zfs_type_t type) 1266 { 1267 *listp = NULL; 1268 1269 /* 1270 * If 'all' is specified, return a NULL list. 1271 */ 1272 if (strcmp(props, "all") == 0) 1273 return (0); 1274 1275 /* 1276 * If no props were specified, return an error. 1277 */ 1278 if (props[0] == '\0') { 1279 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1280 "no properties specified")); 1281 return (zfs_error(hdl, EZFS_BADPROP, dgettext(TEXT_DOMAIN, 1282 "bad property list"))); 1283 } 1284 1285 /* 1286 * It would be nice to use getsubopt() here, but the inclusion of column 1287 * aliases makes this more effort than it's worth. 1288 */ 1289 while (*props != '\0') { 1290 size_t len; 1291 char *p; 1292 char c; 1293 1294 if ((p = strchr(props, ',')) == NULL) { 1295 len = strlen(props); 1296 p = props + len; 1297 } else { 1298 len = p - props; 1299 } 1300 1301 /* 1302 * Check for empty options. 1303 */ 1304 if (len == 0) { 1305 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1306 "empty property name")); 1307 return (zfs_error(hdl, EZFS_BADPROP, 1308 dgettext(TEXT_DOMAIN, "bad property list"))); 1309 } 1310 1311 /* 1312 * Check all regular property names. 1313 */ 1314 c = props[len]; 1315 props[len] = '\0'; 1316 1317 if (strcmp(props, "space") == 0) { 1318 static char *spaceprops[] = { 1319 "name", "avail", "used", "usedbysnapshots", 1320 "usedbydataset", "usedbyrefreservation", 1321 "usedbychildren", NULL 1322 }; 1323 int i; 1324 1325 for (i = 0; spaceprops[i]; i++) { 1326 if (addlist(hdl, spaceprops[i], listp, type)) 1327 return (-1); 1328 listp = &(*listp)->pl_next; 1329 } 1330 } else { 1331 if (addlist(hdl, props, listp, type)) 1332 return (-1); 1333 listp = &(*listp)->pl_next; 1334 } 1335 1336 props = p; 1337 if (c == ',') 1338 props++; 1339 } 1340 1341 return (0); 1342 } 1343 1344 void 1345 zprop_free_list(zprop_list_t *pl) 1346 { 1347 zprop_list_t *next; 1348 1349 while (pl != NULL) { 1350 next = pl->pl_next; 1351 free(pl->pl_user_prop); 1352 free(pl); 1353 pl = next; 1354 } 1355 } 1356 1357 typedef struct expand_data { 1358 zprop_list_t **last; 1359 libzfs_handle_t *hdl; 1360 zfs_type_t type; 1361 } expand_data_t; 1362 1363 int 1364 zprop_expand_list_cb(int prop, void *cb) 1365 { 1366 zprop_list_t *entry; 1367 expand_data_t *edp = cb; 1368 1369 if ((entry = zfs_alloc(edp->hdl, sizeof (zprop_list_t))) == NULL) 1370 return (ZPROP_INVAL); 1371 1372 entry->pl_prop = prop; 1373 entry->pl_width = zprop_width(prop, &entry->pl_fixed, edp->type); 1374 entry->pl_all = B_TRUE; 1375 1376 *(edp->last) = entry; 1377 edp->last = &entry->pl_next; 1378 1379 return (ZPROP_CONT); 1380 } 1381 1382 int 1383 zprop_expand_list(libzfs_handle_t *hdl, zprop_list_t **plp, zfs_type_t type) 1384 { 1385 zprop_list_t *entry; 1386 zprop_list_t **last; 1387 expand_data_t exp; 1388 1389 if (*plp == NULL) { 1390 /* 1391 * If this is the very first time we've been called for an 'all' 1392 * specification, expand the list to include all native 1393 * properties. 1394 */ 1395 last = plp; 1396 1397 exp.last = last; 1398 exp.hdl = hdl; 1399 exp.type = type; 1400 1401 if (zprop_iter_common(zprop_expand_list_cb, &exp, B_FALSE, 1402 B_FALSE, type) == ZPROP_INVAL) 1403 return (-1); 1404 1405 /* 1406 * Add 'name' to the beginning of the list, which is handled 1407 * specially. 1408 */ 1409 if ((entry = zfs_alloc(hdl, sizeof (zprop_list_t))) == NULL) 1410 return (-1); 1411 1412 entry->pl_prop = (type == ZFS_TYPE_POOL) ? ZPOOL_PROP_NAME : 1413 ZFS_PROP_NAME; 1414 entry->pl_width = zprop_width(entry->pl_prop, 1415 &entry->pl_fixed, type); 1416 entry->pl_all = B_TRUE; 1417 entry->pl_next = *plp; 1418 *plp = entry; 1419 } 1420 return (0); 1421 } 1422 1423 int 1424 zprop_iter(zprop_func func, void *cb, boolean_t show_all, boolean_t ordered, 1425 zfs_type_t type) 1426 { 1427 return (zprop_iter_common(func, cb, show_all, ordered, type)); 1428 } 1429