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