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 2019 Joyent, Inc. 25 * Copyright (c) 2011, 2020 by Delphix. All rights reserved. 26 * Copyright (c) 2012 DEY Storage Systems, Inc. All rights reserved. 27 * Copyright (c) 2012 Pawel Jakub Dawidek <pawel@dawidek.net>. 28 * Copyright (c) 2013 Martin Matuska. All rights reserved. 29 * Copyright (c) 2013 Steven Hartland. All rights reserved. 30 * Copyright 2017 Nexenta Systems, Inc. 31 * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com> 32 * Copyright 2017-2018 RackTop Systems. 33 * Copyright (c) 2019 Datto Inc. 34 * Copyright (c) 2019, loli10K <ezomori.nozomu@gmail.com> 35 * Copyright (c) 2021 Matt Fiddaman 36 */ 37 38 #include <ctype.h> 39 #include <errno.h> 40 #include <libintl.h> 41 #include <stdio.h> 42 #include <stdlib.h> 43 #include <strings.h> 44 #include <unistd.h> 45 #include <stddef.h> 46 #include <zone.h> 47 #include <fcntl.h> 48 #include <sys/mntent.h> 49 #include <sys/mount.h> 50 #include <pwd.h> 51 #include <grp.h> 52 #include <ucred.h> 53 #ifdef HAVE_IDMAP 54 #include <idmap.h> 55 #include <aclutils.h> 56 #include <directory.h> 57 #endif /* HAVE_IDMAP */ 58 59 #include <sys/dnode.h> 60 #include <sys/spa.h> 61 #include <sys/zap.h> 62 #include <sys/dsl_crypt.h> 63 #include <libzfs.h> 64 #include <libzutil.h> 65 66 #include "zfs_namecheck.h" 67 #include "zfs_prop.h" 68 #include "libzfs_impl.h" 69 #include "zfs_deleg.h" 70 71 static int userquota_propname_decode(const char *propname, boolean_t zoned, 72 zfs_userquota_prop_t *typep, char *domain, int domainlen, uint64_t *ridp); 73 74 /* 75 * Given a single type (not a mask of types), return the type in a human 76 * readable form. 77 */ 78 const char * 79 zfs_type_to_name(zfs_type_t type) 80 { 81 switch (type) { 82 case ZFS_TYPE_FILESYSTEM: 83 return (dgettext(TEXT_DOMAIN, "filesystem")); 84 case ZFS_TYPE_SNAPSHOT: 85 return (dgettext(TEXT_DOMAIN, "snapshot")); 86 case ZFS_TYPE_VOLUME: 87 return (dgettext(TEXT_DOMAIN, "volume")); 88 case ZFS_TYPE_POOL: 89 return (dgettext(TEXT_DOMAIN, "pool")); 90 case ZFS_TYPE_BOOKMARK: 91 return (dgettext(TEXT_DOMAIN, "bookmark")); 92 default: 93 assert(!"unhandled zfs_type_t"); 94 } 95 96 return (NULL); 97 } 98 99 /* 100 * Validate a ZFS path. This is used even before trying to open the dataset, to 101 * provide a more meaningful error message. We call zfs_error_aux() to 102 * explain exactly why the name was not valid. 103 */ 104 int 105 zfs_validate_name(libzfs_handle_t *hdl, const char *path, int type, 106 boolean_t modifying) 107 { 108 namecheck_err_t why; 109 char what; 110 111 if (!(type & ZFS_TYPE_SNAPSHOT) && strchr(path, '@') != NULL) { 112 if (hdl != NULL) 113 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 114 "snapshot delimiter '@' is not expected here")); 115 return (0); 116 } 117 118 if (type == ZFS_TYPE_SNAPSHOT && strchr(path, '@') == NULL) { 119 if (hdl != NULL) 120 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 121 "missing '@' delimiter in snapshot name")); 122 return (0); 123 } 124 125 if (!(type & ZFS_TYPE_BOOKMARK) && strchr(path, '#') != NULL) { 126 if (hdl != NULL) 127 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 128 "bookmark delimiter '#' is not expected here")); 129 return (0); 130 } 131 132 if (type == ZFS_TYPE_BOOKMARK && strchr(path, '#') == NULL) { 133 if (hdl != NULL) 134 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 135 "missing '#' delimiter in bookmark name")); 136 return (0); 137 } 138 139 if (modifying && strchr(path, '%') != NULL) { 140 if (hdl != NULL) 141 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 142 "invalid character %c in name"), '%'); 143 return (0); 144 } 145 146 if (entity_namecheck(path, &why, &what) != 0) { 147 if (hdl != NULL) { 148 switch (why) { 149 case NAME_ERR_TOOLONG: 150 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 151 "name is too long")); 152 break; 153 154 case NAME_ERR_LEADING_SLASH: 155 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 156 "leading slash in name")); 157 break; 158 159 case NAME_ERR_EMPTY_COMPONENT: 160 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 161 "empty component or misplaced '@'" 162 " or '#' delimiter in name")); 163 break; 164 165 case NAME_ERR_TRAILING_SLASH: 166 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 167 "trailing slash in name")); 168 break; 169 170 case NAME_ERR_INVALCHAR: 171 zfs_error_aux(hdl, 172 dgettext(TEXT_DOMAIN, "invalid character " 173 "'%c' in name"), what); 174 break; 175 176 case NAME_ERR_MULTIPLE_DELIMITERS: 177 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 178 "multiple '@' and/or '#' delimiters in " 179 "name")); 180 break; 181 182 case NAME_ERR_NOLETTER: 183 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 184 "pool doesn't begin with a letter")); 185 break; 186 187 case NAME_ERR_RESERVED: 188 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 189 "name is reserved")); 190 break; 191 192 case NAME_ERR_DISKLIKE: 193 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 194 "reserved disk name")); 195 break; 196 197 case NAME_ERR_SELF_REF: 198 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 199 "self reference, '.' is found in name")); 200 break; 201 202 case NAME_ERR_PARENT_REF: 203 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 204 "parent reference, '..' is found in name")); 205 break; 206 207 default: 208 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 209 "(%d) not defined"), why); 210 break; 211 } 212 } 213 214 return (0); 215 } 216 217 return (-1); 218 } 219 220 int 221 zfs_name_valid(const char *name, zfs_type_t type) 222 { 223 if (type == ZFS_TYPE_POOL) 224 return (zpool_name_valid(NULL, B_FALSE, name)); 225 return (zfs_validate_name(NULL, name, type, B_FALSE)); 226 } 227 228 /* 229 * This function takes the raw DSL properties, and filters out the user-defined 230 * properties into a separate nvlist. 231 */ 232 static nvlist_t * 233 process_user_props(zfs_handle_t *zhp, nvlist_t *props) 234 { 235 libzfs_handle_t *hdl = zhp->zfs_hdl; 236 nvpair_t *elem; 237 nvlist_t *propval; 238 nvlist_t *nvl; 239 240 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) { 241 (void) no_memory(hdl); 242 return (NULL); 243 } 244 245 elem = NULL; 246 while ((elem = nvlist_next_nvpair(props, elem)) != NULL) { 247 if (!zfs_prop_user(nvpair_name(elem))) 248 continue; 249 250 verify(nvpair_value_nvlist(elem, &propval) == 0); 251 if (nvlist_add_nvlist(nvl, nvpair_name(elem), propval) != 0) { 252 nvlist_free(nvl); 253 (void) no_memory(hdl); 254 return (NULL); 255 } 256 } 257 258 return (nvl); 259 } 260 261 static zpool_handle_t * 262 zpool_add_handle(zfs_handle_t *zhp, const char *pool_name) 263 { 264 libzfs_handle_t *hdl = zhp->zfs_hdl; 265 zpool_handle_t *zph; 266 267 if ((zph = zpool_open_canfail(hdl, pool_name)) != NULL) { 268 if (hdl->libzfs_pool_handles != NULL) 269 zph->zpool_next = hdl->libzfs_pool_handles; 270 hdl->libzfs_pool_handles = zph; 271 } 272 return (zph); 273 } 274 275 static zpool_handle_t * 276 zpool_find_handle(zfs_handle_t *zhp, const char *pool_name, int len) 277 { 278 libzfs_handle_t *hdl = zhp->zfs_hdl; 279 zpool_handle_t *zph = hdl->libzfs_pool_handles; 280 281 while ((zph != NULL) && 282 (strncmp(pool_name, zpool_get_name(zph), len) != 0)) 283 zph = zph->zpool_next; 284 return (zph); 285 } 286 287 /* 288 * Returns a handle to the pool that contains the provided dataset. 289 * If a handle to that pool already exists then that handle is returned. 290 * Otherwise, a new handle is created and added to the list of handles. 291 */ 292 static zpool_handle_t * 293 zpool_handle(zfs_handle_t *zhp) 294 { 295 char *pool_name; 296 int len; 297 zpool_handle_t *zph; 298 299 len = strcspn(zhp->zfs_name, "/@#") + 1; 300 pool_name = zfs_alloc(zhp->zfs_hdl, len); 301 (void) strlcpy(pool_name, zhp->zfs_name, len); 302 303 zph = zpool_find_handle(zhp, pool_name, len); 304 if (zph == NULL) 305 zph = zpool_add_handle(zhp, pool_name); 306 307 free(pool_name); 308 return (zph); 309 } 310 311 void 312 zpool_free_handles(libzfs_handle_t *hdl) 313 { 314 zpool_handle_t *next, *zph = hdl->libzfs_pool_handles; 315 316 while (zph != NULL) { 317 next = zph->zpool_next; 318 zpool_close(zph); 319 zph = next; 320 } 321 hdl->libzfs_pool_handles = NULL; 322 } 323 324 /* 325 * Utility function to gather stats (objset and zpl) for the given object. 326 */ 327 static int 328 get_stats_ioctl(zfs_handle_t *zhp, zfs_cmd_t *zc) 329 { 330 libzfs_handle_t *hdl = zhp->zfs_hdl; 331 332 (void) strlcpy(zc->zc_name, zhp->zfs_name, sizeof (zc->zc_name)); 333 334 while (zfs_ioctl(hdl, ZFS_IOC_OBJSET_STATS, zc) != 0) { 335 if (errno == ENOMEM) { 336 if (zcmd_expand_dst_nvlist(hdl, zc) != 0) { 337 return (-1); 338 } 339 } else { 340 return (-1); 341 } 342 } 343 return (0); 344 } 345 346 /* 347 * Utility function to get the received properties of the given object. 348 */ 349 static int 350 get_recvd_props_ioctl(zfs_handle_t *zhp) 351 { 352 libzfs_handle_t *hdl = zhp->zfs_hdl; 353 nvlist_t *recvdprops; 354 zfs_cmd_t zc = {"\0"}; 355 int err; 356 357 if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0) 358 return (-1); 359 360 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 361 362 while (zfs_ioctl(hdl, ZFS_IOC_OBJSET_RECVD_PROPS, &zc) != 0) { 363 if (errno == ENOMEM) { 364 if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) { 365 return (-1); 366 } 367 } else { 368 zcmd_free_nvlists(&zc); 369 return (-1); 370 } 371 } 372 373 err = zcmd_read_dst_nvlist(zhp->zfs_hdl, &zc, &recvdprops); 374 zcmd_free_nvlists(&zc); 375 if (err != 0) 376 return (-1); 377 378 nvlist_free(zhp->zfs_recvd_props); 379 zhp->zfs_recvd_props = recvdprops; 380 381 return (0); 382 } 383 384 static int 385 put_stats_zhdl(zfs_handle_t *zhp, zfs_cmd_t *zc) 386 { 387 nvlist_t *allprops, *userprops; 388 389 zhp->zfs_dmustats = zc->zc_objset_stats; /* structure assignment */ 390 391 if (zcmd_read_dst_nvlist(zhp->zfs_hdl, zc, &allprops) != 0) { 392 return (-1); 393 } 394 395 /* 396 * XXX Why do we store the user props separately, in addition to 397 * storing them in zfs_props? 398 */ 399 if ((userprops = process_user_props(zhp, allprops)) == NULL) { 400 nvlist_free(allprops); 401 return (-1); 402 } 403 404 nvlist_free(zhp->zfs_props); 405 nvlist_free(zhp->zfs_user_props); 406 407 zhp->zfs_props = allprops; 408 zhp->zfs_user_props = userprops; 409 410 return (0); 411 } 412 413 static int 414 get_stats(zfs_handle_t *zhp) 415 { 416 int rc = 0; 417 zfs_cmd_t zc = {"\0"}; 418 419 if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0) 420 return (-1); 421 if (get_stats_ioctl(zhp, &zc) != 0) 422 rc = -1; 423 else if (put_stats_zhdl(zhp, &zc) != 0) 424 rc = -1; 425 zcmd_free_nvlists(&zc); 426 return (rc); 427 } 428 429 /* 430 * Refresh the properties currently stored in the handle. 431 */ 432 void 433 zfs_refresh_properties(zfs_handle_t *zhp) 434 { 435 (void) get_stats(zhp); 436 } 437 438 /* 439 * Makes a handle from the given dataset name. Used by zfs_open() and 440 * zfs_iter_* to create child handles on the fly. 441 */ 442 static int 443 make_dataset_handle_common(zfs_handle_t *zhp, zfs_cmd_t *zc) 444 { 445 if (put_stats_zhdl(zhp, zc) != 0) 446 return (-1); 447 448 /* 449 * We've managed to open the dataset and gather statistics. Determine 450 * the high-level type. 451 */ 452 if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL) 453 zhp->zfs_head_type = ZFS_TYPE_VOLUME; 454 else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS) 455 zhp->zfs_head_type = ZFS_TYPE_FILESYSTEM; 456 else if (zhp->zfs_dmustats.dds_type == DMU_OST_OTHER) 457 return (-1); 458 else 459 abort(); 460 461 if (zhp->zfs_dmustats.dds_is_snapshot) 462 zhp->zfs_type = ZFS_TYPE_SNAPSHOT; 463 else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL) 464 zhp->zfs_type = ZFS_TYPE_VOLUME; 465 else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS) 466 zhp->zfs_type = ZFS_TYPE_FILESYSTEM; 467 else 468 abort(); /* we should never see any other types */ 469 470 if ((zhp->zpool_hdl = zpool_handle(zhp)) == NULL) 471 return (-1); 472 473 return (0); 474 } 475 476 zfs_handle_t * 477 make_dataset_handle(libzfs_handle_t *hdl, const char *path) 478 { 479 zfs_cmd_t zc = {"\0"}; 480 481 zfs_handle_t *zhp = calloc(1, sizeof (zfs_handle_t)); 482 483 if (zhp == NULL) 484 return (NULL); 485 486 zhp->zfs_hdl = hdl; 487 (void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name)); 488 if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0) { 489 free(zhp); 490 return (NULL); 491 } 492 if (get_stats_ioctl(zhp, &zc) == -1) { 493 zcmd_free_nvlists(&zc); 494 free(zhp); 495 return (NULL); 496 } 497 if (make_dataset_handle_common(zhp, &zc) == -1) { 498 free(zhp); 499 zhp = NULL; 500 } 501 zcmd_free_nvlists(&zc); 502 return (zhp); 503 } 504 505 zfs_handle_t * 506 make_dataset_handle_zc(libzfs_handle_t *hdl, zfs_cmd_t *zc) 507 { 508 zfs_handle_t *zhp = calloc(1, sizeof (zfs_handle_t)); 509 510 if (zhp == NULL) 511 return (NULL); 512 513 zhp->zfs_hdl = hdl; 514 (void) strlcpy(zhp->zfs_name, zc->zc_name, sizeof (zhp->zfs_name)); 515 if (make_dataset_handle_common(zhp, zc) == -1) { 516 free(zhp); 517 return (NULL); 518 } 519 return (zhp); 520 } 521 522 zfs_handle_t * 523 make_dataset_simple_handle_zc(zfs_handle_t *pzhp, zfs_cmd_t *zc) 524 { 525 zfs_handle_t *zhp = calloc(1, sizeof (zfs_handle_t)); 526 527 if (zhp == NULL) 528 return (NULL); 529 530 zhp->zfs_hdl = pzhp->zfs_hdl; 531 (void) strlcpy(zhp->zfs_name, zc->zc_name, sizeof (zhp->zfs_name)); 532 zhp->zfs_head_type = pzhp->zfs_type; 533 zhp->zfs_type = ZFS_TYPE_SNAPSHOT; 534 zhp->zpool_hdl = zpool_handle(zhp); 535 536 return (zhp); 537 } 538 539 zfs_handle_t * 540 zfs_handle_dup(zfs_handle_t *zhp_orig) 541 { 542 zfs_handle_t *zhp = calloc(1, sizeof (zfs_handle_t)); 543 544 if (zhp == NULL) 545 return (NULL); 546 547 zhp->zfs_hdl = zhp_orig->zfs_hdl; 548 zhp->zpool_hdl = zhp_orig->zpool_hdl; 549 (void) strlcpy(zhp->zfs_name, zhp_orig->zfs_name, 550 sizeof (zhp->zfs_name)); 551 zhp->zfs_type = zhp_orig->zfs_type; 552 zhp->zfs_head_type = zhp_orig->zfs_head_type; 553 zhp->zfs_dmustats = zhp_orig->zfs_dmustats; 554 if (zhp_orig->zfs_props != NULL) { 555 if (nvlist_dup(zhp_orig->zfs_props, &zhp->zfs_props, 0) != 0) { 556 (void) no_memory(zhp->zfs_hdl); 557 zfs_close(zhp); 558 return (NULL); 559 } 560 } 561 if (zhp_orig->zfs_user_props != NULL) { 562 if (nvlist_dup(zhp_orig->zfs_user_props, 563 &zhp->zfs_user_props, 0) != 0) { 564 (void) no_memory(zhp->zfs_hdl); 565 zfs_close(zhp); 566 return (NULL); 567 } 568 } 569 if (zhp_orig->zfs_recvd_props != NULL) { 570 if (nvlist_dup(zhp_orig->zfs_recvd_props, 571 &zhp->zfs_recvd_props, 0)) { 572 (void) no_memory(zhp->zfs_hdl); 573 zfs_close(zhp); 574 return (NULL); 575 } 576 } 577 zhp->zfs_mntcheck = zhp_orig->zfs_mntcheck; 578 if (zhp_orig->zfs_mntopts != NULL) { 579 zhp->zfs_mntopts = zfs_strdup(zhp_orig->zfs_hdl, 580 zhp_orig->zfs_mntopts); 581 } 582 zhp->zfs_props_table = zhp_orig->zfs_props_table; 583 return (zhp); 584 } 585 586 boolean_t 587 zfs_bookmark_exists(const char *path) 588 { 589 nvlist_t *bmarks; 590 nvlist_t *props; 591 char fsname[ZFS_MAX_DATASET_NAME_LEN]; 592 char *bmark_name; 593 char *pound; 594 int err; 595 boolean_t rv; 596 597 (void) strlcpy(fsname, path, sizeof (fsname)); 598 pound = strchr(fsname, '#'); 599 if (pound == NULL) 600 return (B_FALSE); 601 602 *pound = '\0'; 603 bmark_name = pound + 1; 604 props = fnvlist_alloc(); 605 err = lzc_get_bookmarks(fsname, props, &bmarks); 606 nvlist_free(props); 607 if (err != 0) { 608 nvlist_free(bmarks); 609 return (B_FALSE); 610 } 611 612 rv = nvlist_exists(bmarks, bmark_name); 613 nvlist_free(bmarks); 614 return (rv); 615 } 616 617 zfs_handle_t * 618 make_bookmark_handle(zfs_handle_t *parent, const char *path, 619 nvlist_t *bmark_props) 620 { 621 zfs_handle_t *zhp = calloc(1, sizeof (zfs_handle_t)); 622 623 if (zhp == NULL) 624 return (NULL); 625 626 /* Fill in the name. */ 627 zhp->zfs_hdl = parent->zfs_hdl; 628 (void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name)); 629 630 /* Set the property lists. */ 631 if (nvlist_dup(bmark_props, &zhp->zfs_props, 0) != 0) { 632 free(zhp); 633 return (NULL); 634 } 635 636 /* Set the types. */ 637 zhp->zfs_head_type = parent->zfs_head_type; 638 zhp->zfs_type = ZFS_TYPE_BOOKMARK; 639 640 if ((zhp->zpool_hdl = zpool_handle(zhp)) == NULL) { 641 nvlist_free(zhp->zfs_props); 642 free(zhp); 643 return (NULL); 644 } 645 646 return (zhp); 647 } 648 649 struct zfs_open_bookmarks_cb_data { 650 const char *path; 651 zfs_handle_t *zhp; 652 }; 653 654 static int 655 zfs_open_bookmarks_cb(zfs_handle_t *zhp, void *data) 656 { 657 struct zfs_open_bookmarks_cb_data *dp = data; 658 659 /* 660 * Is it the one we are looking for? 661 */ 662 if (strcmp(dp->path, zfs_get_name(zhp)) == 0) { 663 /* 664 * We found it. Save it and let the caller know we are done. 665 */ 666 dp->zhp = zhp; 667 return (EEXIST); 668 } 669 670 /* 671 * Not found. Close the handle and ask for another one. 672 */ 673 zfs_close(zhp); 674 return (0); 675 } 676 677 /* 678 * Opens the given snapshot, bookmark, filesystem, or volume. The 'types' 679 * argument is a mask of acceptable types. The function will print an 680 * appropriate error message and return NULL if it can't be opened. 681 */ 682 zfs_handle_t * 683 zfs_open(libzfs_handle_t *hdl, const char *path, int types) 684 { 685 zfs_handle_t *zhp; 686 char errbuf[1024]; 687 char *bookp; 688 689 (void) snprintf(errbuf, sizeof (errbuf), 690 dgettext(TEXT_DOMAIN, "cannot open '%s'"), path); 691 692 /* 693 * Validate the name before we even try to open it. 694 */ 695 if (!zfs_validate_name(hdl, path, types, B_FALSE)) { 696 (void) zfs_error(hdl, EZFS_INVALIDNAME, errbuf); 697 return (NULL); 698 } 699 700 /* 701 * Bookmarks needs to be handled separately. 702 */ 703 bookp = strchr(path, '#'); 704 if (bookp == NULL) { 705 /* 706 * Try to get stats for the dataset, which will tell us if it 707 * exists. 708 */ 709 errno = 0; 710 if ((zhp = make_dataset_handle(hdl, path)) == NULL) { 711 (void) zfs_standard_error(hdl, errno, errbuf); 712 return (NULL); 713 } 714 } else { 715 char dsname[ZFS_MAX_DATASET_NAME_LEN]; 716 zfs_handle_t *pzhp; 717 struct zfs_open_bookmarks_cb_data cb_data = {path, NULL}; 718 719 /* 720 * We need to cut out '#' and everything after '#' 721 * to get the parent dataset name only. 722 */ 723 assert(bookp - path < sizeof (dsname)); 724 (void) strncpy(dsname, path, bookp - path); 725 dsname[bookp - path] = '\0'; 726 727 /* 728 * Create handle for the parent dataset. 729 */ 730 errno = 0; 731 if ((pzhp = make_dataset_handle(hdl, dsname)) == NULL) { 732 (void) zfs_standard_error(hdl, errno, errbuf); 733 return (NULL); 734 } 735 736 /* 737 * Iterate bookmarks to find the right one. 738 */ 739 errno = 0; 740 if ((zfs_iter_bookmarks(pzhp, zfs_open_bookmarks_cb, 741 &cb_data) == 0) && (cb_data.zhp == NULL)) { 742 (void) zfs_error(hdl, EZFS_NOENT, errbuf); 743 zfs_close(pzhp); 744 return (NULL); 745 } 746 if (cb_data.zhp == NULL) { 747 (void) zfs_standard_error(hdl, errno, errbuf); 748 zfs_close(pzhp); 749 return (NULL); 750 } 751 zhp = cb_data.zhp; 752 753 /* 754 * Cleanup. 755 */ 756 zfs_close(pzhp); 757 } 758 759 if (!(types & zhp->zfs_type)) { 760 (void) zfs_error(hdl, EZFS_BADTYPE, errbuf); 761 zfs_close(zhp); 762 return (NULL); 763 } 764 765 return (zhp); 766 } 767 768 /* 769 * Release a ZFS handle. Nothing to do but free the associated memory. 770 */ 771 void 772 zfs_close(zfs_handle_t *zhp) 773 { 774 if (zhp->zfs_mntopts) 775 free(zhp->zfs_mntopts); 776 nvlist_free(zhp->zfs_props); 777 nvlist_free(zhp->zfs_user_props); 778 nvlist_free(zhp->zfs_recvd_props); 779 free(zhp); 780 } 781 782 typedef struct mnttab_node { 783 struct mnttab mtn_mt; 784 avl_node_t mtn_node; 785 } mnttab_node_t; 786 787 static int 788 libzfs_mnttab_cache_compare(const void *arg1, const void *arg2) 789 { 790 const mnttab_node_t *mtn1 = (const mnttab_node_t *)arg1; 791 const mnttab_node_t *mtn2 = (const mnttab_node_t *)arg2; 792 int rv; 793 794 rv = strcmp(mtn1->mtn_mt.mnt_special, mtn2->mtn_mt.mnt_special); 795 796 return (TREE_ISIGN(rv)); 797 } 798 799 void 800 libzfs_mnttab_init(libzfs_handle_t *hdl) 801 { 802 pthread_mutex_init(&hdl->libzfs_mnttab_cache_lock, NULL); 803 assert(avl_numnodes(&hdl->libzfs_mnttab_cache) == 0); 804 avl_create(&hdl->libzfs_mnttab_cache, libzfs_mnttab_cache_compare, 805 sizeof (mnttab_node_t), offsetof(mnttab_node_t, mtn_node)); 806 } 807 808 static int 809 libzfs_mnttab_update(libzfs_handle_t *hdl) 810 { 811 FILE *mnttab; 812 struct mnttab entry; 813 814 if ((mnttab = fopen(MNTTAB, "re")) == NULL) 815 return (ENOENT); 816 817 while (getmntent(mnttab, &entry) == 0) { 818 mnttab_node_t *mtn; 819 avl_index_t where; 820 821 if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) 822 continue; 823 824 mtn = zfs_alloc(hdl, sizeof (mnttab_node_t)); 825 mtn->mtn_mt.mnt_special = zfs_strdup(hdl, entry.mnt_special); 826 mtn->mtn_mt.mnt_mountp = zfs_strdup(hdl, entry.mnt_mountp); 827 mtn->mtn_mt.mnt_fstype = zfs_strdup(hdl, entry.mnt_fstype); 828 mtn->mtn_mt.mnt_mntopts = zfs_strdup(hdl, entry.mnt_mntopts); 829 830 /* Exclude duplicate mounts */ 831 if (avl_find(&hdl->libzfs_mnttab_cache, mtn, &where) != NULL) { 832 free(mtn->mtn_mt.mnt_special); 833 free(mtn->mtn_mt.mnt_mountp); 834 free(mtn->mtn_mt.mnt_fstype); 835 free(mtn->mtn_mt.mnt_mntopts); 836 free(mtn); 837 continue; 838 } 839 840 avl_add(&hdl->libzfs_mnttab_cache, mtn); 841 } 842 843 (void) fclose(mnttab); 844 return (0); 845 } 846 847 void 848 libzfs_mnttab_fini(libzfs_handle_t *hdl) 849 { 850 void *cookie = NULL; 851 mnttab_node_t *mtn; 852 853 while ((mtn = avl_destroy_nodes(&hdl->libzfs_mnttab_cache, &cookie)) 854 != NULL) { 855 free(mtn->mtn_mt.mnt_special); 856 free(mtn->mtn_mt.mnt_mountp); 857 free(mtn->mtn_mt.mnt_fstype); 858 free(mtn->mtn_mt.mnt_mntopts); 859 free(mtn); 860 } 861 avl_destroy(&hdl->libzfs_mnttab_cache); 862 (void) pthread_mutex_destroy(&hdl->libzfs_mnttab_cache_lock); 863 } 864 865 void 866 libzfs_mnttab_cache(libzfs_handle_t *hdl, boolean_t enable) 867 { 868 hdl->libzfs_mnttab_enable = enable; 869 } 870 871 int 872 libzfs_mnttab_find(libzfs_handle_t *hdl, const char *fsname, 873 struct mnttab *entry) 874 { 875 FILE *mnttab; 876 mnttab_node_t find; 877 mnttab_node_t *mtn; 878 int ret = ENOENT; 879 880 if (!hdl->libzfs_mnttab_enable) { 881 struct mnttab srch = { 0 }; 882 883 if (avl_numnodes(&hdl->libzfs_mnttab_cache)) 884 libzfs_mnttab_fini(hdl); 885 886 if ((mnttab = fopen(MNTTAB, "re")) == NULL) 887 return (ENOENT); 888 889 srch.mnt_special = (char *)fsname; 890 srch.mnt_fstype = MNTTYPE_ZFS; 891 ret = getmntany(mnttab, entry, &srch) ? ENOENT : 0; 892 (void) fclose(mnttab); 893 return (ret); 894 } 895 896 pthread_mutex_lock(&hdl->libzfs_mnttab_cache_lock); 897 if (avl_numnodes(&hdl->libzfs_mnttab_cache) == 0) { 898 int error; 899 900 if ((error = libzfs_mnttab_update(hdl)) != 0) { 901 pthread_mutex_unlock(&hdl->libzfs_mnttab_cache_lock); 902 return (error); 903 } 904 } 905 906 find.mtn_mt.mnt_special = (char *)fsname; 907 mtn = avl_find(&hdl->libzfs_mnttab_cache, &find, NULL); 908 if (mtn) { 909 *entry = mtn->mtn_mt; 910 ret = 0; 911 } 912 pthread_mutex_unlock(&hdl->libzfs_mnttab_cache_lock); 913 return (ret); 914 } 915 916 void 917 libzfs_mnttab_add(libzfs_handle_t *hdl, const char *special, 918 const char *mountp, const char *mntopts) 919 { 920 mnttab_node_t *mtn; 921 922 pthread_mutex_lock(&hdl->libzfs_mnttab_cache_lock); 923 if (avl_numnodes(&hdl->libzfs_mnttab_cache) != 0) { 924 mtn = zfs_alloc(hdl, sizeof (mnttab_node_t)); 925 mtn->mtn_mt.mnt_special = zfs_strdup(hdl, special); 926 mtn->mtn_mt.mnt_mountp = zfs_strdup(hdl, mountp); 927 mtn->mtn_mt.mnt_fstype = zfs_strdup(hdl, MNTTYPE_ZFS); 928 mtn->mtn_mt.mnt_mntopts = zfs_strdup(hdl, mntopts); 929 /* 930 * Another thread may have already added this entry 931 * via libzfs_mnttab_update. If so we should skip it. 932 */ 933 if (avl_find(&hdl->libzfs_mnttab_cache, mtn, NULL) != NULL) { 934 free(mtn->mtn_mt.mnt_special); 935 free(mtn->mtn_mt.mnt_mountp); 936 free(mtn->mtn_mt.mnt_fstype); 937 free(mtn->mtn_mt.mnt_mntopts); 938 free(mtn); 939 } else { 940 avl_add(&hdl->libzfs_mnttab_cache, mtn); 941 } 942 } 943 pthread_mutex_unlock(&hdl->libzfs_mnttab_cache_lock); 944 } 945 946 void 947 libzfs_mnttab_remove(libzfs_handle_t *hdl, const char *fsname) 948 { 949 mnttab_node_t find; 950 mnttab_node_t *ret; 951 952 pthread_mutex_lock(&hdl->libzfs_mnttab_cache_lock); 953 find.mtn_mt.mnt_special = (char *)fsname; 954 if ((ret = avl_find(&hdl->libzfs_mnttab_cache, (void *)&find, NULL)) 955 != NULL) { 956 avl_remove(&hdl->libzfs_mnttab_cache, ret); 957 free(ret->mtn_mt.mnt_special); 958 free(ret->mtn_mt.mnt_mountp); 959 free(ret->mtn_mt.mnt_fstype); 960 free(ret->mtn_mt.mnt_mntopts); 961 free(ret); 962 } 963 pthread_mutex_unlock(&hdl->libzfs_mnttab_cache_lock); 964 } 965 966 int 967 zfs_spa_version(zfs_handle_t *zhp, int *spa_version) 968 { 969 zpool_handle_t *zpool_handle = zhp->zpool_hdl; 970 971 if (zpool_handle == NULL) 972 return (-1); 973 974 *spa_version = zpool_get_prop_int(zpool_handle, 975 ZPOOL_PROP_VERSION, NULL); 976 return (0); 977 } 978 979 /* 980 * The choice of reservation property depends on the SPA version. 981 */ 982 static int 983 zfs_which_resv_prop(zfs_handle_t *zhp, zfs_prop_t *resv_prop) 984 { 985 int spa_version; 986 987 if (zfs_spa_version(zhp, &spa_version) < 0) 988 return (-1); 989 990 if (spa_version >= SPA_VERSION_REFRESERVATION) 991 *resv_prop = ZFS_PROP_REFRESERVATION; 992 else 993 *resv_prop = ZFS_PROP_RESERVATION; 994 995 return (0); 996 } 997 998 /* 999 * Given an nvlist of properties to set, validates that they are correct, and 1000 * parses any numeric properties (index, boolean, etc) if they are specified as 1001 * strings. 1002 */ 1003 nvlist_t * 1004 zfs_valid_proplist(libzfs_handle_t *hdl, zfs_type_t type, nvlist_t *nvl, 1005 uint64_t zoned, zfs_handle_t *zhp, zpool_handle_t *zpool_hdl, 1006 boolean_t key_params_ok, const char *errbuf) 1007 { 1008 nvpair_t *elem; 1009 uint64_t intval; 1010 char *strval; 1011 zfs_prop_t prop; 1012 nvlist_t *ret; 1013 int chosen_normal = -1; 1014 int chosen_utf = -1; 1015 1016 if (nvlist_alloc(&ret, NV_UNIQUE_NAME, 0) != 0) { 1017 (void) no_memory(hdl); 1018 return (NULL); 1019 } 1020 1021 /* 1022 * Make sure this property is valid and applies to this type. 1023 */ 1024 1025 elem = NULL; 1026 while ((elem = nvlist_next_nvpair(nvl, elem)) != NULL) { 1027 const char *propname = nvpair_name(elem); 1028 1029 prop = zfs_name_to_prop(propname); 1030 if (prop == ZPROP_INVAL && zfs_prop_user(propname)) { 1031 /* 1032 * This is a user property: make sure it's a 1033 * string, and that it's less than ZAP_MAXNAMELEN. 1034 */ 1035 if (nvpair_type(elem) != DATA_TYPE_STRING) { 1036 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1037 "'%s' must be a string"), propname); 1038 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1039 goto error; 1040 } 1041 1042 if (strlen(nvpair_name(elem)) >= ZAP_MAXNAMELEN) { 1043 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1044 "property name '%s' is too long"), 1045 propname); 1046 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1047 goto error; 1048 } 1049 1050 (void) nvpair_value_string(elem, &strval); 1051 if (nvlist_add_string(ret, propname, strval) != 0) { 1052 (void) no_memory(hdl); 1053 goto error; 1054 } 1055 continue; 1056 } 1057 1058 /* 1059 * Currently, only user properties can be modified on 1060 * snapshots. 1061 */ 1062 if (type == ZFS_TYPE_SNAPSHOT) { 1063 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1064 "this property can not be modified for snapshots")); 1065 (void) zfs_error(hdl, EZFS_PROPTYPE, errbuf); 1066 goto error; 1067 } 1068 1069 if (prop == ZPROP_INVAL && zfs_prop_userquota(propname)) { 1070 zfs_userquota_prop_t uqtype; 1071 char *newpropname = NULL; 1072 char domain[128]; 1073 uint64_t rid; 1074 uint64_t valary[3]; 1075 int rc; 1076 1077 if (userquota_propname_decode(propname, zoned, 1078 &uqtype, domain, sizeof (domain), &rid) != 0) { 1079 zfs_error_aux(hdl, 1080 dgettext(TEXT_DOMAIN, 1081 "'%s' has an invalid user/group name"), 1082 propname); 1083 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1084 goto error; 1085 } 1086 1087 if (uqtype != ZFS_PROP_USERQUOTA && 1088 uqtype != ZFS_PROP_GROUPQUOTA && 1089 uqtype != ZFS_PROP_USEROBJQUOTA && 1090 uqtype != ZFS_PROP_GROUPOBJQUOTA && 1091 uqtype != ZFS_PROP_PROJECTQUOTA && 1092 uqtype != ZFS_PROP_PROJECTOBJQUOTA) { 1093 zfs_error_aux(hdl, 1094 dgettext(TEXT_DOMAIN, "'%s' is readonly"), 1095 propname); 1096 (void) zfs_error(hdl, EZFS_PROPREADONLY, 1097 errbuf); 1098 goto error; 1099 } 1100 1101 if (nvpair_type(elem) == DATA_TYPE_STRING) { 1102 (void) nvpair_value_string(elem, &strval); 1103 if (strcmp(strval, "none") == 0) { 1104 intval = 0; 1105 } else if (zfs_nicestrtonum(hdl, 1106 strval, &intval) != 0) { 1107 (void) zfs_error(hdl, 1108 EZFS_BADPROP, errbuf); 1109 goto error; 1110 } 1111 } else if (nvpair_type(elem) == 1112 DATA_TYPE_UINT64) { 1113 (void) nvpair_value_uint64(elem, &intval); 1114 if (intval == 0) { 1115 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1116 "use 'none' to disable " 1117 "{user|group|project}quota")); 1118 goto error; 1119 } 1120 } else { 1121 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1122 "'%s' must be a number"), propname); 1123 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1124 goto error; 1125 } 1126 1127 /* 1128 * Encode the prop name as 1129 * userquota@<hex-rid>-domain, to make it easy 1130 * for the kernel to decode. 1131 */ 1132 rc = asprintf(&newpropname, "%s%llx-%s", 1133 zfs_userquota_prop_prefixes[uqtype], 1134 (longlong_t)rid, domain); 1135 if (rc == -1 || newpropname == NULL) { 1136 (void) no_memory(hdl); 1137 goto error; 1138 } 1139 1140 valary[0] = uqtype; 1141 valary[1] = rid; 1142 valary[2] = intval; 1143 if (nvlist_add_uint64_array(ret, newpropname, 1144 valary, 3) != 0) { 1145 free(newpropname); 1146 (void) no_memory(hdl); 1147 goto error; 1148 } 1149 free(newpropname); 1150 continue; 1151 } else if (prop == ZPROP_INVAL && zfs_prop_written(propname)) { 1152 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1153 "'%s' is readonly"), 1154 propname); 1155 (void) zfs_error(hdl, EZFS_PROPREADONLY, errbuf); 1156 goto error; 1157 } 1158 1159 if (prop == ZPROP_INVAL) { 1160 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1161 "invalid property '%s'"), propname); 1162 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1163 goto error; 1164 } 1165 1166 if (!zfs_prop_valid_for_type(prop, type, B_FALSE)) { 1167 zfs_error_aux(hdl, 1168 dgettext(TEXT_DOMAIN, "'%s' does not " 1169 "apply to datasets of this type"), propname); 1170 (void) zfs_error(hdl, EZFS_PROPTYPE, errbuf); 1171 goto error; 1172 } 1173 1174 if (zfs_prop_readonly(prop) && 1175 !(zfs_prop_setonce(prop) && zhp == NULL) && 1176 !(zfs_prop_encryption_key_param(prop) && key_params_ok)) { 1177 zfs_error_aux(hdl, 1178 dgettext(TEXT_DOMAIN, "'%s' is readonly"), 1179 propname); 1180 (void) zfs_error(hdl, EZFS_PROPREADONLY, errbuf); 1181 goto error; 1182 } 1183 1184 if (zprop_parse_value(hdl, elem, prop, type, ret, 1185 &strval, &intval, errbuf) != 0) 1186 goto error; 1187 1188 /* 1189 * Perform some additional checks for specific properties. 1190 */ 1191 switch (prop) { 1192 case ZFS_PROP_VERSION: 1193 { 1194 int version; 1195 1196 if (zhp == NULL) 1197 break; 1198 version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION); 1199 if (intval < version) { 1200 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1201 "Can not downgrade; already at version %u"), 1202 version); 1203 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1204 goto error; 1205 } 1206 break; 1207 } 1208 1209 case ZFS_PROP_VOLBLOCKSIZE: 1210 case ZFS_PROP_RECORDSIZE: 1211 { 1212 int maxbs = SPA_MAXBLOCKSIZE; 1213 char buf[64]; 1214 1215 if (zpool_hdl != NULL) { 1216 maxbs = zpool_get_prop_int(zpool_hdl, 1217 ZPOOL_PROP_MAXBLOCKSIZE, NULL); 1218 } 1219 /* 1220 * The value must be a power of two between 1221 * SPA_MINBLOCKSIZE and maxbs. 1222 */ 1223 if (intval < SPA_MINBLOCKSIZE || 1224 intval > maxbs || !ISP2(intval)) { 1225 zfs_nicebytes(maxbs, buf, sizeof (buf)); 1226 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1227 "'%s' must be power of 2 from 512B " 1228 "to %s"), propname, buf); 1229 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1230 goto error; 1231 } 1232 break; 1233 } 1234 1235 case ZFS_PROP_SPECIAL_SMALL_BLOCKS: 1236 { 1237 int maxbs = SPA_OLD_MAXBLOCKSIZE; 1238 char buf[64]; 1239 1240 if (zpool_hdl != NULL) { 1241 char state[64] = ""; 1242 1243 maxbs = zpool_get_prop_int(zpool_hdl, 1244 ZPOOL_PROP_MAXBLOCKSIZE, NULL); 1245 1246 /* 1247 * Issue a warning but do not fail so that 1248 * tests for settable properties succeed. 1249 */ 1250 if (zpool_prop_get_feature(zpool_hdl, 1251 "feature@allocation_classes", state, 1252 sizeof (state)) != 0 || 1253 strcmp(state, ZFS_FEATURE_ACTIVE) != 0) { 1254 (void) fprintf(stderr, gettext( 1255 "%s: property requires a special " 1256 "device in the pool\n"), propname); 1257 } 1258 } 1259 if (intval != 0 && 1260 (intval < SPA_MINBLOCKSIZE || 1261 intval > maxbs || !ISP2(intval))) { 1262 zfs_nicebytes(maxbs, buf, sizeof (buf)); 1263 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1264 "invalid '%s=%llu' property: must be zero " 1265 "or a power of 2 from 512B to %s"), 1266 propname, (unsigned long long)intval, buf); 1267 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1268 goto error; 1269 } 1270 break; 1271 } 1272 1273 case ZFS_PROP_MLSLABEL: 1274 { 1275 #ifdef HAVE_MLSLABEL 1276 /* 1277 * Verify the mlslabel string and convert to 1278 * internal hex label string. 1279 */ 1280 1281 m_label_t *new_sl; 1282 char *hex = NULL; /* internal label string */ 1283 1284 /* Default value is already OK. */ 1285 if (strcasecmp(strval, ZFS_MLSLABEL_DEFAULT) == 0) 1286 break; 1287 1288 /* Verify the label can be converted to binary form */ 1289 if (((new_sl = m_label_alloc(MAC_LABEL)) == NULL) || 1290 (str_to_label(strval, &new_sl, MAC_LABEL, 1291 L_NO_CORRECTION, NULL) == -1)) { 1292 goto badlabel; 1293 } 1294 1295 /* Now translate to hex internal label string */ 1296 if (label_to_str(new_sl, &hex, M_INTERNAL, 1297 DEF_NAMES) != 0) { 1298 if (hex) 1299 free(hex); 1300 goto badlabel; 1301 } 1302 m_label_free(new_sl); 1303 1304 /* If string is already in internal form, we're done. */ 1305 if (strcmp(strval, hex) == 0) { 1306 free(hex); 1307 break; 1308 } 1309 1310 /* Replace the label string with the internal form. */ 1311 (void) nvlist_remove(ret, zfs_prop_to_name(prop), 1312 DATA_TYPE_STRING); 1313 verify(nvlist_add_string(ret, zfs_prop_to_name(prop), 1314 hex) == 0); 1315 free(hex); 1316 1317 break; 1318 1319 badlabel: 1320 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1321 "invalid mlslabel '%s'"), strval); 1322 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1323 m_label_free(new_sl); /* OK if null */ 1324 goto error; 1325 #else 1326 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1327 "mlslabels are unsupported")); 1328 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1329 goto error; 1330 #endif /* HAVE_MLSLABEL */ 1331 } 1332 1333 case ZFS_PROP_MOUNTPOINT: 1334 { 1335 namecheck_err_t why; 1336 1337 if (strcmp(strval, ZFS_MOUNTPOINT_NONE) == 0 || 1338 strcmp(strval, ZFS_MOUNTPOINT_LEGACY) == 0) 1339 break; 1340 1341 if (mountpoint_namecheck(strval, &why)) { 1342 switch (why) { 1343 case NAME_ERR_LEADING_SLASH: 1344 zfs_error_aux(hdl, 1345 dgettext(TEXT_DOMAIN, 1346 "'%s' must be an absolute path, " 1347 "'none', or 'legacy'"), propname); 1348 break; 1349 case NAME_ERR_TOOLONG: 1350 zfs_error_aux(hdl, 1351 dgettext(TEXT_DOMAIN, 1352 "component of '%s' is too long"), 1353 propname); 1354 break; 1355 1356 default: 1357 zfs_error_aux(hdl, 1358 dgettext(TEXT_DOMAIN, 1359 "(%d) not defined"), 1360 why); 1361 break; 1362 } 1363 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1364 goto error; 1365 } 1366 fallthrough; 1367 } 1368 1369 case ZFS_PROP_SHARESMB: 1370 case ZFS_PROP_SHARENFS: 1371 /* 1372 * For the mountpoint and sharenfs or sharesmb 1373 * properties, check if it can be set in a 1374 * global/non-global zone based on 1375 * the zoned property value: 1376 * 1377 * global zone non-global zone 1378 * -------------------------------------------------- 1379 * zoned=on mountpoint (no) mountpoint (yes) 1380 * sharenfs (no) sharenfs (no) 1381 * sharesmb (no) sharesmb (no) 1382 * 1383 * zoned=off mountpoint (yes) N/A 1384 * sharenfs (yes) 1385 * sharesmb (yes) 1386 */ 1387 if (zoned) { 1388 if (getzoneid() == GLOBAL_ZONEID) { 1389 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1390 "'%s' cannot be set on " 1391 "dataset in a non-global zone"), 1392 propname); 1393 (void) zfs_error(hdl, EZFS_ZONED, 1394 errbuf); 1395 goto error; 1396 } else if (prop == ZFS_PROP_SHARENFS || 1397 prop == ZFS_PROP_SHARESMB) { 1398 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1399 "'%s' cannot be set in " 1400 "a non-global zone"), propname); 1401 (void) zfs_error(hdl, EZFS_ZONED, 1402 errbuf); 1403 goto error; 1404 } 1405 } else if (getzoneid() != GLOBAL_ZONEID) { 1406 /* 1407 * If zoned property is 'off', this must be in 1408 * a global zone. If not, something is wrong. 1409 */ 1410 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1411 "'%s' cannot be set while dataset " 1412 "'zoned' property is set"), propname); 1413 (void) zfs_error(hdl, EZFS_ZONED, errbuf); 1414 goto error; 1415 } 1416 1417 /* 1418 * At this point, it is legitimate to set the 1419 * property. Now we want to make sure that the 1420 * property value is valid if it is sharenfs. 1421 */ 1422 if ((prop == ZFS_PROP_SHARENFS || 1423 prop == ZFS_PROP_SHARESMB) && 1424 strcmp(strval, "on") != 0 && 1425 strcmp(strval, "off") != 0) { 1426 zfs_share_proto_t proto; 1427 1428 if (prop == ZFS_PROP_SHARESMB) 1429 proto = PROTO_SMB; 1430 else 1431 proto = PROTO_NFS; 1432 1433 if (zfs_parse_options(strval, proto) != SA_OK) { 1434 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1435 "'%s' cannot be set to invalid " 1436 "options"), propname); 1437 (void) zfs_error(hdl, EZFS_BADPROP, 1438 errbuf); 1439 goto error; 1440 } 1441 } 1442 1443 break; 1444 1445 case ZFS_PROP_KEYLOCATION: 1446 if (!zfs_prop_valid_keylocation(strval, B_FALSE)) { 1447 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1448 "invalid keylocation")); 1449 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1450 goto error; 1451 } 1452 1453 if (zhp != NULL) { 1454 uint64_t crypt = 1455 zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION); 1456 1457 if (crypt == ZIO_CRYPT_OFF && 1458 strcmp(strval, "none") != 0) { 1459 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1460 "keylocation must be 'none' " 1461 "for unencrypted datasets")); 1462 (void) zfs_error(hdl, EZFS_BADPROP, 1463 errbuf); 1464 goto error; 1465 } else if (crypt != ZIO_CRYPT_OFF && 1466 strcmp(strval, "none") == 0) { 1467 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1468 "keylocation must not be 'none' " 1469 "for encrypted datasets")); 1470 (void) zfs_error(hdl, EZFS_BADPROP, 1471 errbuf); 1472 goto error; 1473 } 1474 } 1475 break; 1476 1477 case ZFS_PROP_PBKDF2_ITERS: 1478 if (intval < MIN_PBKDF2_ITERATIONS) { 1479 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1480 "minimum pbkdf2 iterations is %u"), 1481 MIN_PBKDF2_ITERATIONS); 1482 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1483 goto error; 1484 } 1485 break; 1486 1487 case ZFS_PROP_UTF8ONLY: 1488 chosen_utf = (int)intval; 1489 break; 1490 1491 case ZFS_PROP_NORMALIZE: 1492 chosen_normal = (int)intval; 1493 break; 1494 1495 default: 1496 break; 1497 } 1498 1499 /* 1500 * For changes to existing volumes, we have some additional 1501 * checks to enforce. 1502 */ 1503 if (type == ZFS_TYPE_VOLUME && zhp != NULL) { 1504 uint64_t blocksize = zfs_prop_get_int(zhp, 1505 ZFS_PROP_VOLBLOCKSIZE); 1506 char buf[64]; 1507 1508 switch (prop) { 1509 case ZFS_PROP_VOLSIZE: 1510 if (intval % blocksize != 0) { 1511 zfs_nicebytes(blocksize, buf, 1512 sizeof (buf)); 1513 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1514 "'%s' must be a multiple of " 1515 "volume block size (%s)"), 1516 propname, buf); 1517 (void) zfs_error(hdl, EZFS_BADPROP, 1518 errbuf); 1519 goto error; 1520 } 1521 1522 if (intval == 0) { 1523 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1524 "'%s' cannot be zero"), 1525 propname); 1526 (void) zfs_error(hdl, EZFS_BADPROP, 1527 errbuf); 1528 goto error; 1529 } 1530 break; 1531 1532 default: 1533 break; 1534 } 1535 } 1536 1537 /* check encryption properties */ 1538 if (zhp != NULL) { 1539 int64_t crypt = zfs_prop_get_int(zhp, 1540 ZFS_PROP_ENCRYPTION); 1541 1542 switch (prop) { 1543 case ZFS_PROP_COPIES: 1544 if (crypt != ZIO_CRYPT_OFF && intval > 2) { 1545 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1546 "encrypted datasets cannot have " 1547 "3 copies")); 1548 (void) zfs_error(hdl, EZFS_BADPROP, 1549 errbuf); 1550 goto error; 1551 } 1552 break; 1553 default: 1554 break; 1555 } 1556 } 1557 } 1558 1559 /* 1560 * If normalization was chosen, but no UTF8 choice was made, 1561 * enforce rejection of non-UTF8 names. 1562 * 1563 * If normalization was chosen, but rejecting non-UTF8 names 1564 * was explicitly not chosen, it is an error. 1565 */ 1566 if (chosen_normal > 0 && chosen_utf < 0) { 1567 if (nvlist_add_uint64(ret, 1568 zfs_prop_to_name(ZFS_PROP_UTF8ONLY), 1) != 0) { 1569 (void) no_memory(hdl); 1570 goto error; 1571 } 1572 } else if (chosen_normal > 0 && chosen_utf == 0) { 1573 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1574 "'%s' must be set 'on' if normalization chosen"), 1575 zfs_prop_to_name(ZFS_PROP_UTF8ONLY)); 1576 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1577 goto error; 1578 } 1579 return (ret); 1580 1581 error: 1582 nvlist_free(ret); 1583 return (NULL); 1584 } 1585 1586 static int 1587 zfs_add_synthetic_resv(zfs_handle_t *zhp, nvlist_t *nvl) 1588 { 1589 uint64_t old_volsize; 1590 uint64_t new_volsize; 1591 uint64_t old_reservation; 1592 uint64_t new_reservation; 1593 zfs_prop_t resv_prop; 1594 nvlist_t *props; 1595 zpool_handle_t *zph = zpool_handle(zhp); 1596 1597 /* 1598 * If this is an existing volume, and someone is setting the volsize, 1599 * make sure that it matches the reservation, or add it if necessary. 1600 */ 1601 old_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE); 1602 if (zfs_which_resv_prop(zhp, &resv_prop) < 0) 1603 return (-1); 1604 old_reservation = zfs_prop_get_int(zhp, resv_prop); 1605 1606 props = fnvlist_alloc(); 1607 fnvlist_add_uint64(props, zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE), 1608 zfs_prop_get_int(zhp, ZFS_PROP_VOLBLOCKSIZE)); 1609 1610 if ((zvol_volsize_to_reservation(zph, old_volsize, props) != 1611 old_reservation) || nvlist_exists(nvl, 1612 zfs_prop_to_name(resv_prop))) { 1613 fnvlist_free(props); 1614 return (0); 1615 } 1616 if (nvlist_lookup_uint64(nvl, zfs_prop_to_name(ZFS_PROP_VOLSIZE), 1617 &new_volsize) != 0) { 1618 fnvlist_free(props); 1619 return (-1); 1620 } 1621 new_reservation = zvol_volsize_to_reservation(zph, new_volsize, props); 1622 fnvlist_free(props); 1623 1624 if (nvlist_add_uint64(nvl, zfs_prop_to_name(resv_prop), 1625 new_reservation) != 0) { 1626 (void) no_memory(zhp->zfs_hdl); 1627 return (-1); 1628 } 1629 return (1); 1630 } 1631 1632 /* 1633 * Helper for 'zfs {set|clone} refreservation=auto'. Must be called after 1634 * zfs_valid_proplist(), as it is what sets the UINT64_MAX sentinel value. 1635 * Return codes must match zfs_add_synthetic_resv(). 1636 */ 1637 static int 1638 zfs_fix_auto_resv(zfs_handle_t *zhp, nvlist_t *nvl) 1639 { 1640 uint64_t volsize; 1641 uint64_t resvsize; 1642 zfs_prop_t prop; 1643 nvlist_t *props; 1644 1645 if (!ZFS_IS_VOLUME(zhp)) { 1646 return (0); 1647 } 1648 1649 if (zfs_which_resv_prop(zhp, &prop) != 0) { 1650 return (-1); 1651 } 1652 1653 if (prop != ZFS_PROP_REFRESERVATION) { 1654 return (0); 1655 } 1656 1657 if (nvlist_lookup_uint64(nvl, zfs_prop_to_name(prop), &resvsize) != 0) { 1658 /* No value being set, so it can't be "auto" */ 1659 return (0); 1660 } 1661 if (resvsize != UINT64_MAX) { 1662 /* Being set to a value other than "auto" */ 1663 return (0); 1664 } 1665 1666 props = fnvlist_alloc(); 1667 1668 fnvlist_add_uint64(props, zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE), 1669 zfs_prop_get_int(zhp, ZFS_PROP_VOLBLOCKSIZE)); 1670 1671 if (nvlist_lookup_uint64(nvl, zfs_prop_to_name(ZFS_PROP_VOLSIZE), 1672 &volsize) != 0) { 1673 volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE); 1674 } 1675 1676 resvsize = zvol_volsize_to_reservation(zpool_handle(zhp), volsize, 1677 props); 1678 fnvlist_free(props); 1679 1680 (void) nvlist_remove_all(nvl, zfs_prop_to_name(prop)); 1681 if (nvlist_add_uint64(nvl, zfs_prop_to_name(prop), resvsize) != 0) { 1682 (void) no_memory(zhp->zfs_hdl); 1683 return (-1); 1684 } 1685 return (1); 1686 } 1687 1688 static boolean_t 1689 zfs_is_namespace_prop(zfs_prop_t prop) 1690 { 1691 switch (prop) { 1692 1693 case ZFS_PROP_ATIME: 1694 case ZFS_PROP_RELATIME: 1695 case ZFS_PROP_DEVICES: 1696 case ZFS_PROP_EXEC: 1697 case ZFS_PROP_SETUID: 1698 case ZFS_PROP_READONLY: 1699 case ZFS_PROP_XATTR: 1700 case ZFS_PROP_NBMAND: 1701 return (B_TRUE); 1702 1703 default: 1704 return (B_FALSE); 1705 } 1706 } 1707 1708 /* 1709 * Given a property name and value, set the property for the given dataset. 1710 */ 1711 int 1712 zfs_prop_set(zfs_handle_t *zhp, const char *propname, const char *propval) 1713 { 1714 int ret = -1; 1715 char errbuf[1024]; 1716 libzfs_handle_t *hdl = zhp->zfs_hdl; 1717 nvlist_t *nvl = NULL; 1718 1719 (void) snprintf(errbuf, sizeof (errbuf), 1720 dgettext(TEXT_DOMAIN, "cannot set property for '%s'"), 1721 zhp->zfs_name); 1722 1723 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0 || 1724 nvlist_add_string(nvl, propname, propval) != 0) { 1725 (void) no_memory(hdl); 1726 goto error; 1727 } 1728 1729 ret = zfs_prop_set_list(zhp, nvl); 1730 1731 error: 1732 nvlist_free(nvl); 1733 return (ret); 1734 } 1735 1736 1737 1738 /* 1739 * Given an nvlist of property names and values, set the properties for the 1740 * given dataset. 1741 */ 1742 int 1743 zfs_prop_set_list(zfs_handle_t *zhp, nvlist_t *props) 1744 { 1745 zfs_cmd_t zc = {"\0"}; 1746 int ret = -1; 1747 prop_changelist_t **cls = NULL; 1748 int cl_idx; 1749 char errbuf[1024]; 1750 libzfs_handle_t *hdl = zhp->zfs_hdl; 1751 nvlist_t *nvl; 1752 int nvl_len = 0; 1753 int added_resv = 0; 1754 zfs_prop_t prop = 0; 1755 nvpair_t *elem; 1756 1757 (void) snprintf(errbuf, sizeof (errbuf), 1758 dgettext(TEXT_DOMAIN, "cannot set property for '%s'"), 1759 zhp->zfs_name); 1760 1761 if ((nvl = zfs_valid_proplist(hdl, zhp->zfs_type, props, 1762 zfs_prop_get_int(zhp, ZFS_PROP_ZONED), zhp, zhp->zpool_hdl, 1763 B_FALSE, errbuf)) == NULL) 1764 goto error; 1765 1766 /* 1767 * We have to check for any extra properties which need to be added 1768 * before computing the length of the nvlist. 1769 */ 1770 for (elem = nvlist_next_nvpair(nvl, NULL); 1771 elem != NULL; 1772 elem = nvlist_next_nvpair(nvl, elem)) { 1773 if (zfs_name_to_prop(nvpair_name(elem)) == ZFS_PROP_VOLSIZE && 1774 (added_resv = zfs_add_synthetic_resv(zhp, nvl)) == -1) { 1775 goto error; 1776 } 1777 } 1778 1779 if (added_resv != 1 && 1780 (added_resv = zfs_fix_auto_resv(zhp, nvl)) == -1) { 1781 goto error; 1782 } 1783 1784 /* 1785 * Check how many properties we're setting and allocate an array to 1786 * store changelist pointers for postfix(). 1787 */ 1788 for (elem = nvlist_next_nvpair(nvl, NULL); 1789 elem != NULL; 1790 elem = nvlist_next_nvpair(nvl, elem)) 1791 nvl_len++; 1792 if ((cls = calloc(nvl_len, sizeof (prop_changelist_t *))) == NULL) 1793 goto error; 1794 1795 cl_idx = 0; 1796 for (elem = nvlist_next_nvpair(nvl, NULL); 1797 elem != NULL; 1798 elem = nvlist_next_nvpair(nvl, elem)) { 1799 1800 prop = zfs_name_to_prop(nvpair_name(elem)); 1801 1802 assert(cl_idx < nvl_len); 1803 /* 1804 * We don't want to unmount & remount the dataset when changing 1805 * its canmount property to 'on' or 'noauto'. We only use 1806 * the changelist logic to unmount when setting canmount=off. 1807 */ 1808 if (prop != ZFS_PROP_CANMOUNT || 1809 (fnvpair_value_uint64(elem) == ZFS_CANMOUNT_OFF && 1810 zfs_is_mounted(zhp, NULL))) { 1811 cls[cl_idx] = changelist_gather(zhp, prop, 0, 0); 1812 if (cls[cl_idx] == NULL) 1813 goto error; 1814 } 1815 1816 if (prop == ZFS_PROP_MOUNTPOINT && 1817 changelist_haszonedchild(cls[cl_idx])) { 1818 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1819 "child dataset with inherited mountpoint is used " 1820 "in a non-global zone")); 1821 ret = zfs_error(hdl, EZFS_ZONED, errbuf); 1822 goto error; 1823 } 1824 1825 if (cls[cl_idx] != NULL && 1826 (ret = changelist_prefix(cls[cl_idx])) != 0) 1827 goto error; 1828 1829 cl_idx++; 1830 } 1831 assert(cl_idx == nvl_len); 1832 1833 /* 1834 * Execute the corresponding ioctl() to set this list of properties. 1835 */ 1836 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 1837 1838 if ((ret = zcmd_write_src_nvlist(hdl, &zc, nvl)) != 0 || 1839 (ret = zcmd_alloc_dst_nvlist(hdl, &zc, 0)) != 0) 1840 goto error; 1841 1842 ret = zfs_ioctl(hdl, ZFS_IOC_SET_PROP, &zc); 1843 1844 if (ret != 0) { 1845 if (zc.zc_nvlist_dst_filled == B_FALSE) { 1846 (void) zfs_standard_error(hdl, errno, errbuf); 1847 goto error; 1848 } 1849 1850 /* Get the list of unset properties back and report them. */ 1851 nvlist_t *errorprops = NULL; 1852 if (zcmd_read_dst_nvlist(hdl, &zc, &errorprops) != 0) 1853 goto error; 1854 for (nvpair_t *elem = nvlist_next_nvpair(errorprops, NULL); 1855 elem != NULL; 1856 elem = nvlist_next_nvpair(errorprops, elem)) { 1857 prop = zfs_name_to_prop(nvpair_name(elem)); 1858 zfs_setprop_error(hdl, prop, errno, errbuf); 1859 } 1860 nvlist_free(errorprops); 1861 1862 if (added_resv && errno == ENOSPC) { 1863 /* clean up the volsize property we tried to set */ 1864 uint64_t old_volsize = zfs_prop_get_int(zhp, 1865 ZFS_PROP_VOLSIZE); 1866 nvlist_free(nvl); 1867 nvl = NULL; 1868 zcmd_free_nvlists(&zc); 1869 1870 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) 1871 goto error; 1872 if (nvlist_add_uint64(nvl, 1873 zfs_prop_to_name(ZFS_PROP_VOLSIZE), 1874 old_volsize) != 0) 1875 goto error; 1876 if (zcmd_write_src_nvlist(hdl, &zc, nvl) != 0) 1877 goto error; 1878 (void) zfs_ioctl(hdl, ZFS_IOC_SET_PROP, &zc); 1879 } 1880 } else { 1881 for (cl_idx = 0; cl_idx < nvl_len; cl_idx++) { 1882 if (cls[cl_idx] != NULL) { 1883 int clp_err = changelist_postfix(cls[cl_idx]); 1884 if (clp_err != 0) 1885 ret = clp_err; 1886 } 1887 } 1888 1889 if (ret == 0) { 1890 /* 1891 * Refresh the statistics so the new property 1892 * value is reflected. 1893 */ 1894 (void) get_stats(zhp); 1895 1896 /* 1897 * Remount the filesystem to propagate the change 1898 * if one of the options handled by the generic 1899 * Linux namespace layer has been modified. 1900 */ 1901 if (zfs_is_namespace_prop(prop) && 1902 zfs_is_mounted(zhp, NULL)) 1903 ret = zfs_mount(zhp, MNTOPT_REMOUNT, 0); 1904 } 1905 } 1906 1907 error: 1908 nvlist_free(nvl); 1909 zcmd_free_nvlists(&zc); 1910 if (cls != NULL) { 1911 for (cl_idx = 0; cl_idx < nvl_len; cl_idx++) { 1912 if (cls[cl_idx] != NULL) 1913 changelist_free(cls[cl_idx]); 1914 } 1915 free(cls); 1916 } 1917 return (ret); 1918 } 1919 1920 /* 1921 * Given a property, inherit the value from the parent dataset, or if received 1922 * is TRUE, revert to the received value, if any. 1923 */ 1924 int 1925 zfs_prop_inherit(zfs_handle_t *zhp, const char *propname, boolean_t received) 1926 { 1927 zfs_cmd_t zc = {"\0"}; 1928 int ret; 1929 prop_changelist_t *cl; 1930 libzfs_handle_t *hdl = zhp->zfs_hdl; 1931 char errbuf[1024]; 1932 zfs_prop_t prop; 1933 1934 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 1935 "cannot inherit %s for '%s'"), propname, zhp->zfs_name); 1936 1937 zc.zc_cookie = received; 1938 if ((prop = zfs_name_to_prop(propname)) == ZPROP_INVAL) { 1939 /* 1940 * For user properties, the amount of work we have to do is very 1941 * small, so just do it here. 1942 */ 1943 if (!zfs_prop_user(propname)) { 1944 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1945 "invalid property")); 1946 return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 1947 } 1948 1949 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 1950 (void) strlcpy(zc.zc_value, propname, sizeof (zc.zc_value)); 1951 1952 if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_INHERIT_PROP, &zc) != 0) 1953 return (zfs_standard_error(hdl, errno, errbuf)); 1954 1955 (void) get_stats(zhp); 1956 return (0); 1957 } 1958 1959 /* 1960 * Verify that this property is inheritable. 1961 */ 1962 if (zfs_prop_readonly(prop)) 1963 return (zfs_error(hdl, EZFS_PROPREADONLY, errbuf)); 1964 1965 if (!zfs_prop_inheritable(prop) && !received) 1966 return (zfs_error(hdl, EZFS_PROPNONINHERIT, errbuf)); 1967 1968 /* 1969 * Check to see if the value applies to this type 1970 */ 1971 if (!zfs_prop_valid_for_type(prop, zhp->zfs_type, B_FALSE)) 1972 return (zfs_error(hdl, EZFS_PROPTYPE, errbuf)); 1973 1974 /* 1975 * Normalize the name, to get rid of shorthand abbreviations. 1976 */ 1977 propname = zfs_prop_to_name(prop); 1978 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 1979 (void) strlcpy(zc.zc_value, propname, sizeof (zc.zc_value)); 1980 1981 if (prop == ZFS_PROP_MOUNTPOINT && getzoneid() == GLOBAL_ZONEID && 1982 zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) { 1983 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1984 "dataset is used in a non-global zone")); 1985 return (zfs_error(hdl, EZFS_ZONED, errbuf)); 1986 } 1987 1988 /* 1989 * Determine datasets which will be affected by this change, if any. 1990 */ 1991 if ((cl = changelist_gather(zhp, prop, 0, 0)) == NULL) 1992 return (-1); 1993 1994 if (prop == ZFS_PROP_MOUNTPOINT && changelist_haszonedchild(cl)) { 1995 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1996 "child dataset with inherited mountpoint is used " 1997 "in a non-global zone")); 1998 ret = zfs_error(hdl, EZFS_ZONED, errbuf); 1999 goto error; 2000 } 2001 2002 if ((ret = changelist_prefix(cl)) != 0) 2003 goto error; 2004 2005 if ((ret = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_INHERIT_PROP, &zc)) != 0) { 2006 return (zfs_standard_error(hdl, errno, errbuf)); 2007 } else { 2008 2009 if ((ret = changelist_postfix(cl)) != 0) 2010 goto error; 2011 2012 /* 2013 * Refresh the statistics so the new property is reflected. 2014 */ 2015 (void) get_stats(zhp); 2016 2017 /* 2018 * Remount the filesystem to propagate the change 2019 * if one of the options handled by the generic 2020 * Linux namespace layer has been modified. 2021 */ 2022 if (zfs_is_namespace_prop(prop) && 2023 zfs_is_mounted(zhp, NULL)) 2024 ret = zfs_mount(zhp, MNTOPT_REMOUNT, 0); 2025 } 2026 2027 error: 2028 changelist_free(cl); 2029 return (ret); 2030 } 2031 2032 /* 2033 * True DSL properties are stored in an nvlist. The following two functions 2034 * extract them appropriately. 2035 */ 2036 uint64_t 2037 getprop_uint64(zfs_handle_t *zhp, zfs_prop_t prop, char **source) 2038 { 2039 nvlist_t *nv; 2040 uint64_t value; 2041 2042 *source = NULL; 2043 if (nvlist_lookup_nvlist(zhp->zfs_props, 2044 zfs_prop_to_name(prop), &nv) == 0) { 2045 verify(nvlist_lookup_uint64(nv, ZPROP_VALUE, &value) == 0); 2046 (void) nvlist_lookup_string(nv, ZPROP_SOURCE, source); 2047 } else { 2048 verify(!zhp->zfs_props_table || 2049 zhp->zfs_props_table[prop] == B_TRUE); 2050 value = zfs_prop_default_numeric(prop); 2051 *source = ""; 2052 } 2053 2054 return (value); 2055 } 2056 2057 static const char * 2058 getprop_string(zfs_handle_t *zhp, zfs_prop_t prop, char **source) 2059 { 2060 nvlist_t *nv; 2061 const char *value; 2062 2063 *source = NULL; 2064 if (nvlist_lookup_nvlist(zhp->zfs_props, 2065 zfs_prop_to_name(prop), &nv) == 0) { 2066 value = fnvlist_lookup_string(nv, ZPROP_VALUE); 2067 (void) nvlist_lookup_string(nv, ZPROP_SOURCE, source); 2068 } else { 2069 verify(!zhp->zfs_props_table || 2070 zhp->zfs_props_table[prop] == B_TRUE); 2071 value = zfs_prop_default_string(prop); 2072 *source = ""; 2073 } 2074 2075 return (value); 2076 } 2077 2078 static boolean_t 2079 zfs_is_recvd_props_mode(zfs_handle_t *zhp) 2080 { 2081 return (zhp->zfs_props == zhp->zfs_recvd_props); 2082 } 2083 2084 static void 2085 zfs_set_recvd_props_mode(zfs_handle_t *zhp, uint64_t *cookie) 2086 { 2087 *cookie = (uint64_t)(uintptr_t)zhp->zfs_props; 2088 zhp->zfs_props = zhp->zfs_recvd_props; 2089 } 2090 2091 static void 2092 zfs_unset_recvd_props_mode(zfs_handle_t *zhp, uint64_t *cookie) 2093 { 2094 zhp->zfs_props = (nvlist_t *)(uintptr_t)*cookie; 2095 *cookie = 0; 2096 } 2097 2098 /* 2099 * Internal function for getting a numeric property. Both zfs_prop_get() and 2100 * zfs_prop_get_int() are built using this interface. 2101 * 2102 * Certain properties can be overridden using 'mount -o'. In this case, scan 2103 * the contents of the /proc/self/mounts entry, searching for the 2104 * appropriate options. If they differ from the on-disk values, report the 2105 * current values and mark the source "temporary". 2106 */ 2107 static int 2108 get_numeric_property(zfs_handle_t *zhp, zfs_prop_t prop, zprop_source_t *src, 2109 char **source, uint64_t *val) 2110 { 2111 zfs_cmd_t zc = {"\0"}; 2112 nvlist_t *zplprops = NULL; 2113 struct mnttab mnt; 2114 char *mntopt_on = NULL; 2115 char *mntopt_off = NULL; 2116 boolean_t received = zfs_is_recvd_props_mode(zhp); 2117 2118 *source = NULL; 2119 2120 /* 2121 * If the property is being fetched for a snapshot, check whether 2122 * the property is valid for the snapshot's head dataset type. 2123 */ 2124 if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT && 2125 !zfs_prop_valid_for_type(prop, zhp->zfs_head_type, B_TRUE)) { 2126 *val = zfs_prop_default_numeric(prop); 2127 return (-1); 2128 } 2129 2130 switch (prop) { 2131 case ZFS_PROP_ATIME: 2132 mntopt_on = MNTOPT_ATIME; 2133 mntopt_off = MNTOPT_NOATIME; 2134 break; 2135 2136 case ZFS_PROP_RELATIME: 2137 mntopt_on = MNTOPT_RELATIME; 2138 mntopt_off = MNTOPT_NORELATIME; 2139 break; 2140 2141 case ZFS_PROP_DEVICES: 2142 mntopt_on = MNTOPT_DEVICES; 2143 mntopt_off = MNTOPT_NODEVICES; 2144 break; 2145 2146 case ZFS_PROP_EXEC: 2147 mntopt_on = MNTOPT_EXEC; 2148 mntopt_off = MNTOPT_NOEXEC; 2149 break; 2150 2151 case ZFS_PROP_READONLY: 2152 mntopt_on = MNTOPT_RO; 2153 mntopt_off = MNTOPT_RW; 2154 break; 2155 2156 case ZFS_PROP_SETUID: 2157 mntopt_on = MNTOPT_SETUID; 2158 mntopt_off = MNTOPT_NOSETUID; 2159 break; 2160 2161 case ZFS_PROP_XATTR: 2162 mntopt_on = MNTOPT_XATTR; 2163 mntopt_off = MNTOPT_NOXATTR; 2164 break; 2165 2166 case ZFS_PROP_NBMAND: 2167 mntopt_on = MNTOPT_NBMAND; 2168 mntopt_off = MNTOPT_NONBMAND; 2169 break; 2170 2171 default: 2172 break; 2173 } 2174 2175 /* 2176 * Because looking up the mount options is potentially expensive 2177 * (iterating over all of /proc/self/mounts), we defer its 2178 * calculation until we're looking up a property which requires 2179 * its presence. 2180 */ 2181 if (!zhp->zfs_mntcheck && 2182 (mntopt_on != NULL || prop == ZFS_PROP_MOUNTED)) { 2183 libzfs_handle_t *hdl = zhp->zfs_hdl; 2184 struct mnttab entry; 2185 2186 if (libzfs_mnttab_find(hdl, zhp->zfs_name, &entry) == 0) { 2187 zhp->zfs_mntopts = zfs_strdup(hdl, 2188 entry.mnt_mntopts); 2189 if (zhp->zfs_mntopts == NULL) 2190 return (-1); 2191 } 2192 2193 zhp->zfs_mntcheck = B_TRUE; 2194 } 2195 2196 if (zhp->zfs_mntopts == NULL) 2197 mnt.mnt_mntopts = ""; 2198 else 2199 mnt.mnt_mntopts = zhp->zfs_mntopts; 2200 2201 switch (prop) { 2202 case ZFS_PROP_ATIME: 2203 case ZFS_PROP_RELATIME: 2204 case ZFS_PROP_DEVICES: 2205 case ZFS_PROP_EXEC: 2206 case ZFS_PROP_READONLY: 2207 case ZFS_PROP_SETUID: 2208 #ifndef __FreeBSD__ 2209 case ZFS_PROP_XATTR: 2210 #endif 2211 case ZFS_PROP_NBMAND: 2212 *val = getprop_uint64(zhp, prop, source); 2213 2214 if (received) 2215 break; 2216 2217 if (hasmntopt(&mnt, mntopt_on) && !*val) { 2218 *val = B_TRUE; 2219 if (src) 2220 *src = ZPROP_SRC_TEMPORARY; 2221 } else if (hasmntopt(&mnt, mntopt_off) && *val) { 2222 *val = B_FALSE; 2223 if (src) 2224 *src = ZPROP_SRC_TEMPORARY; 2225 } 2226 break; 2227 2228 case ZFS_PROP_CANMOUNT: 2229 case ZFS_PROP_VOLSIZE: 2230 case ZFS_PROP_QUOTA: 2231 case ZFS_PROP_REFQUOTA: 2232 case ZFS_PROP_RESERVATION: 2233 case ZFS_PROP_REFRESERVATION: 2234 case ZFS_PROP_FILESYSTEM_LIMIT: 2235 case ZFS_PROP_SNAPSHOT_LIMIT: 2236 case ZFS_PROP_FILESYSTEM_COUNT: 2237 case ZFS_PROP_SNAPSHOT_COUNT: 2238 *val = getprop_uint64(zhp, prop, source); 2239 2240 if (*source == NULL) { 2241 /* not default, must be local */ 2242 *source = zhp->zfs_name; 2243 } 2244 break; 2245 2246 case ZFS_PROP_MOUNTED: 2247 *val = (zhp->zfs_mntopts != NULL); 2248 break; 2249 2250 case ZFS_PROP_NUMCLONES: 2251 *val = zhp->zfs_dmustats.dds_num_clones; 2252 break; 2253 2254 case ZFS_PROP_VERSION: 2255 case ZFS_PROP_NORMALIZE: 2256 case ZFS_PROP_UTF8ONLY: 2257 case ZFS_PROP_CASE: 2258 if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0) 2259 return (-1); 2260 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 2261 if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_OBJSET_ZPLPROPS, &zc)) { 2262 zcmd_free_nvlists(&zc); 2263 if (prop == ZFS_PROP_VERSION && 2264 zhp->zfs_type == ZFS_TYPE_VOLUME) 2265 *val = zfs_prop_default_numeric(prop); 2266 return (-1); 2267 } 2268 if (zcmd_read_dst_nvlist(zhp->zfs_hdl, &zc, &zplprops) != 0 || 2269 nvlist_lookup_uint64(zplprops, zfs_prop_to_name(prop), 2270 val) != 0) { 2271 zcmd_free_nvlists(&zc); 2272 return (-1); 2273 } 2274 nvlist_free(zplprops); 2275 zcmd_free_nvlists(&zc); 2276 break; 2277 2278 case ZFS_PROP_INCONSISTENT: 2279 *val = zhp->zfs_dmustats.dds_inconsistent; 2280 break; 2281 2282 case ZFS_PROP_REDACTED: 2283 *val = zhp->zfs_dmustats.dds_redacted; 2284 break; 2285 2286 default: 2287 switch (zfs_prop_get_type(prop)) { 2288 case PROP_TYPE_NUMBER: 2289 case PROP_TYPE_INDEX: 2290 *val = getprop_uint64(zhp, prop, source); 2291 /* 2292 * If we tried to use a default value for a 2293 * readonly property, it means that it was not 2294 * present. Note this only applies to "truly" 2295 * readonly properties, not set-once properties 2296 * like volblocksize. 2297 */ 2298 if (zfs_prop_readonly(prop) && 2299 !zfs_prop_setonce(prop) && 2300 *source != NULL && (*source)[0] == '\0') { 2301 *source = NULL; 2302 return (-1); 2303 } 2304 break; 2305 2306 case PROP_TYPE_STRING: 2307 default: 2308 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 2309 "cannot get non-numeric property")); 2310 return (zfs_error(zhp->zfs_hdl, EZFS_BADPROP, 2311 dgettext(TEXT_DOMAIN, "internal error"))); 2312 } 2313 } 2314 2315 return (0); 2316 } 2317 2318 /* 2319 * Calculate the source type, given the raw source string. 2320 */ 2321 static void 2322 get_source(zfs_handle_t *zhp, zprop_source_t *srctype, char *source, 2323 char *statbuf, size_t statlen) 2324 { 2325 if (statbuf == NULL || 2326 srctype == NULL || *srctype == ZPROP_SRC_TEMPORARY) { 2327 return; 2328 } 2329 2330 if (source == NULL) { 2331 *srctype = ZPROP_SRC_NONE; 2332 } else if (source[0] == '\0') { 2333 *srctype = ZPROP_SRC_DEFAULT; 2334 } else if (strstr(source, ZPROP_SOURCE_VAL_RECVD) != NULL) { 2335 *srctype = ZPROP_SRC_RECEIVED; 2336 } else { 2337 if (strcmp(source, zhp->zfs_name) == 0) { 2338 *srctype = ZPROP_SRC_LOCAL; 2339 } else { 2340 (void) strlcpy(statbuf, source, statlen); 2341 *srctype = ZPROP_SRC_INHERITED; 2342 } 2343 } 2344 2345 } 2346 2347 int 2348 zfs_prop_get_recvd(zfs_handle_t *zhp, const char *propname, char *propbuf, 2349 size_t proplen, boolean_t literal) 2350 { 2351 zfs_prop_t prop; 2352 int err = 0; 2353 2354 if (zhp->zfs_recvd_props == NULL) 2355 if (get_recvd_props_ioctl(zhp) != 0) 2356 return (-1); 2357 2358 prop = zfs_name_to_prop(propname); 2359 2360 if (prop != ZPROP_INVAL) { 2361 uint64_t cookie; 2362 if (!nvlist_exists(zhp->zfs_recvd_props, propname)) 2363 return (-1); 2364 zfs_set_recvd_props_mode(zhp, &cookie); 2365 err = zfs_prop_get(zhp, prop, propbuf, proplen, 2366 NULL, NULL, 0, literal); 2367 zfs_unset_recvd_props_mode(zhp, &cookie); 2368 } else { 2369 nvlist_t *propval; 2370 char *recvdval; 2371 if (nvlist_lookup_nvlist(zhp->zfs_recvd_props, 2372 propname, &propval) != 0) 2373 return (-1); 2374 verify(nvlist_lookup_string(propval, ZPROP_VALUE, 2375 &recvdval) == 0); 2376 (void) strlcpy(propbuf, recvdval, proplen); 2377 } 2378 2379 return (err == 0 ? 0 : -1); 2380 } 2381 2382 static int 2383 get_clones_string(zfs_handle_t *zhp, char *propbuf, size_t proplen) 2384 { 2385 nvlist_t *value; 2386 nvpair_t *pair; 2387 2388 value = zfs_get_clones_nvl(zhp); 2389 if (value == NULL || nvlist_empty(value)) 2390 return (-1); 2391 2392 propbuf[0] = '\0'; 2393 for (pair = nvlist_next_nvpair(value, NULL); pair != NULL; 2394 pair = nvlist_next_nvpair(value, pair)) { 2395 if (propbuf[0] != '\0') 2396 (void) strlcat(propbuf, ",", proplen); 2397 (void) strlcat(propbuf, nvpair_name(pair), proplen); 2398 } 2399 2400 return (0); 2401 } 2402 2403 struct get_clones_arg { 2404 uint64_t numclones; 2405 nvlist_t *value; 2406 const char *origin; 2407 char buf[ZFS_MAX_DATASET_NAME_LEN]; 2408 }; 2409 2410 static int 2411 get_clones_cb(zfs_handle_t *zhp, void *arg) 2412 { 2413 struct get_clones_arg *gca = arg; 2414 2415 if (gca->numclones == 0) { 2416 zfs_close(zhp); 2417 return (0); 2418 } 2419 2420 if (zfs_prop_get(zhp, ZFS_PROP_ORIGIN, gca->buf, sizeof (gca->buf), 2421 NULL, NULL, 0, B_TRUE) != 0) 2422 goto out; 2423 if (strcmp(gca->buf, gca->origin) == 0) { 2424 fnvlist_add_boolean(gca->value, zfs_get_name(zhp)); 2425 gca->numclones--; 2426 } 2427 2428 out: 2429 (void) zfs_iter_children(zhp, get_clones_cb, gca); 2430 zfs_close(zhp); 2431 return (0); 2432 } 2433 2434 nvlist_t * 2435 zfs_get_clones_nvl(zfs_handle_t *zhp) 2436 { 2437 nvlist_t *nv, *value; 2438 2439 if (nvlist_lookup_nvlist(zhp->zfs_props, 2440 zfs_prop_to_name(ZFS_PROP_CLONES), &nv) != 0) { 2441 struct get_clones_arg gca; 2442 2443 /* 2444 * if this is a snapshot, then the kernel wasn't able 2445 * to get the clones. Do it by slowly iterating. 2446 */ 2447 if (zhp->zfs_type != ZFS_TYPE_SNAPSHOT) 2448 return (NULL); 2449 if (nvlist_alloc(&nv, NV_UNIQUE_NAME, 0) != 0) 2450 return (NULL); 2451 if (nvlist_alloc(&value, NV_UNIQUE_NAME, 0) != 0) { 2452 nvlist_free(nv); 2453 return (NULL); 2454 } 2455 2456 gca.numclones = zfs_prop_get_int(zhp, ZFS_PROP_NUMCLONES); 2457 gca.value = value; 2458 gca.origin = zhp->zfs_name; 2459 2460 if (gca.numclones != 0) { 2461 zfs_handle_t *root; 2462 char pool[ZFS_MAX_DATASET_NAME_LEN]; 2463 char *cp = pool; 2464 2465 /* get the pool name */ 2466 (void) strlcpy(pool, zhp->zfs_name, sizeof (pool)); 2467 (void) strsep(&cp, "/@"); 2468 root = zfs_open(zhp->zfs_hdl, pool, 2469 ZFS_TYPE_FILESYSTEM); 2470 if (root == NULL) { 2471 nvlist_free(nv); 2472 nvlist_free(value); 2473 return (NULL); 2474 } 2475 2476 (void) get_clones_cb(root, &gca); 2477 } 2478 2479 if (gca.numclones != 0 || 2480 nvlist_add_nvlist(nv, ZPROP_VALUE, value) != 0 || 2481 nvlist_add_nvlist(zhp->zfs_props, 2482 zfs_prop_to_name(ZFS_PROP_CLONES), nv) != 0) { 2483 nvlist_free(nv); 2484 nvlist_free(value); 2485 return (NULL); 2486 } 2487 nvlist_free(nv); 2488 nvlist_free(value); 2489 verify(0 == nvlist_lookup_nvlist(zhp->zfs_props, 2490 zfs_prop_to_name(ZFS_PROP_CLONES), &nv)); 2491 } 2492 2493 verify(nvlist_lookup_nvlist(nv, ZPROP_VALUE, &value) == 0); 2494 2495 return (value); 2496 } 2497 2498 static int 2499 get_rsnaps_string(zfs_handle_t *zhp, char *propbuf, size_t proplen) 2500 { 2501 nvlist_t *value; 2502 uint64_t *snaps; 2503 uint_t nsnaps; 2504 2505 if (nvlist_lookup_nvlist(zhp->zfs_props, 2506 zfs_prop_to_name(ZFS_PROP_REDACT_SNAPS), &value) != 0) 2507 return (-1); 2508 if (nvlist_lookup_uint64_array(value, ZPROP_VALUE, &snaps, 2509 &nsnaps) != 0) 2510 return (-1); 2511 if (nsnaps == 0) { 2512 /* There's no redaction snapshots; pass a special value back */ 2513 (void) snprintf(propbuf, proplen, "none"); 2514 return (0); 2515 } 2516 propbuf[0] = '\0'; 2517 for (int i = 0; i < nsnaps; i++) { 2518 char buf[128]; 2519 if (propbuf[0] != '\0') 2520 (void) strlcat(propbuf, ",", proplen); 2521 (void) snprintf(buf, sizeof (buf), "%llu", 2522 (u_longlong_t)snaps[i]); 2523 (void) strlcat(propbuf, buf, proplen); 2524 } 2525 2526 return (0); 2527 } 2528 2529 /* 2530 * Accepts a property and value and checks that the value 2531 * matches the one found by the channel program. If they are 2532 * not equal, print both of them. 2533 */ 2534 static void 2535 zcp_check(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t intval, 2536 const char *strval) 2537 { 2538 if (!zhp->zfs_hdl->libzfs_prop_debug) 2539 return; 2540 int error; 2541 char *poolname = zhp->zpool_hdl->zpool_name; 2542 const char *prop_name = zfs_prop_to_name(prop); 2543 const char *program = 2544 "args = ...\n" 2545 "ds = args['dataset']\n" 2546 "prop = args['property']\n" 2547 "value, setpoint = zfs.get_prop(ds, prop)\n" 2548 "return {value=value, setpoint=setpoint}\n"; 2549 nvlist_t *outnvl; 2550 nvlist_t *retnvl; 2551 nvlist_t *argnvl = fnvlist_alloc(); 2552 2553 fnvlist_add_string(argnvl, "dataset", zhp->zfs_name); 2554 fnvlist_add_string(argnvl, "property", zfs_prop_to_name(prop)); 2555 2556 error = lzc_channel_program_nosync(poolname, program, 2557 10 * 1000 * 1000, 10 * 1024 * 1024, argnvl, &outnvl); 2558 2559 if (error == 0) { 2560 retnvl = fnvlist_lookup_nvlist(outnvl, "return"); 2561 if (zfs_prop_get_type(prop) == PROP_TYPE_NUMBER) { 2562 int64_t ans; 2563 error = nvlist_lookup_int64(retnvl, "value", &ans); 2564 if (error != 0) { 2565 (void) fprintf(stderr, "%s: zcp check error: " 2566 "%u\n", prop_name, error); 2567 return; 2568 } 2569 if (ans != intval) { 2570 (void) fprintf(stderr, "%s: zfs found %llu, " 2571 "but zcp found %llu\n", prop_name, 2572 (u_longlong_t)intval, (u_longlong_t)ans); 2573 } 2574 } else { 2575 char *str_ans; 2576 error = nvlist_lookup_string(retnvl, "value", &str_ans); 2577 if (error != 0) { 2578 (void) fprintf(stderr, "%s: zcp check error: " 2579 "%u\n", prop_name, error); 2580 return; 2581 } 2582 if (strcmp(strval, str_ans) != 0) { 2583 (void) fprintf(stderr, 2584 "%s: zfs found '%s', but zcp found '%s'\n", 2585 prop_name, strval, str_ans); 2586 } 2587 } 2588 } else { 2589 (void) fprintf(stderr, "%s: zcp check failed, channel program " 2590 "error: %u\n", prop_name, error); 2591 } 2592 nvlist_free(argnvl); 2593 nvlist_free(outnvl); 2594 } 2595 2596 /* 2597 * Retrieve a property from the given object. If 'literal' is specified, then 2598 * numbers are left as exact values. Otherwise, numbers are converted to a 2599 * human-readable form. 2600 * 2601 * Returns 0 on success, or -1 on error. 2602 */ 2603 int 2604 zfs_prop_get(zfs_handle_t *zhp, zfs_prop_t prop, char *propbuf, size_t proplen, 2605 zprop_source_t *src, char *statbuf, size_t statlen, boolean_t literal) 2606 { 2607 char *source = NULL; 2608 uint64_t val; 2609 const char *str; 2610 const char *strval; 2611 boolean_t received = zfs_is_recvd_props_mode(zhp); 2612 2613 /* 2614 * Check to see if this property applies to our object 2615 */ 2616 if (!zfs_prop_valid_for_type(prop, zhp->zfs_type, B_FALSE)) 2617 return (-1); 2618 2619 if (received && zfs_prop_readonly(prop)) 2620 return (-1); 2621 2622 if (src) 2623 *src = ZPROP_SRC_NONE; 2624 2625 switch (prop) { 2626 case ZFS_PROP_CREATION: 2627 /* 2628 * 'creation' is a time_t stored in the statistics. We convert 2629 * this into a string unless 'literal' is specified. 2630 */ 2631 { 2632 val = getprop_uint64(zhp, prop, &source); 2633 time_t time = (time_t)val; 2634 struct tm t; 2635 2636 if (literal || 2637 localtime_r(&time, &t) == NULL || 2638 strftime(propbuf, proplen, "%a %b %e %k:%M %Y", 2639 &t) == 0) 2640 (void) snprintf(propbuf, proplen, "%llu", 2641 (u_longlong_t)val); 2642 } 2643 zcp_check(zhp, prop, val, NULL); 2644 break; 2645 2646 case ZFS_PROP_MOUNTPOINT: 2647 /* 2648 * Getting the precise mountpoint can be tricky. 2649 * 2650 * - for 'none' or 'legacy', return those values. 2651 * - for inherited mountpoints, we want to take everything 2652 * after our ancestor and append it to the inherited value. 2653 * 2654 * If the pool has an alternate root, we want to prepend that 2655 * root to any values we return. 2656 */ 2657 2658 str = getprop_string(zhp, prop, &source); 2659 2660 if (str[0] == '/') { 2661 char buf[MAXPATHLEN]; 2662 char *root = buf; 2663 const char *relpath; 2664 2665 /* 2666 * If we inherit the mountpoint, even from a dataset 2667 * with a received value, the source will be the path of 2668 * the dataset we inherit from. If source is 2669 * ZPROP_SOURCE_VAL_RECVD, the received value is not 2670 * inherited. 2671 */ 2672 if (strcmp(source, ZPROP_SOURCE_VAL_RECVD) == 0) { 2673 relpath = ""; 2674 } else { 2675 relpath = zhp->zfs_name + strlen(source); 2676 if (relpath[0] == '/') 2677 relpath++; 2678 } 2679 2680 if ((zpool_get_prop(zhp->zpool_hdl, 2681 ZPOOL_PROP_ALTROOT, buf, MAXPATHLEN, NULL, 2682 B_FALSE)) || (strcmp(root, "-") == 0)) 2683 root[0] = '\0'; 2684 /* 2685 * Special case an alternate root of '/'. This will 2686 * avoid having multiple leading slashes in the 2687 * mountpoint path. 2688 */ 2689 if (strcmp(root, "/") == 0) 2690 root++; 2691 2692 /* 2693 * If the mountpoint is '/' then skip over this 2694 * if we are obtaining either an alternate root or 2695 * an inherited mountpoint. 2696 */ 2697 if (str[1] == '\0' && (root[0] != '\0' || 2698 relpath[0] != '\0')) 2699 str++; 2700 2701 if (relpath[0] == '\0') 2702 (void) snprintf(propbuf, proplen, "%s%s", 2703 root, str); 2704 else 2705 (void) snprintf(propbuf, proplen, "%s%s%s%s", 2706 root, str, relpath[0] == '@' ? "" : "/", 2707 relpath); 2708 } else { 2709 /* 'legacy' or 'none' */ 2710 (void) strlcpy(propbuf, str, proplen); 2711 } 2712 zcp_check(zhp, prop, 0, propbuf); 2713 break; 2714 2715 case ZFS_PROP_ORIGIN: 2716 str = getprop_string(zhp, prop, &source); 2717 if (str == NULL) 2718 return (-1); 2719 (void) strlcpy(propbuf, str, proplen); 2720 zcp_check(zhp, prop, 0, str); 2721 break; 2722 2723 case ZFS_PROP_REDACT_SNAPS: 2724 if (get_rsnaps_string(zhp, propbuf, proplen) != 0) 2725 return (-1); 2726 break; 2727 2728 case ZFS_PROP_CLONES: 2729 if (get_clones_string(zhp, propbuf, proplen) != 0) 2730 return (-1); 2731 break; 2732 2733 case ZFS_PROP_QUOTA: 2734 case ZFS_PROP_REFQUOTA: 2735 case ZFS_PROP_RESERVATION: 2736 case ZFS_PROP_REFRESERVATION: 2737 2738 if (get_numeric_property(zhp, prop, src, &source, &val) != 0) 2739 return (-1); 2740 /* 2741 * If quota or reservation is 0, we translate this into 'none' 2742 * (unless literal is set), and indicate that it's the default 2743 * value. Otherwise, we print the number nicely and indicate 2744 * that its set locally. 2745 */ 2746 if (val == 0) { 2747 if (literal) 2748 (void) strlcpy(propbuf, "0", proplen); 2749 else 2750 (void) strlcpy(propbuf, "none", proplen); 2751 } else { 2752 if (literal) 2753 (void) snprintf(propbuf, proplen, "%llu", 2754 (u_longlong_t)val); 2755 else 2756 zfs_nicebytes(val, propbuf, proplen); 2757 } 2758 zcp_check(zhp, prop, val, NULL); 2759 break; 2760 2761 case ZFS_PROP_FILESYSTEM_LIMIT: 2762 case ZFS_PROP_SNAPSHOT_LIMIT: 2763 case ZFS_PROP_FILESYSTEM_COUNT: 2764 case ZFS_PROP_SNAPSHOT_COUNT: 2765 2766 if (get_numeric_property(zhp, prop, src, &source, &val) != 0) 2767 return (-1); 2768 2769 /* 2770 * If limit is UINT64_MAX, we translate this into 'none' (unless 2771 * literal is set), and indicate that it's the default value. 2772 * Otherwise, we print the number nicely and indicate that it's 2773 * set locally. 2774 */ 2775 if (literal) { 2776 (void) snprintf(propbuf, proplen, "%llu", 2777 (u_longlong_t)val); 2778 } else if (val == UINT64_MAX) { 2779 (void) strlcpy(propbuf, "none", proplen); 2780 } else { 2781 zfs_nicenum(val, propbuf, proplen); 2782 } 2783 2784 zcp_check(zhp, prop, val, NULL); 2785 break; 2786 2787 case ZFS_PROP_REFRATIO: 2788 case ZFS_PROP_COMPRESSRATIO: 2789 if (get_numeric_property(zhp, prop, src, &source, &val) != 0) 2790 return (-1); 2791 if (literal) 2792 (void) snprintf(propbuf, proplen, "%llu.%02llu", 2793 (u_longlong_t)(val / 100), 2794 (u_longlong_t)(val % 100)); 2795 else 2796 (void) snprintf(propbuf, proplen, "%llu.%02llux", 2797 (u_longlong_t)(val / 100), 2798 (u_longlong_t)(val % 100)); 2799 zcp_check(zhp, prop, val, NULL); 2800 break; 2801 2802 case ZFS_PROP_TYPE: 2803 switch (zhp->zfs_type) { 2804 case ZFS_TYPE_FILESYSTEM: 2805 str = "filesystem"; 2806 break; 2807 case ZFS_TYPE_VOLUME: 2808 str = "volume"; 2809 break; 2810 case ZFS_TYPE_SNAPSHOT: 2811 str = "snapshot"; 2812 break; 2813 case ZFS_TYPE_BOOKMARK: 2814 str = "bookmark"; 2815 break; 2816 default: 2817 abort(); 2818 } 2819 (void) snprintf(propbuf, proplen, "%s", str); 2820 zcp_check(zhp, prop, 0, propbuf); 2821 break; 2822 2823 case ZFS_PROP_MOUNTED: 2824 /* 2825 * The 'mounted' property is a pseudo-property that described 2826 * whether the filesystem is currently mounted. Even though 2827 * it's a boolean value, the typical values of "on" and "off" 2828 * don't make sense, so we translate to "yes" and "no". 2829 */ 2830 if (get_numeric_property(zhp, ZFS_PROP_MOUNTED, 2831 src, &source, &val) != 0) 2832 return (-1); 2833 if (val) 2834 (void) strlcpy(propbuf, "yes", proplen); 2835 else 2836 (void) strlcpy(propbuf, "no", proplen); 2837 break; 2838 2839 case ZFS_PROP_NAME: 2840 /* 2841 * The 'name' property is a pseudo-property derived from the 2842 * dataset name. It is presented as a real property to simplify 2843 * consumers. 2844 */ 2845 (void) strlcpy(propbuf, zhp->zfs_name, proplen); 2846 zcp_check(zhp, prop, 0, propbuf); 2847 break; 2848 2849 case ZFS_PROP_MLSLABEL: 2850 { 2851 #ifdef HAVE_MLSLABEL 2852 m_label_t *new_sl = NULL; 2853 char *ascii = NULL; /* human readable label */ 2854 2855 (void) strlcpy(propbuf, 2856 getprop_string(zhp, prop, &source), proplen); 2857 2858 if (literal || (strcasecmp(propbuf, 2859 ZFS_MLSLABEL_DEFAULT) == 0)) 2860 break; 2861 2862 /* 2863 * Try to translate the internal hex string to 2864 * human-readable output. If there are any 2865 * problems just use the hex string. 2866 */ 2867 2868 if (str_to_label(propbuf, &new_sl, MAC_LABEL, 2869 L_NO_CORRECTION, NULL) == -1) { 2870 m_label_free(new_sl); 2871 break; 2872 } 2873 2874 if (label_to_str(new_sl, &ascii, M_LABEL, 2875 DEF_NAMES) != 0) { 2876 if (ascii) 2877 free(ascii); 2878 m_label_free(new_sl); 2879 break; 2880 } 2881 m_label_free(new_sl); 2882 2883 (void) strlcpy(propbuf, ascii, proplen); 2884 free(ascii); 2885 #else 2886 (void) strlcpy(propbuf, 2887 getprop_string(zhp, prop, &source), proplen); 2888 #endif /* HAVE_MLSLABEL */ 2889 } 2890 break; 2891 2892 case ZFS_PROP_GUID: 2893 case ZFS_PROP_CREATETXG: 2894 case ZFS_PROP_OBJSETID: 2895 case ZFS_PROP_PBKDF2_ITERS: 2896 /* 2897 * These properties are stored as numbers, but they are 2898 * identifiers or counters. 2899 * We don't want them to be pretty printed, because pretty 2900 * printing truncates their values making them useless. 2901 */ 2902 if (get_numeric_property(zhp, prop, src, &source, &val) != 0) 2903 return (-1); 2904 (void) snprintf(propbuf, proplen, "%llu", (u_longlong_t)val); 2905 zcp_check(zhp, prop, val, NULL); 2906 break; 2907 2908 case ZFS_PROP_REFERENCED: 2909 case ZFS_PROP_AVAILABLE: 2910 case ZFS_PROP_USED: 2911 case ZFS_PROP_USEDSNAP: 2912 case ZFS_PROP_USEDDS: 2913 case ZFS_PROP_USEDREFRESERV: 2914 case ZFS_PROP_USEDCHILD: 2915 if (get_numeric_property(zhp, prop, src, &source, &val) != 0) 2916 return (-1); 2917 if (literal) { 2918 (void) snprintf(propbuf, proplen, "%llu", 2919 (u_longlong_t)val); 2920 } else { 2921 zfs_nicebytes(val, propbuf, proplen); 2922 } 2923 zcp_check(zhp, prop, val, NULL); 2924 break; 2925 2926 default: 2927 switch (zfs_prop_get_type(prop)) { 2928 case PROP_TYPE_NUMBER: 2929 if (get_numeric_property(zhp, prop, src, 2930 &source, &val) != 0) { 2931 return (-1); 2932 } 2933 2934 if (literal) { 2935 (void) snprintf(propbuf, proplen, "%llu", 2936 (u_longlong_t)val); 2937 } else { 2938 zfs_nicenum(val, propbuf, proplen); 2939 } 2940 zcp_check(zhp, prop, val, NULL); 2941 break; 2942 2943 case PROP_TYPE_STRING: 2944 str = getprop_string(zhp, prop, &source); 2945 if (str == NULL) 2946 return (-1); 2947 2948 (void) strlcpy(propbuf, str, proplen); 2949 zcp_check(zhp, prop, 0, str); 2950 break; 2951 2952 case PROP_TYPE_INDEX: 2953 if (get_numeric_property(zhp, prop, src, 2954 &source, &val) != 0) 2955 return (-1); 2956 if (zfs_prop_index_to_string(prop, val, &strval) != 0) 2957 return (-1); 2958 2959 (void) strlcpy(propbuf, strval, proplen); 2960 zcp_check(zhp, prop, 0, strval); 2961 break; 2962 2963 default: 2964 abort(); 2965 } 2966 } 2967 2968 get_source(zhp, src, source, statbuf, statlen); 2969 2970 return (0); 2971 } 2972 2973 /* 2974 * Utility function to get the given numeric property. Does no validation that 2975 * the given property is the appropriate type; should only be used with 2976 * hard-coded property types. 2977 */ 2978 uint64_t 2979 zfs_prop_get_int(zfs_handle_t *zhp, zfs_prop_t prop) 2980 { 2981 char *source; 2982 uint64_t val = 0; 2983 2984 (void) get_numeric_property(zhp, prop, NULL, &source, &val); 2985 2986 return (val); 2987 } 2988 2989 static int 2990 zfs_prop_set_int(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t val) 2991 { 2992 char buf[64]; 2993 2994 (void) snprintf(buf, sizeof (buf), "%llu", (longlong_t)val); 2995 return (zfs_prop_set(zhp, zfs_prop_to_name(prop), buf)); 2996 } 2997 2998 /* 2999 * Similar to zfs_prop_get(), but returns the value as an integer. 3000 */ 3001 int 3002 zfs_prop_get_numeric(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t *value, 3003 zprop_source_t *src, char *statbuf, size_t statlen) 3004 { 3005 char *source; 3006 3007 /* 3008 * Check to see if this property applies to our object 3009 */ 3010 if (!zfs_prop_valid_for_type(prop, zhp->zfs_type, B_FALSE)) { 3011 return (zfs_error_fmt(zhp->zfs_hdl, EZFS_PROPTYPE, 3012 dgettext(TEXT_DOMAIN, "cannot get property '%s'"), 3013 zfs_prop_to_name(prop))); 3014 } 3015 3016 if (src) 3017 *src = ZPROP_SRC_NONE; 3018 3019 if (get_numeric_property(zhp, prop, src, &source, value) != 0) 3020 return (-1); 3021 3022 get_source(zhp, src, source, statbuf, statlen); 3023 3024 return (0); 3025 } 3026 3027 #ifdef HAVE_IDMAP 3028 static int 3029 idmap_id_to_numeric_domain_rid(uid_t id, boolean_t isuser, 3030 char **domainp, idmap_rid_t *ridp) 3031 { 3032 idmap_get_handle_t *get_hdl = NULL; 3033 idmap_stat status; 3034 int err = EINVAL; 3035 3036 if (idmap_get_create(&get_hdl) != IDMAP_SUCCESS) 3037 goto out; 3038 3039 if (isuser) { 3040 err = idmap_get_sidbyuid(get_hdl, id, 3041 IDMAP_REQ_FLG_USE_CACHE, domainp, ridp, &status); 3042 } else { 3043 err = idmap_get_sidbygid(get_hdl, id, 3044 IDMAP_REQ_FLG_USE_CACHE, domainp, ridp, &status); 3045 } 3046 if (err == IDMAP_SUCCESS && 3047 idmap_get_mappings(get_hdl) == IDMAP_SUCCESS && 3048 status == IDMAP_SUCCESS) 3049 err = 0; 3050 else 3051 err = EINVAL; 3052 out: 3053 if (get_hdl) 3054 idmap_get_destroy(get_hdl); 3055 return (err); 3056 } 3057 #endif /* HAVE_IDMAP */ 3058 3059 /* 3060 * convert the propname into parameters needed by kernel 3061 * Eg: userquota@ahrens -> ZFS_PROP_USERQUOTA, "", 126829 3062 * Eg: userused@matt@domain -> ZFS_PROP_USERUSED, "S-1-123-456", 789 3063 * Eg: groupquota@staff -> ZFS_PROP_GROUPQUOTA, "", 1234 3064 * Eg: groupused@staff -> ZFS_PROP_GROUPUSED, "", 1234 3065 * Eg: projectquota@123 -> ZFS_PROP_PROJECTQUOTA, "", 123 3066 * Eg: projectused@789 -> ZFS_PROP_PROJECTUSED, "", 789 3067 */ 3068 static int 3069 userquota_propname_decode(const char *propname, boolean_t zoned, 3070 zfs_userquota_prop_t *typep, char *domain, int domainlen, uint64_t *ridp) 3071 { 3072 zfs_userquota_prop_t type; 3073 char *cp; 3074 boolean_t isuser; 3075 boolean_t isgroup; 3076 boolean_t isproject; 3077 struct passwd *pw; 3078 struct group *gr; 3079 3080 domain[0] = '\0'; 3081 3082 /* Figure out the property type ({user|group|project}{quota|space}) */ 3083 for (type = 0; type < ZFS_NUM_USERQUOTA_PROPS; type++) { 3084 if (strncmp(propname, zfs_userquota_prop_prefixes[type], 3085 strlen(zfs_userquota_prop_prefixes[type])) == 0) 3086 break; 3087 } 3088 if (type == ZFS_NUM_USERQUOTA_PROPS) 3089 return (EINVAL); 3090 *typep = type; 3091 3092 isuser = (type == ZFS_PROP_USERQUOTA || type == ZFS_PROP_USERUSED || 3093 type == ZFS_PROP_USEROBJQUOTA || 3094 type == ZFS_PROP_USEROBJUSED); 3095 isgroup = (type == ZFS_PROP_GROUPQUOTA || type == ZFS_PROP_GROUPUSED || 3096 type == ZFS_PROP_GROUPOBJQUOTA || 3097 type == ZFS_PROP_GROUPOBJUSED); 3098 isproject = (type == ZFS_PROP_PROJECTQUOTA || 3099 type == ZFS_PROP_PROJECTUSED || type == ZFS_PROP_PROJECTOBJQUOTA || 3100 type == ZFS_PROP_PROJECTOBJUSED); 3101 3102 cp = strchr(propname, '@') + 1; 3103 3104 if (isuser && (pw = getpwnam(cp)) != NULL) { 3105 if (zoned && getzoneid() == GLOBAL_ZONEID) 3106 return (ENOENT); 3107 *ridp = pw->pw_uid; 3108 } else if (isgroup && (gr = getgrnam(cp)) != NULL) { 3109 if (zoned && getzoneid() == GLOBAL_ZONEID) 3110 return (ENOENT); 3111 *ridp = gr->gr_gid; 3112 } else if (!isproject && strchr(cp, '@')) { 3113 #ifdef HAVE_IDMAP 3114 /* 3115 * It's a SID name (eg "user@domain") that needs to be 3116 * turned into S-1-domainID-RID. 3117 */ 3118 directory_error_t e; 3119 char *numericsid = NULL; 3120 char *end; 3121 3122 if (zoned && getzoneid() == GLOBAL_ZONEID) 3123 return (ENOENT); 3124 if (isuser) { 3125 e = directory_sid_from_user_name(NULL, 3126 cp, &numericsid); 3127 } else { 3128 e = directory_sid_from_group_name(NULL, 3129 cp, &numericsid); 3130 } 3131 if (e != NULL) { 3132 directory_error_free(e); 3133 return (ENOENT); 3134 } 3135 if (numericsid == NULL) 3136 return (ENOENT); 3137 cp = numericsid; 3138 (void) strlcpy(domain, cp, domainlen); 3139 cp = strrchr(domain, '-'); 3140 *cp = '\0'; 3141 cp++; 3142 3143 errno = 0; 3144 *ridp = strtoull(cp, &end, 10); 3145 free(numericsid); 3146 3147 if (errno != 0 || *end != '\0') 3148 return (EINVAL); 3149 #else 3150 return (ENOSYS); 3151 #endif /* HAVE_IDMAP */ 3152 } else { 3153 /* It's a user/group/project ID (eg "12345"). */ 3154 uid_t id; 3155 char *end; 3156 id = strtoul(cp, &end, 10); 3157 if (*end != '\0') 3158 return (EINVAL); 3159 if (id > MAXUID && !isproject) { 3160 #ifdef HAVE_IDMAP 3161 /* It's an ephemeral ID. */ 3162 idmap_rid_t rid; 3163 char *mapdomain; 3164 3165 if (idmap_id_to_numeric_domain_rid(id, isuser, 3166 &mapdomain, &rid) != 0) 3167 return (ENOENT); 3168 (void) strlcpy(domain, mapdomain, domainlen); 3169 *ridp = rid; 3170 #else 3171 return (ENOSYS); 3172 #endif /* HAVE_IDMAP */ 3173 } else { 3174 *ridp = id; 3175 } 3176 } 3177 3178 return (0); 3179 } 3180 3181 static int 3182 zfs_prop_get_userquota_common(zfs_handle_t *zhp, const char *propname, 3183 uint64_t *propvalue, zfs_userquota_prop_t *typep) 3184 { 3185 int err; 3186 zfs_cmd_t zc = {"\0"}; 3187 3188 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 3189 3190 err = userquota_propname_decode(propname, 3191 zfs_prop_get_int(zhp, ZFS_PROP_ZONED), 3192 typep, zc.zc_value, sizeof (zc.zc_value), &zc.zc_guid); 3193 zc.zc_objset_type = *typep; 3194 if (err) 3195 return (err); 3196 3197 err = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_USERSPACE_ONE, &zc); 3198 if (err) 3199 return (err); 3200 3201 *propvalue = zc.zc_cookie; 3202 return (0); 3203 } 3204 3205 int 3206 zfs_prop_get_userquota_int(zfs_handle_t *zhp, const char *propname, 3207 uint64_t *propvalue) 3208 { 3209 zfs_userquota_prop_t type; 3210 3211 return (zfs_prop_get_userquota_common(zhp, propname, propvalue, 3212 &type)); 3213 } 3214 3215 int 3216 zfs_prop_get_userquota(zfs_handle_t *zhp, const char *propname, 3217 char *propbuf, int proplen, boolean_t literal) 3218 { 3219 int err; 3220 uint64_t propvalue; 3221 zfs_userquota_prop_t type; 3222 3223 err = zfs_prop_get_userquota_common(zhp, propname, &propvalue, 3224 &type); 3225 3226 if (err) 3227 return (err); 3228 3229 if (literal) { 3230 (void) snprintf(propbuf, proplen, "%llu", 3231 (u_longlong_t)propvalue); 3232 } else if (propvalue == 0 && 3233 (type == ZFS_PROP_USERQUOTA || type == ZFS_PROP_GROUPQUOTA || 3234 type == ZFS_PROP_USEROBJQUOTA || type == ZFS_PROP_GROUPOBJQUOTA || 3235 type == ZFS_PROP_PROJECTQUOTA || 3236 type == ZFS_PROP_PROJECTOBJQUOTA)) { 3237 (void) strlcpy(propbuf, "none", proplen); 3238 } else if (type == ZFS_PROP_USERQUOTA || type == ZFS_PROP_GROUPQUOTA || 3239 type == ZFS_PROP_USERUSED || type == ZFS_PROP_GROUPUSED || 3240 type == ZFS_PROP_PROJECTUSED || type == ZFS_PROP_PROJECTQUOTA) { 3241 zfs_nicebytes(propvalue, propbuf, proplen); 3242 } else { 3243 zfs_nicenum(propvalue, propbuf, proplen); 3244 } 3245 return (0); 3246 } 3247 3248 /* 3249 * propname must start with "written@" or "written#". 3250 */ 3251 int 3252 zfs_prop_get_written_int(zfs_handle_t *zhp, const char *propname, 3253 uint64_t *propvalue) 3254 { 3255 int err; 3256 zfs_cmd_t zc = {"\0"}; 3257 const char *snapname; 3258 3259 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 3260 3261 assert(zfs_prop_written(propname)); 3262 snapname = propname + strlen("written@"); 3263 if (strchr(snapname, '@') != NULL || strchr(snapname, '#') != NULL) { 3264 /* full snapshot or bookmark name specified */ 3265 (void) strlcpy(zc.zc_value, snapname, sizeof (zc.zc_value)); 3266 } else { 3267 /* snapname is the short name, append it to zhp's fsname */ 3268 char *cp; 3269 3270 (void) strlcpy(zc.zc_value, zhp->zfs_name, 3271 sizeof (zc.zc_value)); 3272 cp = strchr(zc.zc_value, '@'); 3273 if (cp != NULL) 3274 *cp = '\0'; 3275 (void) strlcat(zc.zc_value, snapname - 1, sizeof (zc.zc_value)); 3276 } 3277 3278 err = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_SPACE_WRITTEN, &zc); 3279 if (err) 3280 return (err); 3281 3282 *propvalue = zc.zc_cookie; 3283 return (0); 3284 } 3285 3286 int 3287 zfs_prop_get_written(zfs_handle_t *zhp, const char *propname, 3288 char *propbuf, int proplen, boolean_t literal) 3289 { 3290 int err; 3291 uint64_t propvalue; 3292 3293 err = zfs_prop_get_written_int(zhp, propname, &propvalue); 3294 3295 if (err) 3296 return (err); 3297 3298 if (literal) { 3299 (void) snprintf(propbuf, proplen, "%llu", 3300 (u_longlong_t)propvalue); 3301 } else { 3302 zfs_nicebytes(propvalue, propbuf, proplen); 3303 } 3304 3305 return (0); 3306 } 3307 3308 /* 3309 * Returns the name of the given zfs handle. 3310 */ 3311 const char * 3312 zfs_get_name(const zfs_handle_t *zhp) 3313 { 3314 return (zhp->zfs_name); 3315 } 3316 3317 /* 3318 * Returns the name of the parent pool for the given zfs handle. 3319 */ 3320 const char * 3321 zfs_get_pool_name(const zfs_handle_t *zhp) 3322 { 3323 return (zhp->zpool_hdl->zpool_name); 3324 } 3325 3326 /* 3327 * Returns the type of the given zfs handle. 3328 */ 3329 zfs_type_t 3330 zfs_get_type(const zfs_handle_t *zhp) 3331 { 3332 return (zhp->zfs_type); 3333 } 3334 3335 /* 3336 * Returns the type of the given zfs handle, 3337 * or, if a snapshot, the type of the snapshotted dataset. 3338 */ 3339 zfs_type_t 3340 zfs_get_underlying_type(const zfs_handle_t *zhp) 3341 { 3342 return (zhp->zfs_head_type); 3343 } 3344 3345 /* 3346 * Is one dataset name a child dataset of another? 3347 * 3348 * Needs to handle these cases: 3349 * Dataset 1 "a/foo" "a/foo" "a/foo" "a/foo" 3350 * Dataset 2 "a/fo" "a/foobar" "a/bar/baz" "a/foo/bar" 3351 * Descendant? No. No. No. Yes. 3352 */ 3353 static boolean_t 3354 is_descendant(const char *ds1, const char *ds2) 3355 { 3356 size_t d1len = strlen(ds1); 3357 3358 /* ds2 can't be a descendant if it's smaller */ 3359 if (strlen(ds2) < d1len) 3360 return (B_FALSE); 3361 3362 /* otherwise, compare strings and verify that there's a '/' char */ 3363 return (ds2[d1len] == '/' && (strncmp(ds1, ds2, d1len) == 0)); 3364 } 3365 3366 /* 3367 * Given a complete name, return just the portion that refers to the parent. 3368 * Will return -1 if there is no parent (path is just the name of the 3369 * pool). 3370 */ 3371 static int 3372 parent_name(const char *path, char *buf, size_t buflen) 3373 { 3374 char *slashp; 3375 3376 (void) strlcpy(buf, path, buflen); 3377 3378 if ((slashp = strrchr(buf, '/')) == NULL) 3379 return (-1); 3380 *slashp = '\0'; 3381 3382 return (0); 3383 } 3384 3385 int 3386 zfs_parent_name(zfs_handle_t *zhp, char *buf, size_t buflen) 3387 { 3388 return (parent_name(zfs_get_name(zhp), buf, buflen)); 3389 } 3390 3391 /* 3392 * If accept_ancestor is false, then check to make sure that the given path has 3393 * a parent, and that it exists. If accept_ancestor is true, then find the 3394 * closest existing ancestor for the given path. In prefixlen return the 3395 * length of already existing prefix of the given path. We also fetch the 3396 * 'zoned' property, which is used to validate property settings when creating 3397 * new datasets. 3398 */ 3399 static int 3400 check_parents(libzfs_handle_t *hdl, const char *path, uint64_t *zoned, 3401 boolean_t accept_ancestor, int *prefixlen) 3402 { 3403 zfs_cmd_t zc = {"\0"}; 3404 char parent[ZFS_MAX_DATASET_NAME_LEN]; 3405 char *slash; 3406 zfs_handle_t *zhp; 3407 char errbuf[1024]; 3408 uint64_t is_zoned; 3409 3410 (void) snprintf(errbuf, sizeof (errbuf), 3411 dgettext(TEXT_DOMAIN, "cannot create '%s'"), path); 3412 3413 /* get parent, and check to see if this is just a pool */ 3414 if (parent_name(path, parent, sizeof (parent)) != 0) { 3415 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3416 "missing dataset name")); 3417 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 3418 } 3419 3420 /* check to see if the pool exists */ 3421 if ((slash = strchr(parent, '/')) == NULL) 3422 slash = parent + strlen(parent); 3423 (void) strncpy(zc.zc_name, parent, slash - parent); 3424 zc.zc_name[slash - parent] = '\0'; 3425 if (zfs_ioctl(hdl, ZFS_IOC_OBJSET_STATS, &zc) != 0 && 3426 errno == ENOENT) { 3427 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3428 "no such pool '%s'"), zc.zc_name); 3429 return (zfs_error(hdl, EZFS_NOENT, errbuf)); 3430 } 3431 3432 /* check to see if the parent dataset exists */ 3433 while ((zhp = make_dataset_handle(hdl, parent)) == NULL) { 3434 if (errno == ENOENT && accept_ancestor) { 3435 /* 3436 * Go deeper to find an ancestor, give up on top level. 3437 */ 3438 if (parent_name(parent, parent, sizeof (parent)) != 0) { 3439 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3440 "no such pool '%s'"), zc.zc_name); 3441 return (zfs_error(hdl, EZFS_NOENT, errbuf)); 3442 } 3443 } else if (errno == ENOENT) { 3444 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3445 "parent does not exist")); 3446 return (zfs_error(hdl, EZFS_NOENT, errbuf)); 3447 } else 3448 return (zfs_standard_error(hdl, errno, errbuf)); 3449 } 3450 3451 is_zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED); 3452 if (zoned != NULL) 3453 *zoned = is_zoned; 3454 3455 /* we are in a non-global zone, but parent is in the global zone */ 3456 if (getzoneid() != GLOBAL_ZONEID && !is_zoned) { 3457 (void) zfs_standard_error(hdl, EPERM, errbuf); 3458 zfs_close(zhp); 3459 return (-1); 3460 } 3461 3462 /* make sure parent is a filesystem */ 3463 if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) { 3464 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3465 "parent is not a filesystem")); 3466 (void) zfs_error(hdl, EZFS_BADTYPE, errbuf); 3467 zfs_close(zhp); 3468 return (-1); 3469 } 3470 3471 zfs_close(zhp); 3472 if (prefixlen != NULL) 3473 *prefixlen = strlen(parent); 3474 return (0); 3475 } 3476 3477 /* 3478 * Finds whether the dataset of the given type(s) exists. 3479 */ 3480 boolean_t 3481 zfs_dataset_exists(libzfs_handle_t *hdl, const char *path, zfs_type_t types) 3482 { 3483 zfs_handle_t *zhp; 3484 3485 if (!zfs_validate_name(hdl, path, types, B_FALSE)) 3486 return (B_FALSE); 3487 3488 /* 3489 * Try to get stats for the dataset, which will tell us if it exists. 3490 */ 3491 if ((zhp = make_dataset_handle(hdl, path)) != NULL) { 3492 int ds_type = zhp->zfs_type; 3493 3494 zfs_close(zhp); 3495 if (types & ds_type) 3496 return (B_TRUE); 3497 } 3498 return (B_FALSE); 3499 } 3500 3501 /* 3502 * Given a path to 'target', create all the ancestors between 3503 * the prefixlen portion of the path, and the target itself. 3504 * Fail if the initial prefixlen-ancestor does not already exist. 3505 */ 3506 int 3507 create_parents(libzfs_handle_t *hdl, char *target, int prefixlen) 3508 { 3509 zfs_handle_t *h; 3510 char *cp; 3511 const char *opname; 3512 3513 /* make sure prefix exists */ 3514 cp = target + prefixlen; 3515 if (*cp != '/') { 3516 assert(strchr(cp, '/') == NULL); 3517 h = zfs_open(hdl, target, ZFS_TYPE_FILESYSTEM); 3518 } else { 3519 *cp = '\0'; 3520 h = zfs_open(hdl, target, ZFS_TYPE_FILESYSTEM); 3521 *cp = '/'; 3522 } 3523 if (h == NULL) 3524 return (-1); 3525 zfs_close(h); 3526 3527 /* 3528 * Attempt to create, mount, and share any ancestor filesystems, 3529 * up to the prefixlen-long one. 3530 */ 3531 for (cp = target + prefixlen + 1; 3532 (cp = strchr(cp, '/')) != NULL; *cp = '/', cp++) { 3533 3534 *cp = '\0'; 3535 3536 h = make_dataset_handle(hdl, target); 3537 if (h) { 3538 /* it already exists, nothing to do here */ 3539 zfs_close(h); 3540 continue; 3541 } 3542 3543 if (zfs_create(hdl, target, ZFS_TYPE_FILESYSTEM, 3544 NULL) != 0) { 3545 opname = dgettext(TEXT_DOMAIN, "create"); 3546 goto ancestorerr; 3547 } 3548 3549 h = zfs_open(hdl, target, ZFS_TYPE_FILESYSTEM); 3550 if (h == NULL) { 3551 opname = dgettext(TEXT_DOMAIN, "open"); 3552 goto ancestorerr; 3553 } 3554 3555 if (zfs_mount(h, NULL, 0) != 0) { 3556 opname = dgettext(TEXT_DOMAIN, "mount"); 3557 goto ancestorerr; 3558 } 3559 3560 if (zfs_share(h) != 0) { 3561 opname = dgettext(TEXT_DOMAIN, "share"); 3562 goto ancestorerr; 3563 } 3564 3565 zfs_close(h); 3566 } 3567 zfs_commit_all_shares(); 3568 3569 return (0); 3570 3571 ancestorerr: 3572 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3573 "failed to %s ancestor '%s'"), opname, target); 3574 return (-1); 3575 } 3576 3577 /* 3578 * Creates non-existing ancestors of the given path. 3579 */ 3580 int 3581 zfs_create_ancestors(libzfs_handle_t *hdl, const char *path) 3582 { 3583 int prefix; 3584 char *path_copy; 3585 char errbuf[1024]; 3586 int rc = 0; 3587 3588 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 3589 "cannot create '%s'"), path); 3590 3591 /* 3592 * Check that we are not passing the nesting limit 3593 * before we start creating any ancestors. 3594 */ 3595 if (dataset_nestcheck(path) != 0) { 3596 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3597 "maximum name nesting depth exceeded")); 3598 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 3599 } 3600 3601 if (check_parents(hdl, path, NULL, B_TRUE, &prefix) != 0) 3602 return (-1); 3603 3604 if ((path_copy = strdup(path)) != NULL) { 3605 rc = create_parents(hdl, path_copy, prefix); 3606 free(path_copy); 3607 } 3608 if (path_copy == NULL || rc != 0) 3609 return (-1); 3610 3611 return (0); 3612 } 3613 3614 /* 3615 * Create a new filesystem or volume. 3616 */ 3617 int 3618 zfs_create(libzfs_handle_t *hdl, const char *path, zfs_type_t type, 3619 nvlist_t *props) 3620 { 3621 int ret; 3622 uint64_t size = 0; 3623 uint64_t blocksize = zfs_prop_default_numeric(ZFS_PROP_VOLBLOCKSIZE); 3624 uint64_t zoned; 3625 enum lzc_dataset_type ost; 3626 zpool_handle_t *zpool_handle; 3627 uint8_t *wkeydata = NULL; 3628 uint_t wkeylen = 0; 3629 char errbuf[1024]; 3630 char parent[ZFS_MAX_DATASET_NAME_LEN]; 3631 3632 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 3633 "cannot create '%s'"), path); 3634 3635 /* validate the path, taking care to note the extended error message */ 3636 if (!zfs_validate_name(hdl, path, type, B_TRUE)) 3637 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 3638 3639 if (dataset_nestcheck(path) != 0) { 3640 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3641 "maximum name nesting depth exceeded")); 3642 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 3643 } 3644 3645 /* validate parents exist */ 3646 if (check_parents(hdl, path, &zoned, B_FALSE, NULL) != 0) 3647 return (-1); 3648 3649 /* 3650 * The failure modes when creating a dataset of a different type over 3651 * one that already exists is a little strange. In particular, if you 3652 * try to create a dataset on top of an existing dataset, the ioctl() 3653 * will return ENOENT, not EEXIST. To prevent this from happening, we 3654 * first try to see if the dataset exists. 3655 */ 3656 if (zfs_dataset_exists(hdl, path, ZFS_TYPE_DATASET)) { 3657 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3658 "dataset already exists")); 3659 return (zfs_error(hdl, EZFS_EXISTS, errbuf)); 3660 } 3661 3662 if (type == ZFS_TYPE_VOLUME) 3663 ost = LZC_DATSET_TYPE_ZVOL; 3664 else 3665 ost = LZC_DATSET_TYPE_ZFS; 3666 3667 /* open zpool handle for prop validation */ 3668 char pool_path[ZFS_MAX_DATASET_NAME_LEN]; 3669 (void) strlcpy(pool_path, path, sizeof (pool_path)); 3670 3671 /* truncate pool_path at first slash */ 3672 char *p = strchr(pool_path, '/'); 3673 if (p != NULL) 3674 *p = '\0'; 3675 3676 if ((zpool_handle = zpool_open(hdl, pool_path)) == NULL) 3677 return (-1); 3678 3679 if (props && (props = zfs_valid_proplist(hdl, type, props, 3680 zoned, NULL, zpool_handle, B_TRUE, errbuf)) == 0) { 3681 zpool_close(zpool_handle); 3682 return (-1); 3683 } 3684 zpool_close(zpool_handle); 3685 3686 if (type == ZFS_TYPE_VOLUME) { 3687 /* 3688 * If we are creating a volume, the size and block size must 3689 * satisfy a few restraints. First, the blocksize must be a 3690 * valid block size between SPA_{MIN,MAX}BLOCKSIZE. Second, the 3691 * volsize must be a multiple of the block size, and cannot be 3692 * zero. 3693 */ 3694 if (props == NULL || nvlist_lookup_uint64(props, 3695 zfs_prop_to_name(ZFS_PROP_VOLSIZE), &size) != 0) { 3696 nvlist_free(props); 3697 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3698 "missing volume size")); 3699 return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 3700 } 3701 3702 if ((ret = nvlist_lookup_uint64(props, 3703 zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE), 3704 &blocksize)) != 0) { 3705 if (ret == ENOENT) { 3706 blocksize = zfs_prop_default_numeric( 3707 ZFS_PROP_VOLBLOCKSIZE); 3708 } else { 3709 nvlist_free(props); 3710 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3711 "missing volume block size")); 3712 return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 3713 } 3714 } 3715 3716 if (size == 0) { 3717 nvlist_free(props); 3718 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3719 "volume size cannot be zero")); 3720 return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 3721 } 3722 3723 if (size % blocksize != 0) { 3724 nvlist_free(props); 3725 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3726 "volume size must be a multiple of volume block " 3727 "size")); 3728 return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 3729 } 3730 } 3731 3732 (void) parent_name(path, parent, sizeof (parent)); 3733 if (zfs_crypto_create(hdl, parent, props, NULL, B_TRUE, 3734 &wkeydata, &wkeylen) != 0) { 3735 nvlist_free(props); 3736 return (zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf)); 3737 } 3738 3739 /* create the dataset */ 3740 ret = lzc_create(path, ost, props, wkeydata, wkeylen); 3741 nvlist_free(props); 3742 if (wkeydata != NULL) 3743 free(wkeydata); 3744 3745 /* check for failure */ 3746 if (ret != 0) { 3747 switch (errno) { 3748 case ENOENT: 3749 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3750 "no such parent '%s'"), parent); 3751 return (zfs_error(hdl, EZFS_NOENT, errbuf)); 3752 3753 case ENOTSUP: 3754 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3755 "pool must be upgraded to set this " 3756 "property or value")); 3757 return (zfs_error(hdl, EZFS_BADVERSION, errbuf)); 3758 3759 case EACCES: 3760 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3761 "encryption root's key is not loaded " 3762 "or provided")); 3763 return (zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf)); 3764 3765 case ERANGE: 3766 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3767 "invalid property value(s) specified")); 3768 return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 3769 #ifdef _ILP32 3770 case EOVERFLOW: 3771 /* 3772 * This platform can't address a volume this big. 3773 */ 3774 if (type == ZFS_TYPE_VOLUME) 3775 return (zfs_error(hdl, EZFS_VOLTOOBIG, 3776 errbuf)); 3777 fallthrough; 3778 #endif 3779 default: 3780 return (zfs_standard_error(hdl, errno, errbuf)); 3781 } 3782 } 3783 3784 return (0); 3785 } 3786 3787 /* 3788 * Destroys the given dataset. The caller must make sure that the filesystem 3789 * isn't mounted, and that there are no active dependents. If the file system 3790 * does not exist this function does nothing. 3791 */ 3792 int 3793 zfs_destroy(zfs_handle_t *zhp, boolean_t defer) 3794 { 3795 int error; 3796 3797 if (zhp->zfs_type != ZFS_TYPE_SNAPSHOT && defer) 3798 return (EINVAL); 3799 3800 if (zhp->zfs_type == ZFS_TYPE_BOOKMARK) { 3801 nvlist_t *nv = fnvlist_alloc(); 3802 fnvlist_add_boolean(nv, zhp->zfs_name); 3803 error = lzc_destroy_bookmarks(nv, NULL); 3804 fnvlist_free(nv); 3805 if (error != 0) { 3806 return (zfs_standard_error_fmt(zhp->zfs_hdl, error, 3807 dgettext(TEXT_DOMAIN, "cannot destroy '%s'"), 3808 zhp->zfs_name)); 3809 } 3810 return (0); 3811 } 3812 3813 if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) { 3814 nvlist_t *nv = fnvlist_alloc(); 3815 fnvlist_add_boolean(nv, zhp->zfs_name); 3816 error = lzc_destroy_snaps(nv, defer, NULL); 3817 fnvlist_free(nv); 3818 } else { 3819 error = lzc_destroy(zhp->zfs_name); 3820 } 3821 3822 if (error != 0 && error != ENOENT) { 3823 return (zfs_standard_error_fmt(zhp->zfs_hdl, errno, 3824 dgettext(TEXT_DOMAIN, "cannot destroy '%s'"), 3825 zhp->zfs_name)); 3826 } 3827 3828 remove_mountpoint(zhp); 3829 3830 return (0); 3831 } 3832 3833 struct destroydata { 3834 nvlist_t *nvl; 3835 const char *snapname; 3836 }; 3837 3838 static int 3839 zfs_check_snap_cb(zfs_handle_t *zhp, void *arg) 3840 { 3841 struct destroydata *dd = arg; 3842 char name[ZFS_MAX_DATASET_NAME_LEN]; 3843 int rv = 0; 3844 3845 if (snprintf(name, sizeof (name), "%s@%s", zhp->zfs_name, 3846 dd->snapname) >= sizeof (name)) 3847 return (EINVAL); 3848 3849 if (lzc_exists(name)) 3850 verify(nvlist_add_boolean(dd->nvl, name) == 0); 3851 3852 rv = zfs_iter_filesystems(zhp, zfs_check_snap_cb, dd); 3853 zfs_close(zhp); 3854 return (rv); 3855 } 3856 3857 /* 3858 * Destroys all snapshots with the given name in zhp & descendants. 3859 */ 3860 int 3861 zfs_destroy_snaps(zfs_handle_t *zhp, char *snapname, boolean_t defer) 3862 { 3863 int ret; 3864 struct destroydata dd = { 0 }; 3865 3866 dd.snapname = snapname; 3867 verify(nvlist_alloc(&dd.nvl, NV_UNIQUE_NAME, 0) == 0); 3868 (void) zfs_check_snap_cb(zfs_handle_dup(zhp), &dd); 3869 3870 if (nvlist_empty(dd.nvl)) { 3871 ret = zfs_standard_error_fmt(zhp->zfs_hdl, ENOENT, 3872 dgettext(TEXT_DOMAIN, "cannot destroy '%s@%s'"), 3873 zhp->zfs_name, snapname); 3874 } else { 3875 ret = zfs_destroy_snaps_nvl(zhp->zfs_hdl, dd.nvl, defer); 3876 } 3877 nvlist_free(dd.nvl); 3878 return (ret); 3879 } 3880 3881 /* 3882 * Destroys all the snapshots named in the nvlist. 3883 */ 3884 int 3885 zfs_destroy_snaps_nvl(libzfs_handle_t *hdl, nvlist_t *snaps, boolean_t defer) 3886 { 3887 int ret; 3888 nvlist_t *errlist = NULL; 3889 nvpair_t *pair; 3890 3891 ret = lzc_destroy_snaps(snaps, defer, &errlist); 3892 3893 if (ret == 0) { 3894 nvlist_free(errlist); 3895 return (0); 3896 } 3897 3898 if (nvlist_empty(errlist)) { 3899 char errbuf[1024]; 3900 (void) snprintf(errbuf, sizeof (errbuf), 3901 dgettext(TEXT_DOMAIN, "cannot destroy snapshots")); 3902 3903 ret = zfs_standard_error(hdl, ret, errbuf); 3904 } 3905 for (pair = nvlist_next_nvpair(errlist, NULL); 3906 pair != NULL; pair = nvlist_next_nvpair(errlist, pair)) { 3907 char errbuf[1024]; 3908 (void) snprintf(errbuf, sizeof (errbuf), 3909 dgettext(TEXT_DOMAIN, "cannot destroy snapshot %s"), 3910 nvpair_name(pair)); 3911 3912 switch (fnvpair_value_int32(pair)) { 3913 case EEXIST: 3914 zfs_error_aux(hdl, 3915 dgettext(TEXT_DOMAIN, "snapshot is cloned")); 3916 ret = zfs_error(hdl, EZFS_EXISTS, errbuf); 3917 break; 3918 default: 3919 ret = zfs_standard_error(hdl, errno, errbuf); 3920 break; 3921 } 3922 } 3923 3924 nvlist_free(errlist); 3925 return (ret); 3926 } 3927 3928 /* 3929 * Clones the given dataset. The target must be of the same type as the source. 3930 */ 3931 int 3932 zfs_clone(zfs_handle_t *zhp, const char *target, nvlist_t *props) 3933 { 3934 char parent[ZFS_MAX_DATASET_NAME_LEN]; 3935 int ret; 3936 char errbuf[1024]; 3937 libzfs_handle_t *hdl = zhp->zfs_hdl; 3938 uint64_t zoned; 3939 3940 assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT); 3941 3942 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 3943 "cannot create '%s'"), target); 3944 3945 /* validate the target/clone name */ 3946 if (!zfs_validate_name(hdl, target, ZFS_TYPE_FILESYSTEM, B_TRUE)) 3947 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 3948 3949 /* validate parents exist */ 3950 if (check_parents(hdl, target, &zoned, B_FALSE, NULL) != 0) 3951 return (-1); 3952 3953 (void) parent_name(target, parent, sizeof (parent)); 3954 3955 /* do the clone */ 3956 3957 if (props) { 3958 zfs_type_t type; 3959 3960 if (ZFS_IS_VOLUME(zhp)) { 3961 type = ZFS_TYPE_VOLUME; 3962 } else { 3963 type = ZFS_TYPE_FILESYSTEM; 3964 } 3965 if ((props = zfs_valid_proplist(hdl, type, props, zoned, 3966 zhp, zhp->zpool_hdl, B_TRUE, errbuf)) == NULL) 3967 return (-1); 3968 if (zfs_fix_auto_resv(zhp, props) == -1) { 3969 nvlist_free(props); 3970 return (-1); 3971 } 3972 } 3973 3974 if (zfs_crypto_clone_check(hdl, zhp, parent, props) != 0) { 3975 nvlist_free(props); 3976 return (zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf)); 3977 } 3978 3979 ret = lzc_clone(target, zhp->zfs_name, props); 3980 nvlist_free(props); 3981 3982 if (ret != 0) { 3983 switch (errno) { 3984 3985 case ENOENT: 3986 /* 3987 * The parent doesn't exist. We should have caught this 3988 * above, but there may a race condition that has since 3989 * destroyed the parent. 3990 * 3991 * At this point, we don't know whether it's the source 3992 * that doesn't exist anymore, or whether the target 3993 * dataset doesn't exist. 3994 */ 3995 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 3996 "no such parent '%s'"), parent); 3997 return (zfs_error(zhp->zfs_hdl, EZFS_NOENT, errbuf)); 3998 3999 case EXDEV: 4000 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 4001 "source and target pools differ")); 4002 return (zfs_error(zhp->zfs_hdl, EZFS_CROSSTARGET, 4003 errbuf)); 4004 4005 default: 4006 return (zfs_standard_error(zhp->zfs_hdl, errno, 4007 errbuf)); 4008 } 4009 } 4010 4011 return (ret); 4012 } 4013 4014 /* 4015 * Promotes the given clone fs to be the clone parent. 4016 */ 4017 int 4018 zfs_promote(zfs_handle_t *zhp) 4019 { 4020 libzfs_handle_t *hdl = zhp->zfs_hdl; 4021 char snapname[ZFS_MAX_DATASET_NAME_LEN]; 4022 int ret; 4023 char errbuf[1024]; 4024 4025 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 4026 "cannot promote '%s'"), zhp->zfs_name); 4027 4028 if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) { 4029 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 4030 "snapshots can not be promoted")); 4031 return (zfs_error(hdl, EZFS_BADTYPE, errbuf)); 4032 } 4033 4034 if (zhp->zfs_dmustats.dds_origin[0] == '\0') { 4035 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 4036 "not a cloned filesystem")); 4037 return (zfs_error(hdl, EZFS_BADTYPE, errbuf)); 4038 } 4039 4040 if (!zfs_validate_name(hdl, zhp->zfs_name, zhp->zfs_type, B_TRUE)) 4041 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 4042 4043 ret = lzc_promote(zhp->zfs_name, snapname, sizeof (snapname)); 4044 4045 if (ret != 0) { 4046 switch (ret) { 4047 case EACCES: 4048 /* 4049 * Promoting encrypted dataset outside its 4050 * encryption root. 4051 */ 4052 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 4053 "cannot promote dataset outside its " 4054 "encryption root")); 4055 return (zfs_error(hdl, EZFS_EXISTS, errbuf)); 4056 4057 case EEXIST: 4058 /* There is a conflicting snapshot name. */ 4059 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 4060 "conflicting snapshot '%s' from parent '%s'"), 4061 snapname, zhp->zfs_dmustats.dds_origin); 4062 return (zfs_error(hdl, EZFS_EXISTS, errbuf)); 4063 4064 default: 4065 return (zfs_standard_error(hdl, ret, errbuf)); 4066 } 4067 } 4068 return (ret); 4069 } 4070 4071 typedef struct snapdata { 4072 nvlist_t *sd_nvl; 4073 const char *sd_snapname; 4074 } snapdata_t; 4075 4076 static int 4077 zfs_snapshot_cb(zfs_handle_t *zhp, void *arg) 4078 { 4079 snapdata_t *sd = arg; 4080 char name[ZFS_MAX_DATASET_NAME_LEN]; 4081 int rv = 0; 4082 4083 if (zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) == 0) { 4084 if (snprintf(name, sizeof (name), "%s@%s", zfs_get_name(zhp), 4085 sd->sd_snapname) >= sizeof (name)) 4086 return (EINVAL); 4087 4088 fnvlist_add_boolean(sd->sd_nvl, name); 4089 4090 rv = zfs_iter_filesystems(zhp, zfs_snapshot_cb, sd); 4091 } 4092 zfs_close(zhp); 4093 4094 return (rv); 4095 } 4096 4097 /* 4098 * Creates snapshots. The keys in the snaps nvlist are the snapshots to be 4099 * created. 4100 */ 4101 int 4102 zfs_snapshot_nvl(libzfs_handle_t *hdl, nvlist_t *snaps, nvlist_t *props) 4103 { 4104 int ret; 4105 char errbuf[1024]; 4106 nvpair_t *elem; 4107 nvlist_t *errors; 4108 zpool_handle_t *zpool_hdl; 4109 char pool[ZFS_MAX_DATASET_NAME_LEN]; 4110 4111 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 4112 "cannot create snapshots ")); 4113 4114 elem = NULL; 4115 while ((elem = nvlist_next_nvpair(snaps, elem)) != NULL) { 4116 const char *snapname = nvpair_name(elem); 4117 4118 /* validate the target name */ 4119 if (!zfs_validate_name(hdl, snapname, ZFS_TYPE_SNAPSHOT, 4120 B_TRUE)) { 4121 (void) snprintf(errbuf, sizeof (errbuf), 4122 dgettext(TEXT_DOMAIN, 4123 "cannot create snapshot '%s'"), snapname); 4124 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 4125 } 4126 } 4127 4128 /* 4129 * get pool handle for prop validation. assumes all snaps are in the 4130 * same pool, as does lzc_snapshot (below). 4131 */ 4132 elem = nvlist_next_nvpair(snaps, NULL); 4133 (void) strlcpy(pool, nvpair_name(elem), sizeof (pool)); 4134 pool[strcspn(pool, "/@")] = '\0'; 4135 zpool_hdl = zpool_open(hdl, pool); 4136 if (zpool_hdl == NULL) 4137 return (-1); 4138 4139 if (props != NULL && 4140 (props = zfs_valid_proplist(hdl, ZFS_TYPE_SNAPSHOT, 4141 props, B_FALSE, NULL, zpool_hdl, B_FALSE, errbuf)) == NULL) { 4142 zpool_close(zpool_hdl); 4143 return (-1); 4144 } 4145 zpool_close(zpool_hdl); 4146 4147 ret = lzc_snapshot(snaps, props, &errors); 4148 4149 if (ret != 0) { 4150 boolean_t printed = B_FALSE; 4151 for (elem = nvlist_next_nvpair(errors, NULL); 4152 elem != NULL; 4153 elem = nvlist_next_nvpair(errors, elem)) { 4154 (void) snprintf(errbuf, sizeof (errbuf), 4155 dgettext(TEXT_DOMAIN, 4156 "cannot create snapshot '%s'"), nvpair_name(elem)); 4157 (void) zfs_standard_error(hdl, 4158 fnvpair_value_int32(elem), errbuf); 4159 printed = B_TRUE; 4160 } 4161 if (!printed) { 4162 switch (ret) { 4163 case EXDEV: 4164 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 4165 "multiple snapshots of same " 4166 "fs not allowed")); 4167 (void) zfs_error(hdl, EZFS_EXISTS, errbuf); 4168 4169 break; 4170 default: 4171 (void) zfs_standard_error(hdl, ret, errbuf); 4172 } 4173 } 4174 } 4175 4176 nvlist_free(props); 4177 nvlist_free(errors); 4178 return (ret); 4179 } 4180 4181 int 4182 zfs_snapshot(libzfs_handle_t *hdl, const char *path, boolean_t recursive, 4183 nvlist_t *props) 4184 { 4185 int ret; 4186 snapdata_t sd = { 0 }; 4187 char fsname[ZFS_MAX_DATASET_NAME_LEN]; 4188 char *cp; 4189 zfs_handle_t *zhp; 4190 char errbuf[1024]; 4191 4192 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 4193 "cannot snapshot %s"), path); 4194 4195 if (!zfs_validate_name(hdl, path, ZFS_TYPE_SNAPSHOT, B_TRUE)) 4196 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 4197 4198 (void) strlcpy(fsname, path, sizeof (fsname)); 4199 cp = strchr(fsname, '@'); 4200 *cp = '\0'; 4201 sd.sd_snapname = cp + 1; 4202 4203 if ((zhp = zfs_open(hdl, fsname, ZFS_TYPE_FILESYSTEM | 4204 ZFS_TYPE_VOLUME)) == NULL) { 4205 return (-1); 4206 } 4207 4208 verify(nvlist_alloc(&sd.sd_nvl, NV_UNIQUE_NAME, 0) == 0); 4209 if (recursive) { 4210 (void) zfs_snapshot_cb(zfs_handle_dup(zhp), &sd); 4211 } else { 4212 fnvlist_add_boolean(sd.sd_nvl, path); 4213 } 4214 4215 ret = zfs_snapshot_nvl(hdl, sd.sd_nvl, props); 4216 nvlist_free(sd.sd_nvl); 4217 zfs_close(zhp); 4218 return (ret); 4219 } 4220 4221 /* 4222 * Destroy any more recent snapshots. We invoke this callback on any dependents 4223 * of the snapshot first. If the 'cb_dependent' member is non-zero, then this 4224 * is a dependent and we should just destroy it without checking the transaction 4225 * group. 4226 */ 4227 typedef struct rollback_data { 4228 const char *cb_target; /* the snapshot */ 4229 uint64_t cb_create; /* creation time reference */ 4230 boolean_t cb_error; 4231 boolean_t cb_force; 4232 } rollback_data_t; 4233 4234 static int 4235 rollback_destroy_dependent(zfs_handle_t *zhp, void *data) 4236 { 4237 rollback_data_t *cbp = data; 4238 prop_changelist_t *clp; 4239 4240 /* We must destroy this clone; first unmount it */ 4241 clp = changelist_gather(zhp, ZFS_PROP_NAME, 0, 4242 cbp->cb_force ? MS_FORCE: 0); 4243 if (clp == NULL || changelist_prefix(clp) != 0) { 4244 cbp->cb_error = B_TRUE; 4245 zfs_close(zhp); 4246 return (0); 4247 } 4248 if (zfs_destroy(zhp, B_FALSE) != 0) 4249 cbp->cb_error = B_TRUE; 4250 else 4251 changelist_remove(clp, zhp->zfs_name); 4252 (void) changelist_postfix(clp); 4253 changelist_free(clp); 4254 4255 zfs_close(zhp); 4256 return (0); 4257 } 4258 4259 static int 4260 rollback_destroy(zfs_handle_t *zhp, void *data) 4261 { 4262 rollback_data_t *cbp = data; 4263 4264 if (zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > cbp->cb_create) { 4265 cbp->cb_error |= zfs_iter_dependents(zhp, B_FALSE, 4266 rollback_destroy_dependent, cbp); 4267 4268 cbp->cb_error |= zfs_destroy(zhp, B_FALSE); 4269 } 4270 4271 zfs_close(zhp); 4272 return (0); 4273 } 4274 4275 /* 4276 * Given a dataset, rollback to a specific snapshot, discarding any 4277 * data changes since then and making it the active dataset. 4278 * 4279 * Any snapshots and bookmarks more recent than the target are 4280 * destroyed, along with their dependents (i.e. clones). 4281 */ 4282 int 4283 zfs_rollback(zfs_handle_t *zhp, zfs_handle_t *snap, boolean_t force) 4284 { 4285 rollback_data_t cb = { 0 }; 4286 int err; 4287 boolean_t restore_resv = 0; 4288 uint64_t old_volsize = 0, new_volsize; 4289 zfs_prop_t resv_prop = { 0 }; 4290 uint64_t min_txg = 0; 4291 4292 assert(zhp->zfs_type == ZFS_TYPE_FILESYSTEM || 4293 zhp->zfs_type == ZFS_TYPE_VOLUME); 4294 4295 /* 4296 * Destroy all recent snapshots and their dependents. 4297 */ 4298 cb.cb_force = force; 4299 cb.cb_target = snap->zfs_name; 4300 cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG); 4301 4302 if (cb.cb_create > 0) 4303 min_txg = cb.cb_create; 4304 4305 (void) zfs_iter_snapshots(zhp, B_FALSE, rollback_destroy, &cb, 4306 min_txg, 0); 4307 4308 (void) zfs_iter_bookmarks(zhp, rollback_destroy, &cb); 4309 4310 if (cb.cb_error) 4311 return (-1); 4312 4313 /* 4314 * Now that we have verified that the snapshot is the latest, 4315 * rollback to the given snapshot. 4316 */ 4317 4318 if (zhp->zfs_type == ZFS_TYPE_VOLUME) { 4319 if (zfs_which_resv_prop(zhp, &resv_prop) < 0) 4320 return (-1); 4321 old_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE); 4322 restore_resv = 4323 (old_volsize == zfs_prop_get_int(zhp, resv_prop)); 4324 } 4325 4326 /* 4327 * Pass both the filesystem and the wanted snapshot names, 4328 * we would get an error back if the snapshot is destroyed or 4329 * a new snapshot is created before this request is processed. 4330 */ 4331 err = lzc_rollback_to(zhp->zfs_name, snap->zfs_name); 4332 if (err != 0) { 4333 char errbuf[1024]; 4334 4335 (void) snprintf(errbuf, sizeof (errbuf), 4336 dgettext(TEXT_DOMAIN, "cannot rollback '%s'"), 4337 zhp->zfs_name); 4338 switch (err) { 4339 case EEXIST: 4340 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 4341 "there is a snapshot or bookmark more recent " 4342 "than '%s'"), snap->zfs_name); 4343 (void) zfs_error(zhp->zfs_hdl, EZFS_EXISTS, errbuf); 4344 break; 4345 case ESRCH: 4346 zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, 4347 "'%s' is not found among snapshots of '%s'"), 4348 snap->zfs_name, zhp->zfs_name); 4349 (void) zfs_error(zhp->zfs_hdl, EZFS_NOENT, errbuf); 4350 break; 4351 case EINVAL: 4352 (void) zfs_error(zhp->zfs_hdl, EZFS_BADTYPE, errbuf); 4353 break; 4354 default: 4355 (void) zfs_standard_error(zhp->zfs_hdl, err, errbuf); 4356 } 4357 return (err); 4358 } 4359 4360 /* 4361 * For volumes, if the pre-rollback volsize matched the pre- 4362 * rollback reservation and the volsize has changed then set 4363 * the reservation property to the post-rollback volsize. 4364 * Make a new handle since the rollback closed the dataset. 4365 */ 4366 if ((zhp->zfs_type == ZFS_TYPE_VOLUME) && 4367 (zhp = make_dataset_handle(zhp->zfs_hdl, zhp->zfs_name))) { 4368 if (restore_resv) { 4369 new_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE); 4370 if (old_volsize != new_volsize) 4371 err = zfs_prop_set_int(zhp, resv_prop, 4372 new_volsize); 4373 } 4374 zfs_close(zhp); 4375 } 4376 return (err); 4377 } 4378 4379 /* 4380 * Renames the given dataset. 4381 */ 4382 int 4383 zfs_rename(zfs_handle_t *zhp, const char *target, renameflags_t flags) 4384 { 4385 int ret = 0; 4386 zfs_cmd_t zc = {"\0"}; 4387 char *delim; 4388 prop_changelist_t *cl = NULL; 4389 char parent[ZFS_MAX_DATASET_NAME_LEN]; 4390 char property[ZFS_MAXPROPLEN]; 4391 libzfs_handle_t *hdl = zhp->zfs_hdl; 4392 char errbuf[1024]; 4393 4394 /* if we have the same exact name, just return success */ 4395 if (strcmp(zhp->zfs_name, target) == 0) 4396 return (0); 4397 4398 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 4399 "cannot rename to '%s'"), target); 4400 4401 /* make sure source name is valid */ 4402 if (!zfs_validate_name(hdl, zhp->zfs_name, zhp->zfs_type, B_TRUE)) 4403 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 4404 4405 /* 4406 * Make sure the target name is valid 4407 */ 4408 if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) { 4409 if ((strchr(target, '@') == NULL) || 4410 *target == '@') { 4411 /* 4412 * Snapshot target name is abbreviated, 4413 * reconstruct full dataset name 4414 */ 4415 (void) strlcpy(parent, zhp->zfs_name, 4416 sizeof (parent)); 4417 delim = strchr(parent, '@'); 4418 if (strchr(target, '@') == NULL) 4419 *(++delim) = '\0'; 4420 else 4421 *delim = '\0'; 4422 (void) strlcat(parent, target, sizeof (parent)); 4423 target = parent; 4424 } else { 4425 /* 4426 * Make sure we're renaming within the same dataset. 4427 */ 4428 delim = strchr(target, '@'); 4429 if (strncmp(zhp->zfs_name, target, delim - target) 4430 != 0 || zhp->zfs_name[delim - target] != '@') { 4431 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 4432 "snapshots must be part of same " 4433 "dataset")); 4434 return (zfs_error(hdl, EZFS_CROSSTARGET, 4435 errbuf)); 4436 } 4437 } 4438 4439 if (!zfs_validate_name(hdl, target, zhp->zfs_type, B_TRUE)) 4440 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 4441 } else { 4442 if (flags.recursive) { 4443 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 4444 "recursive rename must be a snapshot")); 4445 return (zfs_error(hdl, EZFS_BADTYPE, errbuf)); 4446 } 4447 4448 if (!zfs_validate_name(hdl, target, zhp->zfs_type, B_TRUE)) 4449 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 4450 4451 /* validate parents */ 4452 if (check_parents(hdl, target, NULL, B_FALSE, NULL) != 0) 4453 return (-1); 4454 4455 /* make sure we're in the same pool */ 4456 verify((delim = strchr(target, '/')) != NULL); 4457 if (strncmp(zhp->zfs_name, target, delim - target) != 0 || 4458 zhp->zfs_name[delim - target] != '/') { 4459 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 4460 "datasets must be within same pool")); 4461 return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf)); 4462 } 4463 4464 /* new name cannot be a child of the current dataset name */ 4465 if (is_descendant(zhp->zfs_name, target)) { 4466 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 4467 "New dataset name cannot be a descendant of " 4468 "current dataset name")); 4469 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 4470 } 4471 } 4472 4473 (void) snprintf(errbuf, sizeof (errbuf), 4474 dgettext(TEXT_DOMAIN, "cannot rename '%s'"), zhp->zfs_name); 4475 4476 if (getzoneid() == GLOBAL_ZONEID && 4477 zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) { 4478 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 4479 "dataset is used in a non-global zone")); 4480 return (zfs_error(hdl, EZFS_ZONED, errbuf)); 4481 } 4482 4483 /* 4484 * Avoid unmounting file systems with mountpoint property set to 4485 * 'legacy' or 'none' even if -u option is not given. 4486 */ 4487 if (zhp->zfs_type == ZFS_TYPE_FILESYSTEM && 4488 !flags.recursive && !flags.nounmount && 4489 zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, property, 4490 sizeof (property), NULL, NULL, 0, B_FALSE) == 0 && 4491 (strcmp(property, "legacy") == 0 || 4492 strcmp(property, "none") == 0)) { 4493 flags.nounmount = B_TRUE; 4494 } 4495 if (flags.recursive) { 4496 char *parentname = zfs_strdup(zhp->zfs_hdl, zhp->zfs_name); 4497 if (parentname == NULL) { 4498 ret = -1; 4499 goto error; 4500 } 4501 delim = strchr(parentname, '@'); 4502 *delim = '\0'; 4503 zfs_handle_t *zhrp = zfs_open(zhp->zfs_hdl, parentname, 4504 ZFS_TYPE_DATASET); 4505 free(parentname); 4506 if (zhrp == NULL) { 4507 ret = -1; 4508 goto error; 4509 } 4510 zfs_close(zhrp); 4511 } else if (zhp->zfs_type != ZFS_TYPE_SNAPSHOT) { 4512 if ((cl = changelist_gather(zhp, ZFS_PROP_NAME, 4513 flags.nounmount ? CL_GATHER_DONT_UNMOUNT : 4514 CL_GATHER_ITER_MOUNTED, 4515 flags.forceunmount ? MS_FORCE : 0)) == NULL) 4516 return (-1); 4517 4518 if (changelist_haszonedchild(cl)) { 4519 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 4520 "child dataset with inherited mountpoint is used " 4521 "in a non-global zone")); 4522 (void) zfs_error(hdl, EZFS_ZONED, errbuf); 4523 ret = -1; 4524 goto error; 4525 } 4526 4527 if ((ret = changelist_prefix(cl)) != 0) 4528 goto error; 4529 } 4530 4531 if (ZFS_IS_VOLUME(zhp)) 4532 zc.zc_objset_type = DMU_OST_ZVOL; 4533 else 4534 zc.zc_objset_type = DMU_OST_ZFS; 4535 4536 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 4537 (void) strlcpy(zc.zc_value, target, sizeof (zc.zc_value)); 4538 4539 zc.zc_cookie = !!flags.recursive; 4540 zc.zc_cookie |= (!!flags.nounmount) << 1; 4541 4542 if ((ret = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_RENAME, &zc)) != 0) { 4543 /* 4544 * if it was recursive, the one that actually failed will 4545 * be in zc.zc_name 4546 */ 4547 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 4548 "cannot rename '%s'"), zc.zc_name); 4549 4550 if (flags.recursive && errno == EEXIST) { 4551 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 4552 "a child dataset already has a snapshot " 4553 "with the new name")); 4554 (void) zfs_error(hdl, EZFS_EXISTS, errbuf); 4555 } else if (errno == EACCES) { 4556 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 4557 "cannot move encrypted child outside of " 4558 "its encryption root")); 4559 (void) zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf); 4560 } else { 4561 (void) zfs_standard_error(zhp->zfs_hdl, errno, errbuf); 4562 } 4563 4564 /* 4565 * On failure, we still want to remount any filesystems that 4566 * were previously mounted, so we don't alter the system state. 4567 */ 4568 if (cl != NULL) 4569 (void) changelist_postfix(cl); 4570 } else { 4571 if (cl != NULL) { 4572 changelist_rename(cl, zfs_get_name(zhp), target); 4573 ret = changelist_postfix(cl); 4574 } 4575 } 4576 4577 error: 4578 if (cl != NULL) { 4579 changelist_free(cl); 4580 } 4581 return (ret); 4582 } 4583 4584 nvlist_t * 4585 zfs_get_all_props(zfs_handle_t *zhp) 4586 { 4587 return (zhp->zfs_props); 4588 } 4589 4590 nvlist_t * 4591 zfs_get_recvd_props(zfs_handle_t *zhp) 4592 { 4593 if (zhp->zfs_recvd_props == NULL) 4594 if (get_recvd_props_ioctl(zhp) != 0) 4595 return (NULL); 4596 return (zhp->zfs_recvd_props); 4597 } 4598 4599 nvlist_t * 4600 zfs_get_user_props(zfs_handle_t *zhp) 4601 { 4602 return (zhp->zfs_user_props); 4603 } 4604 4605 /* 4606 * This function is used by 'zfs list' to determine the exact set of columns to 4607 * display, and their maximum widths. This does two main things: 4608 * 4609 * - If this is a list of all properties, then expand the list to include 4610 * all native properties, and set a flag so that for each dataset we look 4611 * for new unique user properties and add them to the list. 4612 * 4613 * - For non fixed-width properties, keep track of the maximum width seen 4614 * so that we can size the column appropriately. If the user has 4615 * requested received property values, we also need to compute the width 4616 * of the RECEIVED column. 4617 */ 4618 int 4619 zfs_expand_proplist(zfs_handle_t *zhp, zprop_list_t **plp, boolean_t received, 4620 boolean_t literal) 4621 { 4622 libzfs_handle_t *hdl = zhp->zfs_hdl; 4623 zprop_list_t *entry; 4624 zprop_list_t **last, **start; 4625 nvlist_t *userprops, *propval; 4626 nvpair_t *elem; 4627 char *strval; 4628 char buf[ZFS_MAXPROPLEN]; 4629 4630 if (zprop_expand_list(hdl, plp, ZFS_TYPE_DATASET) != 0) 4631 return (-1); 4632 4633 userprops = zfs_get_user_props(zhp); 4634 4635 entry = *plp; 4636 if (entry->pl_all && nvlist_next_nvpair(userprops, NULL) != NULL) { 4637 /* 4638 * Go through and add any user properties as necessary. We 4639 * start by incrementing our list pointer to the first 4640 * non-native property. 4641 */ 4642 start = plp; 4643 while (*start != NULL) { 4644 if ((*start)->pl_prop == ZPROP_INVAL) 4645 break; 4646 start = &(*start)->pl_next; 4647 } 4648 4649 elem = NULL; 4650 while ((elem = nvlist_next_nvpair(userprops, elem)) != NULL) { 4651 /* 4652 * See if we've already found this property in our list. 4653 */ 4654 for (last = start; *last != NULL; 4655 last = &(*last)->pl_next) { 4656 if (strcmp((*last)->pl_user_prop, 4657 nvpair_name(elem)) == 0) 4658 break; 4659 } 4660 4661 if (*last == NULL) { 4662 if ((entry = zfs_alloc(hdl, 4663 sizeof (zprop_list_t))) == NULL || 4664 ((entry->pl_user_prop = zfs_strdup(hdl, 4665 nvpair_name(elem)))) == NULL) { 4666 free(entry); 4667 return (-1); 4668 } 4669 4670 entry->pl_prop = ZPROP_INVAL; 4671 entry->pl_width = strlen(nvpair_name(elem)); 4672 entry->pl_all = B_TRUE; 4673 *last = entry; 4674 } 4675 } 4676 } 4677 4678 /* 4679 * Now go through and check the width of any non-fixed columns 4680 */ 4681 for (entry = *plp; entry != NULL; entry = entry->pl_next) { 4682 if (entry->pl_fixed && !literal) 4683 continue; 4684 4685 if (entry->pl_prop != ZPROP_INVAL) { 4686 if (zfs_prop_get(zhp, entry->pl_prop, 4687 buf, sizeof (buf), NULL, NULL, 0, literal) == 0) { 4688 if (strlen(buf) > entry->pl_width) 4689 entry->pl_width = strlen(buf); 4690 } 4691 if (received && zfs_prop_get_recvd(zhp, 4692 zfs_prop_to_name(entry->pl_prop), 4693 buf, sizeof (buf), literal) == 0) 4694 if (strlen(buf) > entry->pl_recvd_width) 4695 entry->pl_recvd_width = strlen(buf); 4696 } else { 4697 if (nvlist_lookup_nvlist(userprops, entry->pl_user_prop, 4698 &propval) == 0) { 4699 verify(nvlist_lookup_string(propval, 4700 ZPROP_VALUE, &strval) == 0); 4701 if (strlen(strval) > entry->pl_width) 4702 entry->pl_width = strlen(strval); 4703 } 4704 if (received && zfs_prop_get_recvd(zhp, 4705 entry->pl_user_prop, 4706 buf, sizeof (buf), literal) == 0) 4707 if (strlen(buf) > entry->pl_recvd_width) 4708 entry->pl_recvd_width = strlen(buf); 4709 } 4710 } 4711 4712 return (0); 4713 } 4714 4715 void 4716 zfs_prune_proplist(zfs_handle_t *zhp, uint8_t *props) 4717 { 4718 nvpair_t *curr; 4719 nvpair_t *next; 4720 4721 /* 4722 * Keep a reference to the props-table against which we prune the 4723 * properties. 4724 */ 4725 zhp->zfs_props_table = props; 4726 4727 curr = nvlist_next_nvpair(zhp->zfs_props, NULL); 4728 4729 while (curr) { 4730 zfs_prop_t zfs_prop = zfs_name_to_prop(nvpair_name(curr)); 4731 next = nvlist_next_nvpair(zhp->zfs_props, curr); 4732 4733 /* 4734 * User properties will result in ZPROP_INVAL, and since we 4735 * only know how to prune standard ZFS properties, we always 4736 * leave these in the list. This can also happen if we 4737 * encounter an unknown DSL property (when running older 4738 * software, for example). 4739 */ 4740 if (zfs_prop != ZPROP_INVAL && props[zfs_prop] == B_FALSE) 4741 (void) nvlist_remove(zhp->zfs_props, 4742 nvpair_name(curr), nvpair_type(curr)); 4743 curr = next; 4744 } 4745 } 4746 4747 static int 4748 zfs_smb_acl_mgmt(libzfs_handle_t *hdl, char *dataset, char *path, 4749 zfs_smb_acl_op_t cmd, char *resource1, char *resource2) 4750 { 4751 zfs_cmd_t zc = {"\0"}; 4752 nvlist_t *nvlist = NULL; 4753 int error; 4754 4755 (void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name)); 4756 (void) strlcpy(zc.zc_value, path, sizeof (zc.zc_value)); 4757 zc.zc_cookie = (uint64_t)cmd; 4758 4759 if (cmd == ZFS_SMB_ACL_RENAME) { 4760 if (nvlist_alloc(&nvlist, NV_UNIQUE_NAME, 0) != 0) { 4761 (void) no_memory(hdl); 4762 return (0); 4763 } 4764 } 4765 4766 switch (cmd) { 4767 case ZFS_SMB_ACL_ADD: 4768 case ZFS_SMB_ACL_REMOVE: 4769 (void) strlcpy(zc.zc_string, resource1, sizeof (zc.zc_string)); 4770 break; 4771 case ZFS_SMB_ACL_RENAME: 4772 if (nvlist_add_string(nvlist, ZFS_SMB_ACL_SRC, 4773 resource1) != 0) { 4774 (void) no_memory(hdl); 4775 return (-1); 4776 } 4777 if (nvlist_add_string(nvlist, ZFS_SMB_ACL_TARGET, 4778 resource2) != 0) { 4779 (void) no_memory(hdl); 4780 return (-1); 4781 } 4782 if (zcmd_write_src_nvlist(hdl, &zc, nvlist) != 0) { 4783 nvlist_free(nvlist); 4784 return (-1); 4785 } 4786 break; 4787 case ZFS_SMB_ACL_PURGE: 4788 break; 4789 default: 4790 return (-1); 4791 } 4792 error = ioctl(hdl->libzfs_fd, ZFS_IOC_SMB_ACL, &zc); 4793 nvlist_free(nvlist); 4794 return (error); 4795 } 4796 4797 int 4798 zfs_smb_acl_add(libzfs_handle_t *hdl, char *dataset, 4799 char *path, char *resource) 4800 { 4801 return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_ADD, 4802 resource, NULL)); 4803 } 4804 4805 int 4806 zfs_smb_acl_remove(libzfs_handle_t *hdl, char *dataset, 4807 char *path, char *resource) 4808 { 4809 return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_REMOVE, 4810 resource, NULL)); 4811 } 4812 4813 int 4814 zfs_smb_acl_purge(libzfs_handle_t *hdl, char *dataset, char *path) 4815 { 4816 return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_PURGE, 4817 NULL, NULL)); 4818 } 4819 4820 int 4821 zfs_smb_acl_rename(libzfs_handle_t *hdl, char *dataset, char *path, 4822 char *oldname, char *newname) 4823 { 4824 return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_RENAME, 4825 oldname, newname)); 4826 } 4827 4828 int 4829 zfs_userspace(zfs_handle_t *zhp, zfs_userquota_prop_t type, 4830 zfs_userspace_cb_t func, void *arg) 4831 { 4832 zfs_cmd_t zc = {"\0"}; 4833 zfs_useracct_t buf[100]; 4834 libzfs_handle_t *hdl = zhp->zfs_hdl; 4835 int ret; 4836 4837 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 4838 4839 zc.zc_objset_type = type; 4840 zc.zc_nvlist_dst = (uintptr_t)buf; 4841 4842 for (;;) { 4843 zfs_useracct_t *zua = buf; 4844 4845 zc.zc_nvlist_dst_size = sizeof (buf); 4846 if (zfs_ioctl(hdl, ZFS_IOC_USERSPACE_MANY, &zc) != 0) { 4847 if ((errno == ENOTSUP && 4848 (type == ZFS_PROP_USEROBJUSED || 4849 type == ZFS_PROP_GROUPOBJUSED || 4850 type == ZFS_PROP_USEROBJQUOTA || 4851 type == ZFS_PROP_GROUPOBJQUOTA || 4852 type == ZFS_PROP_PROJECTOBJUSED || 4853 type == ZFS_PROP_PROJECTOBJQUOTA || 4854 type == ZFS_PROP_PROJECTUSED || 4855 type == ZFS_PROP_PROJECTQUOTA))) 4856 break; 4857 4858 return (zfs_standard_error_fmt(hdl, errno, 4859 dgettext(TEXT_DOMAIN, 4860 "cannot get used/quota for %s"), zc.zc_name)); 4861 } 4862 if (zc.zc_nvlist_dst_size == 0) 4863 break; 4864 4865 while (zc.zc_nvlist_dst_size > 0) { 4866 if ((ret = func(arg, zua->zu_domain, zua->zu_rid, 4867 zua->zu_space)) != 0) 4868 return (ret); 4869 zua++; 4870 zc.zc_nvlist_dst_size -= sizeof (zfs_useracct_t); 4871 } 4872 } 4873 4874 return (0); 4875 } 4876 4877 struct holdarg { 4878 nvlist_t *nvl; 4879 const char *snapname; 4880 const char *tag; 4881 boolean_t recursive; 4882 int error; 4883 }; 4884 4885 static int 4886 zfs_hold_one(zfs_handle_t *zhp, void *arg) 4887 { 4888 struct holdarg *ha = arg; 4889 char name[ZFS_MAX_DATASET_NAME_LEN]; 4890 int rv = 0; 4891 4892 if (snprintf(name, sizeof (name), "%s@%s", zhp->zfs_name, 4893 ha->snapname) >= sizeof (name)) 4894 return (EINVAL); 4895 4896 if (lzc_exists(name)) 4897 fnvlist_add_string(ha->nvl, name, ha->tag); 4898 4899 if (ha->recursive) 4900 rv = zfs_iter_filesystems(zhp, zfs_hold_one, ha); 4901 zfs_close(zhp); 4902 return (rv); 4903 } 4904 4905 int 4906 zfs_hold(zfs_handle_t *zhp, const char *snapname, const char *tag, 4907 boolean_t recursive, int cleanup_fd) 4908 { 4909 int ret; 4910 struct holdarg ha; 4911 4912 ha.nvl = fnvlist_alloc(); 4913 ha.snapname = snapname; 4914 ha.tag = tag; 4915 ha.recursive = recursive; 4916 (void) zfs_hold_one(zfs_handle_dup(zhp), &ha); 4917 4918 if (nvlist_empty(ha.nvl)) { 4919 char errbuf[1024]; 4920 4921 fnvlist_free(ha.nvl); 4922 ret = ENOENT; 4923 (void) snprintf(errbuf, sizeof (errbuf), 4924 dgettext(TEXT_DOMAIN, 4925 "cannot hold snapshot '%s@%s'"), 4926 zhp->zfs_name, snapname); 4927 (void) zfs_standard_error(zhp->zfs_hdl, ret, errbuf); 4928 return (ret); 4929 } 4930 4931 ret = zfs_hold_nvl(zhp, cleanup_fd, ha.nvl); 4932 fnvlist_free(ha.nvl); 4933 4934 return (ret); 4935 } 4936 4937 int 4938 zfs_hold_nvl(zfs_handle_t *zhp, int cleanup_fd, nvlist_t *holds) 4939 { 4940 int ret; 4941 nvlist_t *errors; 4942 libzfs_handle_t *hdl = zhp->zfs_hdl; 4943 char errbuf[1024]; 4944 nvpair_t *elem; 4945 4946 errors = NULL; 4947 ret = lzc_hold(holds, cleanup_fd, &errors); 4948 4949 if (ret == 0) { 4950 /* There may be errors even in the success case. */ 4951 fnvlist_free(errors); 4952 return (0); 4953 } 4954 4955 if (nvlist_empty(errors)) { 4956 /* no hold-specific errors */ 4957 (void) snprintf(errbuf, sizeof (errbuf), 4958 dgettext(TEXT_DOMAIN, "cannot hold")); 4959 switch (ret) { 4960 case ENOTSUP: 4961 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 4962 "pool must be upgraded")); 4963 (void) zfs_error(hdl, EZFS_BADVERSION, errbuf); 4964 break; 4965 case EINVAL: 4966 (void) zfs_error(hdl, EZFS_BADTYPE, errbuf); 4967 break; 4968 default: 4969 (void) zfs_standard_error(hdl, ret, errbuf); 4970 } 4971 } 4972 4973 for (elem = nvlist_next_nvpair(errors, NULL); 4974 elem != NULL; 4975 elem = nvlist_next_nvpair(errors, elem)) { 4976 (void) snprintf(errbuf, sizeof (errbuf), 4977 dgettext(TEXT_DOMAIN, 4978 "cannot hold snapshot '%s'"), nvpair_name(elem)); 4979 switch (fnvpair_value_int32(elem)) { 4980 case E2BIG: 4981 /* 4982 * Temporary tags wind up having the ds object id 4983 * prepended. So even if we passed the length check 4984 * above, it's still possible for the tag to wind 4985 * up being slightly too long. 4986 */ 4987 (void) zfs_error(hdl, EZFS_TAGTOOLONG, errbuf); 4988 break; 4989 case EINVAL: 4990 (void) zfs_error(hdl, EZFS_BADTYPE, errbuf); 4991 break; 4992 case EEXIST: 4993 (void) zfs_error(hdl, EZFS_REFTAG_HOLD, errbuf); 4994 break; 4995 default: 4996 (void) zfs_standard_error(hdl, 4997 fnvpair_value_int32(elem), errbuf); 4998 } 4999 } 5000 5001 fnvlist_free(errors); 5002 return (ret); 5003 } 5004 5005 static int 5006 zfs_release_one(zfs_handle_t *zhp, void *arg) 5007 { 5008 struct holdarg *ha = arg; 5009 char name[ZFS_MAX_DATASET_NAME_LEN]; 5010 int rv = 0; 5011 nvlist_t *existing_holds; 5012 5013 if (snprintf(name, sizeof (name), "%s@%s", zhp->zfs_name, 5014 ha->snapname) >= sizeof (name)) { 5015 ha->error = EINVAL; 5016 rv = EINVAL; 5017 } 5018 5019 if (lzc_get_holds(name, &existing_holds) != 0) { 5020 ha->error = ENOENT; 5021 } else if (!nvlist_exists(existing_holds, ha->tag)) { 5022 ha->error = ESRCH; 5023 } else { 5024 nvlist_t *torelease = fnvlist_alloc(); 5025 fnvlist_add_boolean(torelease, ha->tag); 5026 fnvlist_add_nvlist(ha->nvl, name, torelease); 5027 fnvlist_free(torelease); 5028 } 5029 5030 if (ha->recursive) 5031 rv = zfs_iter_filesystems(zhp, zfs_release_one, ha); 5032 zfs_close(zhp); 5033 return (rv); 5034 } 5035 5036 int 5037 zfs_release(zfs_handle_t *zhp, const char *snapname, const char *tag, 5038 boolean_t recursive) 5039 { 5040 int ret; 5041 struct holdarg ha; 5042 nvlist_t *errors = NULL; 5043 nvpair_t *elem; 5044 libzfs_handle_t *hdl = zhp->zfs_hdl; 5045 char errbuf[1024]; 5046 5047 ha.nvl = fnvlist_alloc(); 5048 ha.snapname = snapname; 5049 ha.tag = tag; 5050 ha.recursive = recursive; 5051 ha.error = 0; 5052 (void) zfs_release_one(zfs_handle_dup(zhp), &ha); 5053 5054 if (nvlist_empty(ha.nvl)) { 5055 fnvlist_free(ha.nvl); 5056 ret = ha.error; 5057 (void) snprintf(errbuf, sizeof (errbuf), 5058 dgettext(TEXT_DOMAIN, 5059 "cannot release hold from snapshot '%s@%s'"), 5060 zhp->zfs_name, snapname); 5061 if (ret == ESRCH) { 5062 (void) zfs_error(hdl, EZFS_REFTAG_RELE, errbuf); 5063 } else { 5064 (void) zfs_standard_error(hdl, ret, errbuf); 5065 } 5066 return (ret); 5067 } 5068 5069 ret = lzc_release(ha.nvl, &errors); 5070 fnvlist_free(ha.nvl); 5071 5072 if (ret == 0) { 5073 /* There may be errors even in the success case. */ 5074 fnvlist_free(errors); 5075 return (0); 5076 } 5077 5078 if (nvlist_empty(errors)) { 5079 /* no hold-specific errors */ 5080 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 5081 "cannot release")); 5082 switch (errno) { 5083 case ENOTSUP: 5084 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 5085 "pool must be upgraded")); 5086 (void) zfs_error(hdl, EZFS_BADVERSION, errbuf); 5087 break; 5088 default: 5089 (void) zfs_standard_error(hdl, errno, errbuf); 5090 } 5091 } 5092 5093 for (elem = nvlist_next_nvpair(errors, NULL); 5094 elem != NULL; 5095 elem = nvlist_next_nvpair(errors, elem)) { 5096 (void) snprintf(errbuf, sizeof (errbuf), 5097 dgettext(TEXT_DOMAIN, 5098 "cannot release hold from snapshot '%s'"), 5099 nvpair_name(elem)); 5100 switch (fnvpair_value_int32(elem)) { 5101 case ESRCH: 5102 (void) zfs_error(hdl, EZFS_REFTAG_RELE, errbuf); 5103 break; 5104 case EINVAL: 5105 (void) zfs_error(hdl, EZFS_BADTYPE, errbuf); 5106 break; 5107 default: 5108 (void) zfs_standard_error(hdl, 5109 fnvpair_value_int32(elem), errbuf); 5110 } 5111 } 5112 5113 fnvlist_free(errors); 5114 return (ret); 5115 } 5116 5117 int 5118 zfs_get_fsacl(zfs_handle_t *zhp, nvlist_t **nvl) 5119 { 5120 zfs_cmd_t zc = {"\0"}; 5121 libzfs_handle_t *hdl = zhp->zfs_hdl; 5122 int nvsz = 2048; 5123 void *nvbuf; 5124 int err = 0; 5125 char errbuf[1024]; 5126 5127 assert(zhp->zfs_type == ZFS_TYPE_VOLUME || 5128 zhp->zfs_type == ZFS_TYPE_FILESYSTEM); 5129 5130 tryagain: 5131 5132 nvbuf = malloc(nvsz); 5133 if (nvbuf == NULL) { 5134 err = (zfs_error(hdl, EZFS_NOMEM, strerror(errno))); 5135 goto out; 5136 } 5137 5138 zc.zc_nvlist_dst_size = nvsz; 5139 zc.zc_nvlist_dst = (uintptr_t)nvbuf; 5140 5141 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 5142 5143 if (zfs_ioctl(hdl, ZFS_IOC_GET_FSACL, &zc) != 0) { 5144 (void) snprintf(errbuf, sizeof (errbuf), 5145 dgettext(TEXT_DOMAIN, "cannot get permissions on '%s'"), 5146 zc.zc_name); 5147 switch (errno) { 5148 case ENOMEM: 5149 free(nvbuf); 5150 nvsz = zc.zc_nvlist_dst_size; 5151 goto tryagain; 5152 5153 case ENOTSUP: 5154 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 5155 "pool must be upgraded")); 5156 err = zfs_error(hdl, EZFS_BADVERSION, errbuf); 5157 break; 5158 case EINVAL: 5159 err = zfs_error(hdl, EZFS_BADTYPE, errbuf); 5160 break; 5161 case ENOENT: 5162 err = zfs_error(hdl, EZFS_NOENT, errbuf); 5163 break; 5164 default: 5165 err = zfs_standard_error(hdl, errno, errbuf); 5166 break; 5167 } 5168 } else { 5169 /* success */ 5170 int rc = nvlist_unpack(nvbuf, zc.zc_nvlist_dst_size, nvl, 0); 5171 if (rc) { 5172 err = zfs_standard_error_fmt(hdl, rc, dgettext( 5173 TEXT_DOMAIN, "cannot get permissions on '%s'"), 5174 zc.zc_name); 5175 } 5176 } 5177 5178 free(nvbuf); 5179 out: 5180 return (err); 5181 } 5182 5183 int 5184 zfs_set_fsacl(zfs_handle_t *zhp, boolean_t un, nvlist_t *nvl) 5185 { 5186 zfs_cmd_t zc = {"\0"}; 5187 libzfs_handle_t *hdl = zhp->zfs_hdl; 5188 char *nvbuf; 5189 char errbuf[1024]; 5190 size_t nvsz; 5191 int err; 5192 5193 assert(zhp->zfs_type == ZFS_TYPE_VOLUME || 5194 zhp->zfs_type == ZFS_TYPE_FILESYSTEM); 5195 5196 err = nvlist_size(nvl, &nvsz, NV_ENCODE_NATIVE); 5197 assert(err == 0); 5198 5199 nvbuf = malloc(nvsz); 5200 5201 err = nvlist_pack(nvl, &nvbuf, &nvsz, NV_ENCODE_NATIVE, 0); 5202 assert(err == 0); 5203 5204 zc.zc_nvlist_src_size = nvsz; 5205 zc.zc_nvlist_src = (uintptr_t)nvbuf; 5206 zc.zc_perm_action = un; 5207 5208 (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name)); 5209 5210 if (zfs_ioctl(hdl, ZFS_IOC_SET_FSACL, &zc) != 0) { 5211 (void) snprintf(errbuf, sizeof (errbuf), 5212 dgettext(TEXT_DOMAIN, "cannot set permissions on '%s'"), 5213 zc.zc_name); 5214 switch (errno) { 5215 case ENOTSUP: 5216 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 5217 "pool must be upgraded")); 5218 err = zfs_error(hdl, EZFS_BADVERSION, errbuf); 5219 break; 5220 case EINVAL: 5221 err = zfs_error(hdl, EZFS_BADTYPE, errbuf); 5222 break; 5223 case ENOENT: 5224 err = zfs_error(hdl, EZFS_NOENT, errbuf); 5225 break; 5226 default: 5227 err = zfs_standard_error(hdl, errno, errbuf); 5228 break; 5229 } 5230 } 5231 5232 free(nvbuf); 5233 5234 return (err); 5235 } 5236 5237 int 5238 zfs_get_holds(zfs_handle_t *zhp, nvlist_t **nvl) 5239 { 5240 int err; 5241 char errbuf[1024]; 5242 5243 err = lzc_get_holds(zhp->zfs_name, nvl); 5244 5245 if (err != 0) { 5246 libzfs_handle_t *hdl = zhp->zfs_hdl; 5247 5248 (void) snprintf(errbuf, sizeof (errbuf), 5249 dgettext(TEXT_DOMAIN, "cannot get holds for '%s'"), 5250 zhp->zfs_name); 5251 switch (err) { 5252 case ENOTSUP: 5253 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 5254 "pool must be upgraded")); 5255 err = zfs_error(hdl, EZFS_BADVERSION, errbuf); 5256 break; 5257 case EINVAL: 5258 err = zfs_error(hdl, EZFS_BADTYPE, errbuf); 5259 break; 5260 case ENOENT: 5261 err = zfs_error(hdl, EZFS_NOENT, errbuf); 5262 break; 5263 default: 5264 err = zfs_standard_error(hdl, errno, errbuf); 5265 break; 5266 } 5267 } 5268 5269 return (err); 5270 } 5271 5272 /* 5273 * The theory of raidz space accounting 5274 * 5275 * The "referenced" property of RAIDZ vdevs is scaled such that a 128KB block 5276 * will "reference" 128KB, even though it allocates more than that, to store the 5277 * parity information (and perhaps skip sectors). This concept of the 5278 * "referenced" (and other DMU space accounting) being lower than the allocated 5279 * space by a constant factor is called "raidz deflation." 5280 * 5281 * As mentioned above, the constant factor for raidz deflation assumes a 128KB 5282 * block size. However, zvols typically have a much smaller block size (default 5283 * 8KB). These smaller blocks may require proportionally much more parity 5284 * information (and perhaps skip sectors). In this case, the change to the 5285 * "referenced" property may be much more than the logical block size. 5286 * 5287 * Suppose a raidz vdev has 5 disks with ashift=12. A 128k block may be written 5288 * as follows. 5289 * 5290 * +-------+-------+-------+-------+-------+ 5291 * | disk1 | disk2 | disk3 | disk4 | disk5 | 5292 * +-------+-------+-------+-------+-------+ 5293 * | P0 | D0 | D8 | D16 | D24 | 5294 * | P1 | D1 | D9 | D17 | D25 | 5295 * | P2 | D2 | D10 | D18 | D26 | 5296 * | P3 | D3 | D11 | D19 | D27 | 5297 * | P4 | D4 | D12 | D20 | D28 | 5298 * | P5 | D5 | D13 | D21 | D29 | 5299 * | P6 | D6 | D14 | D22 | D30 | 5300 * | P7 | D7 | D15 | D23 | D31 | 5301 * +-------+-------+-------+-------+-------+ 5302 * 5303 * Above, notice that 160k was allocated: 8 x 4k parity sectors + 32 x 4k data 5304 * sectors. The dataset's referenced will increase by 128k and the pool's 5305 * allocated and free properties will be adjusted by 160k. 5306 * 5307 * A 4k block written to the same raidz vdev will require two 4k sectors. The 5308 * blank cells represent unallocated space. 5309 * 5310 * +-------+-------+-------+-------+-------+ 5311 * | disk1 | disk2 | disk3 | disk4 | disk5 | 5312 * +-------+-------+-------+-------+-------+ 5313 * | P0 | D0 | | | | 5314 * +-------+-------+-------+-------+-------+ 5315 * 5316 * Above, notice that the 4k block required one sector for parity and another 5317 * for data. vdev_raidz_asize() will return 8k and as such the pool's allocated 5318 * and free properties will be adjusted by 8k. The dataset will not be charged 5319 * 8k. Rather, it will be charged a value that is scaled according to the 5320 * overhead of the 128k block on the same vdev. This 8k allocation will be 5321 * charged 8k * 128k / 160k. 128k is from SPA_OLD_MAXBLOCKSIZE and 160k is as 5322 * calculated in the 128k block example above. 5323 * 5324 * Every raidz allocation is sized to be a multiple of nparity+1 sectors. That 5325 * is, every raidz1 allocation will be a multiple of 2 sectors, raidz2 5326 * allocations are a multiple of 3 sectors, and raidz3 allocations are a 5327 * multiple of of 4 sectors. When a block does not fill the required number of 5328 * sectors, skip blocks (sectors) are used. 5329 * 5330 * An 8k block being written to a raidz vdev may be written as follows: 5331 * 5332 * +-------+-------+-------+-------+-------+ 5333 * | disk1 | disk2 | disk3 | disk4 | disk5 | 5334 * +-------+-------+-------+-------+-------+ 5335 * | P0 | D0 | D1 | S0 | | 5336 * +-------+-------+-------+-------+-------+ 5337 * 5338 * In order to maintain the nparity+1 allocation size, a skip block (S0) was 5339 * added. For this 8k block, the pool's allocated and free properties are 5340 * adjusted by 16k and the dataset's referenced is increased by 16k * 128k / 5341 * 160k. Again, 128k is from SPA_OLD_MAXBLOCKSIZE and 160k is as calculated in 5342 * the 128k block example above. 5343 * 5344 * The situation is slightly different for dRAID since the minimum allocation 5345 * size is the full group width. The same 8K block above would be written as 5346 * follows in a dRAID group: 5347 * 5348 * +-------+-------+-------+-------+-------+ 5349 * | disk1 | disk2 | disk3 | disk4 | disk5 | 5350 * +-------+-------+-------+-------+-------+ 5351 * | P0 | D0 | D1 | S0 | S1 | 5352 * +-------+-------+-------+-------+-------+ 5353 * 5354 * Compression may lead to a variety of block sizes being written for the same 5355 * volume or file. There is no clear way to reserve just the amount of space 5356 * that will be required, so the worst case (no compression) is assumed. 5357 * Note that metadata blocks will typically be compressed, so the reservation 5358 * size returned by zvol_volsize_to_reservation() will generally be slightly 5359 * larger than the maximum that the volume can reference. 5360 */ 5361 5362 /* 5363 * Derived from function of same name in module/zfs/vdev_raidz.c. Returns the 5364 * amount of space (in bytes) that will be allocated for the specified block 5365 * size. Note that the "referenced" space accounted will be less than this, but 5366 * not necessarily equal to "blksize", due to RAIDZ deflation. 5367 */ 5368 static uint64_t 5369 vdev_raidz_asize(uint64_t ndisks, uint64_t nparity, uint64_t ashift, 5370 uint64_t blksize) 5371 { 5372 uint64_t asize, ndata; 5373 5374 ASSERT3U(ndisks, >, nparity); 5375 ndata = ndisks - nparity; 5376 asize = ((blksize - 1) >> ashift) + 1; 5377 asize += nparity * ((asize + ndata - 1) / ndata); 5378 asize = roundup(asize, nparity + 1) << ashift; 5379 5380 return (asize); 5381 } 5382 5383 /* 5384 * Derived from function of same name in module/zfs/vdev_draid.c. Returns the 5385 * amount of space (in bytes) that will be allocated for the specified block 5386 * size. 5387 */ 5388 static uint64_t 5389 vdev_draid_asize(uint64_t ndisks, uint64_t nparity, uint64_t ashift, 5390 uint64_t blksize) 5391 { 5392 ASSERT3U(ndisks, >, nparity); 5393 uint64_t ndata = ndisks - nparity; 5394 uint64_t rows = ((blksize - 1) / (ndata << ashift)) + 1; 5395 uint64_t asize = (rows * ndisks) << ashift; 5396 5397 return (asize); 5398 } 5399 5400 /* 5401 * Determine how much space will be allocated if it lands on the most space- 5402 * inefficient top-level vdev. Returns the size in bytes required to store one 5403 * copy of the volume data. See theory comment above. 5404 */ 5405 static uint64_t 5406 volsize_from_vdevs(zpool_handle_t *zhp, uint64_t nblocks, uint64_t blksize) 5407 { 5408 nvlist_t *config, *tree, **vdevs; 5409 uint_t nvdevs; 5410 uint64_t ret = 0; 5411 5412 config = zpool_get_config(zhp, NULL); 5413 if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &tree) != 0 || 5414 nvlist_lookup_nvlist_array(tree, ZPOOL_CONFIG_CHILDREN, 5415 &vdevs, &nvdevs) != 0) { 5416 return (nblocks * blksize); 5417 } 5418 5419 for (int v = 0; v < nvdevs; v++) { 5420 char *type; 5421 uint64_t nparity, ashift, asize, tsize; 5422 uint64_t volsize; 5423 5424 if (nvlist_lookup_string(vdevs[v], ZPOOL_CONFIG_TYPE, 5425 &type) != 0) 5426 continue; 5427 5428 if (strcmp(type, VDEV_TYPE_RAIDZ) != 0 && 5429 strcmp(type, VDEV_TYPE_DRAID) != 0) 5430 continue; 5431 5432 if (nvlist_lookup_uint64(vdevs[v], 5433 ZPOOL_CONFIG_NPARITY, &nparity) != 0) 5434 continue; 5435 5436 if (nvlist_lookup_uint64(vdevs[v], 5437 ZPOOL_CONFIG_ASHIFT, &ashift) != 0) 5438 continue; 5439 5440 if (strcmp(type, VDEV_TYPE_RAIDZ) == 0) { 5441 nvlist_t **disks; 5442 uint_t ndisks; 5443 5444 if (nvlist_lookup_nvlist_array(vdevs[v], 5445 ZPOOL_CONFIG_CHILDREN, &disks, &ndisks) != 0) 5446 continue; 5447 5448 /* allocation size for the "typical" 128k block */ 5449 tsize = vdev_raidz_asize(ndisks, nparity, ashift, 5450 SPA_OLD_MAXBLOCKSIZE); 5451 5452 /* allocation size for the blksize block */ 5453 asize = vdev_raidz_asize(ndisks, nparity, ashift, 5454 blksize); 5455 } else { 5456 uint64_t ndata; 5457 5458 if (nvlist_lookup_uint64(vdevs[v], 5459 ZPOOL_CONFIG_DRAID_NDATA, &ndata) != 0) 5460 continue; 5461 5462 /* allocation size for the "typical" 128k block */ 5463 tsize = vdev_draid_asize(ndata + nparity, nparity, 5464 ashift, SPA_OLD_MAXBLOCKSIZE); 5465 5466 /* allocation size for the blksize block */ 5467 asize = vdev_draid_asize(ndata + nparity, nparity, 5468 ashift, blksize); 5469 } 5470 5471 /* 5472 * Scale this size down as a ratio of 128k / tsize. 5473 * See theory statement above. 5474 */ 5475 volsize = nblocks * asize * SPA_OLD_MAXBLOCKSIZE / tsize; 5476 if (volsize > ret) { 5477 ret = volsize; 5478 } 5479 } 5480 5481 if (ret == 0) { 5482 ret = nblocks * blksize; 5483 } 5484 5485 return (ret); 5486 } 5487 5488 /* 5489 * Convert the zvol's volume size to an appropriate reservation. See theory 5490 * comment above. 5491 * 5492 * Note: If this routine is updated, it is necessary to update the ZFS test 5493 * suite's shell version in reservation.shlib. 5494 */ 5495 uint64_t 5496 zvol_volsize_to_reservation(zpool_handle_t *zph, uint64_t volsize, 5497 nvlist_t *props) 5498 { 5499 uint64_t numdb; 5500 uint64_t nblocks, volblocksize; 5501 int ncopies; 5502 char *strval; 5503 5504 if (nvlist_lookup_string(props, 5505 zfs_prop_to_name(ZFS_PROP_COPIES), &strval) == 0) 5506 ncopies = atoi(strval); 5507 else 5508 ncopies = 1; 5509 if (nvlist_lookup_uint64(props, 5510 zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE), 5511 &volblocksize) != 0) 5512 volblocksize = ZVOL_DEFAULT_BLOCKSIZE; 5513 5514 nblocks = volsize / volblocksize; 5515 /* 5516 * Metadata defaults to using 128k blocks, not volblocksize blocks. For 5517 * this reason, only the data blocks are scaled based on vdev config. 5518 */ 5519 volsize = volsize_from_vdevs(zph, nblocks, volblocksize); 5520 5521 /* start with metadnode L0-L6 */ 5522 numdb = 7; 5523 /* calculate number of indirects */ 5524 while (nblocks > 1) { 5525 nblocks += DNODES_PER_LEVEL - 1; 5526 nblocks /= DNODES_PER_LEVEL; 5527 numdb += nblocks; 5528 } 5529 numdb *= MIN(SPA_DVAS_PER_BP, ncopies + 1); 5530 volsize *= ncopies; 5531 /* 5532 * this is exactly DN_MAX_INDBLKSHIFT when metadata isn't 5533 * compressed, but in practice they compress down to about 5534 * 1100 bytes 5535 */ 5536 numdb *= 1ULL << DN_MAX_INDBLKSHIFT; 5537 volsize += numdb; 5538 return (volsize); 5539 } 5540 5541 /* 5542 * Wait for the given activity and return the status of the wait (whether or not 5543 * any waiting was done) in the 'waited' parameter. Non-existent fses are 5544 * reported via the 'missing' parameter, rather than by printing an error 5545 * message. This is convenient when this function is called in a loop over a 5546 * long period of time (as it is, for example, by zfs's wait cmd). In that 5547 * scenario, a fs being exported or destroyed should be considered a normal 5548 * event, so we don't want to print an error when we find that the fs doesn't 5549 * exist. 5550 */ 5551 int 5552 zfs_wait_status(zfs_handle_t *zhp, zfs_wait_activity_t activity, 5553 boolean_t *missing, boolean_t *waited) 5554 { 5555 int error = lzc_wait_fs(zhp->zfs_name, activity, waited); 5556 *missing = (error == ENOENT); 5557 if (*missing) 5558 return (0); 5559 5560 if (error != 0) { 5561 (void) zfs_standard_error_fmt(zhp->zfs_hdl, error, 5562 dgettext(TEXT_DOMAIN, "error waiting in fs '%s'"), 5563 zhp->zfs_name); 5564 } 5565 5566 return (error); 5567 } 5568