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) 2011, 2015 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 zc->zc_nvlist_dst = 743 (uint64_t)(uintptr_t)zfs_alloc(hdl, zc->zc_nvlist_dst_size); 744 if (zc->zc_nvlist_dst == 0) 745 return (-1); 746 747 return (0); 748 } 749 750 /* 751 * Called when an ioctl() which returns an nvlist fails with ENOMEM. This will 752 * expand the nvlist to the size specified in 'zc_nvlist_dst_size', which was 753 * filled in by the kernel to indicate the actual required size. 754 */ 755 int 756 zcmd_expand_dst_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc) 757 { 758 free((void *)(uintptr_t)zc->zc_nvlist_dst); 759 zc->zc_nvlist_dst = 760 (uint64_t)(uintptr_t)zfs_alloc(hdl, zc->zc_nvlist_dst_size); 761 if (zc->zc_nvlist_dst == 0) 762 return (-1); 763 764 return (0); 765 } 766 767 /* 768 * Called to free the src and dst nvlists stored in the command structure. 769 */ 770 void 771 zcmd_free_nvlists(zfs_cmd_t *zc) 772 { 773 free((void *)(uintptr_t)zc->zc_nvlist_conf); 774 free((void *)(uintptr_t)zc->zc_nvlist_src); 775 free((void *)(uintptr_t)zc->zc_nvlist_dst); 776 zc->zc_nvlist_conf = NULL; 777 zc->zc_nvlist_src = NULL; 778 zc->zc_nvlist_dst = NULL; 779 } 780 781 static int 782 zcmd_write_nvlist_com(libzfs_handle_t *hdl, uint64_t *outnv, uint64_t *outlen, 783 nvlist_t *nvl) 784 { 785 char *packed; 786 size_t len; 787 788 verify(nvlist_size(nvl, &len, NV_ENCODE_NATIVE) == 0); 789 790 if ((packed = zfs_alloc(hdl, len)) == NULL) 791 return (-1); 792 793 verify(nvlist_pack(nvl, &packed, &len, NV_ENCODE_NATIVE, 0) == 0); 794 795 *outnv = (uint64_t)(uintptr_t)packed; 796 *outlen = len; 797 798 return (0); 799 } 800 801 int 802 zcmd_write_conf_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc, nvlist_t *nvl) 803 { 804 return (zcmd_write_nvlist_com(hdl, &zc->zc_nvlist_conf, 805 &zc->zc_nvlist_conf_size, nvl)); 806 } 807 808 int 809 zcmd_write_src_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc, nvlist_t *nvl) 810 { 811 return (zcmd_write_nvlist_com(hdl, &zc->zc_nvlist_src, 812 &zc->zc_nvlist_src_size, nvl)); 813 } 814 815 /* 816 * Unpacks an nvlist from the ZFS ioctl command structure. 817 */ 818 int 819 zcmd_read_dst_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc, nvlist_t **nvlp) 820 { 821 if (nvlist_unpack((void *)(uintptr_t)zc->zc_nvlist_dst, 822 zc->zc_nvlist_dst_size, nvlp, 0) != 0) 823 return (no_memory(hdl)); 824 825 return (0); 826 } 827 828 int 829 zfs_ioctl(libzfs_handle_t *hdl, int request, zfs_cmd_t *zc) 830 { 831 return (ioctl(hdl->libzfs_fd, request, zc)); 832 } 833 834 /* 835 * ================================================================ 836 * API shared by zfs and zpool property management 837 * ================================================================ 838 */ 839 840 static void 841 zprop_print_headers(zprop_get_cbdata_t *cbp, zfs_type_t type) 842 { 843 zprop_list_t *pl = cbp->cb_proplist; 844 int i; 845 char *title; 846 size_t len; 847 848 cbp->cb_first = B_FALSE; 849 if (cbp->cb_scripted) 850 return; 851 852 /* 853 * Start with the length of the column headers. 854 */ 855 cbp->cb_colwidths[GET_COL_NAME] = strlen(dgettext(TEXT_DOMAIN, "NAME")); 856 cbp->cb_colwidths[GET_COL_PROPERTY] = strlen(dgettext(TEXT_DOMAIN, 857 "PROPERTY")); 858 cbp->cb_colwidths[GET_COL_VALUE] = strlen(dgettext(TEXT_DOMAIN, 859 "VALUE")); 860 cbp->cb_colwidths[GET_COL_RECVD] = strlen(dgettext(TEXT_DOMAIN, 861 "RECEIVED")); 862 cbp->cb_colwidths[GET_COL_SOURCE] = strlen(dgettext(TEXT_DOMAIN, 863 "SOURCE")); 864 865 /* first property is always NAME */ 866 assert(cbp->cb_proplist->pl_prop == 867 ((type == ZFS_TYPE_POOL) ? ZPOOL_PROP_NAME : ZFS_PROP_NAME)); 868 869 /* 870 * Go through and calculate the widths for each column. For the 871 * 'source' column, we kludge it up by taking the worst-case scenario of 872 * inheriting from the longest name. This is acceptable because in the 873 * majority of cases 'SOURCE' is the last column displayed, and we don't 874 * use the width anyway. Note that the 'VALUE' column can be oversized, 875 * if the name of the property is much longer than any values we find. 876 */ 877 for (pl = cbp->cb_proplist; pl != NULL; pl = pl->pl_next) { 878 /* 879 * 'PROPERTY' column 880 */ 881 if (pl->pl_prop != ZPROP_INVAL) { 882 const char *propname = (type == ZFS_TYPE_POOL) ? 883 zpool_prop_to_name(pl->pl_prop) : 884 zfs_prop_to_name(pl->pl_prop); 885 886 len = strlen(propname); 887 if (len > cbp->cb_colwidths[GET_COL_PROPERTY]) 888 cbp->cb_colwidths[GET_COL_PROPERTY] = len; 889 } else { 890 len = strlen(pl->pl_user_prop); 891 if (len > cbp->cb_colwidths[GET_COL_PROPERTY]) 892 cbp->cb_colwidths[GET_COL_PROPERTY] = len; 893 } 894 895 /* 896 * 'VALUE' column. The first property is always the 'name' 897 * property that was tacked on either by /sbin/zfs's 898 * zfs_do_get() or when calling zprop_expand_list(), so we 899 * ignore its width. If the user specified the name property 900 * to display, then it will be later in the list in any case. 901 */ 902 if (pl != cbp->cb_proplist && 903 pl->pl_width > cbp->cb_colwidths[GET_COL_VALUE]) 904 cbp->cb_colwidths[GET_COL_VALUE] = pl->pl_width; 905 906 /* 'RECEIVED' column. */ 907 if (pl != cbp->cb_proplist && 908 pl->pl_recvd_width > cbp->cb_colwidths[GET_COL_RECVD]) 909 cbp->cb_colwidths[GET_COL_RECVD] = pl->pl_recvd_width; 910 911 /* 912 * 'NAME' and 'SOURCE' columns 913 */ 914 if (pl->pl_prop == (type == ZFS_TYPE_POOL ? ZPOOL_PROP_NAME : 915 ZFS_PROP_NAME) && 916 pl->pl_width > cbp->cb_colwidths[GET_COL_NAME]) { 917 cbp->cb_colwidths[GET_COL_NAME] = pl->pl_width; 918 cbp->cb_colwidths[GET_COL_SOURCE] = pl->pl_width + 919 strlen(dgettext(TEXT_DOMAIN, "inherited from")); 920 } 921 } 922 923 /* 924 * Now go through and print the headers. 925 */ 926 for (i = 0; i < ZFS_GET_NCOLS; i++) { 927 switch (cbp->cb_columns[i]) { 928 case GET_COL_NAME: 929 title = dgettext(TEXT_DOMAIN, "NAME"); 930 break; 931 case GET_COL_PROPERTY: 932 title = dgettext(TEXT_DOMAIN, "PROPERTY"); 933 break; 934 case GET_COL_VALUE: 935 title = dgettext(TEXT_DOMAIN, "VALUE"); 936 break; 937 case GET_COL_RECVD: 938 title = dgettext(TEXT_DOMAIN, "RECEIVED"); 939 break; 940 case GET_COL_SOURCE: 941 title = dgettext(TEXT_DOMAIN, "SOURCE"); 942 break; 943 default: 944 title = NULL; 945 } 946 947 if (title != NULL) { 948 if (i == (ZFS_GET_NCOLS - 1) || 949 cbp->cb_columns[i + 1] == GET_COL_NONE) 950 (void) printf("%s", title); 951 else 952 (void) printf("%-*s ", 953 cbp->cb_colwidths[cbp->cb_columns[i]], 954 title); 955 } 956 } 957 (void) printf("\n"); 958 } 959 960 /* 961 * Display a single line of output, according to the settings in the callback 962 * structure. 963 */ 964 void 965 zprop_print_one_property(const char *name, zprop_get_cbdata_t *cbp, 966 const char *propname, const char *value, zprop_source_t sourcetype, 967 const char *source, const char *recvd_value) 968 { 969 int i; 970 const char *str = NULL; 971 char buf[128]; 972 973 /* 974 * Ignore those source types that the user has chosen to ignore. 975 */ 976 if ((sourcetype & cbp->cb_sources) == 0) 977 return; 978 979 if (cbp->cb_first) 980 zprop_print_headers(cbp, cbp->cb_type); 981 982 for (i = 0; i < ZFS_GET_NCOLS; i++) { 983 switch (cbp->cb_columns[i]) { 984 case GET_COL_NAME: 985 str = name; 986 break; 987 988 case GET_COL_PROPERTY: 989 str = propname; 990 break; 991 992 case GET_COL_VALUE: 993 str = value; 994 break; 995 996 case GET_COL_SOURCE: 997 switch (sourcetype) { 998 case ZPROP_SRC_NONE: 999 str = "-"; 1000 break; 1001 1002 case ZPROP_SRC_DEFAULT: 1003 str = "default"; 1004 break; 1005 1006 case ZPROP_SRC_LOCAL: 1007 str = "local"; 1008 break; 1009 1010 case ZPROP_SRC_TEMPORARY: 1011 str = "temporary"; 1012 break; 1013 1014 case ZPROP_SRC_INHERITED: 1015 (void) snprintf(buf, sizeof (buf), 1016 "inherited from %s", source); 1017 str = buf; 1018 break; 1019 case ZPROP_SRC_RECEIVED: 1020 str = "received"; 1021 break; 1022 } 1023 break; 1024 1025 case GET_COL_RECVD: 1026 str = (recvd_value == NULL ? "-" : recvd_value); 1027 break; 1028 1029 default: 1030 continue; 1031 } 1032 1033 if (cbp->cb_columns[i + 1] == GET_COL_NONE) 1034 (void) printf("%s", str); 1035 else if (cbp->cb_scripted) 1036 (void) printf("%s\t", str); 1037 else 1038 (void) printf("%-*s ", 1039 cbp->cb_colwidths[cbp->cb_columns[i]], 1040 str); 1041 } 1042 1043 (void) printf("\n"); 1044 } 1045 1046 /* 1047 * Given a numeric suffix, convert the value into a number of bits that the 1048 * resulting value must be shifted. 1049 */ 1050 static int 1051 str2shift(libzfs_handle_t *hdl, const char *buf) 1052 { 1053 const char *ends = "BKMGTPEZ"; 1054 int i; 1055 1056 if (buf[0] == '\0') 1057 return (0); 1058 for (i = 0; i < strlen(ends); i++) { 1059 if (toupper(buf[0]) == ends[i]) 1060 break; 1061 } 1062 if (i == strlen(ends)) { 1063 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1064 "invalid numeric suffix '%s'"), buf); 1065 return (-1); 1066 } 1067 1068 /* 1069 * We want to allow trailing 'b' characters for 'GB' or 'Mb'. But don't 1070 * allow 'BB' - that's just weird. 1071 */ 1072 if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0' && 1073 toupper(buf[0]) != 'B')) 1074 return (10*i); 1075 1076 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1077 "invalid numeric suffix '%s'"), buf); 1078 return (-1); 1079 } 1080 1081 /* 1082 * Convert a string of the form '100G' into a real number. Used when setting 1083 * properties or creating a volume. 'buf' is used to place an extended error 1084 * message for the caller to use. 1085 */ 1086 int 1087 zfs_nicestrtonum(libzfs_handle_t *hdl, const char *value, uint64_t *num) 1088 { 1089 char *end; 1090 int shift; 1091 1092 *num = 0; 1093 1094 /* Check to see if this looks like a number. */ 1095 if ((value[0] < '0' || value[0] > '9') && value[0] != '.') { 1096 if (hdl) 1097 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1098 "bad numeric value '%s'"), value); 1099 return (-1); 1100 } 1101 1102 /* Rely on strtoull() to process the numeric portion. */ 1103 errno = 0; 1104 *num = strtoull(value, &end, 10); 1105 1106 /* 1107 * Check for ERANGE, which indicates that the value is too large to fit 1108 * in a 64-bit value. 1109 */ 1110 if (errno == ERANGE) { 1111 if (hdl) 1112 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1113 "numeric value is too large")); 1114 return (-1); 1115 } 1116 1117 /* 1118 * If we have a decimal value, then do the computation with floating 1119 * point arithmetic. Otherwise, use standard arithmetic. 1120 */ 1121 if (*end == '.') { 1122 double fval = strtod(value, &end); 1123 1124 if ((shift = str2shift(hdl, end)) == -1) 1125 return (-1); 1126 1127 fval *= pow(2, shift); 1128 1129 if (fval > UINT64_MAX) { 1130 if (hdl) 1131 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1132 "numeric value is too large")); 1133 return (-1); 1134 } 1135 1136 *num = (uint64_t)fval; 1137 } else { 1138 if ((shift = str2shift(hdl, end)) == -1) 1139 return (-1); 1140 1141 /* Check for overflow */ 1142 if (shift >= 64 || (*num << shift) >> shift != *num) { 1143 if (hdl) 1144 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1145 "numeric value is too large")); 1146 return (-1); 1147 } 1148 1149 *num <<= shift; 1150 } 1151 1152 return (0); 1153 } 1154 1155 /* 1156 * Given a propname=value nvpair to set, parse any numeric properties 1157 * (index, boolean, etc) if they are specified as strings and add the 1158 * resulting nvpair to the returned nvlist. 1159 * 1160 * At the DSL layer, all properties are either 64-bit numbers or strings. 1161 * We want the user to be able to ignore this fact and specify properties 1162 * as native values (numbers, for example) or as strings (to simplify 1163 * command line utilities). This also handles converting index types 1164 * (compression, checksum, etc) from strings to their on-disk index. 1165 */ 1166 int 1167 zprop_parse_value(libzfs_handle_t *hdl, nvpair_t *elem, int prop, 1168 zfs_type_t type, nvlist_t *ret, char **svalp, uint64_t *ivalp, 1169 const char *errbuf) 1170 { 1171 data_type_t datatype = nvpair_type(elem); 1172 zprop_type_t proptype; 1173 const char *propname; 1174 char *value; 1175 boolean_t isnone = B_FALSE; 1176 1177 if (type == ZFS_TYPE_POOL) { 1178 proptype = zpool_prop_get_type(prop); 1179 propname = zpool_prop_to_name(prop); 1180 } else { 1181 proptype = zfs_prop_get_type(prop); 1182 propname = zfs_prop_to_name(prop); 1183 } 1184 1185 /* 1186 * Convert any properties to the internal DSL value types. 1187 */ 1188 *svalp = NULL; 1189 *ivalp = 0; 1190 1191 switch (proptype) { 1192 case PROP_TYPE_STRING: 1193 if (datatype != DATA_TYPE_STRING) { 1194 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1195 "'%s' must be a string"), nvpair_name(elem)); 1196 goto error; 1197 } 1198 (void) nvpair_value_string(elem, svalp); 1199 if (strlen(*svalp) >= ZFS_MAXPROPLEN) { 1200 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1201 "'%s' is too long"), nvpair_name(elem)); 1202 goto error; 1203 } 1204 break; 1205 1206 case PROP_TYPE_NUMBER: 1207 if (datatype == DATA_TYPE_STRING) { 1208 (void) nvpair_value_string(elem, &value); 1209 if (strcmp(value, "none") == 0) { 1210 isnone = B_TRUE; 1211 } else if (zfs_nicestrtonum(hdl, value, ivalp) 1212 != 0) { 1213 goto error; 1214 } 1215 } else if (datatype == DATA_TYPE_UINT64) { 1216 (void) nvpair_value_uint64(elem, ivalp); 1217 } else { 1218 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1219 "'%s' must be a number"), nvpair_name(elem)); 1220 goto error; 1221 } 1222 1223 /* 1224 * Quota special: force 'none' and don't allow 0. 1225 */ 1226 if ((type & ZFS_TYPE_DATASET) && *ivalp == 0 && !isnone && 1227 (prop == ZFS_PROP_QUOTA || prop == ZFS_PROP_REFQUOTA)) { 1228 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1229 "use 'none' to disable quota/refquota")); 1230 goto error; 1231 } 1232 1233 /* 1234 * Special handling for "*_limit=none". In this case it's not 1235 * 0 but UINT64_MAX. 1236 */ 1237 if ((type & ZFS_TYPE_DATASET) && isnone && 1238 (prop == ZFS_PROP_FILESYSTEM_LIMIT || 1239 prop == ZFS_PROP_SNAPSHOT_LIMIT)) { 1240 *ivalp = UINT64_MAX; 1241 } 1242 break; 1243 1244 case PROP_TYPE_INDEX: 1245 if (datatype != DATA_TYPE_STRING) { 1246 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1247 "'%s' must be a string"), nvpair_name(elem)); 1248 goto error; 1249 } 1250 1251 (void) nvpair_value_string(elem, &value); 1252 1253 if (zprop_string_to_index(prop, value, ivalp, type) != 0) { 1254 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1255 "'%s' must be one of '%s'"), propname, 1256 zprop_values(prop, type)); 1257 goto error; 1258 } 1259 break; 1260 1261 default: 1262 abort(); 1263 } 1264 1265 /* 1266 * Add the result to our return set of properties. 1267 */ 1268 if (*svalp != NULL) { 1269 if (nvlist_add_string(ret, propname, *svalp) != 0) { 1270 (void) no_memory(hdl); 1271 return (-1); 1272 } 1273 } else { 1274 if (nvlist_add_uint64(ret, propname, *ivalp) != 0) { 1275 (void) no_memory(hdl); 1276 return (-1); 1277 } 1278 } 1279 1280 return (0); 1281 error: 1282 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1283 return (-1); 1284 } 1285 1286 static int 1287 addlist(libzfs_handle_t *hdl, char *propname, zprop_list_t **listp, 1288 zfs_type_t type) 1289 { 1290 int prop; 1291 zprop_list_t *entry; 1292 1293 prop = zprop_name_to_prop(propname, type); 1294 1295 if (prop != ZPROP_INVAL && !zprop_valid_for_type(prop, type)) 1296 prop = ZPROP_INVAL; 1297 1298 /* 1299 * When no property table entry can be found, return failure if 1300 * this is a pool property or if this isn't a user-defined 1301 * dataset property, 1302 */ 1303 if (prop == ZPROP_INVAL && ((type == ZFS_TYPE_POOL && 1304 !zpool_prop_feature(propname) && 1305 !zpool_prop_unsupported(propname)) || 1306 (type == ZFS_TYPE_DATASET && !zfs_prop_user(propname) && 1307 !zfs_prop_userquota(propname) && !zfs_prop_written(propname)))) { 1308 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1309 "invalid property '%s'"), propname); 1310 return (zfs_error(hdl, EZFS_BADPROP, 1311 dgettext(TEXT_DOMAIN, "bad property list"))); 1312 } 1313 1314 if ((entry = zfs_alloc(hdl, sizeof (zprop_list_t))) == NULL) 1315 return (-1); 1316 1317 entry->pl_prop = prop; 1318 if (prop == ZPROP_INVAL) { 1319 if ((entry->pl_user_prop = zfs_strdup(hdl, propname)) == 1320 NULL) { 1321 free(entry); 1322 return (-1); 1323 } 1324 entry->pl_width = strlen(propname); 1325 } else { 1326 entry->pl_width = zprop_width(prop, &entry->pl_fixed, 1327 type); 1328 } 1329 1330 *listp = entry; 1331 1332 return (0); 1333 } 1334 1335 /* 1336 * Given a comma-separated list of properties, construct a property list 1337 * containing both user-defined and native properties. This function will 1338 * return a NULL list if 'all' is specified, which can later be expanded 1339 * by zprop_expand_list(). 1340 */ 1341 int 1342 zprop_get_list(libzfs_handle_t *hdl, char *props, zprop_list_t **listp, 1343 zfs_type_t type) 1344 { 1345 *listp = NULL; 1346 1347 /* 1348 * If 'all' is specified, return a NULL list. 1349 */ 1350 if (strcmp(props, "all") == 0) 1351 return (0); 1352 1353 /* 1354 * If no props were specified, return an error. 1355 */ 1356 if (props[0] == '\0') { 1357 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1358 "no properties specified")); 1359 return (zfs_error(hdl, EZFS_BADPROP, dgettext(TEXT_DOMAIN, 1360 "bad property list"))); 1361 } 1362 1363 /* 1364 * It would be nice to use getsubopt() here, but the inclusion of column 1365 * aliases makes this more effort than it's worth. 1366 */ 1367 while (*props != '\0') { 1368 size_t len; 1369 char *p; 1370 char c; 1371 1372 if ((p = strchr(props, ',')) == NULL) { 1373 len = strlen(props); 1374 p = props + len; 1375 } else { 1376 len = p - props; 1377 } 1378 1379 /* 1380 * Check for empty options. 1381 */ 1382 if (len == 0) { 1383 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1384 "empty property name")); 1385 return (zfs_error(hdl, EZFS_BADPROP, 1386 dgettext(TEXT_DOMAIN, "bad property list"))); 1387 } 1388 1389 /* 1390 * Check all regular property names. 1391 */ 1392 c = props[len]; 1393 props[len] = '\0'; 1394 1395 if (strcmp(props, "space") == 0) { 1396 static char *spaceprops[] = { 1397 "name", "avail", "used", "usedbysnapshots", 1398 "usedbydataset", "usedbyrefreservation", 1399 "usedbychildren", NULL 1400 }; 1401 int i; 1402 1403 for (i = 0; spaceprops[i]; i++) { 1404 if (addlist(hdl, spaceprops[i], listp, type)) 1405 return (-1); 1406 listp = &(*listp)->pl_next; 1407 } 1408 } else { 1409 if (addlist(hdl, props, listp, type)) 1410 return (-1); 1411 listp = &(*listp)->pl_next; 1412 } 1413 1414 props = p; 1415 if (c == ',') 1416 props++; 1417 } 1418 1419 return (0); 1420 } 1421 1422 void 1423 zprop_free_list(zprop_list_t *pl) 1424 { 1425 zprop_list_t *next; 1426 1427 while (pl != NULL) { 1428 next = pl->pl_next; 1429 free(pl->pl_user_prop); 1430 free(pl); 1431 pl = next; 1432 } 1433 } 1434 1435 typedef struct expand_data { 1436 zprop_list_t **last; 1437 libzfs_handle_t *hdl; 1438 zfs_type_t type; 1439 } expand_data_t; 1440 1441 int 1442 zprop_expand_list_cb(int prop, void *cb) 1443 { 1444 zprop_list_t *entry; 1445 expand_data_t *edp = cb; 1446 1447 if ((entry = zfs_alloc(edp->hdl, sizeof (zprop_list_t))) == NULL) 1448 return (ZPROP_INVAL); 1449 1450 entry->pl_prop = prop; 1451 entry->pl_width = zprop_width(prop, &entry->pl_fixed, edp->type); 1452 entry->pl_all = B_TRUE; 1453 1454 *(edp->last) = entry; 1455 edp->last = &entry->pl_next; 1456 1457 return (ZPROP_CONT); 1458 } 1459 1460 int 1461 zprop_expand_list(libzfs_handle_t *hdl, zprop_list_t **plp, zfs_type_t type) 1462 { 1463 zprop_list_t *entry; 1464 zprop_list_t **last; 1465 expand_data_t exp; 1466 1467 if (*plp == NULL) { 1468 /* 1469 * If this is the very first time we've been called for an 'all' 1470 * specification, expand the list to include all native 1471 * properties. 1472 */ 1473 last = plp; 1474 1475 exp.last = last; 1476 exp.hdl = hdl; 1477 exp.type = type; 1478 1479 if (zprop_iter_common(zprop_expand_list_cb, &exp, B_FALSE, 1480 B_FALSE, type) == ZPROP_INVAL) 1481 return (-1); 1482 1483 /* 1484 * Add 'name' to the beginning of the list, which is handled 1485 * specially. 1486 */ 1487 if ((entry = zfs_alloc(hdl, sizeof (zprop_list_t))) == NULL) 1488 return (-1); 1489 1490 entry->pl_prop = (type == ZFS_TYPE_POOL) ? ZPOOL_PROP_NAME : 1491 ZFS_PROP_NAME; 1492 entry->pl_width = zprop_width(entry->pl_prop, 1493 &entry->pl_fixed, type); 1494 entry->pl_all = B_TRUE; 1495 entry->pl_next = *plp; 1496 *plp = entry; 1497 } 1498 return (0); 1499 } 1500 1501 int 1502 zprop_iter(zprop_func func, void *cb, boolean_t show_all, boolean_t ordered, 1503 zfs_type_t type) 1504 { 1505 return (zprop_iter_common(func, cb, show_all, ordered, type)); 1506 } 1507 1508 /* 1509 * zfs_get_hole_count retrieves the number of holes (blocks which are 1510 * zero-filled) in the specified file using the _FIO_COUNT_FILLED ioctl. It 1511 * also optionally fetches the block size when bs is non-NULL. With hole count 1512 * and block size the full space consumed by the holes of a file can be 1513 * calculated. 1514 * 1515 * On success, zero is returned, the count argument is set to the 1516 * number of holes, and the bs argument is set to the block size (if it is 1517 * not NULL). On error, a non-zero errno is returned and the values in count 1518 * and bs are undefined. 1519 */ 1520 int 1521 zfs_get_hole_count(const char *path, uint64_t *count, uint64_t *bs) 1522 { 1523 int fd, err; 1524 struct stat64 ss; 1525 uint64_t fill; 1526 1527 fd = open(path, O_RDONLY | O_LARGEFILE); 1528 if (fd == -1) 1529 return (errno); 1530 1531 if (ioctl(fd, _FIO_COUNT_FILLED, &fill) == -1) { 1532 err = errno; 1533 (void) close(fd); 1534 return (err); 1535 } 1536 1537 if (fstat64(fd, &ss) == -1) { 1538 err = errno; 1539 (void) close(fd); 1540 return (err); 1541 } 1542 1543 *count = (ss.st_size + ss.st_blksize - 1) / ss.st_blksize - fill; 1544 VERIFY3S(*count, >=, 0); 1545 if (bs != NULL) { 1546 *bs = ss.st_blksize; 1547 } 1548 1549 if (close(fd) == -1) { 1550 return (errno); 1551 } 1552 return (0); 1553 } 1554