10b5de56dSgjelinek /* 20b5de56dSgjelinek * CDDL HEADER START 30b5de56dSgjelinek * 40b5de56dSgjelinek * The contents of this file are subject to the terms of the 50b5de56dSgjelinek * Common Development and Distribution License (the "License"). 60b5de56dSgjelinek * You may not use this file except in compliance with the License. 70b5de56dSgjelinek * 80b5de56dSgjelinek * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 90b5de56dSgjelinek * or http://www.opensolaris.org/os/licensing. 100b5de56dSgjelinek * See the License for the specific language governing permissions 110b5de56dSgjelinek * and limitations under the License. 120b5de56dSgjelinek * 130b5de56dSgjelinek * When distributing Covered Code, include this CDDL HEADER in each 140b5de56dSgjelinek * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 150b5de56dSgjelinek * If applicable, add the following below this CDDL HEADER, with the 160b5de56dSgjelinek * fields enclosed by brackets "[]" replaced with your own identifying 170b5de56dSgjelinek * information: Portions Copyright [yyyy] [name of copyright owner] 180b5de56dSgjelinek * 190b5de56dSgjelinek * CDDL HEADER END 200b5de56dSgjelinek */ 210b5de56dSgjelinek 220b5de56dSgjelinek /* 23d9e728a2Sgjelinek * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 240b5de56dSgjelinek * Use is subject to license terms. 250b5de56dSgjelinek */ 260b5de56dSgjelinek 270b5de56dSgjelinek #pragma ident "%Z%%M% %I% %E% SMI" 280b5de56dSgjelinek 290b5de56dSgjelinek /* 300b5de56dSgjelinek * This file contains the functions used to support the ZFS integration 310b5de56dSgjelinek * with zones. This includes validation (e.g. zonecfg dataset), cloning, 320b5de56dSgjelinek * file system creation and destruction. 330b5de56dSgjelinek */ 340b5de56dSgjelinek 350b5de56dSgjelinek #include <stdio.h> 360b5de56dSgjelinek #include <errno.h> 370b5de56dSgjelinek #include <unistd.h> 380b5de56dSgjelinek #include <string.h> 390b5de56dSgjelinek #include <locale.h> 400b5de56dSgjelinek #include <libintl.h> 410b5de56dSgjelinek #include <sys/stat.h> 420b5de56dSgjelinek #include <sys/statvfs.h> 430b5de56dSgjelinek #include <libgen.h> 440b5de56dSgjelinek #include <libzonecfg.h> 450b5de56dSgjelinek #include <sys/mnttab.h> 460b5de56dSgjelinek #include <libzfs.h> 470b5de56dSgjelinek 480b5de56dSgjelinek #include "zoneadm.h" 490b5de56dSgjelinek 5099653d4eSeschrock libzfs_handle_t *g_zfs; 510b5de56dSgjelinek 520b5de56dSgjelinek typedef struct zfs_mount_data { 530b5de56dSgjelinek char *match_name; 540b5de56dSgjelinek zfs_handle_t *match_handle; 550b5de56dSgjelinek } zfs_mount_data_t; 560b5de56dSgjelinek 570b5de56dSgjelinek typedef struct zfs_snapshot_data { 580b5de56dSgjelinek char *match_name; 590b5de56dSgjelinek int len; 600b5de56dSgjelinek int max; 610b5de56dSgjelinek } zfs_snapshot_data_t; 620b5de56dSgjelinek 630b5de56dSgjelinek /* 640b5de56dSgjelinek * A ZFS file system iterator call-back function which is used to validate 650b5de56dSgjelinek * datasets imported into the zone. 660b5de56dSgjelinek */ 670b5de56dSgjelinek /* ARGSUSED */ 680b5de56dSgjelinek static int 690b5de56dSgjelinek check_zvol(zfs_handle_t *zhp, void *unused) 700b5de56dSgjelinek { 710b5de56dSgjelinek int ret; 720b5de56dSgjelinek 730b5de56dSgjelinek if (zfs_get_type(zhp) == ZFS_TYPE_VOLUME) { 740b5de56dSgjelinek /* 750b5de56dSgjelinek * TRANSLATION_NOTE 760b5de56dSgjelinek * zfs and dataset are literals that should not be translated. 770b5de56dSgjelinek */ 780b5de56dSgjelinek (void) fprintf(stderr, gettext("cannot verify zfs dataset %s: " 790b5de56dSgjelinek "volumes cannot be specified as a zone dataset resource\n"), 800b5de56dSgjelinek zfs_get_name(zhp)); 810b5de56dSgjelinek ret = -1; 820b5de56dSgjelinek } else { 830b5de56dSgjelinek ret = zfs_iter_children(zhp, check_zvol, NULL); 840b5de56dSgjelinek } 850b5de56dSgjelinek 860b5de56dSgjelinek zfs_close(zhp); 870b5de56dSgjelinek 880b5de56dSgjelinek return (ret); 890b5de56dSgjelinek } 900b5de56dSgjelinek 910b5de56dSgjelinek /* 920b5de56dSgjelinek * A ZFS file system iterator call-back function which returns the 930b5de56dSgjelinek * zfs_handle_t for a ZFS file system on the specified mount point. 940b5de56dSgjelinek */ 950b5de56dSgjelinek static int 960b5de56dSgjelinek match_mountpoint(zfs_handle_t *zhp, void *data) 970b5de56dSgjelinek { 980b5de56dSgjelinek int res; 990b5de56dSgjelinek zfs_mount_data_t *cbp; 1000b5de56dSgjelinek char mp[ZFS_MAXPROPLEN]; 1010b5de56dSgjelinek 1020b5de56dSgjelinek if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) { 1030b5de56dSgjelinek zfs_close(zhp); 1040b5de56dSgjelinek return (0); 1050b5de56dSgjelinek } 1060b5de56dSgjelinek 1070b5de56dSgjelinek cbp = (zfs_mount_data_t *)data; 1080b5de56dSgjelinek if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mp, sizeof (mp), NULL, NULL, 10999653d4eSeschrock 0, B_FALSE) == 0 && strcmp(mp, cbp->match_name) == 0) { 1100b5de56dSgjelinek cbp->match_handle = zhp; 1110b5de56dSgjelinek return (1); 1120b5de56dSgjelinek } 1130b5de56dSgjelinek 1140b5de56dSgjelinek res = zfs_iter_filesystems(zhp, match_mountpoint, data); 1150b5de56dSgjelinek zfs_close(zhp); 1160b5de56dSgjelinek return (res); 1170b5de56dSgjelinek } 1180b5de56dSgjelinek 1190b5de56dSgjelinek /* 1200b5de56dSgjelinek * Get ZFS handle for the specified mount point. 1210b5de56dSgjelinek */ 1220b5de56dSgjelinek static zfs_handle_t * 1230b5de56dSgjelinek mount2zhandle(char *mountpoint) 1240b5de56dSgjelinek { 1250b5de56dSgjelinek zfs_mount_data_t cb; 1260b5de56dSgjelinek 1270b5de56dSgjelinek cb.match_name = mountpoint; 1280b5de56dSgjelinek cb.match_handle = NULL; 12999653d4eSeschrock (void) zfs_iter_root(g_zfs, match_mountpoint, &cb); 1300b5de56dSgjelinek return (cb.match_handle); 1310b5de56dSgjelinek } 1320b5de56dSgjelinek 1330b5de56dSgjelinek /* 1340b5de56dSgjelinek * Check if there is already a file system (zfs or any other type) mounted on 1350b5de56dSgjelinek * path. 1360b5de56dSgjelinek */ 1370b5de56dSgjelinek static boolean_t 1380b5de56dSgjelinek is_mountpnt(char *path) 1390b5de56dSgjelinek { 1400b5de56dSgjelinek FILE *fp; 1410b5de56dSgjelinek struct mnttab entry; 1420b5de56dSgjelinek 1430b5de56dSgjelinek if ((fp = fopen("/etc/mnttab", "r")) == NULL) 1440b5de56dSgjelinek return (B_FALSE); 1450b5de56dSgjelinek 1460b5de56dSgjelinek while (getmntent(fp, &entry) == 0) { 1470b5de56dSgjelinek if (strcmp(path, entry.mnt_mountp) == 0) { 1480b5de56dSgjelinek (void) fclose(fp); 1490b5de56dSgjelinek return (B_TRUE); 1500b5de56dSgjelinek } 1510b5de56dSgjelinek } 1520b5de56dSgjelinek 1530b5de56dSgjelinek (void) fclose(fp); 1540b5de56dSgjelinek return (B_FALSE); 1550b5de56dSgjelinek } 1560b5de56dSgjelinek 1570b5de56dSgjelinek /* 1580b5de56dSgjelinek * Perform any necessary housekeeping tasks we need to do before we take 1590b5de56dSgjelinek * a ZFS snapshot of the zone. What this really entails is that we are 1600b5de56dSgjelinek * taking a sw inventory of the source zone, like we do when we detach, 1610b5de56dSgjelinek * so that there is the XML manifest in the snapshot. We use that to 1620b5de56dSgjelinek * validate the snapshot if it is the source of a clone at some later time. 1630b5de56dSgjelinek */ 1640b5de56dSgjelinek static int 1650b5de56dSgjelinek pre_snapshot(char *source_zone) 1660b5de56dSgjelinek { 1670b5de56dSgjelinek int err; 1680b5de56dSgjelinek zone_dochandle_t handle; 1690b5de56dSgjelinek 1700b5de56dSgjelinek if ((handle = zonecfg_init_handle()) == NULL) { 1710b5de56dSgjelinek zperror(cmd_to_str(CMD_CLONE), B_TRUE); 1720b5de56dSgjelinek return (Z_ERR); 1730b5de56dSgjelinek } 1740b5de56dSgjelinek 1750b5de56dSgjelinek if ((err = zonecfg_get_handle(source_zone, handle)) != Z_OK) { 1760b5de56dSgjelinek errno = err; 1770b5de56dSgjelinek zperror(cmd_to_str(CMD_CLONE), B_TRUE); 1780b5de56dSgjelinek zonecfg_fini_handle(handle); 1790b5de56dSgjelinek return (Z_ERR); 1800b5de56dSgjelinek } 1810b5de56dSgjelinek 1820b5de56dSgjelinek if ((err = zonecfg_get_detach_info(handle, B_TRUE)) != Z_OK) { 1830b5de56dSgjelinek errno = err; 1840b5de56dSgjelinek zperror(gettext("getting the software version information " 1850b5de56dSgjelinek "failed"), B_TRUE); 1860b5de56dSgjelinek zonecfg_fini_handle(handle); 1870b5de56dSgjelinek return (Z_ERR); 1880b5de56dSgjelinek } 1890b5de56dSgjelinek 1908cd327d5Sgjelinek if ((err = zonecfg_detach_save(handle, 0)) != Z_OK) { 1910b5de56dSgjelinek errno = err; 1920b5de56dSgjelinek zperror(gettext("saving the software version manifest failed"), 1930b5de56dSgjelinek B_TRUE); 1940b5de56dSgjelinek zonecfg_fini_handle(handle); 1950b5de56dSgjelinek return (Z_ERR); 1960b5de56dSgjelinek } 1970b5de56dSgjelinek 1980b5de56dSgjelinek zonecfg_fini_handle(handle); 1990b5de56dSgjelinek return (Z_OK); 2000b5de56dSgjelinek } 2010b5de56dSgjelinek 2020b5de56dSgjelinek /* 2030b5de56dSgjelinek * Perform any necessary housekeeping tasks we need to do after we take 2040b5de56dSgjelinek * a ZFS snapshot of the zone. What this really entails is removing the 2050b5de56dSgjelinek * sw inventory XML file from the zone. It is still in the snapshot where 2060b5de56dSgjelinek * we want it, but we don't want it in the source zone itself. 2070b5de56dSgjelinek */ 2080b5de56dSgjelinek static int 2090b5de56dSgjelinek post_snapshot(char *source_zone) 2100b5de56dSgjelinek { 2110b5de56dSgjelinek int err; 2120b5de56dSgjelinek zone_dochandle_t handle; 2130b5de56dSgjelinek 2140b5de56dSgjelinek if ((handle = zonecfg_init_handle()) == NULL) { 2150b5de56dSgjelinek zperror(cmd_to_str(CMD_CLONE), B_TRUE); 2160b5de56dSgjelinek return (Z_ERR); 2170b5de56dSgjelinek } 2180b5de56dSgjelinek 2190b5de56dSgjelinek if ((err = zonecfg_get_handle(source_zone, handle)) != Z_OK) { 2200b5de56dSgjelinek errno = err; 2210b5de56dSgjelinek zperror(cmd_to_str(CMD_CLONE), B_TRUE); 2220b5de56dSgjelinek zonecfg_fini_handle(handle); 2230b5de56dSgjelinek return (Z_ERR); 2240b5de56dSgjelinek } 2250b5de56dSgjelinek 2260b5de56dSgjelinek zonecfg_rm_detached(handle, B_FALSE); 2270b5de56dSgjelinek zonecfg_fini_handle(handle); 2280b5de56dSgjelinek 2290b5de56dSgjelinek return (Z_OK); 2300b5de56dSgjelinek } 2310b5de56dSgjelinek 2320b5de56dSgjelinek /* 2330b5de56dSgjelinek * This is a ZFS snapshot iterator call-back function which returns the 2340b5de56dSgjelinek * highest number of SUNWzone snapshots that have been taken. 2350b5de56dSgjelinek */ 2360b5de56dSgjelinek static int 2370b5de56dSgjelinek get_snap_max(zfs_handle_t *zhp, void *data) 2380b5de56dSgjelinek { 2390b5de56dSgjelinek int res; 2400b5de56dSgjelinek zfs_snapshot_data_t *cbp; 2410b5de56dSgjelinek 2420b5de56dSgjelinek if (zfs_get_type(zhp) != ZFS_TYPE_SNAPSHOT) { 2430b5de56dSgjelinek zfs_close(zhp); 2440b5de56dSgjelinek return (0); 2450b5de56dSgjelinek } 2460b5de56dSgjelinek 2470b5de56dSgjelinek cbp = (zfs_snapshot_data_t *)data; 2480b5de56dSgjelinek 2490b5de56dSgjelinek if (strncmp(zfs_get_name(zhp), cbp->match_name, cbp->len) == 0) { 2500b5de56dSgjelinek char *nump; 2510b5de56dSgjelinek int num; 2520b5de56dSgjelinek 2530b5de56dSgjelinek nump = (char *)(zfs_get_name(zhp) + cbp->len); 2540b5de56dSgjelinek num = atoi(nump); 2550b5de56dSgjelinek if (num > cbp->max) 2560b5de56dSgjelinek cbp->max = num; 2570b5de56dSgjelinek } 2580b5de56dSgjelinek 2590b5de56dSgjelinek res = zfs_iter_snapshots(zhp, get_snap_max, data); 2600b5de56dSgjelinek zfs_close(zhp); 2610b5de56dSgjelinek return (res); 2620b5de56dSgjelinek } 2630b5de56dSgjelinek 2640b5de56dSgjelinek /* 2650b5de56dSgjelinek * Take a ZFS snapshot to be used for cloning the zone. 2660b5de56dSgjelinek */ 2670b5de56dSgjelinek static int 2680b5de56dSgjelinek take_snapshot(char *source_zone, zfs_handle_t *zhp, char *snapshot_name, 2690b5de56dSgjelinek int snap_size) 2700b5de56dSgjelinek { 2710b5de56dSgjelinek int res; 2720b5de56dSgjelinek char template[ZFS_MAXNAMELEN]; 2730b5de56dSgjelinek zfs_snapshot_data_t cb; 2740b5de56dSgjelinek 2750b5de56dSgjelinek /* 2760b5de56dSgjelinek * First we need to figure out the next available name for the 2770b5de56dSgjelinek * zone snapshot. Look through the list of zones snapshots for 2780b5de56dSgjelinek * this file system to determine the maximum snapshot name. 2790b5de56dSgjelinek */ 2800b5de56dSgjelinek if (snprintf(template, sizeof (template), "%s@SUNWzone", 2810b5de56dSgjelinek zfs_get_name(zhp)) >= sizeof (template)) 2820b5de56dSgjelinek return (Z_ERR); 2830b5de56dSgjelinek 2840b5de56dSgjelinek cb.match_name = template; 2850b5de56dSgjelinek cb.len = strlen(template); 2860b5de56dSgjelinek cb.max = 0; 2870b5de56dSgjelinek 2880b5de56dSgjelinek if (zfs_iter_snapshots(zhp, get_snap_max, &cb) != 0) 2890b5de56dSgjelinek return (Z_ERR); 2900b5de56dSgjelinek 2910b5de56dSgjelinek cb.max++; 2920b5de56dSgjelinek 2930b5de56dSgjelinek if (snprintf(snapshot_name, snap_size, "%s@SUNWzone%d", 2940b5de56dSgjelinek zfs_get_name(zhp), cb.max) >= snap_size) 2950b5de56dSgjelinek return (Z_ERR); 2960b5de56dSgjelinek 2970b5de56dSgjelinek if (pre_snapshot(source_zone) != Z_OK) 2980b5de56dSgjelinek return (Z_ERR); 2991d452cf5Sahrens res = zfs_snapshot(g_zfs, snapshot_name, B_FALSE); 3000b5de56dSgjelinek if (post_snapshot(source_zone) != Z_OK) 3010b5de56dSgjelinek return (Z_ERR); 3020b5de56dSgjelinek 3030b5de56dSgjelinek if (res != 0) 3040b5de56dSgjelinek return (Z_ERR); 3050b5de56dSgjelinek return (Z_OK); 3060b5de56dSgjelinek } 3070b5de56dSgjelinek 3080b5de56dSgjelinek /* 3090b5de56dSgjelinek * We are using an explicit snapshot from some earlier point in time so 3100b5de56dSgjelinek * we need to validate it. This involves checking the sw inventory that 3110b5de56dSgjelinek * we took when we made the snapshot to verify that the current sw config 3120b5de56dSgjelinek * on the host is still valid to run a zone made from this snapshot. 3130b5de56dSgjelinek */ 3140b5de56dSgjelinek static int 3150b5de56dSgjelinek validate_snapshot(char *snapshot_name, char *snap_path) 3160b5de56dSgjelinek { 3170b5de56dSgjelinek int err; 3180b5de56dSgjelinek zone_dochandle_t handle; 3190b5de56dSgjelinek zone_dochandle_t athandle = NULL; 3200b5de56dSgjelinek 3210b5de56dSgjelinek if ((handle = zonecfg_init_handle()) == NULL) { 3220b5de56dSgjelinek zperror(cmd_to_str(CMD_CLONE), B_TRUE); 3230b5de56dSgjelinek return (Z_ERR); 3240b5de56dSgjelinek } 3250b5de56dSgjelinek 3260b5de56dSgjelinek if ((err = zonecfg_get_handle(target_zone, handle)) != Z_OK) { 3270b5de56dSgjelinek errno = err; 3280b5de56dSgjelinek zperror(cmd_to_str(CMD_CLONE), B_TRUE); 3290b5de56dSgjelinek zonecfg_fini_handle(handle); 3300b5de56dSgjelinek return (Z_ERR); 3310b5de56dSgjelinek } 3320b5de56dSgjelinek 3330b5de56dSgjelinek if ((athandle = zonecfg_init_handle()) == NULL) { 3340b5de56dSgjelinek zperror(cmd_to_str(CMD_CLONE), B_TRUE); 3350b5de56dSgjelinek goto done; 3360b5de56dSgjelinek } 3370b5de56dSgjelinek 3380b5de56dSgjelinek if ((err = zonecfg_get_attach_handle(snap_path, target_zone, B_TRUE, 3390b5de56dSgjelinek athandle)) != Z_OK) { 3400b5de56dSgjelinek if (err == Z_NO_ZONE) 3410b5de56dSgjelinek (void) fprintf(stderr, gettext("snapshot %s was not " 3420b5de56dSgjelinek "taken\n\tby a 'zoneadm clone' command. It can " 3430b5de56dSgjelinek "not be used to clone zones.\n"), snapshot_name); 3440b5de56dSgjelinek else 3450b5de56dSgjelinek (void) fprintf(stderr, gettext("snapshot %s is " 3460b5de56dSgjelinek "out-dated\n\tIt can no longer be used to clone " 3470b5de56dSgjelinek "zones on this system.\n"), snapshot_name); 3480b5de56dSgjelinek goto done; 3490b5de56dSgjelinek } 3500b5de56dSgjelinek 3510b5de56dSgjelinek /* Get the detach information for the locally defined zone. */ 3520b5de56dSgjelinek if ((err = zonecfg_get_detach_info(handle, B_FALSE)) != Z_OK) { 3530b5de56dSgjelinek errno = err; 3540b5de56dSgjelinek zperror(gettext("getting the attach information failed"), 3550b5de56dSgjelinek B_TRUE); 3560b5de56dSgjelinek goto done; 3570b5de56dSgjelinek } 3580b5de56dSgjelinek 3590b5de56dSgjelinek if ((err = sw_cmp(handle, athandle, SW_CMP_SILENT)) != Z_OK) 3600b5de56dSgjelinek (void) fprintf(stderr, gettext("snapshot %s is out-dated\n\t" 3610b5de56dSgjelinek "It can no longer be used to clone zones on this " 3620b5de56dSgjelinek "system.\n"), snapshot_name); 3630b5de56dSgjelinek 3640b5de56dSgjelinek done: 3650b5de56dSgjelinek zonecfg_fini_handle(handle); 3660b5de56dSgjelinek if (athandle != NULL) 3670b5de56dSgjelinek zonecfg_fini_handle(athandle); 3680b5de56dSgjelinek 3690b5de56dSgjelinek return (err); 3700b5de56dSgjelinek } 3710b5de56dSgjelinek 3720b5de56dSgjelinek /* 3730b5de56dSgjelinek * Remove the sw inventory file from inside this zonepath that we picked up out 3740b5de56dSgjelinek * of the snapshot. 3750b5de56dSgjelinek */ 3760b5de56dSgjelinek static int 3770b5de56dSgjelinek clean_out_clone() 3780b5de56dSgjelinek { 3790b5de56dSgjelinek int err; 3800b5de56dSgjelinek zone_dochandle_t handle; 3810b5de56dSgjelinek 3820b5de56dSgjelinek if ((handle = zonecfg_init_handle()) == NULL) { 3830b5de56dSgjelinek zperror(cmd_to_str(CMD_CLONE), B_TRUE); 3840b5de56dSgjelinek return (Z_ERR); 3850b5de56dSgjelinek } 3860b5de56dSgjelinek 3870b5de56dSgjelinek if ((err = zonecfg_get_handle(target_zone, handle)) != Z_OK) { 3880b5de56dSgjelinek errno = err; 3890b5de56dSgjelinek zperror(cmd_to_str(CMD_CLONE), B_TRUE); 3900b5de56dSgjelinek zonecfg_fini_handle(handle); 3910b5de56dSgjelinek return (Z_ERR); 3920b5de56dSgjelinek } 3930b5de56dSgjelinek 3940b5de56dSgjelinek zonecfg_rm_detached(handle, B_FALSE); 3950b5de56dSgjelinek zonecfg_fini_handle(handle); 3960b5de56dSgjelinek 3970b5de56dSgjelinek return (Z_OK); 3980b5de56dSgjelinek } 3990b5de56dSgjelinek 4000b5de56dSgjelinek /* 4010b5de56dSgjelinek * Make a ZFS clone on zonepath from snapshot_name. 4020b5de56dSgjelinek */ 4030b5de56dSgjelinek static int 4040b5de56dSgjelinek clone_snap(char *snapshot_name, char *zonepath) 4050b5de56dSgjelinek { 4060b5de56dSgjelinek int res = Z_OK; 4070b5de56dSgjelinek int err; 4080b5de56dSgjelinek zfs_handle_t *zhp; 4090b5de56dSgjelinek zfs_handle_t *clone; 410e9dbad6fSeschrock nvlist_t *props = NULL; 4110b5de56dSgjelinek 41299653d4eSeschrock if ((zhp = zfs_open(g_zfs, snapshot_name, ZFS_TYPE_SNAPSHOT)) == NULL) 4130b5de56dSgjelinek return (Z_NO_ENTRY); 4140b5de56dSgjelinek 4150b5de56dSgjelinek (void) printf(gettext("Cloning snapshot %s\n"), snapshot_name); 4160b5de56dSgjelinek 417e9dbad6fSeschrock if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0 || 4185f8e1617Snn nvlist_add_string(props, zfs_prop_to_name(ZFS_PROP_SHARENFS), 4195f8e1617Snn "off") != 0) { 4205f8e1617Snn if (props != NULL) 4215f8e1617Snn nvlist_free(props); 422e9dbad6fSeschrock (void) fprintf(stderr, gettext("could not create ZFS clone " 423e9dbad6fSeschrock "%s: out of memory\n"), zonepath); 424e9dbad6fSeschrock return (Z_ERR); 425e9dbad6fSeschrock } 426e9dbad6fSeschrock 427e9dbad6fSeschrock err = zfs_clone(zhp, zonepath, props); 4280b5de56dSgjelinek zfs_close(zhp); 429e9dbad6fSeschrock 430e9dbad6fSeschrock nvlist_free(props); 431e9dbad6fSeschrock 4320b5de56dSgjelinek if (err != 0) 4330b5de56dSgjelinek return (Z_ERR); 4340b5de56dSgjelinek 4350b5de56dSgjelinek /* create the mountpoint if necessary */ 436*990b4856Slling if ((clone = zfs_open(g_zfs, zonepath, ZFS_TYPE_DATASET)) == NULL) 4370b5de56dSgjelinek return (Z_ERR); 4380b5de56dSgjelinek 4390b5de56dSgjelinek /* 4400b5de56dSgjelinek * The clone has been created so we need to print a diagnostic 4410b5de56dSgjelinek * message if one of the following steps fails for some reason. 4420b5de56dSgjelinek */ 4430b5de56dSgjelinek if (zfs_mount(clone, NULL, 0) != 0) { 4440b5de56dSgjelinek (void) fprintf(stderr, gettext("could not mount ZFS clone " 4450b5de56dSgjelinek "%s\n"), zfs_get_name(clone)); 4460b5de56dSgjelinek res = Z_ERR; 4470b5de56dSgjelinek 448e9dbad6fSeschrock } else if (clean_out_clone() != Z_OK) { 449e9dbad6fSeschrock (void) fprintf(stderr, gettext("could not remove the " 450e9dbad6fSeschrock "software inventory from ZFS clone %s\n"), 451e9dbad6fSeschrock zfs_get_name(clone)); 452e9dbad6fSeschrock res = Z_ERR; 4530b5de56dSgjelinek } 4540b5de56dSgjelinek 4550b5de56dSgjelinek zfs_close(clone); 4560b5de56dSgjelinek return (res); 4570b5de56dSgjelinek } 4580b5de56dSgjelinek 4590b5de56dSgjelinek /* 4600b5de56dSgjelinek * This function takes a zonepath and attempts to determine what the ZFS 4610b5de56dSgjelinek * file system name (not mountpoint) should be for that path. We do not 4620b5de56dSgjelinek * assume that zonepath is an existing directory or ZFS fs since we use 4630b5de56dSgjelinek * this function as part of the process of creating a new ZFS fs or clone. 4640b5de56dSgjelinek * 4650b5de56dSgjelinek * The way this works is that we look at the parent directory of the zonepath 4660b5de56dSgjelinek * to see if it is a ZFS fs. If it is, we get the name of that ZFS fs and 4670b5de56dSgjelinek * append the last component of the zonepath to generate the ZFS name for the 4680b5de56dSgjelinek * zonepath. This matches the algorithm that ZFS uses for automatically 4690b5de56dSgjelinek * mounting a new fs after it is created. 4700b5de56dSgjelinek * 4710b5de56dSgjelinek * Although a ZFS fs can be mounted anywhere, we don't worry about handling 4720b5de56dSgjelinek * all of the complexity that a user could possibly configure with arbitrary 4730b5de56dSgjelinek * mounts since there is no way to generate a ZFS name from a random path in 4740b5de56dSgjelinek * the file system. We only try to handle the automatic mounts that ZFS does 4750b5de56dSgjelinek * for each file system. ZFS restricts this so that a new fs must be created 4760b5de56dSgjelinek * in an existing parent ZFS fs. It then automatically mounts the new fs 4770b5de56dSgjelinek * directly under the mountpoint for the parent fs using the last component 4780b5de56dSgjelinek * of the name as the mountpoint directory. 4790b5de56dSgjelinek * 4800b5de56dSgjelinek * For example: 4810b5de56dSgjelinek * Name Mountpoint 4820b5de56dSgjelinek * space/eng/dev/test/zone1 /project1/eng/dev/test/zone1 4830b5de56dSgjelinek * 4840b5de56dSgjelinek * Return Z_OK if the path mapped to a ZFS file system name, otherwise return 4850b5de56dSgjelinek * Z_ERR. 4860b5de56dSgjelinek */ 4870b5de56dSgjelinek static int 4880b5de56dSgjelinek path2name(char *zonepath, char *zfs_name, int len) 4890b5de56dSgjelinek { 4900b5de56dSgjelinek int res; 4910b5de56dSgjelinek char *p; 4920b5de56dSgjelinek zfs_handle_t *zhp; 4930b5de56dSgjelinek 4940b5de56dSgjelinek if ((p = strrchr(zonepath, '/')) == NULL) 4950b5de56dSgjelinek return (Z_ERR); 4960b5de56dSgjelinek 4970b5de56dSgjelinek /* 4980b5de56dSgjelinek * If the parent directory is not its own ZFS fs, then we can't 4990b5de56dSgjelinek * automatically create a new ZFS fs at the 'zonepath' mountpoint 5000b5de56dSgjelinek * so return an error. 5010b5de56dSgjelinek */ 5020b5de56dSgjelinek *p = '\0'; 5030b5de56dSgjelinek zhp = mount2zhandle(zonepath); 5040b5de56dSgjelinek *p = '/'; 5050b5de56dSgjelinek if (zhp == NULL) 5060b5de56dSgjelinek return (Z_ERR); 5070b5de56dSgjelinek 5080b5de56dSgjelinek res = snprintf(zfs_name, len, "%s/%s", zfs_get_name(zhp), p + 1); 5090b5de56dSgjelinek 5100b5de56dSgjelinek zfs_close(zhp); 5110b5de56dSgjelinek if (res >= len) 5120b5de56dSgjelinek return (Z_ERR); 5130b5de56dSgjelinek 5140b5de56dSgjelinek return (Z_OK); 5150b5de56dSgjelinek } 5160b5de56dSgjelinek 5170b5de56dSgjelinek /* 5180b5de56dSgjelinek * A ZFS file system iterator call-back function used to determine if the 5190b5de56dSgjelinek * file system has dependents (snapshots & clones). 5200b5de56dSgjelinek */ 5210b5de56dSgjelinek /* ARGSUSED */ 5220b5de56dSgjelinek static int 5230b5de56dSgjelinek has_dependent(zfs_handle_t *zhp, void *data) 5240b5de56dSgjelinek { 5250b5de56dSgjelinek zfs_close(zhp); 5260b5de56dSgjelinek return (1); 5270b5de56dSgjelinek } 5280b5de56dSgjelinek 5290b5de56dSgjelinek /* 5300b5de56dSgjelinek * Given a snapshot name, get the file system path where the snapshot lives. 5310b5de56dSgjelinek * A snapshot name is of the form fs_name@snap_name. For example, snapshot 5320b5de56dSgjelinek * pl/zones/z1@SUNWzone1 would have a path of 5330b5de56dSgjelinek * /pl/zones/z1/.zfs/snapshot/SUNWzone1. 5340b5de56dSgjelinek */ 5350b5de56dSgjelinek static int 5360b5de56dSgjelinek snap2path(char *snap_name, char *path, int len) 5370b5de56dSgjelinek { 5380b5de56dSgjelinek char *p; 5390b5de56dSgjelinek zfs_handle_t *zhp; 5400b5de56dSgjelinek char mp[ZFS_MAXPROPLEN]; 5410b5de56dSgjelinek 5420b5de56dSgjelinek if ((p = strrchr(snap_name, '@')) == NULL) 5430b5de56dSgjelinek return (Z_ERR); 5440b5de56dSgjelinek 5450b5de56dSgjelinek /* Get the file system name from the snap_name. */ 5460b5de56dSgjelinek *p = '\0'; 547*990b4856Slling zhp = zfs_open(g_zfs, snap_name, ZFS_TYPE_DATASET); 5480b5de56dSgjelinek *p = '@'; 5490b5de56dSgjelinek if (zhp == NULL) 5500b5de56dSgjelinek return (Z_ERR); 5510b5de56dSgjelinek 5520b5de56dSgjelinek /* Get the file system mount point. */ 5530b5de56dSgjelinek if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mp, sizeof (mp), NULL, NULL, 55499653d4eSeschrock 0, B_FALSE) != 0) { 5550b5de56dSgjelinek zfs_close(zhp); 5560b5de56dSgjelinek return (Z_ERR); 5570b5de56dSgjelinek } 5580b5de56dSgjelinek zfs_close(zhp); 5590b5de56dSgjelinek 5600b5de56dSgjelinek p++; 5610b5de56dSgjelinek if (snprintf(path, len, "%s/.zfs/snapshot/%s", mp, p) >= len) 5620b5de56dSgjelinek return (Z_ERR); 5630b5de56dSgjelinek 5640b5de56dSgjelinek return (Z_OK); 5650b5de56dSgjelinek } 5660b5de56dSgjelinek 5670b5de56dSgjelinek /* 5680b5de56dSgjelinek * Clone a pre-existing ZFS snapshot, either by making a direct ZFS clone, if 5690b5de56dSgjelinek * possible, or by copying the data from the snapshot to the zonepath. 5700b5de56dSgjelinek */ 5710b5de56dSgjelinek int 5720b5de56dSgjelinek clone_snapshot_zfs(char *snap_name, char *zonepath) 5730b5de56dSgjelinek { 5740b5de56dSgjelinek int err = Z_OK; 5750b5de56dSgjelinek char clone_name[MAXPATHLEN]; 5760b5de56dSgjelinek char snap_path[MAXPATHLEN]; 5770b5de56dSgjelinek 5780b5de56dSgjelinek if (snap2path(snap_name, snap_path, sizeof (snap_path)) != Z_OK) { 5790b5de56dSgjelinek (void) fprintf(stderr, gettext("unable to find path for %s.\n"), 5800b5de56dSgjelinek snap_name); 5810b5de56dSgjelinek return (Z_ERR); 5820b5de56dSgjelinek } 5830b5de56dSgjelinek 5840b5de56dSgjelinek if (validate_snapshot(snap_name, snap_path) != Z_OK) 5850b5de56dSgjelinek return (Z_NO_ENTRY); 5860b5de56dSgjelinek 5870b5de56dSgjelinek /* 5880b5de56dSgjelinek * The zonepath cannot be ZFS cloned, try to copy the data from 5890b5de56dSgjelinek * within the snapshot to the zonepath. 5900b5de56dSgjelinek */ 5910b5de56dSgjelinek if (path2name(zonepath, clone_name, sizeof (clone_name)) != Z_OK) { 5920b5de56dSgjelinek if ((err = clone_copy(snap_path, zonepath)) == Z_OK) 5930b5de56dSgjelinek if (clean_out_clone() != Z_OK) 5940b5de56dSgjelinek (void) fprintf(stderr, 5950b5de56dSgjelinek gettext("could not remove the " 5960b5de56dSgjelinek "software inventory from %s\n"), zonepath); 5970b5de56dSgjelinek 5980b5de56dSgjelinek return (err); 5990b5de56dSgjelinek } 6000b5de56dSgjelinek 6010b5de56dSgjelinek if ((err = clone_snap(snap_name, clone_name)) != Z_OK) { 6020b5de56dSgjelinek if (err != Z_NO_ENTRY) { 6030b5de56dSgjelinek /* 6040b5de56dSgjelinek * Cloning the snapshot failed. Fall back to trying 6050b5de56dSgjelinek * to install the zone by copying from the snapshot. 6060b5de56dSgjelinek */ 6070b5de56dSgjelinek if ((err = clone_copy(snap_path, zonepath)) == Z_OK) 6080b5de56dSgjelinek if (clean_out_clone() != Z_OK) 6090b5de56dSgjelinek (void) fprintf(stderr, 6100b5de56dSgjelinek gettext("could not remove the " 6110b5de56dSgjelinek "software inventory from %s\n"), 6120b5de56dSgjelinek zonepath); 6130b5de56dSgjelinek } else { 6140b5de56dSgjelinek /* 6150b5de56dSgjelinek * The snapshot is unusable for some reason so restore 6160b5de56dSgjelinek * the zone state to configured since we were unable to 6170b5de56dSgjelinek * actually do anything about getting the zone 6180b5de56dSgjelinek * installed. 6190b5de56dSgjelinek */ 6200b5de56dSgjelinek int tmp; 6210b5de56dSgjelinek 6220b5de56dSgjelinek if ((tmp = zone_set_state(target_zone, 6230b5de56dSgjelinek ZONE_STATE_CONFIGURED)) != Z_OK) { 6240b5de56dSgjelinek errno = tmp; 6250b5de56dSgjelinek zperror2(target_zone, 6260b5de56dSgjelinek gettext("could not set state")); 6270b5de56dSgjelinek } 6280b5de56dSgjelinek } 6290b5de56dSgjelinek } 6300b5de56dSgjelinek 6310b5de56dSgjelinek return (err); 6320b5de56dSgjelinek } 6330b5de56dSgjelinek 6340b5de56dSgjelinek /* 6350b5de56dSgjelinek * Attempt to clone a source_zone to a target zonepath by using a ZFS clone. 6360b5de56dSgjelinek */ 6370b5de56dSgjelinek int 6380b5de56dSgjelinek clone_zfs(char *source_zone, char *source_zonepath, char *zonepath) 6390b5de56dSgjelinek { 6400b5de56dSgjelinek zfs_handle_t *zhp; 6410b5de56dSgjelinek char clone_name[MAXPATHLEN]; 6420b5de56dSgjelinek char snap_name[MAXPATHLEN]; 6430b5de56dSgjelinek 6440b5de56dSgjelinek /* 6450b5de56dSgjelinek * Try to get a zfs handle for the source_zonepath. If this fails 6460b5de56dSgjelinek * the source_zonepath is not ZFS so return an error. 6470b5de56dSgjelinek */ 6480b5de56dSgjelinek if ((zhp = mount2zhandle(source_zonepath)) == NULL) 6490b5de56dSgjelinek return (Z_ERR); 6500b5de56dSgjelinek 6510b5de56dSgjelinek /* 6520b5de56dSgjelinek * Check if there is a file system already mounted on zonepath. If so, 6530b5de56dSgjelinek * we can't clone to the path so we should fall back to copying. 6540b5de56dSgjelinek */ 6550b5de56dSgjelinek if (is_mountpnt(zonepath)) { 6560b5de56dSgjelinek zfs_close(zhp); 6570b5de56dSgjelinek (void) fprintf(stderr, 6580b5de56dSgjelinek gettext("A file system is already mounted on %s,\n" 6590b5de56dSgjelinek "preventing use of a ZFS clone.\n"), zonepath); 6600b5de56dSgjelinek return (Z_ERR); 6610b5de56dSgjelinek } 6620b5de56dSgjelinek 6630b5de56dSgjelinek /* 6640b5de56dSgjelinek * Instead of using path2name to get the clone name from the zonepath, 6650b5de56dSgjelinek * we could generate a name from the source zone ZFS name. However, 6660b5de56dSgjelinek * this would mean we would create the clone under the ZFS fs of the 6670b5de56dSgjelinek * source instead of what the zonepath says. For example, 6680b5de56dSgjelinek * 6690b5de56dSgjelinek * source_zonepath zonepath 6700b5de56dSgjelinek * /pl/zones/dev/z1 /pl/zones/deploy/z2 6710b5de56dSgjelinek * 6720b5de56dSgjelinek * We don't want the clone to be under "dev", we want it under 6730b5de56dSgjelinek * "deploy", so that we can leverage the normal attribute inheritance 6740b5de56dSgjelinek * that ZFS provides in the fs hierarchy. 6750b5de56dSgjelinek */ 6760b5de56dSgjelinek if (path2name(zonepath, clone_name, sizeof (clone_name)) != Z_OK) { 6770b5de56dSgjelinek zfs_close(zhp); 6780b5de56dSgjelinek return (Z_ERR); 6790b5de56dSgjelinek } 6800b5de56dSgjelinek 6810b5de56dSgjelinek if (take_snapshot(source_zone, zhp, snap_name, sizeof (snap_name)) 6820b5de56dSgjelinek != Z_OK) { 6830b5de56dSgjelinek zfs_close(zhp); 6840b5de56dSgjelinek return (Z_ERR); 6850b5de56dSgjelinek } 6860b5de56dSgjelinek zfs_close(zhp); 6870b5de56dSgjelinek 688d9e728a2Sgjelinek if (clone_snap(snap_name, clone_name) != Z_OK) { 689d9e728a2Sgjelinek /* Clean up the snapshot we just took. */ 690d9e728a2Sgjelinek if ((zhp = zfs_open(g_zfs, snap_name, ZFS_TYPE_SNAPSHOT)) 691d9e728a2Sgjelinek != NULL) { 692d9e728a2Sgjelinek if (zfs_unmount(zhp, NULL, 0) == 0) 693d9e728a2Sgjelinek (void) zfs_destroy(zhp); 694d9e728a2Sgjelinek zfs_close(zhp); 695d9e728a2Sgjelinek } 696d9e728a2Sgjelinek 6970b5de56dSgjelinek return (Z_ERR); 698d9e728a2Sgjelinek } 6990b5de56dSgjelinek 7000b5de56dSgjelinek (void) printf(gettext("Instead of copying, a ZFS clone has been " 7010b5de56dSgjelinek "created for this zone.\n")); 7020b5de56dSgjelinek 7030b5de56dSgjelinek return (Z_OK); 7040b5de56dSgjelinek } 7050b5de56dSgjelinek 7060b5de56dSgjelinek /* 7070b5de56dSgjelinek * Attempt to create a ZFS file system for the specified zonepath. 7080b5de56dSgjelinek * We either will successfully create a ZFS file system and get it mounted 7090b5de56dSgjelinek * on the zonepath or we don't. The caller doesn't care since a regular 7100b5de56dSgjelinek * directory is used for the zonepath if no ZFS file system is mounted there. 7110b5de56dSgjelinek */ 7120b5de56dSgjelinek void 7130b5de56dSgjelinek create_zfs_zonepath(char *zonepath) 7140b5de56dSgjelinek { 7150b5de56dSgjelinek zfs_handle_t *zhp; 7160b5de56dSgjelinek char zfs_name[MAXPATHLEN]; 717e9dbad6fSeschrock nvlist_t *props = NULL; 7180b5de56dSgjelinek 7190b5de56dSgjelinek if (path2name(zonepath, zfs_name, sizeof (zfs_name)) != Z_OK) 7200b5de56dSgjelinek return; 7210b5de56dSgjelinek 722e9dbad6fSeschrock if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0 || 7235f8e1617Snn nvlist_add_string(props, zfs_prop_to_name(ZFS_PROP_SHARENFS), 7245f8e1617Snn "off") != 0) { 7255f8e1617Snn if (props != NULL) 7265f8e1617Snn nvlist_free(props); 727e9dbad6fSeschrock (void) fprintf(stderr, gettext("cannot create ZFS dataset %s: " 728e9dbad6fSeschrock "out of memory\n"), zfs_name); 729e9dbad6fSeschrock } 730e9dbad6fSeschrock 731e9dbad6fSeschrock if (zfs_create(g_zfs, zfs_name, ZFS_TYPE_FILESYSTEM, props) != 0 || 732*990b4856Slling (zhp = zfs_open(g_zfs, zfs_name, ZFS_TYPE_DATASET)) == NULL) { 73399653d4eSeschrock (void) fprintf(stderr, gettext("cannot create ZFS dataset %s: " 73499653d4eSeschrock "%s\n"), zfs_name, libzfs_error_description(g_zfs)); 735e9dbad6fSeschrock nvlist_free(props); 7360b5de56dSgjelinek return; 7370b5de56dSgjelinek } 7380b5de56dSgjelinek 739e9dbad6fSeschrock nvlist_free(props); 740e9dbad6fSeschrock 7410b5de56dSgjelinek if (zfs_mount(zhp, NULL, 0) != 0) { 74299653d4eSeschrock (void) fprintf(stderr, gettext("cannot mount ZFS dataset %s: " 74399653d4eSeschrock "%s\n"), zfs_name, libzfs_error_description(g_zfs)); 7440b5de56dSgjelinek (void) zfs_destroy(zhp); 7450b5de56dSgjelinek } else { 7460b5de56dSgjelinek if (chmod(zonepath, S_IRWXU) != 0) { 7470b5de56dSgjelinek (void) fprintf(stderr, gettext("file system %s " 7480b5de56dSgjelinek "successfully created, but chmod %o failed: %s\n"), 7490b5de56dSgjelinek zfs_name, S_IRWXU, strerror(errno)); 7500b5de56dSgjelinek (void) destroy_zfs(zonepath); 7510b5de56dSgjelinek } else { 7520b5de56dSgjelinek (void) printf(gettext("A ZFS file system has been " 7530b5de56dSgjelinek "created for this zone.\n")); 7540b5de56dSgjelinek } 7550b5de56dSgjelinek } 7560b5de56dSgjelinek 7570b5de56dSgjelinek zfs_close(zhp); 7580b5de56dSgjelinek } 7590b5de56dSgjelinek 7600b5de56dSgjelinek /* 7610b5de56dSgjelinek * If the zonepath is a ZFS file system, attempt to destroy it. We return Z_OK 7620b5de56dSgjelinek * if we were able to zfs_destroy the zonepath, otherwise we return Z_ERR 7630b5de56dSgjelinek * which means the caller should clean up the zonepath in the traditional 7640b5de56dSgjelinek * way. 7650b5de56dSgjelinek */ 7660b5de56dSgjelinek int 7670b5de56dSgjelinek destroy_zfs(char *zonepath) 7680b5de56dSgjelinek { 7690b5de56dSgjelinek zfs_handle_t *zhp; 7700b5de56dSgjelinek boolean_t is_clone = B_FALSE; 7710b5de56dSgjelinek char origin[ZFS_MAXPROPLEN]; 7720b5de56dSgjelinek 77399653d4eSeschrock if ((zhp = mount2zhandle(zonepath)) == NULL) 7740b5de56dSgjelinek return (Z_ERR); 7750b5de56dSgjelinek 7760b5de56dSgjelinek /* 7770b5de56dSgjelinek * We can't destroy the file system if it has dependents. 7780b5de56dSgjelinek */ 7793bb79becSeschrock if (zfs_iter_dependents(zhp, B_TRUE, has_dependent, NULL) != 0 || 7800b5de56dSgjelinek zfs_unmount(zhp, NULL, 0) != 0) { 7810b5de56dSgjelinek zfs_close(zhp); 7820b5de56dSgjelinek return (Z_ERR); 7830b5de56dSgjelinek } 7840b5de56dSgjelinek 7850b5de56dSgjelinek /* 7860b5de56dSgjelinek * This might be a clone. Try to get the snapshot so we can attempt 7870b5de56dSgjelinek * to destroy that as well. 7880b5de56dSgjelinek */ 7890b5de56dSgjelinek if (zfs_prop_get(zhp, ZFS_PROP_ORIGIN, origin, sizeof (origin), NULL, 79099653d4eSeschrock NULL, 0, B_FALSE) == 0) 7910b5de56dSgjelinek is_clone = B_TRUE; 7920b5de56dSgjelinek 7930b5de56dSgjelinek if (zfs_destroy(zhp) != 0) { 7940b5de56dSgjelinek /* 7950b5de56dSgjelinek * If the destroy fails for some reason, try to remount 7960b5de56dSgjelinek * the file system so that we can use "rm -rf" to clean up 7970b5de56dSgjelinek * instead. 7980b5de56dSgjelinek */ 7990b5de56dSgjelinek (void) zfs_mount(zhp, NULL, 0); 8000b5de56dSgjelinek zfs_close(zhp); 8010b5de56dSgjelinek return (Z_ERR); 8020b5de56dSgjelinek } 8030b5de56dSgjelinek 804d9e728a2Sgjelinek /* 805d9e728a2Sgjelinek * If the zone has ever been moved then the mountpoint dir will not be 806d9e728a2Sgjelinek * cleaned up by the zfs_destroy(). To handle this case try to clean 807d9e728a2Sgjelinek * it up now but don't worry if it fails, that will be normal. 808d9e728a2Sgjelinek */ 809d9e728a2Sgjelinek (void) rmdir(zonepath); 810d9e728a2Sgjelinek 8110b5de56dSgjelinek (void) printf(gettext("The ZFS file system for this zone has been " 8120b5de56dSgjelinek "destroyed.\n")); 8130b5de56dSgjelinek 8140b5de56dSgjelinek if (is_clone) { 8150b5de56dSgjelinek zfs_handle_t *ohp; 8160b5de56dSgjelinek 8170b5de56dSgjelinek /* 8180b5de56dSgjelinek * Try to clean up the snapshot that the clone was taken from. 8190b5de56dSgjelinek */ 82099653d4eSeschrock if ((ohp = zfs_open(g_zfs, origin, 82199653d4eSeschrock ZFS_TYPE_SNAPSHOT)) != NULL) { 8223bb79becSeschrock if (zfs_iter_dependents(ohp, B_TRUE, has_dependent, 8233bb79becSeschrock NULL) == 0 && zfs_unmount(ohp, NULL, 0) == 0) 8240b5de56dSgjelinek (void) zfs_destroy(ohp); 8250b5de56dSgjelinek zfs_close(ohp); 8260b5de56dSgjelinek } 8270b5de56dSgjelinek } 8280b5de56dSgjelinek 8290b5de56dSgjelinek zfs_close(zhp); 8300b5de56dSgjelinek return (Z_OK); 8310b5de56dSgjelinek } 8320b5de56dSgjelinek 8330b5de56dSgjelinek /* 8340b5de56dSgjelinek * Return true if the path is its own zfs file system. We determine this 8350b5de56dSgjelinek * by stat-ing the path to see if it is zfs and stat-ing the parent to see 8360b5de56dSgjelinek * if it is a different fs. 8370b5de56dSgjelinek */ 8380b5de56dSgjelinek boolean_t 8390b5de56dSgjelinek is_zonepath_zfs(char *zonepath) 8400b5de56dSgjelinek { 8410b5de56dSgjelinek int res; 8420b5de56dSgjelinek char *path; 8430b5de56dSgjelinek char *parent; 8443f2f09c1Sdp struct statvfs64 buf1, buf2; 8450b5de56dSgjelinek 8463f2f09c1Sdp if (statvfs64(zonepath, &buf1) != 0) 8470b5de56dSgjelinek return (B_FALSE); 8480b5de56dSgjelinek 8490b5de56dSgjelinek if (strcmp(buf1.f_basetype, "zfs") != 0) 8500b5de56dSgjelinek return (B_FALSE); 8510b5de56dSgjelinek 8520b5de56dSgjelinek if ((path = strdup(zonepath)) == NULL) 8530b5de56dSgjelinek return (B_FALSE); 8540b5de56dSgjelinek 8550b5de56dSgjelinek parent = dirname(path); 8563f2f09c1Sdp res = statvfs64(parent, &buf2); 8570b5de56dSgjelinek free(path); 8580b5de56dSgjelinek 8590b5de56dSgjelinek if (res != 0) 8600b5de56dSgjelinek return (B_FALSE); 8610b5de56dSgjelinek 8620b5de56dSgjelinek if (buf1.f_fsid == buf2.f_fsid) 8630b5de56dSgjelinek return (B_FALSE); 8640b5de56dSgjelinek 8650b5de56dSgjelinek return (B_TRUE); 8660b5de56dSgjelinek } 8670b5de56dSgjelinek 8680b5de56dSgjelinek /* 8690b5de56dSgjelinek * Implement the fast move of a ZFS file system by simply updating the 8700b5de56dSgjelinek * mountpoint. Since it is file system already, we don't have the 8710b5de56dSgjelinek * issue of cross-file system copying. 8720b5de56dSgjelinek */ 8730b5de56dSgjelinek int 8740b5de56dSgjelinek move_zfs(char *zonepath, char *new_zonepath) 8750b5de56dSgjelinek { 8760b5de56dSgjelinek int ret = Z_ERR; 8770b5de56dSgjelinek zfs_handle_t *zhp; 8780b5de56dSgjelinek 87999653d4eSeschrock if ((zhp = mount2zhandle(zonepath)) == NULL) 8800b5de56dSgjelinek return (Z_ERR); 8810b5de56dSgjelinek 882e9dbad6fSeschrock if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), 883e9dbad6fSeschrock new_zonepath) == 0) { 8840b5de56dSgjelinek /* 8850b5de56dSgjelinek * Clean up the old mount point. We ignore any failure since 8860b5de56dSgjelinek * the zone is already successfully mounted on the new path. 8870b5de56dSgjelinek */ 8880b5de56dSgjelinek (void) rmdir(zonepath); 8890b5de56dSgjelinek ret = Z_OK; 8900b5de56dSgjelinek } 8910b5de56dSgjelinek 8920b5de56dSgjelinek zfs_close(zhp); 8930b5de56dSgjelinek 8940b5de56dSgjelinek return (ret); 8950b5de56dSgjelinek } 8960b5de56dSgjelinek 8970b5de56dSgjelinek /* 8980b5de56dSgjelinek * Validate that the given dataset exists on the system, and that neither it nor 8990b5de56dSgjelinek * its children are zvols. 9000b5de56dSgjelinek * 9010b5de56dSgjelinek * Note that we don't do anything with the 'zoned' property here. All 9020b5de56dSgjelinek * management is done in zoneadmd when the zone is actually rebooted. This 9030b5de56dSgjelinek * allows us to automatically set the zoned property even when a zone is 9040b5de56dSgjelinek * rebooted by the administrator. 9050b5de56dSgjelinek */ 9060b5de56dSgjelinek int 9070b5de56dSgjelinek verify_datasets(zone_dochandle_t handle) 9080b5de56dSgjelinek { 9090b5de56dSgjelinek int return_code = Z_OK; 9100b5de56dSgjelinek struct zone_dstab dstab; 9110b5de56dSgjelinek zfs_handle_t *zhp; 9120b5de56dSgjelinek char propbuf[ZFS_MAXPROPLEN]; 9130b5de56dSgjelinek char source[ZFS_MAXNAMELEN]; 914*990b4856Slling zprop_source_t srctype; 9150b5de56dSgjelinek 9160b5de56dSgjelinek if (zonecfg_setdsent(handle) != Z_OK) { 9170b5de56dSgjelinek /* 9180b5de56dSgjelinek * TRANSLATION_NOTE 9190b5de56dSgjelinek * zfs and dataset are literals that should not be translated. 9200b5de56dSgjelinek */ 9210b5de56dSgjelinek (void) fprintf(stderr, gettext("could not verify zfs datasets: " 9220b5de56dSgjelinek "unable to enumerate datasets\n")); 9230b5de56dSgjelinek return (Z_ERR); 9240b5de56dSgjelinek } 9250b5de56dSgjelinek 9260b5de56dSgjelinek while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 9270b5de56dSgjelinek 92899653d4eSeschrock if ((zhp = zfs_open(g_zfs, dstab.zone_dataset_name, 9290b5de56dSgjelinek ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME)) == NULL) { 93099653d4eSeschrock (void) fprintf(stderr, gettext("could not verify zfs " 93199653d4eSeschrock "dataset %s: %s\n"), dstab.zone_dataset_name, 93299653d4eSeschrock libzfs_error_description(g_zfs)); 9330b5de56dSgjelinek return_code = Z_ERR; 9340b5de56dSgjelinek continue; 9350b5de56dSgjelinek } 9360b5de56dSgjelinek 9370b5de56dSgjelinek if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, propbuf, 9380b5de56dSgjelinek sizeof (propbuf), &srctype, source, 9390b5de56dSgjelinek sizeof (source), 0) == 0 && 940*990b4856Slling (srctype == ZPROP_SRC_INHERITED)) { 9410b5de56dSgjelinek (void) fprintf(stderr, gettext("could not verify zfs " 9420b5de56dSgjelinek "dataset %s: mountpoint cannot be inherited\n"), 9430b5de56dSgjelinek dstab.zone_dataset_name); 9440b5de56dSgjelinek return_code = Z_ERR; 9450b5de56dSgjelinek zfs_close(zhp); 9460b5de56dSgjelinek continue; 9470b5de56dSgjelinek } 9480b5de56dSgjelinek 9490b5de56dSgjelinek if (zfs_get_type(zhp) == ZFS_TYPE_VOLUME) { 9500b5de56dSgjelinek (void) fprintf(stderr, gettext("cannot verify zfs " 9510b5de56dSgjelinek "dataset %s: volumes cannot be specified as a " 9520b5de56dSgjelinek "zone dataset resource\n"), 9530b5de56dSgjelinek dstab.zone_dataset_name); 9540b5de56dSgjelinek return_code = Z_ERR; 9550b5de56dSgjelinek } 9560b5de56dSgjelinek 9570b5de56dSgjelinek if (zfs_iter_children(zhp, check_zvol, NULL) != 0) 9580b5de56dSgjelinek return_code = Z_ERR; 9590b5de56dSgjelinek 9600b5de56dSgjelinek zfs_close(zhp); 9610b5de56dSgjelinek } 9620b5de56dSgjelinek (void) zonecfg_enddsent(handle); 9630b5de56dSgjelinek 9640b5de56dSgjelinek return (return_code); 9650b5de56dSgjelinek } 9660b5de56dSgjelinek 9670b5de56dSgjelinek /* 9680b5de56dSgjelinek * Verify that the ZFS dataset exists, and its mountpoint 9690b5de56dSgjelinek * property is set to "legacy". 9700b5de56dSgjelinek */ 9710b5de56dSgjelinek int 9720b5de56dSgjelinek verify_fs_zfs(struct zone_fstab *fstab) 9730b5de56dSgjelinek { 9740b5de56dSgjelinek zfs_handle_t *zhp; 9750b5de56dSgjelinek char propbuf[ZFS_MAXPROPLEN]; 9760b5de56dSgjelinek 97799653d4eSeschrock if ((zhp = zfs_open(g_zfs, fstab->zone_fs_special, 978*990b4856Slling ZFS_TYPE_DATASET)) == NULL) { 9790b5de56dSgjelinek (void) fprintf(stderr, gettext("could not verify fs %s: " 9800b5de56dSgjelinek "could not access zfs dataset '%s'\n"), 9810b5de56dSgjelinek fstab->zone_fs_dir, fstab->zone_fs_special); 9820b5de56dSgjelinek return (Z_ERR); 9830b5de56dSgjelinek } 9840b5de56dSgjelinek 9850b5de56dSgjelinek if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) { 9860b5de56dSgjelinek (void) fprintf(stderr, gettext("cannot verify fs %s: " 9870b5de56dSgjelinek "'%s' is not a file system\n"), 9880b5de56dSgjelinek fstab->zone_fs_dir, fstab->zone_fs_special); 9890b5de56dSgjelinek zfs_close(zhp); 9900b5de56dSgjelinek return (Z_ERR); 9910b5de56dSgjelinek } 9920b5de56dSgjelinek 9930b5de56dSgjelinek if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, propbuf, sizeof (propbuf), 9940b5de56dSgjelinek NULL, NULL, 0, 0) != 0 || strcmp(propbuf, "legacy") != 0) { 9950b5de56dSgjelinek (void) fprintf(stderr, gettext("could not verify fs %s: " 9960b5de56dSgjelinek "zfs '%s' mountpoint is not \"legacy\"\n"), 9970b5de56dSgjelinek fstab->zone_fs_dir, fstab->zone_fs_special); 9980b5de56dSgjelinek zfs_close(zhp); 9990b5de56dSgjelinek return (Z_ERR); 10000b5de56dSgjelinek } 10010b5de56dSgjelinek 10020b5de56dSgjelinek zfs_close(zhp); 100399653d4eSeschrock return (Z_OK); 100499653d4eSeschrock } 100599653d4eSeschrock 100699653d4eSeschrock int 100799653d4eSeschrock init_zfs(void) 100899653d4eSeschrock { 100999653d4eSeschrock if ((g_zfs = libzfs_init()) == NULL) { 101099653d4eSeschrock (void) fprintf(stderr, gettext("failed to initialize ZFS " 101199653d4eSeschrock "library\n")); 101299653d4eSeschrock return (Z_ERR); 101399653d4eSeschrock } 101499653d4eSeschrock 10150b5de56dSgjelinek return (Z_OK); 10160b5de56dSgjelinek } 1017