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 2008 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 * 26 * Portions Copyright 2007 Ramprakash Jelari 27 */ 28 29 #include <libintl.h> 30 #include <libuutil.h> 31 #include <stddef.h> 32 #include <stdlib.h> 33 #include <string.h> 34 #include <unistd.h> 35 #include <zone.h> 36 37 #include <libzfs.h> 38 39 #include "libzfs_impl.h" 40 41 /* 42 * Structure to keep track of dataset state. Before changing the 'sharenfs' or 43 * 'mountpoint' property, we record whether the filesystem was previously 44 * mounted/shared. This prior state dictates whether we remount/reshare the 45 * dataset after the property has been changed. 46 * 47 * The interface consists of the following sequence of functions: 48 * 49 * changelist_gather() 50 * changelist_prefix() 51 * < change property > 52 * changelist_postfix() 53 * changelist_free() 54 * 55 * Other interfaces: 56 * 57 * changelist_remove() - remove a node from a gathered list 58 * changelist_rename() - renames all datasets appropriately when doing a rename 59 * changelist_unshare() - unshares all the nodes in a given changelist 60 * changelist_haszonedchild() - check if there is any child exported to 61 * a local zone 62 */ 63 typedef struct prop_changenode { 64 zfs_handle_t *cn_handle; 65 int cn_shared; 66 int cn_mounted; 67 int cn_zoned; 68 boolean_t cn_needpost; /* is postfix() needed? */ 69 uu_list_node_t cn_listnode; 70 } prop_changenode_t; 71 72 struct prop_changelist { 73 zfs_prop_t cl_prop; 74 zfs_prop_t cl_realprop; 75 zfs_prop_t cl_shareprop; /* used with sharenfs/sharesmb */ 76 uu_list_pool_t *cl_pool; 77 uu_list_t *cl_list; 78 boolean_t cl_waslegacy; 79 boolean_t cl_allchildren; 80 boolean_t cl_alldependents; 81 int cl_mflags; /* Mount flags */ 82 int cl_gflags; /* Gather request flags */ 83 boolean_t cl_haszonedchild; 84 boolean_t cl_sorted; 85 }; 86 87 /* 88 * If the property is 'mountpoint', go through and unmount filesystems as 89 * necessary. We don't do the same for 'sharenfs', because we can just re-share 90 * with different options without interrupting service. We do handle 'sharesmb' 91 * since there may be old resource names that need to be removed. 92 */ 93 int 94 changelist_prefix(prop_changelist_t *clp) 95 { 96 prop_changenode_t *cn; 97 int ret = 0; 98 99 if (clp->cl_prop != ZFS_PROP_MOUNTPOINT && 100 clp->cl_prop != ZFS_PROP_SHARESMB) 101 return (0); 102 103 for (cn = uu_list_first(clp->cl_list); cn != NULL; 104 cn = uu_list_next(clp->cl_list, cn)) { 105 106 /* if a previous loop failed, set the remaining to false */ 107 if (ret == -1) { 108 cn->cn_needpost = B_FALSE; 109 continue; 110 } 111 112 /* 113 * If we are in the global zone, but this dataset is exported 114 * to a local zone, do nothing. 115 */ 116 if (getzoneid() == GLOBAL_ZONEID && cn->cn_zoned) 117 continue; 118 119 if (ZFS_IS_VOLUME(cn->cn_handle)) { 120 switch (clp->cl_realprop) { 121 case ZFS_PROP_NAME: 122 /* 123 * If this was a rename, unshare the zvol, and 124 * remove the /dev/zvol links. 125 */ 126 (void) zfs_unshare_iscsi(cn->cn_handle); 127 128 if (zvol_remove_link(cn->cn_handle->zfs_hdl, 129 cn->cn_handle->zfs_name) != 0) { 130 ret = -1; 131 cn->cn_needpost = B_FALSE; 132 (void) zfs_share_iscsi(cn->cn_handle); 133 } 134 break; 135 136 case ZFS_PROP_VOLSIZE: 137 /* 138 * If this was a change to the volume size, we 139 * need to unshare and reshare the volume. 140 */ 141 (void) zfs_unshare_iscsi(cn->cn_handle); 142 break; 143 } 144 } else { 145 /* 146 * Do the property specific processing. 147 */ 148 switch (clp->cl_prop) { 149 case ZFS_PROP_MOUNTPOINT: 150 if (zfs_unmount(cn->cn_handle, NULL, 151 clp->cl_mflags) != 0) { 152 ret = -1; 153 cn->cn_needpost = B_FALSE; 154 } 155 break; 156 case ZFS_PROP_SHARESMB: 157 (void) zfs_unshare_smb(cn->cn_handle, NULL); 158 break; 159 } 160 } 161 } 162 163 if (ret == -1) 164 (void) changelist_postfix(clp); 165 166 return (ret); 167 } 168 169 /* 170 * If the property is 'mountpoint' or 'sharenfs', go through and remount and/or 171 * reshare the filesystems as necessary. In changelist_gather() we recorded 172 * whether the filesystem was previously shared or mounted. The action we take 173 * depends on the previous state, and whether the value was previously 'legacy'. 174 * For non-legacy properties, we only remount/reshare the filesystem if it was 175 * previously mounted/shared. Otherwise, we always remount/reshare the 176 * filesystem. 177 */ 178 int 179 changelist_postfix(prop_changelist_t *clp) 180 { 181 prop_changenode_t *cn; 182 char shareopts[ZFS_MAXPROPLEN]; 183 int errors = 0; 184 libzfs_handle_t *hdl; 185 186 /* 187 * If we're changing the mountpoint, attempt to destroy the underlying 188 * mountpoint. All other datasets will have inherited from this dataset 189 * (in which case their mountpoints exist in the filesystem in the new 190 * location), or have explicit mountpoints set (in which case they won't 191 * be in the changelist). 192 */ 193 if ((cn = uu_list_last(clp->cl_list)) == NULL) 194 return (0); 195 196 if (clp->cl_prop == ZFS_PROP_MOUNTPOINT) 197 remove_mountpoint(cn->cn_handle); 198 199 /* 200 * It is possible that the changelist_prefix() used libshare 201 * to unshare some entries. Since libshare caches data, an 202 * attempt to reshare during postfix can fail unless libshare 203 * is uninitialized here so that it will reinitialize later. 204 */ 205 if (cn->cn_handle != NULL) { 206 hdl = cn->cn_handle->zfs_hdl; 207 assert(hdl != NULL); 208 zfs_uninit_libshare(hdl); 209 } 210 211 /* 212 * We walk the datasets in reverse, because we want to mount any parent 213 * datasets before mounting the children. We walk all datasets even if 214 * there are errors. 215 */ 216 for (cn = uu_list_last(clp->cl_list); cn != NULL; 217 cn = uu_list_prev(clp->cl_list, cn)) { 218 219 boolean_t sharenfs; 220 boolean_t sharesmb; 221 222 /* 223 * If we are in the global zone, but this dataset is exported 224 * to a local zone, do nothing. 225 */ 226 if (getzoneid() == GLOBAL_ZONEID && cn->cn_zoned) 227 continue; 228 229 /* Only do post-processing if it's required */ 230 if (!cn->cn_needpost) 231 continue; 232 cn->cn_needpost = B_FALSE; 233 234 zfs_refresh_properties(cn->cn_handle); 235 236 if (ZFS_IS_VOLUME(cn->cn_handle)) { 237 /* 238 * If we're doing a rename, recreate the /dev/zvol 239 * links. 240 */ 241 if (clp->cl_realprop == ZFS_PROP_NAME && 242 zvol_create_link(cn->cn_handle->zfs_hdl, 243 cn->cn_handle->zfs_name) != 0) { 244 errors++; 245 } else if (cn->cn_shared || 246 clp->cl_prop == ZFS_PROP_SHAREISCSI) { 247 if (zfs_prop_get(cn->cn_handle, 248 ZFS_PROP_SHAREISCSI, shareopts, 249 sizeof (shareopts), NULL, NULL, 0, 250 B_FALSE) == 0 && 251 strcmp(shareopts, "off") == 0) { 252 errors += 253 zfs_unshare_iscsi(cn->cn_handle); 254 } else { 255 errors += 256 zfs_share_iscsi(cn->cn_handle); 257 } 258 } 259 260 continue; 261 } 262 263 /* 264 * Remount if previously mounted or mountpoint was legacy, 265 * or sharenfs or sharesmb property is set. 266 */ 267 sharenfs = ((zfs_prop_get(cn->cn_handle, ZFS_PROP_SHARENFS, 268 shareopts, sizeof (shareopts), NULL, NULL, 0, 269 B_FALSE) == 0) && (strcmp(shareopts, "off") != 0)); 270 271 sharesmb = ((zfs_prop_get(cn->cn_handle, ZFS_PROP_SHARESMB, 272 shareopts, sizeof (shareopts), NULL, NULL, 0, 273 B_FALSE) == 0) && (strcmp(shareopts, "off") != 0)); 274 275 if ((cn->cn_mounted || clp->cl_waslegacy || sharenfs || 276 sharesmb) && !zfs_is_mounted(cn->cn_handle, NULL) && 277 zfs_mount(cn->cn_handle, NULL, 0) != 0) 278 errors++; 279 280 /* 281 * We always re-share even if the filesystem is currently 282 * shared, so that we can adopt any new options. 283 */ 284 if (sharenfs) 285 errors += zfs_share_nfs(cn->cn_handle); 286 else if (cn->cn_shared || clp->cl_waslegacy) 287 errors += zfs_unshare_nfs(cn->cn_handle, NULL); 288 if (sharesmb) 289 errors += zfs_share_smb(cn->cn_handle); 290 else if (cn->cn_shared || clp->cl_waslegacy) 291 errors += zfs_unshare_smb(cn->cn_handle, NULL); 292 } 293 294 return (errors ? -1 : 0); 295 } 296 297 /* 298 * Is this "dataset" a child of "parent"? 299 */ 300 boolean_t 301 isa_child_of(const char *dataset, const char *parent) 302 { 303 int len; 304 305 len = strlen(parent); 306 307 if (strncmp(dataset, parent, len) == 0 && 308 (dataset[len] == '@' || dataset[len] == '/' || 309 dataset[len] == '\0')) 310 return (B_TRUE); 311 else 312 return (B_FALSE); 313 314 } 315 316 /* 317 * If we rename a filesystem, child filesystem handles are no longer valid 318 * since we identify each dataset by its name in the ZFS namespace. As a 319 * result, we have to go through and fix up all the names appropriately. We 320 * could do this automatically if libzfs kept track of all open handles, but 321 * this is a lot less work. 322 */ 323 void 324 changelist_rename(prop_changelist_t *clp, const char *src, const char *dst) 325 { 326 prop_changenode_t *cn; 327 char newname[ZFS_MAXNAMELEN]; 328 329 for (cn = uu_list_first(clp->cl_list); cn != NULL; 330 cn = uu_list_next(clp->cl_list, cn)) { 331 /* 332 * Do not rename a clone that's not in the source hierarchy. 333 */ 334 if (!isa_child_of(cn->cn_handle->zfs_name, src)) 335 continue; 336 337 /* 338 * Destroy the previous mountpoint if needed. 339 */ 340 remove_mountpoint(cn->cn_handle); 341 342 (void) strlcpy(newname, dst, sizeof (newname)); 343 (void) strcat(newname, cn->cn_handle->zfs_name + strlen(src)); 344 345 (void) strlcpy(cn->cn_handle->zfs_name, newname, 346 sizeof (cn->cn_handle->zfs_name)); 347 } 348 } 349 350 /* 351 * Given a gathered changelist for the 'sharenfs' or 'sharesmb' property, 352 * unshare all the datasets in the list. 353 */ 354 int 355 changelist_unshare(prop_changelist_t *clp, zfs_share_proto_t *proto) 356 { 357 prop_changenode_t *cn; 358 int ret = 0; 359 360 if (clp->cl_prop != ZFS_PROP_SHARENFS && 361 clp->cl_prop != ZFS_PROP_SHARESMB) 362 return (0); 363 364 for (cn = uu_list_first(clp->cl_list); cn != NULL; 365 cn = uu_list_next(clp->cl_list, cn)) { 366 if (zfs_unshare_proto(cn->cn_handle, NULL, proto) != 0) 367 ret = -1; 368 } 369 370 return (ret); 371 } 372 373 /* 374 * Check if there is any child exported to a local zone in a given changelist. 375 * This information has already been recorded while gathering the changelist 376 * via changelist_gather(). 377 */ 378 int 379 changelist_haszonedchild(prop_changelist_t *clp) 380 { 381 return (clp->cl_haszonedchild); 382 } 383 384 /* 385 * Remove a node from a gathered list. 386 */ 387 void 388 changelist_remove(prop_changelist_t *clp, const char *name) 389 { 390 prop_changenode_t *cn; 391 392 for (cn = uu_list_first(clp->cl_list); cn != NULL; 393 cn = uu_list_next(clp->cl_list, cn)) { 394 395 if (strcmp(cn->cn_handle->zfs_name, name) == 0) { 396 uu_list_remove(clp->cl_list, cn); 397 zfs_close(cn->cn_handle); 398 free(cn); 399 return; 400 } 401 } 402 } 403 404 /* 405 * Release any memory associated with a changelist. 406 */ 407 void 408 changelist_free(prop_changelist_t *clp) 409 { 410 prop_changenode_t *cn; 411 void *cookie; 412 413 if (clp->cl_list) { 414 cookie = NULL; 415 while ((cn = uu_list_teardown(clp->cl_list, &cookie)) != NULL) { 416 zfs_close(cn->cn_handle); 417 free(cn); 418 } 419 420 uu_list_destroy(clp->cl_list); 421 } 422 if (clp->cl_pool) 423 uu_list_pool_destroy(clp->cl_pool); 424 425 free(clp); 426 } 427 428 static int 429 change_one(zfs_handle_t *zhp, void *data) 430 { 431 prop_changelist_t *clp = data; 432 char property[ZFS_MAXPROPLEN]; 433 char where[64]; 434 prop_changenode_t *cn; 435 zprop_source_t sourcetype; 436 zprop_source_t share_sourcetype; 437 438 /* 439 * We only want to unmount/unshare those filesystems that may inherit 440 * from the target filesystem. If we find any filesystem with a 441 * locally set mountpoint, we ignore any children since changing the 442 * property will not affect them. If this is a rename, we iterate 443 * over all children regardless, since we need them unmounted in 444 * order to do the rename. Also, if this is a volume and we're doing 445 * a rename, then always add it to the changelist. 446 */ 447 448 if (!(ZFS_IS_VOLUME(zhp) && clp->cl_realprop == ZFS_PROP_NAME) && 449 zfs_prop_get(zhp, clp->cl_prop, property, 450 sizeof (property), &sourcetype, where, sizeof (where), 451 B_FALSE) != 0) { 452 zfs_close(zhp); 453 return (0); 454 } 455 456 /* 457 * If we are "watching" sharenfs or sharesmb 458 * then check out the companion property which is tracked 459 * in cl_shareprop 460 */ 461 if (clp->cl_shareprop != ZPROP_INVAL && 462 zfs_prop_get(zhp, clp->cl_shareprop, property, 463 sizeof (property), &share_sourcetype, where, sizeof (where), 464 B_FALSE) != 0) { 465 zfs_close(zhp); 466 return (0); 467 } 468 469 if (clp->cl_alldependents || clp->cl_allchildren || 470 sourcetype == ZPROP_SRC_DEFAULT || 471 sourcetype == ZPROP_SRC_INHERITED || 472 (clp->cl_shareprop != ZPROP_INVAL && 473 (share_sourcetype == ZPROP_SRC_DEFAULT || 474 share_sourcetype == ZPROP_SRC_INHERITED))) { 475 if ((cn = zfs_alloc(zfs_get_handle(zhp), 476 sizeof (prop_changenode_t))) == NULL) { 477 zfs_close(zhp); 478 return (-1); 479 } 480 481 cn->cn_handle = zhp; 482 cn->cn_mounted = (clp->cl_gflags & CL_GATHER_MOUNT_ALWAYS) || 483 zfs_is_mounted(zhp, NULL); 484 cn->cn_shared = zfs_is_shared(zhp); 485 cn->cn_zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED); 486 cn->cn_needpost = B_TRUE; 487 488 /* Indicate if any child is exported to a local zone. */ 489 if (getzoneid() == GLOBAL_ZONEID && cn->cn_zoned) 490 clp->cl_haszonedchild = B_TRUE; 491 492 uu_list_node_init(cn, &cn->cn_listnode, clp->cl_pool); 493 494 if (clp->cl_sorted) { 495 uu_list_index_t idx; 496 497 (void) uu_list_find(clp->cl_list, cn, NULL, 498 &idx); 499 uu_list_insert(clp->cl_list, cn, idx); 500 } else { 501 ASSERT(!clp->cl_alldependents); 502 verify(uu_list_insert_before(clp->cl_list, 503 uu_list_first(clp->cl_list), cn) == 0); 504 } 505 506 if (!clp->cl_alldependents) 507 return (zfs_iter_children(zhp, change_one, data)); 508 } else { 509 zfs_close(zhp); 510 } 511 512 return (0); 513 } 514 515 /*ARGSUSED*/ 516 static int 517 compare_mountpoints(const void *a, const void *b, void *unused) 518 { 519 const prop_changenode_t *ca = a; 520 const prop_changenode_t *cb = b; 521 522 char mounta[MAXPATHLEN]; 523 char mountb[MAXPATHLEN]; 524 525 boolean_t hasmounta, hasmountb; 526 527 /* 528 * When unsharing or unmounting filesystems, we need to do it in 529 * mountpoint order. This allows the user to have a mountpoint 530 * hierarchy that is different from the dataset hierarchy, and still 531 * allow it to be changed. However, if either dataset doesn't have a 532 * mountpoint (because it is a volume or a snapshot), we place it at the 533 * end of the list, because it doesn't affect our change at all. 534 */ 535 hasmounta = (zfs_prop_get(ca->cn_handle, ZFS_PROP_MOUNTPOINT, mounta, 536 sizeof (mounta), NULL, NULL, 0, B_FALSE) == 0); 537 hasmountb = (zfs_prop_get(cb->cn_handle, ZFS_PROP_MOUNTPOINT, mountb, 538 sizeof (mountb), NULL, NULL, 0, B_FALSE) == 0); 539 540 if (!hasmounta && hasmountb) 541 return (-1); 542 else if (hasmounta && !hasmountb) 543 return (1); 544 else if (!hasmounta && !hasmountb) 545 return (0); 546 else 547 return (strcmp(mountb, mounta)); 548 } 549 550 /* 551 * Given a ZFS handle and a property, construct a complete list of datasets 552 * that need to be modified as part of this process. For anything but the 553 * 'mountpoint' and 'sharenfs' properties, this just returns an empty list. 554 * Otherwise, we iterate over all children and look for any datasets that 555 * inherit the property. For each such dataset, we add it to the list and 556 * mark whether it was shared beforehand. 557 */ 558 prop_changelist_t * 559 changelist_gather(zfs_handle_t *zhp, zfs_prop_t prop, int gather_flags, 560 int mnt_flags) 561 { 562 prop_changelist_t *clp; 563 prop_changenode_t *cn; 564 zfs_handle_t *temp; 565 char property[ZFS_MAXPROPLEN]; 566 uu_compare_fn_t *compare = NULL; 567 568 if ((clp = zfs_alloc(zhp->zfs_hdl, sizeof (prop_changelist_t))) == NULL) 569 return (NULL); 570 571 /* 572 * For mountpoint-related tasks, we want to sort everything by 573 * mountpoint, so that we mount and unmount them in the appropriate 574 * order, regardless of their position in the hierarchy. 575 */ 576 if (prop == ZFS_PROP_NAME || prop == ZFS_PROP_ZONED || 577 prop == ZFS_PROP_MOUNTPOINT || prop == ZFS_PROP_SHARENFS || 578 prop == ZFS_PROP_SHARESMB) { 579 compare = compare_mountpoints; 580 clp->cl_sorted = B_TRUE; 581 } 582 583 clp->cl_pool = uu_list_pool_create("changelist_pool", 584 sizeof (prop_changenode_t), 585 offsetof(prop_changenode_t, cn_listnode), 586 compare, 0); 587 if (clp->cl_pool == NULL) { 588 assert(uu_error() == UU_ERROR_NO_MEMORY); 589 (void) zfs_error(zhp->zfs_hdl, EZFS_NOMEM, "internal error"); 590 changelist_free(clp); 591 return (NULL); 592 } 593 594 clp->cl_list = uu_list_create(clp->cl_pool, NULL, 595 clp->cl_sorted ? UU_LIST_SORTED : 0); 596 clp->cl_gflags = gather_flags; 597 clp->cl_mflags = mnt_flags; 598 599 if (clp->cl_list == NULL) { 600 assert(uu_error() == UU_ERROR_NO_MEMORY); 601 (void) zfs_error(zhp->zfs_hdl, EZFS_NOMEM, "internal error"); 602 changelist_free(clp); 603 return (NULL); 604 } 605 606 /* 607 * If this is a rename or the 'zoned' property, we pretend we're 608 * changing the mountpoint and flag it so we can catch all children in 609 * change_one(). 610 * 611 * Flag cl_alldependents to catch all children plus the dependents 612 * (clones) that are not in the hierarchy. 613 */ 614 if (prop == ZFS_PROP_NAME) { 615 clp->cl_prop = ZFS_PROP_MOUNTPOINT; 616 clp->cl_alldependents = B_TRUE; 617 } else if (prop == ZFS_PROP_ZONED) { 618 clp->cl_prop = ZFS_PROP_MOUNTPOINT; 619 clp->cl_allchildren = B_TRUE; 620 } else if (prop == ZFS_PROP_CANMOUNT) { 621 clp->cl_prop = ZFS_PROP_MOUNTPOINT; 622 } else if (prop == ZFS_PROP_VOLSIZE) { 623 clp->cl_prop = ZFS_PROP_MOUNTPOINT; 624 } else if (prop == ZFS_PROP_VERSION) { 625 clp->cl_prop = ZFS_PROP_MOUNTPOINT; 626 } else { 627 clp->cl_prop = prop; 628 } 629 clp->cl_realprop = prop; 630 631 if (clp->cl_prop != ZFS_PROP_MOUNTPOINT && 632 clp->cl_prop != ZFS_PROP_SHARENFS && 633 clp->cl_prop != ZFS_PROP_SHARESMB && 634 clp->cl_prop != ZFS_PROP_SHAREISCSI) 635 return (clp); 636 637 /* 638 * If watching SHARENFS or SHARESMB then 639 * also watch its companion property. 640 */ 641 if (clp->cl_prop == ZFS_PROP_SHARENFS) 642 clp->cl_shareprop = ZFS_PROP_SHARESMB; 643 else if (clp->cl_prop == ZFS_PROP_SHARESMB) 644 clp->cl_shareprop = ZFS_PROP_SHARENFS; 645 646 if (clp->cl_alldependents) { 647 if (zfs_iter_dependents(zhp, B_TRUE, change_one, clp) != 0) { 648 changelist_free(clp); 649 return (NULL); 650 } 651 } else if (zfs_iter_children(zhp, change_one, clp) != 0) { 652 changelist_free(clp); 653 return (NULL); 654 } 655 656 /* 657 * We have to re-open ourselves because we auto-close all the handles 658 * and can't tell the difference. 659 */ 660 if ((temp = zfs_open(zhp->zfs_hdl, zfs_get_name(zhp), 661 ZFS_TYPE_DATASET)) == NULL) { 662 changelist_free(clp); 663 return (NULL); 664 } 665 666 /* 667 * Always add ourself to the list. We add ourselves to the end so that 668 * we're the last to be unmounted. 669 */ 670 if ((cn = zfs_alloc(zhp->zfs_hdl, 671 sizeof (prop_changenode_t))) == NULL) { 672 zfs_close(temp); 673 changelist_free(clp); 674 return (NULL); 675 } 676 677 cn->cn_handle = temp; 678 cn->cn_mounted = (clp->cl_gflags & CL_GATHER_MOUNT_ALWAYS) || 679 zfs_is_mounted(temp, NULL); 680 cn->cn_shared = zfs_is_shared(temp); 681 cn->cn_zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED); 682 cn->cn_needpost = B_TRUE; 683 684 uu_list_node_init(cn, &cn->cn_listnode, clp->cl_pool); 685 if (clp->cl_sorted) { 686 uu_list_index_t idx; 687 (void) uu_list_find(clp->cl_list, cn, NULL, &idx); 688 uu_list_insert(clp->cl_list, cn, idx); 689 } else { 690 verify(uu_list_insert_after(clp->cl_list, 691 uu_list_last(clp->cl_list), cn) == 0); 692 } 693 694 /* 695 * If the mountpoint property was previously 'legacy', or 'none', 696 * record it as the behavior of changelist_postfix() will be different. 697 */ 698 if ((clp->cl_prop == ZFS_PROP_MOUNTPOINT) && 699 (zfs_prop_get(zhp, prop, property, sizeof (property), 700 NULL, NULL, 0, B_FALSE) == 0 && 701 (strcmp(property, "legacy") == 0 || 702 strcmp(property, "none") == 0))) { 703 /* 704 * do not automatically mount ex-legacy datasets if 705 * we specifically set canmount to noauto 706 */ 707 if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) != 708 ZFS_CANMOUNT_NOAUTO) 709 clp->cl_waslegacy = B_TRUE; 710 } 711 712 return (clp); 713 } 714