libzfs_util.c revision 209962
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 49int 50libzfs_errno(libzfs_handle_t *hdl) 51{ 52 return (hdl->libzfs_error); 53} 54 55const char * 56libzfs_error_action(libzfs_handle_t *hdl) 57{ 58 return (hdl->libzfs_action); 59} 60 61const char * 62libzfs_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_VOLHASDATA: 98 return (dgettext(TEXT_DOMAIN, "volume has data")); 99 case EZFS_INVALIDNAME: 100 return (dgettext(TEXT_DOMAIN, "invalid name")); 101 case EZFS_BADRESTORE: 102 return (dgettext(TEXT_DOMAIN, "unable to restore to " 103 "destination")); 104 case EZFS_BADBACKUP: 105 return (dgettext(TEXT_DOMAIN, "backup failed")); 106 case EZFS_BADTARGET: 107 return (dgettext(TEXT_DOMAIN, "invalid target vdev")); 108 case EZFS_NODEVICE: 109 return (dgettext(TEXT_DOMAIN, "no such device in pool")); 110 case EZFS_BADDEV: 111 return (dgettext(TEXT_DOMAIN, "invalid device")); 112 case EZFS_NOREPLICAS: 113 return (dgettext(TEXT_DOMAIN, "no valid replicas")); 114 case EZFS_RESILVERING: 115 return (dgettext(TEXT_DOMAIN, "currently resilvering")); 116 case EZFS_BADVERSION: 117 return (dgettext(TEXT_DOMAIN, "unsupported version")); 118 case EZFS_POOLUNAVAIL: 119 return (dgettext(TEXT_DOMAIN, "pool is unavailable")); 120 case EZFS_DEVOVERFLOW: 121 return (dgettext(TEXT_DOMAIN, "too many devices in one vdev")); 122 case EZFS_BADPATH: 123 return (dgettext(TEXT_DOMAIN, "must be an absolute path")); 124 case EZFS_CROSSTARGET: 125 return (dgettext(TEXT_DOMAIN, "operation crosses datasets or " 126 "pools")); 127 case EZFS_ZONED: 128 return (dgettext(TEXT_DOMAIN, "dataset in use by local zone")); 129 case EZFS_MOUNTFAILED: 130 return (dgettext(TEXT_DOMAIN, "mount failed")); 131 case EZFS_UMOUNTFAILED: 132 return (dgettext(TEXT_DOMAIN, "umount failed")); 133 case EZFS_UNSHARENFSFAILED: 134 return (dgettext(TEXT_DOMAIN, "unshare(1M) failed")); 135 case EZFS_SHARENFSFAILED: 136 return (dgettext(TEXT_DOMAIN, "share(1M) failed")); 137 case EZFS_UNSHARESMBFAILED: 138 return (dgettext(TEXT_DOMAIN, "smb remove share failed")); 139 case EZFS_SHARESMBFAILED: 140 return (dgettext(TEXT_DOMAIN, "smb add share failed")); 141 case EZFS_ISCSISVCUNAVAIL: 142 return (dgettext(TEXT_DOMAIN, 143 "iscsitgt service need to be enabled by " 144 "a privileged user")); 145 case EZFS_DEVLINKS: 146 return (dgettext(TEXT_DOMAIN, "failed to create /dev links")); 147 case EZFS_PERM: 148 return (dgettext(TEXT_DOMAIN, "permission denied")); 149 case EZFS_NOSPC: 150 return (dgettext(TEXT_DOMAIN, "out of space")); 151 case EZFS_IO: 152 return (dgettext(TEXT_DOMAIN, "I/O error")); 153 case EZFS_INTR: 154 return (dgettext(TEXT_DOMAIN, "signal received")); 155 case EZFS_ISSPARE: 156 return (dgettext(TEXT_DOMAIN, "device is reserved as a hot " 157 "spare")); 158 case EZFS_INVALCONFIG: 159 return (dgettext(TEXT_DOMAIN, "invalid vdev configuration")); 160 case EZFS_RECURSIVE: 161 return (dgettext(TEXT_DOMAIN, "recursive dataset dependency")); 162 case EZFS_NOHISTORY: 163 return (dgettext(TEXT_DOMAIN, "no history available")); 164 case EZFS_UNSHAREISCSIFAILED: 165 return (dgettext(TEXT_DOMAIN, 166 "iscsitgtd failed request to unshare")); 167 case EZFS_SHAREISCSIFAILED: 168 return (dgettext(TEXT_DOMAIN, 169 "iscsitgtd failed request to share")); 170 case EZFS_POOLPROPS: 171 return (dgettext(TEXT_DOMAIN, "failed to retrieve " 172 "pool properties")); 173 case EZFS_POOL_NOTSUP: 174 return (dgettext(TEXT_DOMAIN, "operation not supported " 175 "on this type of pool")); 176 case EZFS_POOL_INVALARG: 177 return (dgettext(TEXT_DOMAIN, "invalid argument for " 178 "this pool operation")); 179 case EZFS_NAMETOOLONG: 180 return (dgettext(TEXT_DOMAIN, "dataset name is too long")); 181 case EZFS_OPENFAILED: 182 return (dgettext(TEXT_DOMAIN, "open failed")); 183 case EZFS_NOCAP: 184 return (dgettext(TEXT_DOMAIN, 185 "disk capacity information could not be retrieved")); 186 case EZFS_LABELFAILED: 187 return (dgettext(TEXT_DOMAIN, "write of label failed")); 188 case EZFS_BADWHO: 189 return (dgettext(TEXT_DOMAIN, "invalid user/group")); 190 case EZFS_BADPERM: 191 return (dgettext(TEXT_DOMAIN, "invalid permission")); 192 case EZFS_BADPERMSET: 193 return (dgettext(TEXT_DOMAIN, "invalid permission set name")); 194 case EZFS_NODELEGATION: 195 return (dgettext(TEXT_DOMAIN, "delegated administration is " 196 "disabled on pool")); 197 case EZFS_PERMRDONLY: 198 return (dgettext(TEXT_DOMAIN, "snapshot permissions cannot be" 199 " modified")); 200 case EZFS_BADCACHE: 201 return (dgettext(TEXT_DOMAIN, "invalid or missing cache file")); 202 case EZFS_ISL2CACHE: 203 return (dgettext(TEXT_DOMAIN, "device is in use as a cache")); 204 case EZFS_VDEVNOTSUP: 205 return (dgettext(TEXT_DOMAIN, "vdev specification is not " 206 "supported")); 207 case EZFS_NOTSUP: 208 return (dgettext(TEXT_DOMAIN, "operation not supported " 209 "on this dataset")); 210 case EZFS_ACTIVE_SPARE: 211 return (dgettext(TEXT_DOMAIN, "pool has active shared spare " 212 "device")); 213 case EZFS_UNKNOWN: 214 return (dgettext(TEXT_DOMAIN, "unknown error")); 215 default: 216 assert(hdl->libzfs_error == 0); 217 return (dgettext(TEXT_DOMAIN, "no error")); 218 } 219} 220 221/*PRINTFLIKE2*/ 222void 223zfs_error_aux(libzfs_handle_t *hdl, const char *fmt, ...) 224{ 225 va_list ap; 226 227 va_start(ap, fmt); 228 229 (void) vsnprintf(hdl->libzfs_desc, sizeof (hdl->libzfs_desc), 230 fmt, ap); 231 hdl->libzfs_desc_active = 1; 232 233 va_end(ap); 234} 235 236static void 237zfs_verror(libzfs_handle_t *hdl, int error, const char *fmt, va_list ap) 238{ 239 (void) vsnprintf(hdl->libzfs_action, sizeof (hdl->libzfs_action), 240 fmt, ap); 241 hdl->libzfs_error = error; 242 243 if (hdl->libzfs_desc_active) 244 hdl->libzfs_desc_active = 0; 245 else 246 hdl->libzfs_desc[0] = '\0'; 247 248 if (hdl->libzfs_printerr) { 249 if (error == EZFS_UNKNOWN) { 250 (void) fprintf(stderr, dgettext(TEXT_DOMAIN, "internal " 251 "error: %s\n"), libzfs_error_description(hdl)); 252 abort(); 253 } 254 255 (void) fprintf(stderr, "%s: %s\n", hdl->libzfs_action, 256 libzfs_error_description(hdl)); 257 if (error == EZFS_NOMEM) 258 exit(1); 259 } 260} 261 262int 263zfs_error(libzfs_handle_t *hdl, int error, const char *msg) 264{ 265 return (zfs_error_fmt(hdl, error, "%s", msg)); 266} 267 268/*PRINTFLIKE3*/ 269int 270zfs_error_fmt(libzfs_handle_t *hdl, int error, const char *fmt, ...) 271{ 272 va_list ap; 273 274 va_start(ap, fmt); 275 276 zfs_verror(hdl, error, fmt, ap); 277 278 va_end(ap); 279 280 return (-1); 281} 282 283static int 284zfs_common_error(libzfs_handle_t *hdl, int error, const char *fmt, 285 va_list ap) 286{ 287 switch (error) { 288 case EPERM: 289 case EACCES: 290 zfs_verror(hdl, EZFS_PERM, fmt, ap); 291 return (-1); 292 293 case ECANCELED: 294 zfs_verror(hdl, EZFS_NODELEGATION, fmt, ap); 295 return (-1); 296 297 case EIO: 298 zfs_verror(hdl, EZFS_IO, fmt, ap); 299 return (-1); 300 301 case EINTR: 302 zfs_verror(hdl, EZFS_INTR, fmt, ap); 303 return (-1); 304 } 305 306 return (0); 307} 308 309int 310zfs_standard_error(libzfs_handle_t *hdl, int error, const char *msg) 311{ 312 return (zfs_standard_error_fmt(hdl, error, "%s", msg)); 313} 314 315/*PRINTFLIKE3*/ 316int 317zfs_standard_error_fmt(libzfs_handle_t *hdl, int error, const char *fmt, ...) 318{ 319 va_list ap; 320 321 va_start(ap, fmt); 322 323 if (zfs_common_error(hdl, error, fmt, ap) != 0) { 324 va_end(ap); 325 return (-1); 326 } 327 328 switch (error) { 329 case ENXIO: 330 case ENODEV: 331 zfs_verror(hdl, EZFS_IO, fmt, ap); 332 break; 333 334 case ENOENT: 335 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 336 "dataset does not exist")); 337 zfs_verror(hdl, EZFS_NOENT, fmt, ap); 338 break; 339 340 case ENOSPC: 341 case EDQUOT: 342 zfs_verror(hdl, EZFS_NOSPC, fmt, ap); 343 return (-1); 344 345 case EEXIST: 346 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 347 "dataset already exists")); 348 zfs_verror(hdl, EZFS_EXISTS, fmt, ap); 349 break; 350 351 case EBUSY: 352 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 353 "dataset is busy")); 354 zfs_verror(hdl, EZFS_BUSY, fmt, ap); 355 break; 356 case EROFS: 357 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 358 "snapshot permissions cannot be modified")); 359 zfs_verror(hdl, EZFS_PERMRDONLY, fmt, ap); 360 break; 361 case ENAMETOOLONG: 362 zfs_verror(hdl, EZFS_NAMETOOLONG, fmt, ap); 363 break; 364 case ENOTSUP: 365 zfs_verror(hdl, EZFS_BADVERSION, fmt, ap); 366 break; 367 case EAGAIN: 368 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 369 "pool I/O is currently suspended")); 370 zfs_verror(hdl, EZFS_POOLUNAVAIL, fmt, ap); 371 break; 372 default: 373 zfs_error_aux(hdl, strerror(errno)); 374 zfs_verror(hdl, EZFS_UNKNOWN, fmt, ap); 375 break; 376 } 377 378 va_end(ap); 379 return (-1); 380} 381 382int 383zpool_standard_error(libzfs_handle_t *hdl, int error, const char *msg) 384{ 385 return (zpool_standard_error_fmt(hdl, error, "%s", msg)); 386} 387 388/*PRINTFLIKE3*/ 389int 390zpool_standard_error_fmt(libzfs_handle_t *hdl, int error, const char *fmt, ...) 391{ 392 va_list ap; 393 394 va_start(ap, fmt); 395 396 if (zfs_common_error(hdl, error, fmt, ap) != 0) { 397 va_end(ap); 398 return (-1); 399 } 400 401 switch (error) { 402 case ENODEV: 403 zfs_verror(hdl, EZFS_NODEVICE, fmt, ap); 404 break; 405 406 case ENOENT: 407 zfs_error_aux(hdl, 408 dgettext(TEXT_DOMAIN, "no such pool or dataset")); 409 zfs_verror(hdl, EZFS_NOENT, fmt, ap); 410 break; 411 412 case EEXIST: 413 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 414 "pool already exists")); 415 zfs_verror(hdl, EZFS_EXISTS, fmt, ap); 416 break; 417 418 case EBUSY: 419 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "pool is busy")); 420 zfs_verror(hdl, EZFS_BUSY, fmt, ap); 421 break; 422 423 case ENXIO: 424 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 425 "one or more devices is currently unavailable")); 426 zfs_verror(hdl, EZFS_BADDEV, fmt, ap); 427 break; 428 429 case ENAMETOOLONG: 430 zfs_verror(hdl, EZFS_DEVOVERFLOW, fmt, ap); 431 break; 432 433 case ENOTSUP: 434 zfs_verror(hdl, EZFS_POOL_NOTSUP, fmt, ap); 435 break; 436 437 case EINVAL: 438 zfs_verror(hdl, EZFS_POOL_INVALARG, fmt, ap); 439 break; 440 441 case ENOSPC: 442 case EDQUOT: 443 zfs_verror(hdl, EZFS_NOSPC, fmt, ap); 444 return (-1); 445 case EAGAIN: 446 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 447 "pool I/O is currently suspended")); 448 zfs_verror(hdl, EZFS_POOLUNAVAIL, fmt, ap); 449 break; 450 451 default: 452 zfs_error_aux(hdl, strerror(error)); 453 zfs_verror(hdl, EZFS_UNKNOWN, fmt, ap); 454 } 455 456 va_end(ap); 457 return (-1); 458} 459 460/* 461 * Display an out of memory error message and abort the current program. 462 */ 463int 464no_memory(libzfs_handle_t *hdl) 465{ 466 return (zfs_error(hdl, EZFS_NOMEM, "internal error")); 467} 468 469/* 470 * A safe form of malloc() which will die if the allocation fails. 471 */ 472void * 473zfs_alloc(libzfs_handle_t *hdl, size_t size) 474{ 475 void *data; 476 477 if ((data = calloc(1, size)) == NULL) 478 (void) no_memory(hdl); 479 480 return (data); 481} 482 483/* 484 * A safe form of realloc(), which also zeroes newly allocated space. 485 */ 486void * 487zfs_realloc(libzfs_handle_t *hdl, void *ptr, size_t oldsize, size_t newsize) 488{ 489 void *ret; 490 491 if ((ret = realloc(ptr, newsize)) == NULL) { 492 (void) no_memory(hdl); 493 return (NULL); 494 } 495 496 bzero((char *)ret + oldsize, (newsize - oldsize)); 497 return (ret); 498} 499 500/* 501 * A safe form of strdup() which will die if the allocation fails. 502 */ 503char * 504zfs_strdup(libzfs_handle_t *hdl, const char *str) 505{ 506 char *ret; 507 508 if ((ret = strdup(str)) == NULL) 509 (void) no_memory(hdl); 510 511 return (ret); 512} 513 514/* 515 * Convert a number to an appropriately human-readable output. 516 */ 517void 518zfs_nicenum(uint64_t num, char *buf, size_t buflen) 519{ 520 uint64_t n = num; 521 int index = 0; 522 char u; 523 524 while (n >= 1024) { 525 n /= 1024; 526 index++; 527 } 528 529 u = " KMGTPE"[index]; 530 531 if (index == 0) { 532 (void) snprintf(buf, buflen, "%llu", n); 533 } else if ((num & ((1ULL << 10 * index) - 1)) == 0) { 534 /* 535 * If this is an even multiple of the base, always display 536 * without any decimal precision. 537 */ 538 (void) snprintf(buf, buflen, "%llu%c", n, u); 539 } else { 540 /* 541 * We want to choose a precision that reflects the best choice 542 * for fitting in 5 characters. This can get rather tricky when 543 * we have numbers that are very close to an order of magnitude. 544 * For example, when displaying 10239 (which is really 9.999K), 545 * we want only a single place of precision for 10.0K. We could 546 * develop some complex heuristics for this, but it's much 547 * easier just to try each combination in turn. 548 */ 549 int i; 550 for (i = 2; i >= 0; i--) { 551 if (snprintf(buf, buflen, "%.*f%c", i, 552 (double)num / (1ULL << 10 * index), u) <= 5) 553 break; 554 } 555 } 556} 557 558void 559libzfs_print_on_error(libzfs_handle_t *hdl, boolean_t printerr) 560{ 561 hdl->libzfs_printerr = printerr; 562} 563 564static int 565libzfs_load(void) 566{ 567 int error; 568 569 if (modfind("zfs") < 0) { 570 /* Not present in kernel, try loading it. */ 571 if (kldload("zfs") < 0 || modfind("zfs") < 0) { 572 if (errno != EEXIST) 573 return (error); 574 } 575 } 576 return (0); 577} 578 579libzfs_handle_t * 580libzfs_init(void) 581{ 582 libzfs_handle_t *hdl; 583 584 if ((hdl = calloc(sizeof (libzfs_handle_t), 1)) == NULL) { 585 return (NULL); 586 } 587 588 if ((hdl->libzfs_fd = open(ZFS_DEV, O_RDWR)) < 0) { 589 if (libzfs_load() == 0) 590 hdl->libzfs_fd = open(ZFS_DEV, O_RDWR); 591 if (hdl->libzfs_fd < 0) { 592 free(hdl); 593 return (NULL); 594 } 595 } 596 597 if ((hdl->libzfs_mnttab = fopen(MNTTAB, "r")) == NULL) { 598 (void) close(hdl->libzfs_fd); 599 free(hdl); 600 return (NULL); 601 } 602 603 hdl->libzfs_sharetab = fopen(ZFS_EXPORTS_PATH, "r"); 604 605 zfs_prop_init(); 606 zpool_prop_init(); 607 libzfs_mnttab_init(hdl); 608 609 return (hdl); 610} 611 612void 613libzfs_fini(libzfs_handle_t *hdl) 614{ 615 (void) close(hdl->libzfs_fd); 616 if (hdl->libzfs_mnttab) 617 (void) fclose(hdl->libzfs_mnttab); 618 if (hdl->libzfs_sharetab) 619 (void) fclose(hdl->libzfs_sharetab); 620 zfs_uninit_libshare(hdl); 621 if (hdl->libzfs_log_str) 622 (void) free(hdl->libzfs_log_str); 623 zpool_free_handles(hdl); 624 namespace_clear(hdl); 625 libzfs_mnttab_fini(hdl); 626 free(hdl); 627} 628 629libzfs_handle_t * 630zpool_get_handle(zpool_handle_t *zhp) 631{ 632 return (zhp->zpool_hdl); 633} 634 635libzfs_handle_t * 636zfs_get_handle(zfs_handle_t *zhp) 637{ 638 return (zhp->zfs_hdl); 639} 640 641zpool_handle_t * 642zfs_get_pool_handle(const zfs_handle_t *zhp) 643{ 644 return (zhp->zpool_hdl); 645} 646 647/* 648 * Given a name, determine whether or not it's a valid path 649 * (starts with '/' or "./"). If so, walk the mnttab trying 650 * to match the device number. If not, treat the path as an 651 * fs/vol/snap name. 652 */ 653zfs_handle_t * 654zfs_path_to_zhandle(libzfs_handle_t *hdl, char *path, zfs_type_t argtype) 655{ 656 struct statfs statbuf; 657 658 if (path[0] != '/' && strncmp(path, "./", strlen("./")) != 0) { 659 /* 660 * It's not a valid path, assume it's a name of type 'argtype'. 661 */ 662 return (zfs_open(hdl, path, argtype)); 663 } 664 665 if (statfs(path, &statbuf) != 0) { 666 (void) fprintf(stderr, "%s: %s\n", path, strerror(errno)); 667 return (NULL); 668 } 669 670 if (strcmp(statbuf.f_fstypename, 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, statbuf.f_mntfromname, ZFS_TYPE_FILESYSTEM)); 677} 678 679/* 680 * Initialize the zc_nvlist_dst member to prepare for receiving an nvlist from 681 * an ioctl(). 682 */ 683int 684zcmd_alloc_dst_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc, size_t len) 685{ 686 if (len == 0) 687 len = 2048; 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)) == 0) 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 */ 701int 702zcmd_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 == 0) 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 */ 716void 717zcmd_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 724static int 725zcmd_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 744int 745zcmd_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 751int 752zcmd_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 */ 761int 762zcmd_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 771int 772zfs_ioctl(libzfs_handle_t *hdl, unsigned long 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 793static void 794zprop_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 */ 906void 907zprop_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 */ 986static int 987str2shift(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 */ 1022int 1023zfs_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 */ 1102int 1103zprop_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); 1207error: 1208 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1209 return (-1); 1210} 1211 1212static int 1213addlist(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 */ 1263int 1264zprop_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 1344void 1345zprop_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 1357typedef struct expand_data { 1358 zprop_list_t **last; 1359 libzfs_handle_t *hdl; 1360 zfs_type_t type; 1361} expand_data_t; 1362 1363int 1364zprop_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 1382int 1383zprop_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 1423int 1424zprop_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