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) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 /* 26 * Copyright 2013 Nexenta Systems, Inc. All rights reserved. 27 */ 28 29 /* 30 * System includes 31 */ 32 #include <assert.h> 33 #include <errno.h> 34 #include <libgen.h> 35 #include <libintl.h> 36 #include <libnvpair.h> 37 #include <libzfs.h> 38 #include <stdio.h> 39 #include <stdlib.h> 40 #include <string.h> 41 #include <sys/mntent.h> 42 #include <sys/mnttab.h> 43 #include <sys/mount.h> 44 #include <sys/stat.h> 45 #include <sys/types.h> 46 #include <sys/vfstab.h> 47 #include <sys/zone.h> 48 #include <sys/mkdev.h> 49 #include <unistd.h> 50 51 #include <libbe.h> 52 #include <libbe_priv.h> 53 54 #define BE_TMP_MNTPNT "/tmp/.be.XXXXXX" 55 56 typedef struct dir_data { 57 char *dir; 58 char *ds; 59 } dir_data_t; 60 61 /* Private function prototypes */ 62 static int be_mount_callback(zfs_handle_t *, void *); 63 static int be_unmount_callback(zfs_handle_t *, void *); 64 static int be_get_legacy_fs_callback(zfs_handle_t *, void *); 65 static int fix_mountpoint(zfs_handle_t *); 66 static int fix_mountpoint_callback(zfs_handle_t *, void *); 67 static int get_mountpoint_from_vfstab(char *, const char *, char *, size_t, 68 boolean_t); 69 static int loopback_mount_shared_fs(zfs_handle_t *, be_mount_data_t *); 70 static int loopback_mount_zonepath(const char *, be_mount_data_t *); 71 static int iter_shared_fs_callback(zfs_handle_t *, void *); 72 static int zpool_shared_fs_callback(zpool_handle_t *, void *); 73 static int unmount_shared_fs(be_unmount_data_t *); 74 static int add_to_fs_list(be_fs_list_data_t *, const char *); 75 static int be_mount_root(zfs_handle_t *, char *); 76 static int be_unmount_root(zfs_handle_t *, be_unmount_data_t *); 77 static int be_mount_zones(zfs_handle_t *, be_mount_data_t *); 78 static int be_unmount_zones(be_unmount_data_t *); 79 static int be_mount_one_zone(zfs_handle_t *, be_mount_data_t *, char *, char *, 80 char *); 81 static int be_unmount_one_zone(be_unmount_data_t *, char *, char *, char *); 82 static int be_get_ds_from_dir_callback(zfs_handle_t *, void *); 83 84 85 /* ******************************************************************** */ 86 /* Public Functions */ 87 /* ******************************************************************** */ 88 89 /* 90 * Function: be_mount 91 * Description: Mounts a BE and its subordinate datasets at a given mountpoint. 92 * Parameters: 93 * be_attrs - pointer to nvlist_t of attributes being passed in. 94 * The following attributes are used by this function: 95 * 96 * BE_ATTR_ORIG_BE_NAME *required 97 * BE_ATTR_MOUNTPOINT *required 98 * BE_ATTR_MOUNT_FLAGS *optional 99 * Return: 100 * BE_SUCCESS - Success 101 * be_errno_t - Failure 102 * Scope: 103 * Public 104 */ 105 int 106 be_mount(nvlist_t *be_attrs) 107 { 108 char *be_name = NULL; 109 char *mountpoint = NULL; 110 uint16_t flags = 0; 111 int ret = BE_SUCCESS; 112 113 /* Initialize libzfs handle */ 114 if (!be_zfs_init()) 115 return (BE_ERR_INIT); 116 117 /* Get original BE name */ 118 if (nvlist_lookup_string(be_attrs, BE_ATTR_ORIG_BE_NAME, &be_name) 119 != 0) { 120 be_print_err(gettext("be_mount: failed to lookup " 121 "BE_ATTR_ORIG_BE_NAME attribute\n")); 122 return (BE_ERR_INVAL); 123 } 124 125 /* Validate original BE name */ 126 if (!be_valid_be_name(be_name)) { 127 be_print_err(gettext("be_mount: invalid BE name %s\n"), 128 be_name); 129 return (BE_ERR_INVAL); 130 } 131 132 /* Get mountpoint */ 133 if (nvlist_lookup_string(be_attrs, BE_ATTR_MOUNTPOINT, &mountpoint) 134 != 0) { 135 be_print_err(gettext("be_mount: failed to lookup " 136 "BE_ATTR_MOUNTPOINT attribute\n")); 137 return (BE_ERR_INVAL); 138 } 139 140 /* Get flags */ 141 if (nvlist_lookup_pairs(be_attrs, NV_FLAG_NOENTOK, 142 BE_ATTR_MOUNT_FLAGS, DATA_TYPE_UINT16, &flags, NULL) != 0) { 143 be_print_err(gettext("be_mount: failed to lookup " 144 "BE_ATTR_MOUNT_FLAGS attribute\n")); 145 return (BE_ERR_INVAL); 146 } 147 148 ret = _be_mount(be_name, &mountpoint, flags); 149 150 be_zfs_fini(); 151 152 return (ret); 153 } 154 155 /* 156 * Function: be_unmount 157 * Description: Unmounts a BE and its subordinate datasets. 158 * Parameters: 159 * be_attrs - pointer to nvlist_t of attributes being passed in. 160 * The following attributes are used by this function: 161 * 162 * BE_ATTR_ORIG_BE_NAME *required 163 * BE_ATTR_UNMOUNT_FLAGS *optional 164 * Return: 165 * BE_SUCCESS - Success 166 * be_errno_t - Failure 167 * Scope: 168 * Public 169 */ 170 int 171 be_unmount(nvlist_t *be_attrs) 172 { 173 char *be_name = NULL; 174 char *be_name_mnt = NULL; 175 char *ds = NULL; 176 uint16_t flags = 0; 177 int ret = BE_SUCCESS; 178 179 /* Initialize libzfs handle */ 180 if (!be_zfs_init()) 181 return (BE_ERR_INIT); 182 183 /* Get original BE name */ 184 if (nvlist_lookup_string(be_attrs, BE_ATTR_ORIG_BE_NAME, &be_name) 185 != 0) { 186 be_print_err(gettext("be_unmount: failed to lookup " 187 "BE_ATTR_ORIG_BE_NAME attribute\n")); 188 return (BE_ERR_INVAL); 189 } 190 191 /* Check if we have mountpoint argument instead of BE name */ 192 if (be_name[0] == '/') { 193 if ((ds = be_get_ds_from_dir(be_name)) != NULL) { 194 if ((be_name_mnt = strrchr(ds, '/')) != NULL) { 195 free(be_name); 196 be_name = be_name_mnt + 1; 197 } 198 } else { 199 be_print_err(gettext("be_unmount: no datasets mounted " 200 "at '%s'\n"), be_name); 201 return (BE_ERR_INVAL); 202 } 203 } 204 205 /* Validate original BE name */ 206 if (!be_valid_be_name(be_name)) { 207 be_print_err(gettext("be_unmount: invalid BE name %s\n"), 208 be_name); 209 return (BE_ERR_INVAL); 210 } 211 212 /* Get unmount flags */ 213 if (nvlist_lookup_pairs(be_attrs, NV_FLAG_NOENTOK, 214 BE_ATTR_UNMOUNT_FLAGS, DATA_TYPE_UINT16, &flags, NULL) != 0) { 215 be_print_err(gettext("be_unmount: failed to loookup " 216 "BE_ATTR_UNMOUNT_FLAGS attribute\n")); 217 return (BE_ERR_INVAL); 218 } 219 220 ret = _be_unmount(be_name, flags); 221 222 be_zfs_fini(); 223 224 return (ret); 225 } 226 227 /* ******************************************************************** */ 228 /* Semi-Private Functions */ 229 /* ******************************************************************** */ 230 231 /* 232 * Function: _be_mount 233 * Description: Mounts a BE. If the altroot is not provided, this function 234 * will generate a temporary mountpoint to mount the BE at. It 235 * will return this temporary mountpoint to the caller via the 236 * altroot reference pointer passed in. This returned value is 237 * allocated on heap storage and is the repsonsibility of the 238 * caller to free. 239 * Parameters: 240 * be_name - pointer to name of BE to mount. 241 * altroot - reference pointer to altroot of where to mount BE. 242 * flags - flag indicating special handling for mounting the BE 243 * Return: 244 * BE_SUCCESS - Success 245 * be_errno_t - Failure 246 * Scope: 247 * Semi-private (library wide use only) 248 */ 249 int 250 _be_mount(char *be_name, char **altroot, int flags) 251 { 252 be_transaction_data_t bt = { 0 }; 253 be_mount_data_t md = { 0 }; 254 zfs_handle_t *zhp; 255 char obe_root_ds[MAXPATHLEN]; 256 char *mp = NULL; 257 char *tmp_altroot = NULL; 258 int ret = BE_SUCCESS, err = 0; 259 uuid_t uu = { 0 }; 260 boolean_t gen_tmp_altroot = B_FALSE; 261 262 if (be_name == NULL || altroot == NULL) 263 return (BE_ERR_INVAL); 264 265 /* Set be_name as obe_name in bt structure */ 266 bt.obe_name = be_name; 267 268 /* Find which zpool obe_name lives in */ 269 if ((err = zpool_iter(g_zfs, be_find_zpool_callback, &bt)) == 0) { 270 be_print_err(gettext("be_mount: failed to " 271 "find zpool for BE (%s)\n"), bt.obe_name); 272 return (BE_ERR_BE_NOENT); 273 } else if (err < 0) { 274 be_print_err(gettext("be_mount: zpool_iter failed: %s\n"), 275 libzfs_error_description(g_zfs)); 276 return (zfs_err_to_be_err(g_zfs)); 277 } 278 279 /* Generate string for obe_name's root dataset */ 280 be_make_root_ds(bt.obe_zpool, bt.obe_name, obe_root_ds, 281 sizeof (obe_root_ds)); 282 bt.obe_root_ds = obe_root_ds; 283 284 /* Get handle to BE's root dataset */ 285 if ((zhp = zfs_open(g_zfs, bt.obe_root_ds, ZFS_TYPE_FILESYSTEM)) == 286 NULL) { 287 be_print_err(gettext("be_mount: failed to " 288 "open BE root dataset (%s): %s\n"), bt.obe_root_ds, 289 libzfs_error_description(g_zfs)); 290 return (zfs_err_to_be_err(g_zfs)); 291 } 292 293 /* Make sure BE's root dataset isn't already mounted somewhere */ 294 if (zfs_is_mounted(zhp, &mp)) { 295 ZFS_CLOSE(zhp); 296 be_print_err(gettext("be_mount: %s is already mounted " 297 "at %s\n"), bt.obe_name, mp != NULL ? mp : ""); 298 free(mp); 299 return (BE_ERR_MOUNTED); 300 } 301 302 /* 303 * Fix this BE's mountpoint if its root dataset isn't set to 304 * either 'legacy' or '/'. 305 */ 306 if ((ret = fix_mountpoint(zhp)) != BE_SUCCESS) { 307 be_print_err(gettext("be_mount: mountpoint check " 308 "failed for %s\n"), bt.obe_root_ds); 309 ZFS_CLOSE(zhp); 310 return (ret); 311 } 312 313 /* 314 * If altroot not provided, create a temporary alternate root 315 * to mount on 316 */ 317 if (*altroot == NULL) { 318 if ((ret = be_make_tmp_mountpoint(&tmp_altroot)) 319 != BE_SUCCESS) { 320 be_print_err(gettext("be_mount: failed to " 321 "make temporary mountpoint\n")); 322 ZFS_CLOSE(zhp); 323 return (ret); 324 } 325 gen_tmp_altroot = B_TRUE; 326 } else { 327 tmp_altroot = *altroot; 328 } 329 330 md.altroot = tmp_altroot; 331 md.shared_fs = flags & BE_MOUNT_FLAG_SHARED_FS; 332 md.shared_rw = flags & BE_MOUNT_FLAG_SHARED_RW; 333 334 /* Mount the BE's root file system */ 335 if (getzoneid() == GLOBAL_ZONEID) { 336 if ((ret = be_mount_root(zhp, tmp_altroot)) != BE_SUCCESS) { 337 be_print_err(gettext("be_mount: failed to " 338 "mount BE root file system\n")); 339 if (gen_tmp_altroot) 340 free(tmp_altroot); 341 ZFS_CLOSE(zhp); 342 return (ret); 343 } 344 } else { 345 /* Legacy mount the zone root dataset */ 346 if ((ret = be_mount_zone_root(zhp, &md)) != BE_SUCCESS) { 347 be_print_err(gettext("be_mount: failed to " 348 "mount BE zone root file system\n")); 349 free(md.altroot); 350 ZFS_CLOSE(zhp); 351 return (ret); 352 } 353 } 354 355 /* Iterate through BE's children filesystems */ 356 if ((err = zfs_iter_filesystems(zhp, be_mount_callback, 357 tmp_altroot)) != 0) { 358 be_print_err(gettext("be_mount: failed to " 359 "mount BE (%s) on %s\n"), bt.obe_name, tmp_altroot); 360 if (gen_tmp_altroot) 361 free(tmp_altroot); 362 ZFS_CLOSE(zhp); 363 return (err); 364 } 365 366 /* 367 * Mount shared file systems if mount flag says so. 368 */ 369 if (md.shared_fs) { 370 /* 371 * Mount all ZFS file systems not under the BE's root dataset 372 */ 373 (void) zpool_iter(g_zfs, zpool_shared_fs_callback, &md); 374 375 /* TODO: Mount all non-ZFS file systems - Not supported yet */ 376 } 377 378 /* 379 * If we're in the global zone and the global zone has a valid uuid, 380 * mount all supported non-global zones. 381 */ 382 if (getzoneid() == GLOBAL_ZONEID && 383 !(flags & BE_MOUNT_FLAG_NO_ZONES) && 384 be_get_uuid(bt.obe_root_ds, &uu) == BE_SUCCESS) { 385 if (be_mount_zones(zhp, &md) != BE_SUCCESS) { 386 ret = BE_ERR_NO_MOUNTED_ZONE; 387 } 388 } 389 390 ZFS_CLOSE(zhp); 391 392 /* 393 * If a NULL altroot was passed in, pass the generated altroot 394 * back to the caller in altroot. 395 */ 396 if (gen_tmp_altroot) { 397 if (ret == BE_SUCCESS || ret == BE_ERR_NO_MOUNTED_ZONE) 398 *altroot = tmp_altroot; 399 else 400 free(tmp_altroot); 401 } 402 403 return (ret); 404 } 405 406 /* 407 * Function: _be_unmount 408 * Description: Unmount a BE. 409 * Parameters: 410 * be_name - pointer to name of BE to unmount. 411 * flags - flags for unmounting the BE. 412 * Returns: 413 * BE_SUCCESS - Success 414 * be_errno_t - Failure 415 * Scope: 416 * Semi-private (library wide use only) 417 */ 418 int 419 _be_unmount(char *be_name, int flags) 420 { 421 be_transaction_data_t bt = { 0 }; 422 be_unmount_data_t ud = { 0 }; 423 zfs_handle_t *zhp; 424 uuid_t uu = { 0 }; 425 char obe_root_ds[MAXPATHLEN]; 426 char mountpoint[MAXPATHLEN]; 427 char *mp = NULL; 428 int ret = BE_SUCCESS; 429 int zret = 0; 430 431 if (be_name == NULL) 432 return (BE_ERR_INVAL); 433 434 /* Set be_name as obe_name in bt structure */ 435 bt.obe_name = be_name; 436 437 /* Find which zpool obe_name lives in */ 438 if ((zret = zpool_iter(g_zfs, be_find_zpool_callback, &bt)) == 0) { 439 be_print_err(gettext("be_unmount: failed to " 440 "find zpool for BE (%s)\n"), bt.obe_name); 441 return (BE_ERR_BE_NOENT); 442 } else if (zret < 0) { 443 be_print_err(gettext("be_unmount: " 444 "zpool_iter failed: %s\n"), 445 libzfs_error_description(g_zfs)); 446 ret = zfs_err_to_be_err(g_zfs); 447 return (ret); 448 } 449 450 /* Generate string for obe_name's root dataset */ 451 be_make_root_ds(bt.obe_zpool, bt.obe_name, obe_root_ds, 452 sizeof (obe_root_ds)); 453 bt.obe_root_ds = obe_root_ds; 454 455 /* Get handle to BE's root dataset */ 456 if ((zhp = zfs_open(g_zfs, bt.obe_root_ds, ZFS_TYPE_FILESYSTEM)) == 457 NULL) { 458 be_print_err(gettext("be_unmount: failed to " 459 "open BE root dataset (%s): %s\n"), bt.obe_root_ds, 460 libzfs_error_description(g_zfs)); 461 ret = zfs_err_to_be_err(g_zfs); 462 return (ret); 463 } 464 465 /* Make sure BE's root dataset is mounted somewhere */ 466 if (!zfs_is_mounted(zhp, &mp)) { 467 468 be_print_err(gettext("be_unmount: " 469 "(%s) not mounted\n"), bt.obe_name); 470 471 /* 472 * BE is not mounted, fix this BE's mountpoint if its root 473 * dataset isn't set to either 'legacy' or '/'. 474 */ 475 if ((ret = fix_mountpoint(zhp)) != BE_SUCCESS) { 476 be_print_err(gettext("be_unmount: mountpoint check " 477 "failed for %s\n"), bt.obe_root_ds); 478 ZFS_CLOSE(zhp); 479 return (ret); 480 } 481 482 ZFS_CLOSE(zhp); 483 return (BE_ERR_NOTMOUNTED); 484 } 485 486 /* 487 * If we didn't get a mountpoint from the zfs_is_mounted call, 488 * try and get it from its property. 489 */ 490 if (mp == NULL) { 491 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint, 492 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) { 493 be_print_err(gettext("be_unmount: failed to " 494 "get mountpoint of (%s)\n"), bt.obe_name); 495 ZFS_CLOSE(zhp); 496 return (BE_ERR_ZFS); 497 } 498 } else { 499 (void) strlcpy(mountpoint, mp, sizeof (mountpoint)); 500 free(mp); 501 } 502 503 /* If BE mounted as current root, fail */ 504 if (strcmp(mountpoint, "/") == 0) { 505 be_print_err(gettext("be_unmount: " 506 "cannot unmount currently running BE\n")); 507 ZFS_CLOSE(zhp); 508 return (BE_ERR_UMOUNT_CURR_BE); 509 } 510 511 ud.altroot = mountpoint; 512 ud.force = flags & BE_UNMOUNT_FLAG_FORCE; 513 514 /* Unmount all supported non-global zones if we're in the global zone */ 515 if (getzoneid() == GLOBAL_ZONEID && 516 be_get_uuid(bt.obe_root_ds, &uu) == BE_SUCCESS) { 517 if ((ret = be_unmount_zones(&ud)) != BE_SUCCESS) { 518 ZFS_CLOSE(zhp); 519 return (ret); 520 } 521 } 522 523 /* TODO: Unmount all non-ZFS file systems - Not supported yet */ 524 525 /* Unmount all ZFS file systems not under the BE root dataset */ 526 if ((ret = unmount_shared_fs(&ud)) != BE_SUCCESS) { 527 be_print_err(gettext("be_unmount: failed to " 528 "unmount shared file systems\n")); 529 ZFS_CLOSE(zhp); 530 return (ret); 531 } 532 533 /* Unmount all children datasets under the BE's root dataset */ 534 if ((zret = zfs_iter_filesystems(zhp, be_unmount_callback, 535 &ud)) != 0) { 536 be_print_err(gettext("be_unmount: failed to " 537 "unmount BE (%s)\n"), bt.obe_name); 538 ZFS_CLOSE(zhp); 539 return (zret); 540 } 541 542 /* Unmount this BE's root filesystem */ 543 if (getzoneid() == GLOBAL_ZONEID) { 544 if ((ret = be_unmount_root(zhp, &ud)) != BE_SUCCESS) { 545 ZFS_CLOSE(zhp); 546 return (ret); 547 } 548 } else { 549 if ((ret = be_unmount_zone_root(zhp, &ud)) != BE_SUCCESS) { 550 ZFS_CLOSE(zhp); 551 return (ret); 552 } 553 } 554 555 ZFS_CLOSE(zhp); 556 557 return (BE_SUCCESS); 558 } 559 560 /* 561 * Function: be_mount_zone_root 562 * Description: Mounts the zone root dataset for a zone. 563 * Parameters: 564 * zfs - zfs_handle_t pointer to zone root dataset 565 * md - be_mount_data_t pointer to data for zone to be mounted 566 * Returns: 567 * BE_SUCCESS - Success 568 * be_errno_t - Failure 569 * Scope: 570 * Semi-private (library wide use only) 571 */ 572 int 573 be_mount_zone_root(zfs_handle_t *zhp, be_mount_data_t *md) 574 { 575 struct stat buf; 576 char mountpoint[MAXPATHLEN]; 577 int err = 0; 578 579 /* Get mountpoint property of dataset */ 580 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint, 581 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) { 582 be_print_err(gettext("be_mount_zone_root: failed to " 583 "get mountpoint property for %s: %s\n"), zfs_get_name(zhp), 584 libzfs_error_description(g_zfs)); 585 return (zfs_err_to_be_err(g_zfs)); 586 } 587 588 /* 589 * Make sure zone's root dataset is set to 'legacy'. This is 590 * currently a requirement in this implementation of zones 591 * support. 592 */ 593 if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0) { 594 be_print_err(gettext("be_mount_zone_root: " 595 "zone root dataset mountpoint is not 'legacy'\n")); 596 return (BE_ERR_ZONE_ROOT_NOT_LEGACY); 597 } 598 599 /* Create the mountpoint if it doesn't exist */ 600 if (lstat(md->altroot, &buf) != 0) { 601 if (mkdirp(md->altroot, 0755) != 0) { 602 err = errno; 603 be_print_err(gettext("be_mount_zone_root: failed " 604 "to create mountpoint %s\n"), md->altroot); 605 return (errno_to_be_err(err)); 606 } 607 } 608 609 /* 610 * Legacy mount the zone root dataset. 611 * 612 * As a workaround for 6176743, we mount the zone's root with the 613 * MS_OVERLAY option in case an alternate BE is mounted, and we're 614 * mounting the root for the zone from the current BE here. When an 615 * alternate BE is mounted, it ties up the zone's zoneroot directory 616 * for the current BE since the zone's zonepath is loopback mounted 617 * from the current BE. 618 * 619 * TODO: The MS_OVERLAY option needs to be removed when 6176743 620 * is fixed. 621 */ 622 if (mount(zfs_get_name(zhp), md->altroot, MS_OVERLAY, MNTTYPE_ZFS, 623 NULL, 0, NULL, 0) != 0) { 624 err = errno; 625 be_print_err(gettext("be_mount_zone_root: failed to " 626 "legacy mount zone root dataset (%s) at %s\n"), 627 zfs_get_name(zhp), md->altroot); 628 return (errno_to_be_err(err)); 629 } 630 631 return (BE_SUCCESS); 632 } 633 634 /* 635 * Function: be_unmount_zone_root 636 * Description: Unmounts the zone root dataset for a zone. 637 * Parameters: 638 * zhp - zfs_handle_t pointer to zone root dataset 639 * ud - be_unmount_data_t pointer to data for zone to be unmounted 640 * Returns: 641 * BE_SUCCESS - Success 642 * be_errno_t - Failure 643 * Scope: 644 * Semi-private (library wise use only) 645 */ 646 int 647 be_unmount_zone_root(zfs_handle_t *zhp, be_unmount_data_t *ud) 648 { 649 char mountpoint[MAXPATHLEN]; 650 651 /* Unmount the dataset */ 652 if (zfs_unmount(zhp, NULL, ud->force ? MS_FORCE : 0) != 0) { 653 be_print_err(gettext("be_unmount_zone_root: failed to " 654 "unmount zone root dataset %s: %s\n"), zfs_get_name(zhp), 655 libzfs_error_description(g_zfs)); 656 return (zfs_err_to_be_err(g_zfs)); 657 } 658 659 /* Get the current mountpoint property for the zone root dataset */ 660 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint, 661 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) { 662 be_print_err(gettext("be_unmount_zone_root: failed to " 663 "get mountpoint property for zone root dataset (%s): %s\n"), 664 zfs_get_name(zhp), libzfs_error_description(g_zfs)); 665 return (zfs_err_to_be_err(g_zfs)); 666 } 667 668 /* If mountpoint not already set to 'legacy', set it to 'legacy' */ 669 if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0) { 670 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 671 ZFS_MOUNTPOINT_LEGACY) != 0) { 672 be_print_err(gettext("be_unmount_zone_root: " 673 "failed to set mountpoint of zone root dataset " 674 "%s to 'legacy': %s\n"), zfs_get_name(zhp), 675 libzfs_error_description(g_zfs)); 676 return (zfs_err_to_be_err(g_zfs)); 677 } 678 } 679 680 return (BE_SUCCESS); 681 } 682 683 /* 684 * Function: be_get_legacy_fs 685 * Description: This function iterates through all non-shared file systems 686 * of a BE and finds the ones with a legacy mountpoint. For 687 * those file systems, it reads the BE's vfstab to get the 688 * mountpoint. If found, it adds that file system to the 689 * be_fs_list_data_t passed in. 690 * 691 * This function can be used to gather legacy mounted file systems 692 * for both global BEs and non-global zone BEs. To get data for 693 * a non-global zone BE, the zoneroot_ds and zoneroot parameters 694 * will be specified, otherwise they should be set to NULL. 695 * Parameters: 696 * be_name - global BE name from which to get legacy file 697 * system list. 698 * be_root_ds - root dataset of global BE. 699 * zoneroot_ds - root dataset of zone. 700 * zoneroot - zoneroot path of zone. 701 * fld - be_fs_list_data_t pointer. 702 * Returns: 703 * BE_SUCCESS - Success 704 * be_errno_t - Failure 705 * Scope: 706 * Semi-private (library wide use only) 707 */ 708 int 709 be_get_legacy_fs(char *be_name, char *be_root_ds, char *zoneroot_ds, 710 char *zoneroot, be_fs_list_data_t *fld) 711 { 712 zfs_handle_t *zhp = NULL; 713 char mountpoint[MAXPATHLEN]; 714 boolean_t mounted_here = B_FALSE; 715 boolean_t zone_mounted_here = B_FALSE; 716 int ret = BE_SUCCESS, err = 0; 717 718 if (be_name == NULL || be_root_ds == NULL || fld == NULL) 719 return (BE_ERR_INVAL); 720 721 /* Get handle to BE's root dataset */ 722 if ((zhp = zfs_open(g_zfs, be_root_ds, ZFS_TYPE_FILESYSTEM)) 723 == NULL) { 724 be_print_err(gettext("be_get_legacy_fs: failed to " 725 "open BE root dataset (%s): %s\n"), be_root_ds, 726 libzfs_error_description(g_zfs)); 727 ret = zfs_err_to_be_err(g_zfs); 728 return (ret); 729 } 730 731 /* If BE is not already mounted, mount it. */ 732 if (!zfs_is_mounted(zhp, &fld->altroot)) { 733 if ((ret = _be_mount(be_name, &fld->altroot, 734 zoneroot_ds ? BE_MOUNT_FLAG_NULL : 735 BE_MOUNT_FLAG_NO_ZONES)) != BE_SUCCESS) { 736 be_print_err(gettext("be_get_legacy_fs: " 737 "failed to mount BE %s\n"), be_name); 738 goto cleanup; 739 } 740 741 mounted_here = B_TRUE; 742 } else if (fld->altroot == NULL) { 743 be_print_err(gettext("be_get_legacy_fs: failed to " 744 "get altroot of mounted BE %s: %s\n"), 745 be_name, libzfs_error_description(g_zfs)); 746 ret = zfs_err_to_be_err(g_zfs); 747 goto cleanup; 748 } 749 750 /* 751 * If a zone root dataset was passed in, we're wanting to get 752 * legacy mounted file systems for that zone, not the global 753 * BE. 754 */ 755 if (zoneroot_ds != NULL) { 756 be_mount_data_t zone_md = { 0 }; 757 758 /* Close off handle to global BE's root dataset */ 759 ZFS_CLOSE(zhp); 760 761 /* Get handle to zone's root dataset */ 762 if ((zhp = zfs_open(g_zfs, zoneroot_ds, 763 ZFS_TYPE_FILESYSTEM)) == NULL) { 764 be_print_err(gettext("be_get_legacy_fs: failed to " 765 "open zone BE root dataset (%s): %s\n"), 766 zoneroot_ds, libzfs_error_description(g_zfs)); 767 ret = zfs_err_to_be_err(g_zfs); 768 goto cleanup; 769 } 770 771 /* Make sure the zone we're looking for is mounted */ 772 if (!zfs_is_mounted(zhp, &zone_md.altroot)) { 773 char zone_altroot[MAXPATHLEN]; 774 775 /* Generate alternate root path for zone */ 776 (void) snprintf(zone_altroot, sizeof (zone_altroot), 777 "%s%s", fld->altroot, zoneroot); 778 if ((zone_md.altroot = strdup(zone_altroot)) == NULL) { 779 be_print_err(gettext("be_get_legacy_fs: " 780 "memory allocation failed\n")); 781 ret = BE_ERR_NOMEM; 782 goto cleanup; 783 } 784 785 if ((ret = be_mount_zone_root(zhp, &zone_md)) 786 != BE_SUCCESS) { 787 be_print_err(gettext("be_get_legacy_fs: " 788 "failed to mount zone root %s\n"), 789 zoneroot_ds); 790 free(zone_md.altroot); 791 zone_md.altroot = NULL; 792 goto cleanup; 793 } 794 zone_mounted_here = B_TRUE; 795 } 796 797 free(fld->altroot); 798 fld->altroot = zone_md.altroot; 799 } 800 801 /* 802 * If the root dataset is in the vfstab with a mountpoint of "/", 803 * add it to the list 804 */ 805 if (get_mountpoint_from_vfstab(fld->altroot, zfs_get_name(zhp), 806 mountpoint, sizeof (mountpoint), B_FALSE) == BE_SUCCESS) { 807 if (strcmp(mountpoint, "/") == 0) { 808 if (add_to_fs_list(fld, zfs_get_name(zhp)) 809 != BE_SUCCESS) { 810 be_print_err(gettext("be_get_legacy_fs: " 811 "failed to add %s to fs list\n"), 812 zfs_get_name(zhp)); 813 ret = BE_ERR_INVAL; 814 goto cleanup; 815 } 816 } 817 } 818 819 /* Iterate subordinate file systems looking for legacy mounts */ 820 if ((ret = zfs_iter_filesystems(zhp, be_get_legacy_fs_callback, 821 fld)) != 0) { 822 be_print_err(gettext("be_get_legacy_fs: " 823 "failed to iterate %s to get legacy mounts\n"), 824 zfs_get_name(zhp)); 825 } 826 827 cleanup: 828 /* If we mounted the zone BE, unmount it */ 829 if (zone_mounted_here) { 830 be_unmount_data_t zone_ud = { 0 }; 831 832 zone_ud.altroot = fld->altroot; 833 zone_ud.force = B_TRUE; 834 if ((err = be_unmount_zone_root(zhp, &zone_ud)) != BE_SUCCESS) { 835 be_print_err(gettext("be_get_legacy_fs: " 836 "failed to unmount zone root %s\n"), 837 zoneroot_ds); 838 if (ret == BE_SUCCESS) 839 ret = err; 840 } 841 } 842 843 /* If we mounted this BE, unmount it */ 844 if (mounted_here) { 845 if ((err = _be_unmount(be_name, 0)) != BE_SUCCESS) { 846 be_print_err(gettext("be_get_legacy_fs: " 847 "failed to unmount %s\n"), be_name); 848 if (ret == BE_SUCCESS) 849 ret = err; 850 } 851 } 852 853 ZFS_CLOSE(zhp); 854 855 free(fld->altroot); 856 fld->altroot = NULL; 857 858 return (ret); 859 } 860 861 /* 862 * Function: be_free_fs_list 863 * Description: Function used to free the members of a be_fs_list_data_t 864 * structure. 865 * Parameters: 866 * fld - be_fs_list_data_t pointer to free. 867 * Returns: 868 * None 869 * Scope: 870 * Semi-private (library wide use only) 871 */ 872 void 873 be_free_fs_list(be_fs_list_data_t *fld) 874 { 875 int i; 876 877 if (fld == NULL) 878 return; 879 880 free(fld->altroot); 881 882 if (fld->fs_list == NULL) 883 return; 884 885 for (i = 0; i < fld->fs_num; i++) 886 free(fld->fs_list[i]); 887 888 free(fld->fs_list); 889 } 890 891 /* 892 * Function: be_get_ds_from_dir(char *dir) 893 * Description: Given a directory path, find the underlying dataset mounted 894 * at that directory path if there is one. The returned name 895 * is allocated in heap storage, so the caller is responsible 896 * for freeing it. 897 * Parameters: 898 * dir - char pointer of directory to find. 899 * Returns: 900 * NULL - if directory is not mounted from a dataset. 901 * name of dataset mounted at dir. 902 * Scope: 903 * Semi-private (library wide use only) 904 */ 905 char * 906 be_get_ds_from_dir(char *dir) 907 { 908 dir_data_t dd = { 0 }; 909 char resolved_dir[MAXPATHLEN]; 910 911 /* Make sure length of dir is within the max length */ 912 if (dir == NULL || strlen(dir) >= MAXPATHLEN) 913 return (NULL); 914 915 /* Resolve dir in case its lofs mounted */ 916 (void) strlcpy(resolved_dir, dir, sizeof (resolved_dir)); 917 z_resolve_lofs(resolved_dir, sizeof (resolved_dir)); 918 919 dd.dir = resolved_dir; 920 921 (void) zfs_iter_root(g_zfs, be_get_ds_from_dir_callback, &dd); 922 923 return (dd.ds); 924 } 925 926 /* 927 * Function: be_make_tmp_mountpoint 928 * Description: This function generates a random temporary mountpoint 929 * and creates that mountpoint directory. It returns the 930 * mountpoint in heap storage, so the caller is responsible 931 * for freeing it. 932 * Parameters: 933 * tmp_mp - reference to pointer of where to store generated 934 * temporary mountpoint. 935 * Returns: 936 * BE_SUCCESS - Success 937 * be_errno_t - Failure 938 * Scope: 939 * Semi-private (library wide use only) 940 */ 941 int 942 be_make_tmp_mountpoint(char **tmp_mp) 943 { 944 int err = 0; 945 946 if ((*tmp_mp = (char *)calloc(1, sizeof (BE_TMP_MNTPNT) + 1)) == NULL) { 947 be_print_err(gettext("be_make_tmp_mountpoint: " 948 "malloc failed\n")); 949 return (BE_ERR_NOMEM); 950 } 951 (void) strlcpy(*tmp_mp, BE_TMP_MNTPNT, sizeof (BE_TMP_MNTPNT) + 1); 952 if (mkdtemp(*tmp_mp) == NULL) { 953 err = errno; 954 be_print_err(gettext("be_make_tmp_mountpoint: mkdtemp() failed " 955 "for %s: %s\n"), *tmp_mp, strerror(err)); 956 free(*tmp_mp); 957 *tmp_mp = NULL; 958 return (errno_to_be_err(err)); 959 } 960 961 return (BE_SUCCESS); 962 } 963 964 /* 965 * Function: be_mount_pool 966 * Description: This function determines if the pool's datase is mounted 967 * and if not it is used to mount the pool's dataset. The 968 * function returns the current mountpoint if we are able 969 * to mount the dataset. 970 * Parameters: 971 * zhp - handle to the pool's dataset 972 * tmp_mntpnt - The temporary mountpoint that the pool's 973 * dataset is mounted on. This is set only 974 * if the attempt to mount the dataset at it's 975 * set mountpoint fails, and we've used a 976 * temporary mount point for this dataset. It 977 * is expected that the caller will free this 978 * memory. 979 * orig_mntpnt - The original mountpoint for the pool. If a 980 * temporary mount point was needed this will 981 * be used to reset the mountpoint property to 982 * it's original mountpoint. It is expected that 983 * the caller will free this memory. 984 * pool_mounted - This flag indicates that the pool was mounted 985 * in this function. 986 * Returns: 987 * BE_SUCCESS - Success 988 * be_errno_t - Failure 989 * Scope: 990 * Semi-private (library wide use only) 991 */ 992 int 993 be_mount_pool( 994 zfs_handle_t *zhp, 995 char **tmp_mntpnt, 996 char **orig_mntpnt, 997 boolean_t *pool_mounted) 998 { 999 1000 char mountpoint[MAXPATHLEN]; 1001 int ret = 0; 1002 1003 *tmp_mntpnt = NULL; 1004 *orig_mntpnt = NULL; 1005 *pool_mounted = B_FALSE; 1006 1007 if (!zfs_is_mounted(zhp, NULL)) { 1008 if (zfs_mount(zhp, NULL, 0) != 0) { 1009 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint, 1010 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) { 1011 be_print_err(gettext("be_mount_pool: failed to " 1012 "get mountpoint of (%s): %s\n"), 1013 zfs_get_name(zhp), 1014 libzfs_error_description(g_zfs)); 1015 return (zfs_err_to_be_err(g_zfs)); 1016 } 1017 if ((*orig_mntpnt = strdup(mountpoint)) == NULL) { 1018 be_print_err(gettext("be_mount_pool: memory " 1019 "allocation failed\n")); 1020 return (BE_ERR_NOMEM); 1021 } 1022 /* 1023 * attempt to mount on a temp mountpoint 1024 */ 1025 if ((ret = be_make_tmp_mountpoint(tmp_mntpnt)) 1026 != BE_SUCCESS) { 1027 be_print_err(gettext("be_mount_pool: failed " 1028 "to make temporary mountpoint\n")); 1029 free(*orig_mntpnt); 1030 *orig_mntpnt = NULL; 1031 return (ret); 1032 } 1033 1034 if (zfs_prop_set(zhp, 1035 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 1036 *tmp_mntpnt) != 0) { 1037 be_print_err(gettext("be_mount_pool: failed " 1038 "to set mountpoint of pool dataset %s to " 1039 "%s: %s\n"), zfs_get_name(zhp), 1040 *orig_mntpnt, 1041 libzfs_error_description(g_zfs)); 1042 free(*tmp_mntpnt); 1043 free(*orig_mntpnt); 1044 *orig_mntpnt = NULL; 1045 *tmp_mntpnt = NULL; 1046 return (zfs_err_to_be_err(g_zfs)); 1047 } 1048 1049 if (zfs_mount(zhp, NULL, 0) != 0) { 1050 be_print_err(gettext("be_mount_pool: failed " 1051 "to mount dataset %s at %s: %s\n"), 1052 zfs_get_name(zhp), *tmp_mntpnt, 1053 libzfs_error_description(g_zfs)); 1054 ret = zfs_err_to_be_err(g_zfs); 1055 if (zfs_prop_set(zhp, 1056 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 1057 mountpoint) != 0) { 1058 be_print_err(gettext("be_mount_pool: " 1059 "failed to set mountpoint of pool " 1060 "dataset %s to %s: %s\n"), 1061 zfs_get_name(zhp), *tmp_mntpnt, 1062 libzfs_error_description(g_zfs)); 1063 } 1064 free(*tmp_mntpnt); 1065 free(*orig_mntpnt); 1066 *orig_mntpnt = NULL; 1067 *tmp_mntpnt = NULL; 1068 return (ret); 1069 } 1070 } 1071 *pool_mounted = B_TRUE; 1072 } 1073 1074 return (BE_SUCCESS); 1075 } 1076 1077 /* 1078 * Function: be_unmount_pool 1079 * Description: This function is used to unmount the pool's dataset if we 1080 * mounted it previously using be_mount_pool(). 1081 * Parameters: 1082 * zhp - handle to the pool's dataset 1083 * tmp_mntpnt - If a temprary mount point was used this will 1084 * be set. Since this was created in be_mount_pool 1085 * we will need to clean it up here. 1086 * orig_mntpnt - The original mountpoint for the pool. This is 1087 * used to set the dataset mountpoint property 1088 * back to it's original value in the case where a 1089 * temporary mountpoint was used. 1090 * Returns: 1091 * BE_SUCCESS - Success 1092 * be_errno_t - Failure 1093 * Scope: 1094 * Semi-private (library wide use only) 1095 */ 1096 int 1097 be_unmount_pool( 1098 zfs_handle_t *zhp, 1099 char *tmp_mntpnt, 1100 char *orig_mntpnt) 1101 { 1102 if (zfs_unmount(zhp, NULL, 0) != 0) { 1103 be_print_err(gettext("be_unmount_pool: failed to " 1104 "unmount pool (%s): %s\n"), zfs_get_name(zhp), 1105 libzfs_error_description(g_zfs)); 1106 return (zfs_err_to_be_err(g_zfs)); 1107 } 1108 if (orig_mntpnt != NULL) { 1109 if (tmp_mntpnt != NULL && 1110 strcmp(orig_mntpnt, tmp_mntpnt) != 0) { 1111 (void) rmdir(tmp_mntpnt); 1112 } 1113 if (zfs_prop_set(zhp, 1114 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 1115 orig_mntpnt) != 0) { 1116 be_print_err(gettext("be_unmount_pool: failed " 1117 "to set the mountpoint for dataset (%s) to " 1118 "%s: %s\n"), zfs_get_name(zhp), orig_mntpnt, 1119 libzfs_error_description(g_zfs)); 1120 return (zfs_err_to_be_err(g_zfs)); 1121 } 1122 } 1123 1124 return (BE_SUCCESS); 1125 } 1126 1127 /* ******************************************************************** */ 1128 /* Private Functions */ 1129 /* ******************************************************************** */ 1130 1131 /* 1132 * Function: be_mount_callback 1133 * Description: Callback function used to iterate through all of a BE's 1134 * subordinate file systems and to mount them accordingly. 1135 * Parameters: 1136 * zhp - zfs_handle_t pointer to current file system being 1137 * processed. 1138 * data - pointer to the altroot of where to mount BE. 1139 * Returns: 1140 * 0 - Success 1141 * be_errno_t - Failure 1142 * Scope: 1143 * Private 1144 */ 1145 static int 1146 be_mount_callback(zfs_handle_t *zhp, void *data) 1147 { 1148 zprop_source_t sourcetype; 1149 const char *fs_name = zfs_get_name(zhp); 1150 char source[ZFS_MAXNAMELEN]; 1151 char *altroot = data; 1152 char zhp_mountpoint[MAXPATHLEN]; 1153 char mountpoint[MAXPATHLEN]; 1154 int ret = 0; 1155 1156 /* Get dataset's mountpoint and source values */ 1157 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, zhp_mountpoint, 1158 sizeof (zhp_mountpoint), &sourcetype, source, sizeof (source), 1159 B_FALSE) != 0) { 1160 be_print_err(gettext("be_mount_callback: failed to " 1161 "get mountpoint and sourcetype for %s\n"), 1162 fs_name); 1163 ZFS_CLOSE(zhp); 1164 return (BE_ERR_ZFS); 1165 } 1166 1167 /* 1168 * Set this filesystem's 'canmount' property to 'noauto' just incase 1169 * it's been set 'on'. We do this so that when we change its 1170 * mountpoint zfs won't immediately try to mount it. 1171 */ 1172 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_CANMOUNT), "noauto")) { 1173 be_print_err(gettext("be_mount_callback: failed to " 1174 "set canmount to 'noauto' (%s)\n"), fs_name); 1175 ZFS_CLOSE(zhp); 1176 return (BE_ERR_ZFS); 1177 } 1178 1179 /* 1180 * If the mountpoint is none, there's nothing to do, goto next. 1181 * If the mountpoint is legacy, legacy mount it with mount(2). 1182 * If the mountpoint is inherited, its mountpoint should 1183 * already be set. If it's not, then explicitly fix-up 1184 * the mountpoint now by appending its explicitly set 1185 * mountpoint value to the BE mountpoint. 1186 */ 1187 if (strcmp(zhp_mountpoint, ZFS_MOUNTPOINT_NONE) == 0) { 1188 goto next; 1189 } else if (strcmp(zhp_mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) { 1190 /* 1191 * If the mountpoint is set to 'legacy', we need to 1192 * dig into this BE's vfstab to figure out where to 1193 * mount it, and just mount it via mount(2). 1194 */ 1195 if (get_mountpoint_from_vfstab(altroot, fs_name, 1196 mountpoint, sizeof (mountpoint), B_TRUE) == BE_SUCCESS) { 1197 1198 /* Legacy mount the file system */ 1199 if (mount(fs_name, mountpoint, MS_DATA, 1200 MNTTYPE_ZFS, NULL, 0, NULL, 0) != 0) { 1201 be_print_err( 1202 gettext("be_mount_callback: " 1203 "failed to mount %s on %s\n"), 1204 fs_name, mountpoint); 1205 } 1206 } else { 1207 be_print_err( 1208 gettext("be_mount_callback: " 1209 "no entry for %s in vfstab, " 1210 "skipping ...\n"), fs_name); 1211 } 1212 1213 goto next; 1214 1215 } else if (sourcetype & ZPROP_SRC_INHERITED) { 1216 /* 1217 * If the mountpoint is inherited, its parent should have 1218 * already been processed so its current mountpoint value 1219 * is what its mountpoint ought to be. 1220 */ 1221 (void) strlcpy(mountpoint, zhp_mountpoint, sizeof (mountpoint)); 1222 } else if (sourcetype & ZPROP_SRC_LOCAL) { 1223 /* 1224 * Else process dataset with explicitly set mountpoint. 1225 */ 1226 (void) snprintf(mountpoint, sizeof (mountpoint), 1227 "%s%s", altroot, zhp_mountpoint); 1228 1229 /* Set the new mountpoint for the dataset */ 1230 if (zfs_prop_set(zhp, 1231 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 1232 mountpoint)) { 1233 be_print_err(gettext("be_mount_callback: " 1234 "failed to set mountpoint for %s to " 1235 "%s\n"), fs_name, mountpoint); 1236 ZFS_CLOSE(zhp); 1237 return (BE_ERR_ZFS); 1238 } 1239 } else { 1240 be_print_err(gettext("be_mount_callback: " 1241 "mountpoint sourcetype of %s is %d, skipping ...\n"), 1242 fs_name, sourcetype); 1243 1244 goto next; 1245 } 1246 1247 /* Mount this filesystem */ 1248 if (zfs_mount(zhp, NULL, 0) != 0) { 1249 be_print_err(gettext("be_mount_callback: failed to " 1250 "mount dataset %s at %s: %s\n"), fs_name, mountpoint, 1251 libzfs_error_description(g_zfs)); 1252 /* 1253 * Set this filesystem's 'mountpoint' property back to what 1254 * it was 1255 */ 1256 if (sourcetype & ZPROP_SRC_LOCAL && 1257 strcmp(zhp_mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0) { 1258 (void) zfs_prop_set(zhp, 1259 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 1260 zhp_mountpoint); 1261 } 1262 1263 ZFS_CLOSE(zhp); 1264 return (BE_ERR_MOUNT); 1265 } 1266 1267 next: 1268 /* Iterate through this dataset's children and mount them */ 1269 if ((ret = zfs_iter_filesystems(zhp, be_mount_callback, 1270 altroot)) != 0) { 1271 ZFS_CLOSE(zhp); 1272 return (ret); 1273 } 1274 1275 1276 ZFS_CLOSE(zhp); 1277 return (0); 1278 } 1279 1280 /* 1281 * Function: be_unmount_callback 1282 * Description: Callback function used to iterate through all of a BE's 1283 * subordinate file systems and to unmount them. 1284 * Parameters: 1285 * zhp - zfs_handle_t pointer to current file system being 1286 * processed. 1287 * data - pointer to the mountpoint of where BE is mounted. 1288 * Returns: 1289 * 0 - Success 1290 * be_errno_t - Failure 1291 * Scope: 1292 * Private 1293 */ 1294 static int 1295 be_unmount_callback(zfs_handle_t *zhp, void *data) 1296 { 1297 be_unmount_data_t *ud = data; 1298 zprop_source_t sourcetype; 1299 const char *fs_name = zfs_get_name(zhp); 1300 char source[ZFS_MAXNAMELEN]; 1301 char mountpoint[MAXPATHLEN]; 1302 char *zhp_mountpoint; 1303 int ret = 0; 1304 1305 /* Iterate down this dataset's children first */ 1306 if (zfs_iter_filesystems(zhp, be_unmount_callback, ud)) { 1307 ret = BE_ERR_UMOUNT; 1308 goto done; 1309 } 1310 1311 /* Is dataset even mounted ? */ 1312 if (!zfs_is_mounted(zhp, NULL)) 1313 goto done; 1314 1315 /* Unmount this file system */ 1316 if (zfs_unmount(zhp, NULL, ud->force ? MS_FORCE : 0) != 0) { 1317 be_print_err(gettext("be_unmount_callback: " 1318 "failed to unmount %s: %s\n"), fs_name, 1319 libzfs_error_description(g_zfs)); 1320 ret = zfs_err_to_be_err(g_zfs); 1321 goto done; 1322 } 1323 1324 /* Get dataset's current mountpoint and source value */ 1325 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint, 1326 sizeof (mountpoint), &sourcetype, source, sizeof (source), 1327 B_FALSE) != 0) { 1328 be_print_err(gettext("be_unmount_callback: " 1329 "failed to get mountpoint and sourcetype for %s: %s\n"), 1330 fs_name, libzfs_error_description(g_zfs)); 1331 ret = zfs_err_to_be_err(g_zfs); 1332 goto done; 1333 } 1334 1335 if (sourcetype & ZPROP_SRC_INHERITED) { 1336 /* 1337 * If the mountpoint is inherited we don't need to 1338 * do anything. When its parent gets processed 1339 * its mountpoint will be set accordingly. 1340 */ 1341 goto done; 1342 } else if (sourcetype & ZPROP_SRC_LOCAL) { 1343 1344 if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) { 1345 /* 1346 * If the mountpoint is set to 'legacy', its already 1347 * been unmounted (from above call to zfs_unmount), and 1348 * we don't need to do anything else with it. 1349 */ 1350 goto done; 1351 1352 } else { 1353 /* 1354 * Else process dataset with explicitly set mountpoint. 1355 */ 1356 1357 /* 1358 * Get this dataset's mountpoint relative to 1359 * the BE's mountpoint. 1360 */ 1361 if ((strncmp(mountpoint, ud->altroot, 1362 strlen(ud->altroot)) == 0) && 1363 (mountpoint[strlen(ud->altroot)] == '/')) { 1364 1365 zhp_mountpoint = mountpoint + 1366 strlen(ud->altroot); 1367 1368 /* Set this dataset's mountpoint value */ 1369 if (zfs_prop_set(zhp, 1370 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 1371 zhp_mountpoint)) { 1372 be_print_err( 1373 gettext("be_unmount_callback: " 1374 "failed to set mountpoint for " 1375 "%s to %s: %s\n"), fs_name, 1376 zhp_mountpoint, 1377 libzfs_error_description(g_zfs)); 1378 ret = zfs_err_to_be_err(g_zfs); 1379 } 1380 } else { 1381 be_print_err( 1382 gettext("be_unmount_callback: " 1383 "%s not mounted under BE's altroot %s, " 1384 "skipping ...\n"), fs_name, ud->altroot); 1385 /* 1386 * fs_name is mounted but not under the 1387 * root for this BE. 1388 */ 1389 ret = BE_ERR_INVALMOUNTPOINT; 1390 } 1391 } 1392 } else { 1393 be_print_err(gettext("be_unmount_callback: " 1394 "mountpoint sourcetype of %s is %d, skipping ...\n"), 1395 fs_name, sourcetype); 1396 ret = BE_ERR_ZFS; 1397 } 1398 1399 done: 1400 /* Set this filesystem's 'canmount' property to 'noauto' */ 1401 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_CANMOUNT), "noauto")) { 1402 be_print_err(gettext("be_unmount_callback: " 1403 "failed to set canmount to 'noauto' (%s)\n"), fs_name); 1404 if (ret == 0) 1405 ret = BE_ERR_ZFS; 1406 } 1407 1408 ZFS_CLOSE(zhp); 1409 return (ret); 1410 } 1411 1412 /* 1413 * Function: be_get_legacy_fs_callback 1414 * Description: The callback function is used to iterate through all 1415 * non-shared file systems of a BE, finding ones that have 1416 * a legacy mountpoint and an entry in the BE's vfstab. 1417 * It adds these file systems to the callback data. 1418 * Parameters: 1419 * zhp - zfs_handle_t pointer to current file system being 1420 * processed. 1421 * data - be_fs_list_data_t pointer 1422 * Returns: 1423 * 0 - Success 1424 * be_errno_t - Failure 1425 * Scope: 1426 * Private 1427 */ 1428 static int 1429 be_get_legacy_fs_callback(zfs_handle_t *zhp, void *data) 1430 { 1431 be_fs_list_data_t *fld = data; 1432 const char *fs_name = zfs_get_name(zhp); 1433 char zhp_mountpoint[MAXPATHLEN]; 1434 char mountpoint[MAXPATHLEN]; 1435 int ret = 0; 1436 1437 /* Get this dataset's mountpoint property */ 1438 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, zhp_mountpoint, 1439 sizeof (zhp_mountpoint), NULL, NULL, 0, B_FALSE) != 0) { 1440 be_print_err(gettext("be_get_legacy_fs_callback: " 1441 "failed to get mountpoint for %s: %s\n"), 1442 fs_name, libzfs_error_description(g_zfs)); 1443 ret = zfs_err_to_be_err(g_zfs); 1444 ZFS_CLOSE(zhp); 1445 return (ret); 1446 } 1447 1448 /* 1449 * If mountpoint is legacy, try to get its mountpoint from this BE's 1450 * vfstab. If it exists in the vfstab, add this file system to the 1451 * callback data. 1452 */ 1453 if (strcmp(zhp_mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) { 1454 if (get_mountpoint_from_vfstab(fld->altroot, fs_name, 1455 mountpoint, sizeof (mountpoint), B_FALSE) != BE_SUCCESS) { 1456 be_print_err(gettext("be_get_legacy_fs_callback: " 1457 "no entry for %s in vfstab, " 1458 "skipping ...\n"), fs_name); 1459 1460 goto next; 1461 } 1462 1463 /* Record file system into the callback data. */ 1464 if (add_to_fs_list(fld, zfs_get_name(zhp)) != BE_SUCCESS) { 1465 be_print_err(gettext("be_get_legacy_fs_callback: " 1466 "failed to add %s to fs list\n"), mountpoint); 1467 ZFS_CLOSE(zhp); 1468 return (BE_ERR_NOMEM); 1469 } 1470 } 1471 1472 next: 1473 /* Iterate through this dataset's children file systems */ 1474 if ((ret = zfs_iter_filesystems(zhp, be_get_legacy_fs_callback, 1475 fld)) != 0) { 1476 ZFS_CLOSE(zhp); 1477 return (ret); 1478 } 1479 ZFS_CLOSE(zhp); 1480 return (0); 1481 } 1482 1483 /* 1484 * Function: add_to_fs_list 1485 * Description: Function used to add a file system to the fs_list array in 1486 * a be_fs_list_data_t structure. 1487 * Parameters: 1488 * fld - be_fs_list_data_t pointer 1489 * fs - file system to add 1490 * Returns: 1491 * BE_SUCCESS - Success 1492 * 1 - Failure 1493 * Scope: 1494 * Private 1495 */ 1496 static int 1497 add_to_fs_list(be_fs_list_data_t *fld, const char *fs) 1498 { 1499 if (fld == NULL || fs == NULL) 1500 return (1); 1501 1502 if ((fld->fs_list = (char **)realloc(fld->fs_list, 1503 sizeof (char *)*(fld->fs_num + 1))) == NULL) { 1504 be_print_err(gettext("add_to_fs_list: " 1505 "memory allocation failed\n")); 1506 return (1); 1507 } 1508 1509 if ((fld->fs_list[fld->fs_num++] = strdup(fs)) == NULL) { 1510 be_print_err(gettext("add_to_fs_list: " 1511 "memory allocation failed\n")); 1512 return (1); 1513 } 1514 1515 return (BE_SUCCESS); 1516 } 1517 1518 /* 1519 * Function: zpool_shared_fs_callback 1520 * Description: Callback function used to iterate through all existing pools 1521 * to find and mount all shared filesystems. This function 1522 * processes the pool's "pool data" dataset, then uses 1523 * iter_shared_fs_callback to iterate through the pool's 1524 * datasets. 1525 * Parameters: 1526 * zlp - zpool_handle_t pointer to the current pool being 1527 * looked at. 1528 * data - be_mount_data_t pointer 1529 * Returns: 1530 * 0 - Success 1531 * be_errno_t - Failure 1532 * Scope: 1533 * Private 1534 */ 1535 static int 1536 zpool_shared_fs_callback(zpool_handle_t *zlp, void *data) 1537 { 1538 be_mount_data_t *md = data; 1539 zfs_handle_t *zhp = NULL; 1540 const char *zpool = zpool_get_name(zlp); 1541 int ret = 0; 1542 1543 /* 1544 * Get handle to pool's "pool data" dataset 1545 */ 1546 if ((zhp = zfs_open(g_zfs, zpool, ZFS_TYPE_FILESYSTEM)) == NULL) { 1547 be_print_err(gettext("zpool_shared_fs: " 1548 "failed to open pool dataset %s: %s\n"), zpool, 1549 libzfs_error_description(g_zfs)); 1550 ret = zfs_err_to_be_err(g_zfs); 1551 zpool_close(zlp); 1552 return (ret); 1553 } 1554 1555 /* Process this pool's "pool data" dataset */ 1556 (void) loopback_mount_shared_fs(zhp, md); 1557 1558 /* Interate through this pool's children */ 1559 (void) zfs_iter_filesystems(zhp, iter_shared_fs_callback, md); 1560 1561 ZFS_CLOSE(zhp); 1562 zpool_close(zlp); 1563 1564 return (0); 1565 } 1566 1567 /* 1568 * Function: iter_shared_fs_callback 1569 * Description: Callback function used to iterate through a pool's datasets 1570 * to find and mount all shared filesystems. It makes sure to 1571 * find the BE container dataset of the pool, if it exists, and 1572 * does not process and iterate down that path. 1573 * 1574 * Note - This function iterates linearly down the 1575 * hierarchical dataset paths and mounts things as it goes 1576 * along. It does not make sure that something deeper down 1577 * a dataset path has an interim mountpoint for something 1578 * processed earlier. 1579 * 1580 * Parameters: 1581 * zhp - zfs_handle_t pointer to the current dataset being 1582 * processed. 1583 * data - be_mount_data_t pointer 1584 * Returns: 1585 * 0 - Success 1586 * be_errno_t - Failure 1587 * Scope: 1588 * Private 1589 */ 1590 static int 1591 iter_shared_fs_callback(zfs_handle_t *zhp, void *data) 1592 { 1593 be_mount_data_t *md = data; 1594 const char *name = zfs_get_name(zhp); 1595 char container_ds[MAXPATHLEN]; 1596 char tmp_name[MAXPATHLEN]; 1597 char *pool; 1598 1599 /* Get the pool's name */ 1600 (void) strlcpy(tmp_name, name, sizeof (tmp_name)); 1601 pool = strtok(tmp_name, "/"); 1602 1603 if (pool) { 1604 /* Get the name of this pool's container dataset */ 1605 be_make_container_ds(pool, container_ds, 1606 sizeof (container_ds)); 1607 1608 /* 1609 * If what we're processing is this pool's BE container 1610 * dataset, skip it. 1611 */ 1612 if (strcmp(name, container_ds) == 0) { 1613 ZFS_CLOSE(zhp); 1614 return (0); 1615 } 1616 } else { 1617 /* Getting the pool name failed, return error */ 1618 be_print_err(gettext("iter_shared_fs_callback: " 1619 "failed to get pool name from %s\n"), name); 1620 ZFS_CLOSE(zhp); 1621 return (BE_ERR_POOL_NOENT); 1622 } 1623 1624 /* Mount this shared filesystem */ 1625 (void) loopback_mount_shared_fs(zhp, md); 1626 1627 /* Iterate this dataset's children file systems */ 1628 (void) zfs_iter_filesystems(zhp, iter_shared_fs_callback, md); 1629 ZFS_CLOSE(zhp); 1630 1631 return (0); 1632 } 1633 1634 /* 1635 * Function: loopback_mount_shared_fs 1636 * Description: This function loopback mounts a file system into the altroot 1637 * area of the BE being mounted. Since these are shared file 1638 * systems, they are expected to be already mounted for the 1639 * current BE, and this function just loopback mounts them into 1640 * the BE mountpoint. If they are not mounted for the current 1641 * live system, they are skipped and not mounted into the BE 1642 * we're mounting. 1643 * Parameters: 1644 * zhp - zfs_handle_t pointer to the dataset to loopback mount 1645 * md - be_mount_data_t pointer 1646 * Returns: 1647 * BE_SUCCESS - Success 1648 * be_errno_t - Failure 1649 * Scope: 1650 * Private 1651 */ 1652 static int 1653 loopback_mount_shared_fs(zfs_handle_t *zhp, be_mount_data_t *md) 1654 { 1655 char zhp_mountpoint[MAXPATHLEN]; 1656 char mountpoint[MAXPATHLEN]; 1657 char *mp = NULL; 1658 char optstr[MAX_MNTOPT_STR]; 1659 int mflag = MS_OPTIONSTR; 1660 int err; 1661 1662 /* 1663 * Check if file system is currently mounted and not delegated 1664 * to a non-global zone (if we're in the global zone) 1665 */ 1666 if (zfs_is_mounted(zhp, &mp) && (getzoneid() != GLOBAL_ZONEID || 1667 !zfs_prop_get_int(zhp, ZFS_PROP_ZONED))) { 1668 /* 1669 * If we didn't get a mountpoint from the zfs_is_mounted call, 1670 * get it from the mountpoint property. 1671 */ 1672 if (mp == NULL) { 1673 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, 1674 zhp_mountpoint, sizeof (zhp_mountpoint), NULL, 1675 NULL, 0, B_FALSE) != 0) { 1676 be_print_err( 1677 gettext("loopback_mount_shared_fs: " 1678 "failed to get mountpoint property\n")); 1679 return (BE_ERR_ZFS); 1680 } 1681 } else { 1682 (void) strlcpy(zhp_mountpoint, mp, 1683 sizeof (zhp_mountpoint)); 1684 free(mp); 1685 } 1686 1687 (void) snprintf(mountpoint, sizeof (mountpoint), "%s%s", 1688 md->altroot, zhp_mountpoint); 1689 1690 /* Mount it read-only if read-write was not requested */ 1691 if (!md->shared_rw) { 1692 mflag |= MS_RDONLY; 1693 } 1694 1695 /* Add the "nosub" option to the mount options string */ 1696 (void) strlcpy(optstr, MNTOPT_NOSUB, sizeof (optstr)); 1697 1698 /* Loopback mount this dataset at the altroot */ 1699 if (mount(zhp_mountpoint, mountpoint, mflag, MNTTYPE_LOFS, 1700 NULL, 0, optstr, sizeof (optstr)) != 0) { 1701 err = errno; 1702 be_print_err(gettext("loopback_mount_shared_fs: " 1703 "failed to loopback mount %s at %s: %s\n"), 1704 zhp_mountpoint, mountpoint, strerror(err)); 1705 return (BE_ERR_MOUNT); 1706 } 1707 } 1708 1709 return (BE_SUCCESS); 1710 } 1711 1712 /* 1713 * Function: loopback_mount_zonepath 1714 * Description: This function loopback mounts a zonepath into the altroot 1715 * area of the BE being mounted. 1716 * Parameters: 1717 * zonepath - pointer to zone path in the current BE 1718 * md - be_mount_data_t pointer 1719 * Returns: 1720 * BE_SUCCESS - Success 1721 * be_errno_t - Failure 1722 * Scope: 1723 * Private 1724 */ 1725 static int 1726 loopback_mount_zonepath(const char *zonepath, be_mount_data_t *md) 1727 { 1728 FILE *fp = (FILE *)NULL; 1729 struct stat st; 1730 char *p; 1731 char *p1; 1732 char *parent_dir; 1733 struct extmnttab extmtab; 1734 dev_t dev = NODEV; 1735 char *parentmnt; 1736 char alt_parentmnt[MAXPATHLEN]; 1737 struct mnttab mntref; 1738 char altzonepath[MAXPATHLEN]; 1739 char optstr[MAX_MNTOPT_STR]; 1740 int mflag = MS_OPTIONSTR; 1741 int ret; 1742 int err; 1743 1744 fp = fopen(MNTTAB, "r"); 1745 if (fp == NULL) { 1746 err = errno; 1747 be_print_err(gettext("loopback_mount_zonepath: " 1748 "failed to open /etc/mnttab\n")); 1749 return (errno_to_be_err(err)); 1750 } 1751 1752 /* 1753 * before attempting the loopback mount of zonepath under altroot, 1754 * we need to make sure that all intermediate file systems in the 1755 * zone path are also mounted under altroot 1756 */ 1757 1758 /* get the parent directory for zonepath */ 1759 p = strrchr(zonepath, '/'); 1760 if (p != NULL && p != zonepath) { 1761 if ((parent_dir = (char *)calloc(sizeof (char), 1762 p - zonepath + 1)) == NULL) { 1763 ret = BE_ERR_NOMEM; 1764 goto done; 1765 } 1766 (void) strlcpy(parent_dir, zonepath, p - zonepath + 1); 1767 if (stat(parent_dir, &st) < 0) { 1768 ret = errno_to_be_err(errno); 1769 be_print_err(gettext("loopback_mount_zonepath: " 1770 "failed to stat %s"), 1771 parent_dir); 1772 free(parent_dir); 1773 goto done; 1774 } 1775 free(parent_dir); 1776 1777 /* 1778 * After the above stat call, st.st_dev contains ID of the 1779 * device over which parent dir resides. 1780 * Now, search mnttab and find mount point of parent dir device. 1781 */ 1782 1783 resetmnttab(fp); 1784 while (getextmntent(fp, &extmtab, sizeof (extmtab)) == 0) { 1785 dev = makedev(extmtab.mnt_major, extmtab.mnt_minor); 1786 if (st.st_dev == dev && strcmp(extmtab.mnt_fstype, 1787 MNTTYPE_ZFS) == 0) { 1788 p1 = strchr(extmtab.mnt_special, '/'); 1789 if (p1 == NULL || strncmp(p1 + 1, 1790 BE_CONTAINER_DS_NAME, 4) != 0 || 1791 (*(p1 + 5) != '/' && *(p1 + 5) != '\0')) { 1792 /* 1793 * if parent dir is in a shared file 1794 * system, check whether it is already 1795 * loopback mounted under altroot or 1796 * not. It would have been mounted 1797 * already under altroot if it is in 1798 * a non-shared filesystem. 1799 */ 1800 parentmnt = strdup(extmtab.mnt_mountp); 1801 (void) snprintf(alt_parentmnt, 1802 sizeof (alt_parentmnt), "%s%s", 1803 md->altroot, parentmnt); 1804 mntref.mnt_mountp = alt_parentmnt; 1805 mntref.mnt_special = parentmnt; 1806 mntref.mnt_fstype = MNTTYPE_LOFS; 1807 mntref.mnt_mntopts = NULL; 1808 mntref.mnt_time = NULL; 1809 resetmnttab(fp); 1810 if (getmntany(fp, (struct mnttab *) 1811 &extmtab, &mntref) != 0) { 1812 ret = loopback_mount_zonepath( 1813 parentmnt, md); 1814 if (ret != BE_SUCCESS) { 1815 free(parentmnt); 1816 goto done; 1817 } 1818 } 1819 free(parentmnt); 1820 } 1821 break; 1822 } 1823 } 1824 } 1825 1826 1827 if (!md->shared_rw) { 1828 mflag |= MS_RDONLY; 1829 } 1830 1831 (void) snprintf(altzonepath, sizeof (altzonepath), "%s%s", 1832 md->altroot, zonepath); 1833 1834 /* Add the "nosub" option to the mount options string */ 1835 (void) strlcpy(optstr, MNTOPT_NOSUB, sizeof (optstr)); 1836 1837 /* Loopback mount this dataset at the altroot */ 1838 if (mount(zonepath, altzonepath, mflag, MNTTYPE_LOFS, 1839 NULL, 0, optstr, sizeof (optstr)) != 0) { 1840 err = errno; 1841 be_print_err(gettext("loopback_mount_zonepath: " 1842 "failed to loopback mount %s at %s: %s\n"), 1843 zonepath, altzonepath, strerror(err)); 1844 ret = BE_ERR_MOUNT; 1845 goto done; 1846 } 1847 ret = BE_SUCCESS; 1848 1849 done : 1850 (void) fclose(fp); 1851 return (ret); 1852 } 1853 1854 /* 1855 * Function: unmount_shared_fs 1856 * Description: This function iterates through the mnttab and finds all 1857 * loopback mount entries that reside within the altroot of 1858 * where the BE is mounted, and unmounts it. 1859 * Parameters: 1860 * ud - be_unmount_data_t pointer 1861 * Returns: 1862 * BE_SUCCESS - Success 1863 * be_errno_t - Failure 1864 * Scope: 1865 * Private 1866 */ 1867 static int 1868 unmount_shared_fs(be_unmount_data_t *ud) 1869 { 1870 FILE *fp = NULL; 1871 struct mnttab *table = NULL; 1872 struct mnttab ent; 1873 struct mnttab *entp = NULL; 1874 size_t size = 0; 1875 int read_chunk = 32; 1876 int i; 1877 int altroot_len; 1878 int err = 0; 1879 1880 errno = 0; 1881 1882 /* Read in the mnttab into a table */ 1883 if ((fp = fopen(MNTTAB, "r")) == NULL) { 1884 err = errno; 1885 be_print_err(gettext("unmount_shared_fs: " 1886 "failed to open mnttab\n")); 1887 return (errno_to_be_err(err)); 1888 } 1889 1890 while (getmntent(fp, &ent) == 0) { 1891 if (size % read_chunk == 0) { 1892 table = (struct mnttab *)realloc(table, 1893 (size + read_chunk) * sizeof (ent)); 1894 } 1895 entp = &table[size++]; 1896 1897 /* 1898 * Copy over the current mnttab entry into our table, 1899 * copying only the fields that we care about. 1900 */ 1901 (void) memset(entp, 0, sizeof (*entp)); 1902 if ((entp->mnt_mountp = strdup(ent.mnt_mountp)) == NULL || 1903 (entp->mnt_fstype = strdup(ent.mnt_fstype)) == NULL) { 1904 be_print_err(gettext("unmount_shared_fs: " 1905 "memory allocation failed\n")); 1906 return (BE_ERR_NOMEM); 1907 } 1908 } 1909 (void) fclose(fp); 1910 1911 /* 1912 * Process the mnttab entries in reverse order, looking for 1913 * loopback mount entries mounted under our altroot. 1914 */ 1915 altroot_len = strlen(ud->altroot); 1916 for (i = size; i > 0; i--) { 1917 entp = &table[i - 1]; 1918 1919 /* If not of type lofs, skip */ 1920 if (strcmp(entp->mnt_fstype, MNTTYPE_LOFS) != 0) 1921 continue; 1922 1923 /* If inside the altroot, unmount it */ 1924 if (strncmp(entp->mnt_mountp, ud->altroot, altroot_len) == 0 && 1925 entp->mnt_mountp[altroot_len] == '/') { 1926 if (umount(entp->mnt_mountp) != 0) { 1927 err = errno; 1928 if (err == EBUSY) { 1929 (void) sleep(1); 1930 err = errno = 0; 1931 if (umount(entp->mnt_mountp) != 0) 1932 err = errno; 1933 } 1934 if (err != 0) { 1935 be_print_err(gettext( 1936 "unmount_shared_fs: " 1937 "failed to unmount shared file " 1938 "system %s: %s\n"), 1939 entp->mnt_mountp, strerror(err)); 1940 return (errno_to_be_err(err)); 1941 } 1942 } 1943 } 1944 } 1945 1946 return (BE_SUCCESS); 1947 } 1948 1949 /* 1950 * Function: get_mountpoint_from_vfstab 1951 * Description: This function digs into the vfstab in the given altroot, 1952 * and searches for an entry for the fs passed in. If found, 1953 * it returns the mountpoint of that fs in the mountpoint 1954 * buffer passed in. If the get_alt_mountpoint flag is set, 1955 * it returns the mountpoint with the altroot prepended. 1956 * Parameters: 1957 * altroot - pointer to the alternate root location 1958 * fs - pointer to the file system name to look for in the 1959 * vfstab in altroot 1960 * mountpoint - pointer to buffer of where the mountpoint of 1961 * fs will be returned. 1962 * size_mp - size of mountpoint argument 1963 * get_alt_mountpoint - flag to indicate whether or not the 1964 * mountpoint should be populated with the altroot 1965 * prepended. 1966 * Returns: 1967 * BE_SUCCESS - Success 1968 * 1 - Failure 1969 * Scope: 1970 * Private 1971 */ 1972 static int 1973 get_mountpoint_from_vfstab(char *altroot, const char *fs, char *mountpoint, 1974 size_t size_mp, boolean_t get_alt_mountpoint) 1975 { 1976 struct vfstab vp; 1977 FILE *fp = NULL; 1978 char alt_vfstab[MAXPATHLEN]; 1979 1980 /* Generate path to alternate root vfstab */ 1981 (void) snprintf(alt_vfstab, sizeof (alt_vfstab), "%s/etc/vfstab", 1982 altroot); 1983 1984 /* Open alternate root vfstab */ 1985 if ((fp = fopen(alt_vfstab, "r")) == NULL) { 1986 be_print_err(gettext("get_mountpoint_from_vfstab: " 1987 "failed to open vfstab (%s)\n"), alt_vfstab); 1988 return (1); 1989 } 1990 1991 if (getvfsspec(fp, &vp, (char *)fs) == 0) { 1992 /* 1993 * Found entry for fs, grab its mountpoint. 1994 * If the flag to prepend the altroot into the mountpoint 1995 * is set, prepend it. Otherwise, just return the mountpoint. 1996 */ 1997 if (get_alt_mountpoint) { 1998 (void) snprintf(mountpoint, size_mp, "%s%s", altroot, 1999 vp.vfs_mountp); 2000 } else { 2001 (void) strlcpy(mountpoint, vp.vfs_mountp, size_mp); 2002 } 2003 } else { 2004 (void) fclose(fp); 2005 return (1); 2006 } 2007 2008 (void) fclose(fp); 2009 2010 return (BE_SUCCESS); 2011 } 2012 2013 /* 2014 * Function: fix_mountpoint_callback 2015 * Description: This callback function is used to iterate through a BE's 2016 * children filesystems to check if its mountpoint is currently 2017 * set to be mounted at some specified altroot. If so, fix it by 2018 * removing altroot from the beginning of its mountpoint. 2019 * 2020 * Note - There's no way to tell if a child filesystem's 2021 * mountpoint isn't broken, and just happens to begin with 2022 * the altroot we're looking for. In this case, this function 2023 * will errantly remove the altroot portion from the beginning 2024 * of this filesystem's mountpoint. 2025 * 2026 * Parameters: 2027 * zhp - zfs_handle_t pointer to filesystem being processed. 2028 * data - altroot of where BE is to be mounted. 2029 * Returns: 2030 * 0 - Success 2031 * be_errno_t - Failure 2032 * Scope: 2033 * Private 2034 */ 2035 static int 2036 fix_mountpoint_callback(zfs_handle_t *zhp, void *data) 2037 { 2038 zprop_source_t sourcetype; 2039 char source[ZFS_MAXNAMELEN]; 2040 char mountpoint[MAXPATHLEN]; 2041 char *zhp_mountpoint = NULL; 2042 char *altroot = data; 2043 int ret = 0; 2044 2045 /* Get dataset's mountpoint and source values */ 2046 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint, 2047 sizeof (mountpoint), &sourcetype, source, sizeof (source), 2048 B_FALSE) != 0) { 2049 be_print_err(gettext("fix_mountpoint_callback: " 2050 "failed to get mountpoint and sourcetype for %s\n"), 2051 zfs_get_name(zhp)); 2052 ZFS_CLOSE(zhp); 2053 return (BE_ERR_ZFS); 2054 } 2055 2056 /* 2057 * If the mountpoint is not inherited and the mountpoint is not 2058 * 'legacy', this file system potentially needs its mountpoint 2059 * fixed. 2060 */ 2061 if (!(sourcetype & ZPROP_SRC_INHERITED) && 2062 strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0) { 2063 2064 /* 2065 * Check if this file system's current mountpoint is 2066 * under the altroot we're fixing it against. 2067 */ 2068 if (strncmp(mountpoint, altroot, strlen(altroot)) == 0 && 2069 mountpoint[strlen(altroot)] == '/') { 2070 2071 /* 2072 * Get this dataset's mountpoint relative to the 2073 * altroot. 2074 */ 2075 zhp_mountpoint = mountpoint + strlen(altroot); 2076 2077 /* Fix this dataset's mountpoint value */ 2078 if (zfs_prop_set(zhp, 2079 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 2080 zhp_mountpoint)) { 2081 be_print_err(gettext("fix_mountpoint_callback: " 2082 "failed to set mountpoint for %s to " 2083 "%s: %s\n"), zfs_get_name(zhp), 2084 zhp_mountpoint, 2085 libzfs_error_description(g_zfs)); 2086 ret = zfs_err_to_be_err(g_zfs); 2087 ZFS_CLOSE(zhp); 2088 return (ret); 2089 } 2090 } 2091 } 2092 2093 /* Iterate through this dataset's children and fix them */ 2094 if ((ret = zfs_iter_filesystems(zhp, fix_mountpoint_callback, 2095 altroot)) != 0) { 2096 ZFS_CLOSE(zhp); 2097 return (ret); 2098 } 2099 2100 2101 ZFS_CLOSE(zhp); 2102 return (0); 2103 } 2104 2105 /* 2106 * Function: be_mount_root 2107 * Description: This function mounts the root dataset of a BE at the 2108 * specified altroot. 2109 * Parameters: 2110 * zhp - zfs_handle_t pointer to root dataset of a BE that is 2111 * to be mounted at altroot. 2112 * altroot - location of where to mount the BE root. 2113 * Return: 2114 * BE_SUCCESS - Success 2115 * be_errno_t - Failure 2116 * Scope: 2117 * Private 2118 */ 2119 static int 2120 be_mount_root(zfs_handle_t *zhp, char *altroot) 2121 { 2122 char mountpoint[MAXPATHLEN]; 2123 2124 /* Get mountpoint property of dataset */ 2125 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint, 2126 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) { 2127 be_print_err(gettext("be_mount_root: failed to " 2128 "get mountpoint property for %s: %s\n"), zfs_get_name(zhp), 2129 libzfs_error_description(g_zfs)); 2130 return (zfs_err_to_be_err(g_zfs)); 2131 } 2132 2133 /* 2134 * Set the canmount property for the BE's root dataset to 'noauto' just 2135 * in case it's been set to 'on'. We do this so that when we change its 2136 * mountpoint, zfs won't immediately try to mount it. 2137 */ 2138 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_CANMOUNT), "noauto") 2139 != 0) { 2140 be_print_err(gettext("be_mount_root: failed to " 2141 "set canmount property to 'noauto' (%s): %s\n"), 2142 zfs_get_name(zhp), libzfs_error_description(g_zfs)); 2143 return (zfs_err_to_be_err(g_zfs)); 2144 } 2145 2146 /* Set mountpoint for BE's root filesystem */ 2147 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), altroot) 2148 != 0) { 2149 be_print_err(gettext("be_mount_root: failed to " 2150 "set mountpoint of %s to %s: %s\n"), 2151 zfs_get_name(zhp), altroot, 2152 libzfs_error_description(g_zfs)); 2153 return (zfs_err_to_be_err(g_zfs)); 2154 } 2155 2156 /* Mount the BE's root filesystem */ 2157 if (zfs_mount(zhp, NULL, 0) != 0) { 2158 be_print_err(gettext("be_mount_root: failed to " 2159 "mount dataset %s at %s: %s\n"), zfs_get_name(zhp), 2160 altroot, libzfs_error_description(g_zfs)); 2161 /* 2162 * Set this BE's root filesystem 'mountpoint' property 2163 * back to what it was before. 2164 */ 2165 (void) zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 2166 mountpoint); 2167 return (zfs_err_to_be_err(g_zfs)); 2168 } 2169 2170 return (BE_SUCCESS); 2171 } 2172 2173 /* 2174 * Function: be_unmount_root 2175 * Description: This function unmounts the root dataset of a BE, but before 2176 * unmounting, it looks at the BE's vfstab to determine 2177 * if the root dataset mountpoint should be left as 'legacy' 2178 * or '/'. If the vfstab contains an entry for this root 2179 * dataset with a mountpoint of '/', it sets the mountpoint 2180 * property to 'legacy'. 2181 * 2182 * Parameters: 2183 * zhp - zfs_handle_t pointer of the BE root dataset that 2184 * is currently mounted. 2185 * ud - be_unmount_data_t pointer providing unmount data 2186 * for the given BE root dataset. 2187 * Returns: 2188 * BE_SUCCESS - Success 2189 * be_errno_t - Failure 2190 * Scope: 2191 * Private 2192 */ 2193 static int 2194 be_unmount_root(zfs_handle_t *zhp, be_unmount_data_t *ud) 2195 { 2196 char mountpoint[MAXPATHLEN]; 2197 boolean_t is_legacy = B_FALSE; 2198 2199 /* See if this is a legacy mounted root */ 2200 if (get_mountpoint_from_vfstab(ud->altroot, zfs_get_name(zhp), 2201 mountpoint, sizeof (mountpoint), B_FALSE) == BE_SUCCESS && 2202 strcmp(mountpoint, "/") == 0) { 2203 is_legacy = B_TRUE; 2204 } 2205 2206 /* Unmount the dataset */ 2207 if (zfs_unmount(zhp, NULL, ud->force ? MS_FORCE : 0) != 0) { 2208 be_print_err(gettext("be_unmount_root: failed to " 2209 "unmount BE root dataset %s: %s\n"), zfs_get_name(zhp), 2210 libzfs_error_description(g_zfs)); 2211 return (zfs_err_to_be_err(g_zfs)); 2212 } 2213 2214 /* Set canmount property for this BE's root filesystem to noauto */ 2215 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_CANMOUNT), "noauto") 2216 != 0) { 2217 be_print_err(gettext("be_unmount_root: failed to " 2218 "set canmount property for %s to 'noauto': %s\n"), 2219 zfs_get_name(zhp), libzfs_error_description(g_zfs)); 2220 return (zfs_err_to_be_err(g_zfs)); 2221 } 2222 2223 /* 2224 * Set mountpoint for BE's root dataset back to '/', or 'legacy' 2225 * if its a legacy mounted root. 2226 */ 2227 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 2228 is_legacy ? ZFS_MOUNTPOINT_LEGACY : "/") != 0) { 2229 be_print_err(gettext("be_unmount_root: failed to " 2230 "set mountpoint of %s to %s\n"), zfs_get_name(zhp), 2231 is_legacy ? ZFS_MOUNTPOINT_LEGACY : "/"); 2232 return (zfs_err_to_be_err(g_zfs)); 2233 } 2234 2235 return (BE_SUCCESS); 2236 } 2237 2238 /* 2239 * Function: fix_mountpoint 2240 * Description: This function checks the mountpoint of an unmounted BE to make 2241 * sure that it is set to either 'legacy' or '/'. If it's not, 2242 * then we're in a situation where an unmounted BE has some random 2243 * mountpoint set for it. (This could happen if the system was 2244 * rebooted while an inactive BE was mounted). This function 2245 * attempts to fix its mountpoints. 2246 * Parameters: 2247 * zhp - zfs_handle_t pointer to root dataset of the BE 2248 * whose mountpoint needs to be checked. 2249 * Return: 2250 * BE_SUCCESS - Success 2251 * be_errno_t - Failure 2252 * Scope: 2253 * Private 2254 */ 2255 static int 2256 fix_mountpoint(zfs_handle_t *zhp) 2257 { 2258 be_unmount_data_t ud = { 0 }; 2259 char *altroot = NULL; 2260 char mountpoint[MAXPATHLEN]; 2261 int ret = BE_SUCCESS; 2262 2263 /* 2264 * Record what this BE's root dataset mountpoint property is currently 2265 * set to. 2266 */ 2267 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint, 2268 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) { 2269 be_print_err(gettext("fix_mountpoint: failed to get " 2270 "mountpoint property of (%s): %s\n"), zfs_get_name(zhp), 2271 libzfs_error_description(g_zfs)); 2272 return (BE_ERR_ZFS); 2273 } 2274 2275 /* 2276 * If the root dataset mountpoint is set to 'legacy' or '/', we're okay. 2277 */ 2278 if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0 || 2279 strcmp(mountpoint, "/") == 0) { 2280 return (BE_SUCCESS); 2281 } 2282 2283 /* 2284 * Iterate through this BE's children datasets and fix 2285 * them if they need fixing. 2286 */ 2287 if (zfs_iter_filesystems(zhp, fix_mountpoint_callback, mountpoint) 2288 != 0) { 2289 return (BE_ERR_ZFS); 2290 } 2291 2292 /* 2293 * The process of mounting and unmounting the root file system 2294 * will fix its mountpoint to correctly be either 'legacy' or '/' 2295 * since be_unmount_root will do the right thing by looking at 2296 * its vfstab. 2297 */ 2298 2299 /* Generate temporary altroot to mount the root file system */ 2300 if ((ret = be_make_tmp_mountpoint(&altroot)) != BE_SUCCESS) { 2301 be_print_err(gettext("fix_mountpoint: failed to " 2302 "make temporary mountpoint\n")); 2303 return (ret); 2304 } 2305 2306 /* Mount and unmount the root. */ 2307 if ((ret = be_mount_root(zhp, altroot)) != BE_SUCCESS) { 2308 be_print_err(gettext("fix_mountpoint: failed to " 2309 "mount BE root file system\n")); 2310 goto cleanup; 2311 } 2312 ud.altroot = altroot; 2313 if ((ret = be_unmount_root(zhp, &ud)) != BE_SUCCESS) { 2314 be_print_err(gettext("fix_mountpoint: failed to " 2315 "unmount BE root file system\n")); 2316 goto cleanup; 2317 } 2318 2319 cleanup: 2320 free(altroot); 2321 2322 return (ret); 2323 } 2324 2325 /* 2326 * Function: be_mount_zones 2327 * Description: This function finds all supported non-global zones in the 2328 * given global BE and mounts them with respect to where the 2329 * global BE is currently mounted. The global BE datasets 2330 * (including its shared datasets) are expected to already 2331 * be mounted. 2332 * Parameters: 2333 * be_zhp - zfs_handle_t pointer to the root dataset of the 2334 * global BE. 2335 * md - be_mount_data_t pointer to data for global BE. 2336 * Returns: 2337 * BE_SUCCESS - Success 2338 * be_errno_t - Failure 2339 * Scope: 2340 * Private 2341 */ 2342 static int 2343 be_mount_zones(zfs_handle_t *be_zhp, be_mount_data_t *md) 2344 { 2345 zoneBrandList_t *brands = NULL; 2346 zoneList_t zlst = NULL; 2347 char *zonename = NULL; 2348 char *zonepath = NULL; 2349 char *zonepath_ds = NULL; 2350 int k; 2351 int ret = BE_SUCCESS; 2352 2353 z_set_zone_root(md->altroot); 2354 2355 if ((brands = be_get_supported_brandlist()) == NULL) { 2356 be_print_err(gettext("be_mount_zones: " 2357 "no supported brands\n")); 2358 return (BE_SUCCESS); 2359 } 2360 2361 zlst = z_get_nonglobal_zone_list_by_brand(brands); 2362 if (zlst == NULL) { 2363 z_free_brand_list(brands); 2364 return (BE_SUCCESS); 2365 } 2366 2367 for (k = 0; (zonename = z_zlist_get_zonename(zlst, k)) != NULL; k++) { 2368 if (z_zlist_get_current_state(zlst, k) == 2369 ZONE_STATE_INSTALLED) { 2370 zonepath = z_zlist_get_zonepath(zlst, k); 2371 2372 /* 2373 * Get the dataset of this zonepath in current BE. 2374 * If its not a dataset, skip it. 2375 */ 2376 if ((zonepath_ds = be_get_ds_from_dir(zonepath)) 2377 == NULL) 2378 continue; 2379 2380 /* 2381 * Check if this zone is supported based on 2382 * the dataset of its zonepath 2383 */ 2384 if (!be_zone_supported(zonepath_ds)) { 2385 free(zonepath_ds); 2386 zonepath_ds = NULL; 2387 continue; 2388 } 2389 2390 /* 2391 * if BE's shared file systems are already mounted, 2392 * zone path dataset would have already been lofs 2393 * mounted under altroot. Otherwise, we need to do 2394 * it here. 2395 */ 2396 if (!md->shared_fs) { 2397 ret = loopback_mount_zonepath(zonepath, md); 2398 if (ret != BE_SUCCESS) 2399 goto done; 2400 } 2401 2402 2403 /* Mount this zone */ 2404 ret = be_mount_one_zone(be_zhp, md, zonename, 2405 zonepath, zonepath_ds); 2406 2407 free(zonepath_ds); 2408 zonepath_ds = NULL; 2409 2410 if (ret != BE_SUCCESS) { 2411 be_print_err(gettext("be_mount_zones: " 2412 "failed to mount zone %s under " 2413 "altroot %s\n"), zonename, md->altroot); 2414 goto done; 2415 } 2416 } 2417 } 2418 2419 done: 2420 z_free_brand_list(brands); 2421 z_free_zone_list(zlst); 2422 /* 2423 * libinstzones caches mnttab and uses cached version for resolving lofs 2424 * mounts when we call z_resolve_lofs. It creates the cached version 2425 * when the first call to z_resolve_lofs happens. So, library's cached 2426 * mnttab doesn't contain entries for lofs mounts created in the above 2427 * loop. Because of this, subsequent calls to z_resolve_lofs would fail 2428 * to resolve these lofs mounts. So, here we destroy library's cached 2429 * mnttab to force its recreation when the next call to z_resolve_lofs 2430 * happens. 2431 */ 2432 z_destroyMountTable(); 2433 return (ret); 2434 } 2435 2436 /* 2437 * Function: be_unmount_zones 2438 * Description: This function finds all supported non-global zones in the 2439 * given mounted global BE and unmounts them. 2440 * Parameters: 2441 * ud - unmount_data_t pointer data for the global BE. 2442 * Returns: 2443 * BE_SUCCESS - Success 2444 * be_errno_t - Failure 2445 * Scope: 2446 * Private 2447 */ 2448 static int 2449 be_unmount_zones(be_unmount_data_t *ud) 2450 { 2451 zoneBrandList_t *brands = NULL; 2452 zoneList_t zlst = NULL; 2453 char *zonename = NULL; 2454 char *zonepath = NULL; 2455 char alt_zonepath[MAXPATHLEN]; 2456 char *zonepath_ds = NULL; 2457 int k; 2458 int ret = BE_SUCCESS; 2459 2460 z_set_zone_root(ud->altroot); 2461 2462 if ((brands = be_get_supported_brandlist()) == NULL) { 2463 be_print_err(gettext("be_unmount_zones: " 2464 "no supported brands\n")); 2465 return (BE_SUCCESS); 2466 } 2467 2468 zlst = z_get_nonglobal_zone_list_by_brand(brands); 2469 if (zlst == NULL) { 2470 z_free_brand_list(brands); 2471 return (BE_SUCCESS); 2472 } 2473 2474 for (k = 0; (zonename = z_zlist_get_zonename(zlst, k)) != NULL; k++) { 2475 if (z_zlist_get_current_state(zlst, k) == 2476 ZONE_STATE_INSTALLED) { 2477 zonepath = z_zlist_get_zonepath(zlst, k); 2478 2479 /* Build zone's zonepath wrt the global BE altroot */ 2480 (void) snprintf(alt_zonepath, sizeof (alt_zonepath), 2481 "%s%s", ud->altroot, zonepath); 2482 2483 /* 2484 * Get the dataset of this zonepath. If its not 2485 * a dataset, skip it. 2486 */ 2487 if ((zonepath_ds = be_get_ds_from_dir(alt_zonepath)) 2488 == NULL) 2489 continue; 2490 2491 /* 2492 * Check if this zone is supported based on the 2493 * dataset of its zonepath. 2494 */ 2495 if (!be_zone_supported(zonepath_ds)) { 2496 free(zonepath_ds); 2497 zonepath_ds = NULL; 2498 continue; 2499 } 2500 2501 /* Unmount this zone */ 2502 ret = be_unmount_one_zone(ud, zonename, zonepath, 2503 zonepath_ds); 2504 2505 free(zonepath_ds); 2506 zonepath_ds = NULL; 2507 2508 if (ret != BE_SUCCESS) { 2509 be_print_err(gettext("be_unmount_zones:" 2510 " failed to unmount zone %s from " 2511 "altroot %s\n"), zonename, ud->altroot); 2512 goto done; 2513 } 2514 } 2515 } 2516 2517 done: 2518 z_free_brand_list(brands); 2519 z_free_zone_list(zlst); 2520 return (ret); 2521 } 2522 2523 /* 2524 * Function: be_mount_one_zone 2525 * Description: This function is called to mount one zone for a given 2526 * global BE. 2527 * Parameters: 2528 * be_zhp - zfs_handle_t pointer to the root dataset of the 2529 * global BE 2530 * md - be_mount_data_t pointer to data for global BE 2531 * zonename - name of zone to mount 2532 * zonepath - zonepath of zone to mount 2533 * zonepath_ds - dataset for the zonepath 2534 * Returns: 2535 * BE_SUCCESS - Success 2536 * be_errno_t - Failure 2537 * Scope: 2538 * Private 2539 */ 2540 static int 2541 be_mount_one_zone(zfs_handle_t *be_zhp, be_mount_data_t *md, char *zonename, 2542 char *zonepath, char *zonepath_ds) 2543 { 2544 be_mount_data_t zone_md = { 0 }; 2545 zfs_handle_t *zone_zhp = NULL; 2546 char zone_altroot[MAXPATHLEN]; 2547 char zoneroot[MAXPATHLEN]; 2548 char zoneroot_ds[MAXPATHLEN]; 2549 int ret = BE_SUCCESS; 2550 2551 /* Find the active zone root dataset for this zone for this BE */ 2552 if ((ret = be_find_active_zone_root(be_zhp, zonepath_ds, zoneroot_ds, 2553 sizeof (zoneroot_ds))) == BE_ERR_ZONE_NO_ACTIVE_ROOT) { 2554 be_print_err(gettext("be_mount_one_zone: did not " 2555 "find active zone root for zone %s, skipping ...\n"), 2556 zonename); 2557 return (BE_SUCCESS); 2558 } else if (ret != BE_SUCCESS) { 2559 be_print_err(gettext("be_mount_one_zone: failed to " 2560 "find active zone root for zone %s\n"), zonename); 2561 return (ret); 2562 } 2563 2564 /* Get handle to active zoneroot dataset */ 2565 if ((zone_zhp = zfs_open(g_zfs, zoneroot_ds, ZFS_TYPE_FILESYSTEM)) 2566 == NULL) { 2567 be_print_err(gettext("be_mount_one_zone: failed to " 2568 "open zone root dataset (%s): %s\n"), zoneroot_ds, 2569 libzfs_error_description(g_zfs)); 2570 return (zfs_err_to_be_err(g_zfs)); 2571 } 2572 2573 /* Generate string for zone's altroot path */ 2574 be_make_zoneroot(zonepath, zoneroot, sizeof (zoneroot)); 2575 (void) strlcpy(zone_altroot, md->altroot, sizeof (zone_altroot)); 2576 (void) strlcat(zone_altroot, zoneroot, sizeof (zone_altroot)); 2577 2578 /* Build mount_data for the zone */ 2579 zone_md.altroot = zone_altroot; 2580 zone_md.shared_fs = md->shared_fs; 2581 zone_md.shared_rw = md->shared_rw; 2582 2583 /* Mount the zone's root file system */ 2584 if ((ret = be_mount_zone_root(zone_zhp, &zone_md)) != BE_SUCCESS) { 2585 be_print_err(gettext("be_mount_one_zone: failed to " 2586 "mount zone root file system at %s\n"), zone_altroot); 2587 goto done; 2588 } 2589 2590 /* Iterate through zone's children filesystems */ 2591 if ((ret = zfs_iter_filesystems(zone_zhp, be_mount_callback, 2592 zone_altroot)) != 0) { 2593 be_print_err(gettext("be_mount_one_zone: failed to " 2594 "mount zone subordinate file systems at %s\n"), 2595 zone_altroot); 2596 goto done; 2597 } 2598 2599 /* TODO: Mount all shared file systems for this zone */ 2600 2601 done: 2602 ZFS_CLOSE(zone_zhp); 2603 return (ret); 2604 } 2605 2606 /* 2607 * Function: be_unmount_one_zone 2608 * Description: This function unmount one zone for a give global BE. 2609 * Parameters: 2610 * ud - be_unmount_data_t pointer to data for global BE 2611 * zonename - name of zone to unmount 2612 * zonepath - zonepath of the zone to unmount 2613 * zonepath_ds - dataset for the zonepath 2614 * Returns: 2615 * BE_SUCCESS - Success 2616 * be_errno_t - Failure 2617 * Scope: 2618 * Private 2619 */ 2620 static int 2621 be_unmount_one_zone(be_unmount_data_t *ud, char *zonename, char *zonepath, 2622 char *zonepath_ds) 2623 { 2624 be_unmount_data_t zone_ud = { 0 }; 2625 zfs_handle_t *zone_zhp = NULL; 2626 char zone_altroot[MAXPATHLEN]; 2627 char zoneroot[MAXPATHLEN]; 2628 char zoneroot_ds[MAXPATHLEN]; 2629 int ret = BE_SUCCESS; 2630 2631 /* Generate string for zone's alternate root path */ 2632 be_make_zoneroot(zonepath, zoneroot, sizeof (zoneroot)); 2633 (void) strlcpy(zone_altroot, ud->altroot, sizeof (zone_altroot)); 2634 (void) strlcat(zone_altroot, zoneroot, sizeof (zone_altroot)); 2635 2636 /* Build be_unmount_data for zone */ 2637 zone_ud.altroot = zone_altroot; 2638 zone_ud.force = ud->force; 2639 2640 /* Find the mounted zone root dataset for this zone for this BE */ 2641 if ((ret = be_find_mounted_zone_root(zone_altroot, zonepath_ds, 2642 zoneroot_ds, sizeof (zoneroot_ds))) == BE_ERR_NO_MOUNTED_ZONE) { 2643 be_print_err(gettext("be_unmount_one_zone: did not " 2644 "find any zone root mounted for zone %s\n"), zonename); 2645 return (BE_SUCCESS); 2646 } else if (ret != BE_SUCCESS) { 2647 be_print_err(gettext("be_unmount_one_zone: failed to " 2648 "find mounted zone root for zone %s\n"), zonename); 2649 return (ret); 2650 } 2651 2652 /* Get handle to zoneroot dataset mounted for this BE */ 2653 if ((zone_zhp = zfs_open(g_zfs, zoneroot_ds, ZFS_TYPE_FILESYSTEM)) 2654 == NULL) { 2655 be_print_err(gettext("be_unmount_one_zone: failed to " 2656 "open mounted zone root dataset (%s): %s\n"), zoneroot_ds, 2657 libzfs_error_description(g_zfs)); 2658 return (zfs_err_to_be_err(g_zfs)); 2659 } 2660 2661 /* TODO: Unmount all shared file systems for this zone */ 2662 2663 /* Iterate through zone's children filesystems and unmount them */ 2664 if ((ret = zfs_iter_filesystems(zone_zhp, be_unmount_callback, 2665 &zone_ud)) != 0) { 2666 be_print_err(gettext("be_unmount_one_zone: failed to " 2667 "unmount zone subordinate file systems at %s\n"), 2668 zone_altroot); 2669 goto done; 2670 } 2671 2672 /* Unmount the zone's root filesystem */ 2673 if ((ret = be_unmount_zone_root(zone_zhp, &zone_ud)) != BE_SUCCESS) { 2674 be_print_err(gettext("be_unmount_one_zone: failed to " 2675 "unmount zone root file system at %s\n"), zone_altroot); 2676 goto done; 2677 } 2678 2679 done: 2680 ZFS_CLOSE(zone_zhp); 2681 return (ret); 2682 } 2683 2684 /* 2685 * Function: be_get_ds_from_dir_callback 2686 * Description: This is a callback function used to iterate all datasets 2687 * to find the one that is currently mounted at the directory 2688 * being searched for. If matched, the name of the dataset is 2689 * returned in heap storage, so the caller is responsible for 2690 * freeing it. 2691 * Parameters: 2692 * zhp - zfs_handle_t pointer to current dataset being processed. 2693 * data - dir_data_t pointer providing name of directory being 2694 * searched for. 2695 * Returns: 2696 * 1 - This dataset is mounted at directory being searched for. 2697 * 0 - This dataset is not mounted at directory being searched for. 2698 * Scope: 2699 * Private 2700 */ 2701 static int 2702 be_get_ds_from_dir_callback(zfs_handle_t *zhp, void *data) 2703 { 2704 dir_data_t *dd = data; 2705 char *mp = NULL; 2706 int zret = 0; 2707 2708 if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) { 2709 ZFS_CLOSE(zhp); 2710 return (0); 2711 } 2712 2713 if (zfs_is_mounted(zhp, &mp) && mp != NULL && 2714 strcmp(mp, dd->dir) == 0) { 2715 if ((dd->ds = strdup(zfs_get_name(zhp))) == NULL) { 2716 be_print_err(gettext("be_get_ds_from_dir_callback: " 2717 "memory allocation failed\n")); 2718 ZFS_CLOSE(zhp); 2719 return (0); 2720 } 2721 ZFS_CLOSE(zhp); 2722 return (1); 2723 } 2724 2725 zret = zfs_iter_filesystems(zhp, be_get_ds_from_dir_callback, dd); 2726 2727 ZFS_CLOSE(zhp); 2728 2729 return (zret); 2730 } 2731