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