Index: projects/bectl/lib/libbe/be.c =================================================================== --- projects/bectl/lib/libbe/be.c (revision 337413) +++ projects/bectl/lib/libbe/be.c (revision 337414) @@ -1,891 +1,891 @@ -/* - * be.c +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2017 Kyle J. Kneitinger * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include "be.h" #include "be_impl.h" /* * Iterator function for locating the rootfs amongst the children of the * zfs_be_root set by loader(8). data is expected to be a libbe_handle_t *. */ static int be_locate_rootfs(zfs_handle_t *chkds, void *data) { libbe_handle_t *lbh; char *mntpoint; lbh = (libbe_handle_t *)data; if (lbh == NULL) return (1); if (zfs_is_mounted(chkds, &mntpoint) && strcmp(mntpoint, "/") == 0) { strncpy(lbh->rootfs, zfs_get_name(chkds), BE_MAXPATHLEN); return (1); } return (0); } /* * Initializes the libbe context to operate in the root boot environment * dataset, for example, zroot/ROOT. */ libbe_handle_t * libbe_init(void) { struct stat sb; dev_t root_dev, boot_dev; libbe_handle_t *lbh; zfs_handle_t *rootds; char *poolname, *pos; int pnamelen; lbh = NULL; poolname = pos = NULL; pnamelen = 0; rootds = NULL; /* Verify that /boot and / are mounted on the same filesystem */ /* TODO: use errno here?? */ if (stat("/", &sb) != 0) goto err; root_dev = sb.st_dev; if (stat("/boot", &sb) != 0) goto err; boot_dev = sb.st_dev; if (root_dev != boot_dev) { fprintf(stderr, "/ and /boot not on same device, quitting\n"); goto err; } if ((lbh = calloc(1, sizeof(libbe_handle_t))) == NULL) goto err; if ((lbh->lzh = libzfs_init()) == NULL) goto err; /* Obtain path to boot environment root */ if ((kenv(KENV_GET, "zfs_be_root", lbh->root, BE_MAXPATHLEN)) == -1) goto err; /* Remove leading 'zfs:' if present, otherwise use value as-is */ if (strcmp(lbh->root, "zfs:") == 0) strncpy(lbh->root, strchr(lbh->root, ':') + sizeof(char), BE_MAXPATHLEN); if ((pos = strchr(lbh->root, '/')) == NULL) goto err; pnamelen = pos - lbh->root; poolname = malloc(pnamelen + 1); if (poolname == NULL) goto err; strncpy(poolname, lbh->root, pnamelen); poolname[pnamelen] = '\0'; if ((lbh->active_phandle = zpool_open(lbh->lzh, poolname)) == NULL) goto err; if (zpool_get_prop(lbh->active_phandle, ZPOOL_PROP_BOOTFS, lbh->bootfs, BE_MAXPATHLEN, NULL, true) != 0) goto err; /* Obtain path to boot environment rootfs (currently booted) */ /* XXX Get dataset mounted at / by kenv/GUID from mountroot? */ if ((rootds = zfs_open(lbh->lzh, lbh->root, ZFS_TYPE_DATASET)) == NULL) goto err; zfs_iter_filesystems(rootds, be_locate_rootfs, lbh); zfs_close(rootds); rootds = NULL; if (*lbh->rootfs == '\0') goto err; return (lbh); err: if (lbh != NULL) { if (lbh->active_phandle != NULL) zpool_close(lbh->active_phandle); if (lbh->lzh != NULL) libzfs_fini(lbh->lzh); free(lbh); } if (rootds != NULL) zfs_close(rootds); free(poolname); return (NULL); } /* * Free memory allocated by libbe_init() */ void libbe_close(libbe_handle_t *lbh) { if (lbh->active_phandle != NULL) zpool_close(lbh->active_phandle); libzfs_fini(lbh->lzh); free(lbh); } /* * Proxy through to libzfs for the moment. */ void be_nicenum(uint64_t num, char *buf, size_t buflen) { zfs_nicenum(num, buf, buflen); } static int be_destroy_cb(zfs_handle_t *zfs_hdl, void *data) { int err; if ((err = zfs_iter_children(zfs_hdl, be_destroy_cb, data)) != 0) return (err); if ((err = zfs_destroy(zfs_hdl, false)) != 0) return (err); return (0); } /* * Destroy the boot environment or snapshot specified by the name * parameter. Options are or'd together with the possible values: * BE_DESTROY_FORCE : forces operation on mounted datasets */ int be_destroy(libbe_handle_t *lbh, char *name, int options) { zfs_handle_t *fs; char path[BE_MAXPATHLEN]; char *p; int err, force, mounted; p = path; force = options & BE_DESTROY_FORCE; err = BE_ERR_SUCCESS; be_root_concat(lbh, name, path); if (strchr(name, '@') == NULL) { if (!zfs_dataset_exists(lbh->lzh, path, ZFS_TYPE_FILESYSTEM)) return (set_error(lbh, BE_ERR_NOENT)); if (strcmp(path, lbh->rootfs) == 0) return (set_error(lbh, BE_ERR_DESTROYACT)); fs = zfs_open(lbh->lzh, p, ZFS_TYPE_FILESYSTEM); } else { if (!zfs_dataset_exists(lbh->lzh, path, ZFS_TYPE_SNAPSHOT)) return (set_error(lbh, BE_ERR_NOENT)); fs = zfs_open(lbh->lzh, p, ZFS_TYPE_SNAPSHOT); } if (fs == NULL) return (set_error(lbh, BE_ERR_ZFSOPEN)); /* Check if mounted, unmount if force is specified */ if ((mounted = zfs_is_mounted(fs, NULL)) != 0) { if (force) zfs_unmount(fs, NULL, 0); else return (set_error(lbh, BE_ERR_DESTROYMNT)); } if ((err = be_destroy_cb(fs, NULL)) != 0) { /* Children are still present or the mount is referenced */ if (err == EBUSY) return (set_error(lbh, BE_ERR_DESTROYMNT)); return (set_error(lbh, BE_ERR_UNKNOWN)); } return (0); } int be_snapshot(libbe_handle_t *lbh, const char *source, const char *snap_name, bool recursive, char *result) { char buf[BE_MAXPATHLEN]; time_t rawtime; int len, err; be_root_concat(lbh, source, buf); if (!be_exists(lbh, buf)) return (BE_ERR_NOENT); if (snap_name != NULL) { strcat(buf, "@"); strcat(buf, snap_name); if (result != NULL) snprintf(result, BE_MAXPATHLEN, "%s@%s", source, snap_name); } else { time(&rawtime); len = strlen(buf); strftime(buf + len, BE_MAXPATHLEN - len, "@%F-%T", localtime(&rawtime)); if (result != NULL) strcpy(result, strrchr(buf, '/') + 1); } if ((err = zfs_snapshot(lbh->lzh, buf, recursive, NULL)) != 0) { switch (err) { case EZFS_INVALIDNAME: return (set_error(lbh, BE_ERR_INVALIDNAME)); default: /* XXX TODO: elaborate return codes */ return (set_error(lbh, BE_ERR_UNKNOWN)); } } return (BE_ERR_SUCCESS); } /* * Create the boot environment specified by the name parameter */ int be_create(libbe_handle_t *lbh, char *name) { int err; err = be_create_from_existing(lbh, name, be_active_path(lbh)); return (set_error(lbh, err)); } static int be_deep_clone_prop(int prop, void *cb) { int err; struct libbe_dccb *dccb; zprop_source_t src; char pval[BE_MAXPATHLEN]; char source[BE_MAXPATHLEN]; dccb = cb; /* Skip some properties we don't want to touch */ switch (prop) { case ZFS_PROP_CANMOUNT: return (ZPROP_CONT); break; } /* Don't copy readonly properties */ if (zfs_prop_readonly(prop)) return (ZPROP_CONT); if ((err = zfs_prop_get(dccb->zhp, prop, (char *)&pval, sizeof(pval), &src, (char *)&source, sizeof(source), false))) /* Just continue if we fail to read a property */ return (ZPROP_CONT); /* Only copy locally defined properties */ if (src != ZPROP_SRC_LOCAL) return (ZPROP_CONT); nvlist_add_string(dccb->props, zfs_prop_to_name(prop), (char *)pval); return (ZPROP_CONT); } static int be_deep_clone(zfs_handle_t *ds, void *data) { int err; char be_path[BE_MAXPATHLEN]; char snap_path[BE_MAXPATHLEN]; const char *dspath; char *dsname; zfs_handle_t *snap_hdl; nvlist_t *props; struct libbe_deep_clone *isdc, sdc; struct libbe_dccb dccb; isdc = (struct libbe_deep_clone *)data; dspath = zfs_get_name(ds); if ((dsname = strrchr(dspath, '/')) == NULL) return (BE_ERR_UNKNOWN); dsname++; if (isdc->bename == NULL) snprintf(be_path, sizeof(be_path), "%s/%s", isdc->be_root, dsname); else snprintf(be_path, sizeof(be_path), "%s/%s", isdc->be_root, isdc->bename); snprintf(snap_path, sizeof(snap_path), "%s@%s", dspath, isdc->snapname); if (zfs_dataset_exists(isdc->lbh->lzh, be_path, ZFS_TYPE_DATASET)) return (set_error(isdc->lbh, BE_ERR_EXISTS)); if ((snap_hdl = zfs_open(isdc->lbh->lzh, snap_path, ZFS_TYPE_SNAPSHOT)) == NULL) return (set_error(isdc->lbh, BE_ERR_ZFSOPEN)); nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP); nvlist_add_string(props, "canmount", "noauto"); dccb.zhp = ds; dccb.props = props; if (zprop_iter(be_deep_clone_prop, &dccb, B_FALSE, B_FALSE, ZFS_TYPE_FILESYSTEM) == ZPROP_INVAL) return (-1); if ((err = zfs_clone(snap_hdl, be_path, props)) != 0) { switch (err) { case EZFS_SUCCESS: err = BE_ERR_SUCCESS; break; default: err = BE_ERR_ZFSCLONE; break; } } nvlist_free(props); zfs_close(snap_hdl); sdc.lbh = isdc->lbh; sdc.bename = NULL; sdc.snapname = isdc->snapname; sdc.be_root = (char *)&be_path; err = zfs_iter_filesystems(ds, be_deep_clone, &sdc); return (err); } /* * Create the boot environment from pre-existing snapshot */ int be_create_from_existing_snap(libbe_handle_t *lbh, const char *name, const char *snap) { int err; char be_path[BE_MAXPATHLEN]; char snap_path[BE_MAXPATHLEN]; const char *bename; char *parentname, *snapname; zfs_handle_t *parent_hdl; struct libbe_deep_clone sdc; if ((err = be_validate_name(lbh, name)) != 0) return (set_error(lbh, err)); if ((err = be_root_concat(lbh, snap, snap_path)) != 0) return (set_error(lbh, err)); if ((err = be_validate_snap(lbh, snap_path)) != 0) return (set_error(lbh, err)); if ((err = be_root_concat(lbh, name, be_path)) != 0) return (set_error(lbh, err)); if ((bename = strrchr(name, '/')) == NULL) bename = name; else bename++; if ((parentname = strdup(snap_path)) == NULL) { err = BE_ERR_UNKNOWN; return (set_error(lbh, err)); } snapname = strchr(parentname, '@'); if (snapname == NULL) { err = BE_ERR_UNKNOWN; return (set_error(lbh, err)); } *snapname = '\0'; snapname++; sdc.lbh = lbh; sdc.bename = bename; sdc.snapname = snapname; sdc.be_root = lbh->root; parent_hdl = zfs_open(lbh->lzh, parentname, ZFS_TYPE_DATASET); err = be_deep_clone(parent_hdl, &sdc); return (set_error(lbh, err)); } /* * Create a boot environment from an existing boot environment */ int be_create_from_existing(libbe_handle_t *lbh, const char *name, const char *old) { int err; char buf[BE_MAXPATHLEN]; if ((err = be_snapshot(lbh, old, NULL, true, (char *)&buf))) return (set_error(lbh, err)); err = be_create_from_existing_snap(lbh, name, (char *)buf); return (set_error(lbh, err)); } /* * Verifies that a snapshot has a valid name, exists, and has a mountpoint of * '/'. Returns BE_ERR_SUCCESS (0), upon success, or the relevant BE_ERR_* upon * failure. Does not set the internal library error state. */ int be_validate_snap(libbe_handle_t *lbh, const char *snap_name) { zfs_handle_t *zfs_hdl; char buf[BE_MAXPATHLEN]; char *delim_pos; int err = BE_ERR_SUCCESS; if (strlen(snap_name) >= BE_MAXPATHLEN) return (BE_ERR_PATHLEN); if (!zfs_dataset_exists(lbh->lzh, snap_name, ZFS_TYPE_SNAPSHOT)) return (BE_ERR_NOENT); strncpy(buf, snap_name, BE_MAXPATHLEN); /* Find the base filesystem of the snapshot */ if ((delim_pos = strchr(buf, '@')) == NULL) return (BE_ERR_INVALIDNAME); *delim_pos = '\0'; if ((zfs_hdl = zfs_open(lbh->lzh, buf, ZFS_TYPE_DATASET)) == NULL) return (BE_ERR_NOORIGIN); if ((err = zfs_prop_get(zfs_hdl, ZFS_PROP_MOUNTPOINT, buf, BE_MAXPATHLEN, NULL, NULL, 0, 1)) != 0) err = BE_ERR_INVORIGIN; if ((err != 0) && (strncmp(buf, "/", BE_MAXPATHLEN) != 0)) err = BE_ERR_INVORIGIN; zfs_close(zfs_hdl); return (err); } /* * Idempotently appends the name argument to the root boot environment path * and copies the resulting string into the result buffer (which is assumed * to be at least BE_MAXPATHLEN characters long. Returns BE_ERR_SUCCESS upon * success, BE_ERR_PATHLEN if the resulting path is longer than BE_MAXPATHLEN, * or BE_ERR_INVALIDNAME if the name is a path that does not begin with * zfs_be_root. Does not set internal library error state. */ int be_root_concat(libbe_handle_t *lbh, const char *name, char *result) { size_t name_len, root_len; name_len = strlen(name); root_len = strlen(lbh->root); /* Act idempotently; return be name if it is already a full path */ if (strrchr(name, '/') != NULL) { if (strstr(name, lbh->root) != name) return (BE_ERR_INVALIDNAME); if (name_len >= BE_MAXPATHLEN) return (BE_ERR_PATHLEN); strncpy(result, name, BE_MAXPATHLEN); return (BE_ERR_SUCCESS); } else if (name_len + root_len + 1 < BE_MAXPATHLEN) { snprintf(result, BE_MAXPATHLEN, "%s/%s", lbh->root, name); return (BE_ERR_SUCCESS); } return (BE_ERR_PATHLEN); } /* * Verifies the validity of a boot environment name (A-Za-z0-9-_.). Returns * BE_ERR_SUCCESS (0) if name is valid, otherwise returns BE_ERR_INVALIDNAME. * Does not set internal library error state. */ int be_validate_name(libbe_handle_t *lbh __unused, const char *name) { for (int i = 0; *name; i++) { char c = *(name++); if (isalnum(c) || (c == '-') || (c == '_') || (c == '.')) continue; return (BE_ERR_INVALIDNAME); } return (BE_ERR_SUCCESS); } /* * usage */ int be_rename(libbe_handle_t *lbh, char *old, char *new) { char full_old[BE_MAXPATHLEN]; char full_new[BE_MAXPATHLEN]; zfs_handle_t *zfs_hdl; int err; if ((err = be_root_concat(lbh, old, full_old)) != 0) return (set_error(lbh, err)); if ((err = be_root_concat(lbh, new, full_new)) != 0) return (set_error(lbh, err)); if (be_validate_name(lbh, new) != 0) return (BE_ERR_UNKNOWN); /* XXX TODO set and return correct error */ /* Check if old is active BE */ if (strcmp(full_new, be_active_path(lbh)) == 0) return (BE_ERR_UNKNOWN); /* XXX TODO set and return correct error */ if (!zfs_dataset_exists(lbh->lzh, full_old, ZFS_TYPE_DATASET)) return (BE_ERR_UNKNOWN); /* XXX TODO set and return correct error */ if (zfs_dataset_exists(lbh->lzh, full_new, ZFS_TYPE_DATASET)) return (BE_ERR_UNKNOWN); /* XXX TODO set and return correct error */ /* XXX TODO * - What about mounted BEs? * - if mounted error out unless a force flag is set? */ if ((zfs_hdl = zfs_open(lbh->lzh, full_old, ZFS_TYPE_FILESYSTEM)) == NULL) return (BE_ERR_UNKNOWN); /* XXX TODO set and return correct error */ /* recurse, nounmount, forceunmount */ struct renameflags flags = { 0, 0, 0 }; /* XXX TODO: error log on this call */ err = zfs_rename(zfs_hdl, NULL, full_new, flags); zfs_close(zfs_hdl); return (set_error(lbh, err)); } int be_export(libbe_handle_t *lbh, char *bootenv, int fd) { char snap_name[BE_MAXPATHLEN]; char buf[BE_MAXPATHLEN]; zfs_handle_t *zfs; int err; if ((err = be_snapshot(lbh, bootenv, NULL, true, snap_name)) != 0) /* XXX TODO error handle */ return (-1); be_root_concat(lbh, snap_name, buf); if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_DATASET)) == NULL) return (BE_ERR_ZFSOPEN); err = zfs_send_one(zfs, NULL, fd, 0); return (err); } int be_import(libbe_handle_t *lbh, char *bootenv, int fd) { char buf[BE_MAXPATHLEN]; time_t rawtime; nvlist_t *props; zfs_handle_t *zfs; int err, len; /* * XXX TODO: this is a very likely name for someone to already have * used... we should avoid it. */ if ((err = be_root_concat(lbh, "libbe_import_temp", buf)) != 0) /* XXX TODO error handle */ return (-1); time(&rawtime); len = strlen(buf); strftime(buf + len, BE_MAXPATHLEN - len, "@%F-%T", localtime(&rawtime)); /* lzc_receive(SNAPNAME, PROPS, ORIGIN, FORCE, fd)) { */ if ((err = lzc_receive(buf, NULL, NULL, false, fd)) != 0) { /* TODO: go through libzfs_core's recv_impl and find returned * errors and set appropriate BE_ERR * edit: errors are not in libzfs_core, my assumption is * that they use libzfs errors * note: 17 is err for dataset already existing */ return (err); } if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_SNAPSHOT)) == NULL) /* XXX TODO correct error */ return (-1); nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP); nvlist_add_string(props, "canmount", "noauto"); nvlist_add_string(props, "mountpoint", "/"); be_root_concat(lbh, bootenv, buf); err = zfs_clone(zfs, buf, props); zfs_close(zfs); nvlist_free(props); /* XXX TODO: recursively delete be_import_temp dataset */ return (err); } int be_add_child(libbe_handle_t *lbh, char *child_path, bool cp_if_exists) { char active[BE_MAXPATHLEN]; char buf[BE_MAXPATHLEN]; nvlist_t *props; zfs_handle_t *zfs; struct stat sb; int err; /* Require absolute paths */ if (*child_path != '/') /* XXX TODO: create appropriate error */ return (-1); strncpy(active, be_active_path(lbh), BE_MAXPATHLEN); strcpy(buf, active); /* Create non-mountable parent dataset(s) */ char *s = child_path; for (char *p; (p = strchr(s+1, '/')) != NULL; s = p) { size_t len = p - s; strncat(buf, s, len); nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP); nvlist_add_string(props, "canmount", "off"); nvlist_add_string(props, "mountpoint", "none"); zfs_create(lbh->lzh, buf, ZFS_TYPE_DATASET, props); nvlist_free(props); } /* Path does not exist as a descendent of / yet */ int pos = strlen(active); /* XXX TODO: Verify that resulting str is less than BE_MAXPATHLEN */ strncpy(&active[pos], child_path, BE_MAXPATHLEN-pos); if (stat(child_path, &sb) != 0) { /* Verify that error is ENOENT */ if (errno != 2) /* XXX TODO: create appropriate error */ return (-1); nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP); nvlist_add_string(props, "canmount", "noauto"); nvlist_add_string(props, "mountpoint", child_path); /* Create */ if ((err = zfs_create(lbh->lzh, active, ZFS_TYPE_DATASET, props)) != 0) /* XXX TODO handle error */ return (-1); nvlist_free(props); if ((zfs = zfs_open(lbh->lzh, active, ZFS_TYPE_DATASET)) == NULL) /* XXX TODO handle error */ return (-1); /* Set props */ if ((err = zfs_prop_set(zfs, "canmount", "noauto")) != 0) /* TODO handle error */ return (-1); } else if (cp_if_exists) { /* Path is already a descendent of / and should be copied */ /* XXX TODO ? */ /* * Establish if the existing path is a zfs dataset or just * the subdirectory of one */ /* XXX TODO: use mktemp */ long int snap_name = random(); snprintf(buf, BE_MAXPATHLEN, "%s@%ld", child_path, snap_name); if ((err = zfs_snapshot(lbh->lzh, buf, false, NULL)) != 0) /* XXX TODO correct error */ return (-1); /* Clone */ if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_SNAPSHOT)) == NULL) /* XXX TODO correct error */ return (-1); if ((err = zfs_clone(zfs, active, NULL)) != 0) /* XXX TODO correct error */ return (-1); /* set props */ } else /* TODO: error code for exists, but not cp? */ return (-1); return (BE_ERR_SUCCESS); } static int be_set_nextboot(libbe_handle_t *lbh, nvlist_t *config, uint64_t pool_guid, const char *zfsdev) { nvlist_t **child; uint64_t vdev_guid; int c, children; if (nvlist_lookup_nvlist_array(config, ZPOOL_CONFIG_CHILDREN, &child, &children) == 0) { for (c = 0; c < children; ++c) if (be_set_nextboot(lbh, child[c], pool_guid, zfsdev) != 0) return (1); return (0); } if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID, &vdev_guid) != 0) { return (1); } if (zpool_nextboot(lbh->lzh, pool_guid, vdev_guid, zfsdev) != 0) { perror("ZFS_IOC_NEXTBOOT failed"); return (1); } return (0); } int be_activate(libbe_handle_t *lbh, char *bootenv, bool temporary) { char be_path[BE_MAXPATHLEN]; char buf[BE_MAXPATHLEN]; uint64_t pool_guid; nvlist_t *config, *vdevs; int err; be_root_concat(lbh, bootenv, be_path); /* Note: be_exists fails if mountpoint is not / */ if (!be_exists(lbh, be_path)) return (BE_ERR_NOENT); if (temporary) { config = zpool_get_config(lbh->active_phandle, NULL); if (config == NULL) { printf("no config\n"); return (1); } if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pool_guid) != 0) return (1); /* Expected format according to zfsbootcfg(8) man */ strcpy(buf, "zfs:"); strcat(buf, be_path); strcat(buf, ":"); if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &vdevs) != 0) return (1); return (be_set_nextboot(lbh, vdevs, pool_guid, buf)); } else { /* Obtain bootenv zpool */ err = zpool_set_prop(lbh->active_phandle, "bootfs", be_path); switch (err) { case 0: return (BE_ERR_SUCCESS); default: /* XXX TODO correct errors */ return (-1); } } } Index: projects/bectl/lib/libbe/be.h =================================================================== --- projects/bectl/lib/libbe/be.h (revision 337413) +++ projects/bectl/lib/libbe/be.h (revision 337414) @@ -1,125 +1,125 @@ -/* - * be.h +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2017 Kyle J. Kneitinger * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef _LIBBE_H #define _LIBBE_H #include #include #define BE_MAXPATHLEN 512 typedef struct libbe_handle libbe_handle_t; typedef enum be_error { BE_ERR_SUCCESS = 0, /* No error */ BE_ERR_INVALIDNAME, /* invalid boot env name */ BE_ERR_EXISTS, /* boot env name already taken */ BE_ERR_NOENT, /* boot env doesn't exist */ BE_ERR_PERMS, /* insufficient permissions */ BE_ERR_DESTROYACT, /* cannot destroy active boot env */ BE_ERR_DESTROYMNT, /* destroying a mounted be requires force */ BE_ERR_BADPATH, /* path not suitable for operation */ BE_ERR_PATHBUSY, /* requested path is busy */ BE_ERR_PATHLEN, /* provided name exceeds maximum length limit */ BE_ERR_INVORIGIN, /* snapshot origin's mountpoint is not '/' */ BE_ERR_NOORIGIN, /* could not open snapshot's origin */ BE_ERR_MOUNTED, /* boot environment is already mounted */ BE_ERR_NOMOUNT, /* boot environment is not mounted */ BE_ERR_ZFSOPEN, /* calling zfs_open() failed */ BE_ERR_ZFSCLONE, /* error when calling zfs_clone to create be */ BE_ERR_IO, /* error when doing some I/O operation */ BE_ERR_UNKNOWN, /* unknown error */ } be_error_t; /* Library handling functions: be.c */ libbe_handle_t *libbe_init(void); void libbe_close(libbe_handle_t *); /* Bootenv information functions: be_info.c */ const char *be_active_name(libbe_handle_t *); const char *be_active_path(libbe_handle_t *); const char *be_nextboot_name(libbe_handle_t *); const char *be_nextboot_path(libbe_handle_t *); const char *be_root_path(libbe_handle_t *); int be_get_bootenv_props(libbe_handle_t *, nvlist_t *); int be_get_dataset_props(libbe_handle_t *, const char *, nvlist_t *); int be_get_dataset_snapshots(libbe_handle_t *, const char *, nvlist_t *); int be_prop_list_alloc(nvlist_t **be_list); void be_prop_list_free(nvlist_t *be_list); int be_activate(libbe_handle_t *, char *, bool); /* Bootenv creation functions */ int be_create(libbe_handle_t *, char *); int be_create_from_existing(libbe_handle_t *, const char *, const char *); int be_create_from_existing_snap(libbe_handle_t *, const char *, const char *); int be_snapshot(libbe_handle_t *, const char *, const char *, bool, char *); /* Bootenv manipulation functions */ int be_rename(libbe_handle_t *, char *, char *); /* Bootenv removal functions */ typedef enum { BE_DESTROY_FORCE = 1 << 0, } be_destroy_opt_t; int be_destroy(libbe_handle_t *, char *, int); /* Bootenv mounting functions: be_access.c */ typedef enum { BE_MNT_FORCE = 1 << 0, BE_MNT_DEEP = 1 << 1, } be_mount_opt_t; int be_mount(libbe_handle_t *, char *, char *, int, char *); int be_unmount(libbe_handle_t *, char *, int); int be_mounted_at(libbe_handle_t *, const char *path, nvlist_t *); /* Error related functions: be_error.c */ int libbe_errno(libbe_handle_t *); const char *libbe_error_description(libbe_handle_t *); void libbe_print_on_error(libbe_handle_t *, bool); /* Utility Functions */ int be_root_concat(libbe_handle_t *, const char *, char *); int be_validate_name(libbe_handle_t * __unused, const char *); int be_validate_snap(libbe_handle_t *, const char *); bool be_exists(libbe_handle_t *, char *); int be_export(libbe_handle_t *, char *, int fd); int be_import(libbe_handle_t *, char *, int fd); int be_add_child(libbe_handle_t *, char *, bool); void be_nicenum(uint64_t num, char *buf, size_t buflen); #endif /* _LIBBE_H */ Index: projects/bectl/lib/libbe/be_access.c =================================================================== --- projects/bectl/lib/libbe/be_access.c (revision 337413) +++ projects/bectl/lib/libbe/be_access.c (revision 337414) @@ -1,209 +1,210 @@ -/* - * be_access.c +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2017 Kyle J. Kneitinger + * Copyright (c) 2018 Kyle Evans * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include "be.h" #include "be_impl.h" struct be_mountcheck_info { const char *path; char *name; }; static int be_mountcheck_cb(zfs_handle_t *zfs_hdl, void *data) { struct be_mountcheck_info *info; char *mountpoint; if (data == NULL) return (1); info = (struct be_mountcheck_info *)data; if (!zfs_is_mounted(zfs_hdl, &mountpoint)) return (0); if (strcmp(mountpoint, info->path) == 0) { info->name = strdup(zfs_get_name(zfs_hdl)); return (1); } return (0); } /* * usage */ int be_mounted_at(libbe_handle_t *lbh, const char *path, nvlist_t *details) { char be[BE_MAXPATHLEN + 1]; zfs_handle_t *root_hdl; struct be_mountcheck_info info; prop_data_t propinfo; bzero(&be, BE_MAXPATHLEN + 1); if ((root_hdl = zfs_open(lbh->lzh, lbh->root, ZFS_TYPE_FILESYSTEM)) == NULL) return (BE_ERR_ZFSOPEN); info.path = path; info.name = NULL; zfs_iter_filesystems(root_hdl, be_mountcheck_cb, &info); zfs_close(root_hdl); if (info.name != NULL) { if (details != NULL) { if ((root_hdl = zfs_open(lbh->lzh, lbh->root, ZFS_TYPE_FILESYSTEM)) == NULL) { free(info.name); return (BE_ERR_ZFSOPEN); } propinfo.lbh = lbh; propinfo.list = details; propinfo.single_object = false; prop_list_builder_cb(root_hdl, &propinfo); zfs_close(root_hdl); } free(info.name); return (0); } return (1); } /* * usage */ int be_mount(libbe_handle_t *lbh, char *bootenv, char *mountpoint, int flags, char *result_loc) { char be[BE_MAXPATHLEN]; char mnt_temp[BE_MAXPATHLEN]; char *path; int mntflags; int err; if ((err = be_root_concat(lbh, bootenv, be)) != 0) return (set_error(lbh, err)); if (!be_exists(lbh, bootenv)) return (set_error(lbh, BE_ERR_NOENT)); if (is_mounted(lbh->lzh, be, &path)) return (set_error(lbh, BE_ERR_MOUNTED)); mntflags = (flags & BE_MNT_FORCE) ? MNT_FORCE : 0; /* Create mountpoint if it is not specified */ if (mountpoint == NULL) { strcpy(mnt_temp, "/tmp/be_mount.XXXX"); if (mkdtemp(mnt_temp) == NULL) return (set_error(lbh, BE_ERR_IO)); } char opt = '\0'; if ((err = zmount(be, (mountpoint == NULL) ? mnt_temp : mountpoint, mntflags, __DECONST(char *, MNTTYPE_ZFS), NULL, 0, &opt, 1)) != 0) { switch (errno) { case ENAMETOOLONG: return (set_error(lbh, BE_ERR_PATHLEN)); case ELOOP: case ENOENT: case ENOTDIR: return (set_error(lbh, BE_ERR_BADPATH)); case EPERM: return (set_error(lbh, BE_ERR_PERMS)); case EBUSY: return (set_error(lbh, BE_ERR_PATHBUSY)); default: return (set_error(lbh, BE_ERR_UNKNOWN)); } } if (result_loc != NULL) strcpy(result_loc, mountpoint == NULL ? mnt_temp : mountpoint); return (BE_ERR_SUCCESS); } /* * usage */ int be_unmount(libbe_handle_t *lbh, char *bootenv, int flags) { int err, mntflags; char be[BE_MAXPATHLEN]; struct statfs *mntbuf; int mntsize; char *mntpath; if ((err = be_root_concat(lbh, bootenv, be)) != 0) return (set_error(lbh, err)); if ((mntsize = getmntinfo(&mntbuf, MNT_NOWAIT)) == 0) { if (errno == EIO) return (set_error(lbh, BE_ERR_IO)); return (set_error(lbh, BE_ERR_NOMOUNT)); } mntpath = NULL; for (int i = 0; i < mntsize; ++i) { /* 0x000000de is the type number of zfs */ if (mntbuf[i].f_type != 0x000000de) continue; if (strcmp(mntbuf[i].f_mntfromname, be) == 0) { mntpath = mntbuf[i].f_mntonname; break; } } if (mntpath == NULL) return (set_error(lbh, BE_ERR_NOMOUNT)); mntflags = (flags & BE_MNT_FORCE) ? MNT_FORCE : 0; if ((err = unmount(mntpath, mntflags)) != 0) { switch (errno) { case ENAMETOOLONG: return (set_error(lbh, BE_ERR_PATHLEN)); case ELOOP: case ENOENT: case ENOTDIR: return (set_error(lbh, BE_ERR_BADPATH)); case EPERM: return (set_error(lbh, BE_ERR_PERMS)); case EBUSY: return (set_error(lbh, BE_ERR_PATHBUSY)); default: return (set_error(lbh, BE_ERR_UNKNOWN)); } } return (set_error(lbh, BE_ERR_SUCCESS)); } Index: projects/bectl/lib/libbe/be_error.c =================================================================== --- projects/bectl/lib/libbe/be_error.c (revision 337413) +++ projects/bectl/lib/libbe/be_error.c (revision 337414) @@ -1,115 +1,115 @@ -/* - * be_error.c +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2017 Kyle J. Kneitinger * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include "be.h" #include "be_impl.h" /* * Usage */ int libbe_errno(libbe_handle_t *lbh) { return (lbh->error); } const char * libbe_error_description(libbe_handle_t *lbh) { switch (lbh->error) { case BE_ERR_INVALIDNAME: return ("invalid boot environment name"); case BE_ERR_EXISTS: return ("boot environment name already taken"); case BE_ERR_NOENT: return ("specified boot environment does not exist"); case BE_ERR_PERMS: return ("insufficient permissions"); case BE_ERR_DESTROYACT: return ("cannot destroy active boot environment"); case BE_ERR_DESTROYMNT: return ("cannot destroy mounted boot env unless forced"); case BE_ERR_PATHLEN: return ("provided path name exceeds maximum length limit"); case BE_ERR_INVORIGIN: return ("snapshot origin's mountpoint is not \"/\""); case BE_ERR_NOORIGIN: return ("could not open snapshot's origin"); case BE_ERR_MOUNTED: return ("boot environment is already mounted"); case BE_ERR_NOMOUNT: return ("boot environment is not mounted"); case BE_ERR_ZFSOPEN: return ("calling zfs_open() failed"); case BE_ERR_ZFSCLONE: return ("error when calling zfs_clone() to create boot env"); case BE_ERR_UNKNOWN: return ("unknown error"); default: assert(lbh->error == BE_ERR_SUCCESS); return ("no error"); } } void libbe_print_on_error(libbe_handle_t *lbh, bool val) { lbh->print_on_err = val; libzfs_print_on_error(lbh->lzh, val); } int set_error(libbe_handle_t *lbh, be_error_t err) { lbh->error = err; if (lbh->print_on_err && (err != BE_ERR_SUCCESS)) fprintf(stderr, "%s\n", libbe_error_description(lbh)); return (err); } Index: projects/bectl/lib/libbe/be_impl.h =================================================================== --- projects/bectl/lib/libbe/be_impl.h (revision 337413) +++ projects/bectl/lib/libbe/be_impl.h (revision 337414) @@ -1,70 +1,70 @@ -/* - * be_impl.h +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2017 Kyle J. Kneitinger * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef _LIBBE_IMPL_H #define _LIBBE_IMPL_H #include #include "be.h" struct libbe_handle { libzfs_handle_t *lzh; zpool_handle_t *active_phandle; char root[BE_MAXPATHLEN]; char rootfs[BE_MAXPATHLEN]; char bootfs[BE_MAXPATHLEN]; be_error_t error; bool print_on_err; }; struct libbe_deep_clone { libbe_handle_t *lbh; const char *bename; const char *snapname; const char *be_root; }; struct libbe_dccb { zfs_handle_t *zhp; nvlist_t *props; }; typedef struct prop_data { nvlist_t *list; libbe_handle_t *lbh; bool single_object; /* list will contain props directly */ } prop_data_t; int prop_list_builder_cb(zfs_handle_t *, void *); int be_proplist_update(prop_data_t *); /* Clobbers any previous errors */ int set_error(libbe_handle_t *, be_error_t); #endif /* _LIBBE_IMPL_H */ Index: projects/bectl/lib/libbe/be_info.c =================================================================== --- projects/bectl/lib/libbe/be_info.c (revision 337413) +++ projects/bectl/lib/libbe/be_info.c (revision 337414) @@ -1,316 +1,317 @@ -/* - * be_info.c +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2017 Kyle J. Kneitinger + * Copyright (c) 2018 Kyle Evans * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include "be.h" #include "be_impl.h" static int snapshot_proplist_update(zfs_handle_t *hdl, prop_data_t *data); /* * Returns the name of the active boot environment */ const char * be_active_name(libbe_handle_t *lbh) { return (strrchr(lbh->rootfs, '/') + sizeof(char)); } /* * Returns full path of the active boot environment */ const char * be_active_path(libbe_handle_t *lbh) { return (lbh->rootfs); } /* * Returns the name of the next active boot environment */ const char * be_nextboot_name(libbe_handle_t *lbh) { return (strrchr(lbh->bootfs, '/') + sizeof(char)); } /* * Returns full path of the active boot environment */ const char * be_nextboot_path(libbe_handle_t *lbh) { return (lbh->bootfs); } /* * Returns the path of the boot environment root dataset */ const char * be_root_path(libbe_handle_t *lbh) { return (lbh->root); } /* * Populates dsnvl with one nvlist per bootenv dataset describing the properties * of that dataset that we've declared ourselves to care about. */ int be_get_bootenv_props(libbe_handle_t *lbh, nvlist_t *dsnvl) { prop_data_t data; data.lbh = lbh; data.list = dsnvl; data.single_object = false; return (be_proplist_update(&data)); } int be_get_dataset_props(libbe_handle_t *lbh, const char *name, nvlist_t *props) { zfs_handle_t *snap_hdl; prop_data_t data; int ret; data.lbh = lbh; data.list = props; data.single_object = true; if ((snap_hdl = zfs_open(lbh->lzh, name, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_SNAPSHOT)) == NULL) return (BE_ERR_ZFSOPEN); ret = prop_list_builder_cb(snap_hdl, &data); zfs_close(snap_hdl); return (ret); } int be_get_dataset_snapshots(libbe_handle_t *lbh, const char *name, nvlist_t *props) { zfs_handle_t *ds_hdl; prop_data_t data; int ret; data.lbh = lbh; data.list = props; data.single_object = false; if ((ds_hdl = zfs_open(lbh->lzh, name, ZFS_TYPE_FILESYSTEM)) == NULL) return (BE_ERR_ZFSOPEN); ret = snapshot_proplist_update(ds_hdl, &data); zfs_close(ds_hdl); return (ret); } /* * Internal callback function used by zfs_iter_filesystems. For each dataset in * the bootenv root, populate an nvlist_t of its relevant properties. */ int prop_list_builder_cb(zfs_handle_t *zfs_hdl, void *data_p) { char buf[512], *mountpoint; prop_data_t *data; libbe_handle_t *lbh; nvlist_t *props; const char *dataset, *name; boolean_t mounted; /* * XXX TODO: * some system for defining constants for the nvlist keys * error checking */ data = (prop_data_t *)data_p; lbh = data->lbh; if (data->single_object) props = data->list; else nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP); dataset = zfs_get_name(zfs_hdl); nvlist_add_string(props, "dataset", dataset); name = strrchr(dataset, '/') + 1; nvlist_add_string(props, "name", name); mounted = zfs_is_mounted(zfs_hdl, &mountpoint); if (mounted) nvlist_add_string(props, "mounted", mountpoint); if (zfs_prop_get(zfs_hdl, ZFS_PROP_MOUNTPOINT, buf, 512, NULL, NULL, 0, 1) == 0) nvlist_add_string(props, "mountpoint", buf); if (zfs_prop_get(zfs_hdl, ZFS_PROP_ORIGIN, buf, 512, NULL, NULL, 0, 1) == 0) nvlist_add_string(props, "origin", buf); if (zfs_prop_get(zfs_hdl, ZFS_PROP_CREATION, buf, 512, NULL, NULL, 0, 1) == 0) nvlist_add_string(props, "creation", buf); nvlist_add_boolean_value(props, "active", (strcmp(be_active_path(lbh), dataset) == 0)); if (zfs_prop_get(zfs_hdl, ZFS_PROP_USED, buf, 512, NULL, NULL, 0, 1) == 0) nvlist_add_string(props, "used", buf); if (zfs_prop_get(zfs_hdl, ZFS_PROP_USEDDS, buf, 512, NULL, NULL, 0, 1) == 0) nvlist_add_string(props, "usedds", buf); if (zfs_prop_get(zfs_hdl, ZFS_PROP_USEDSNAP, buf, 512, NULL, NULL, 0, 1) == 0) nvlist_add_string(props, "usedsnap", buf); if (zfs_prop_get(zfs_hdl, ZFS_PROP_USEDREFRESERV, buf, 512, NULL, NULL, 0, 1) == 0) nvlist_add_string(props, "usedrefreserv", buf); if (zfs_prop_get(zfs_hdl, ZFS_PROP_REFERENCED, buf, 512, NULL, NULL, 0, 1) == 0) nvlist_add_string(props, "referenced", buf); nvlist_add_boolean_value(props, "nextboot", (strcmp(be_nextboot_path(lbh), dataset) == 0)); if (!data->single_object) nvlist_add_nvlist(data->list, name, props); return (0); } /* * Updates the properties of each bootenv in the libbe handle * XXX TODO: ensure that this is always consistent (run after adds, deletes, * renames,etc */ int be_proplist_update(prop_data_t *data) { zfs_handle_t *root_hdl; if ((root_hdl = zfs_open(data->lbh->lzh, data->lbh->root, ZFS_TYPE_FILESYSTEM)) == NULL) return (BE_ERR_ZFSOPEN); /* XXX TODO: some error checking here */ zfs_iter_filesystems(root_hdl, prop_list_builder_cb, data); zfs_close(root_hdl); return (0); } static int snapshot_proplist_update(zfs_handle_t *hdl, prop_data_t *data) { return (zfs_iter_snapshots_sorted(hdl, prop_list_builder_cb, data)); } int be_prop_list_alloc(nvlist_t **be_list) { return (nvlist_alloc(be_list, NV_UNIQUE_NAME, KM_SLEEP)); } /* * frees property list and its children */ void be_prop_list_free(nvlist_t *be_list) { nvlist_t *prop_list; nvpair_t *be_pair; be_pair = nvlist_next_nvpair(be_list, NULL); if (nvpair_value_nvlist(be_pair, &prop_list) == 0) nvlist_free(prop_list); while ((be_pair = nvlist_next_nvpair(be_list, be_pair)) != NULL) { if (nvpair_value_nvlist(be_pair, &prop_list) == 0) nvlist_free(prop_list); } } /* * Usage */ bool be_exists(libbe_handle_t *lbh, char *be) { char buf[BE_MAXPATHLEN]; nvlist_t *dsprops; char *mntpoint; bool valid; be_root_concat(lbh, be, buf); if (!zfs_dataset_exists(lbh->lzh, buf, ZFS_TYPE_DATASET)) return (false); /* Also check if it's mounted at / */ if (be_prop_list_alloc(&dsprops) != 0) { set_error(lbh, BE_ERR_UNKNOWN); return (false); } if (be_get_dataset_props(lbh, buf, dsprops) != 0) { nvlist_free(dsprops); return (false); } if (nvlist_lookup_string(dsprops, "mountpoint", &mntpoint) == 0) { valid = (strcmp(mntpoint, "/") == 0); nvlist_free(dsprops); return (valid); } nvlist_free(dsprops); return (false); } Index: projects/bectl/lib/libbe/libbe.3 =================================================================== --- projects/bectl/lib/libbe/libbe.3 (revision 337413) +++ projects/bectl/lib/libbe/libbe.3 (revision 337414) @@ -1,215 +1,217 @@ .\" +.\" SPDX-License-Identifier: BSD-2-Clause-FreeBSD +.\" .\" Copyright (c) 2017 Kyle Kneitinger .\" All rights reserved. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice, this list of conditions and the following disclaimer. .\" 2. Redistributions in binary form must reproduce the above copyright .\" notice, this list of conditions and the following disclaimer in the .\" documentation and/or other materials provided with the distribution. .\" .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE .\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF .\" SUCH DAMAGE. .\" .\" This manual page is based on the mp(3X) manual page from Sun Release .\" 4.1, dated 7 September 1989. It's an old, crufty, and relatively ugly .\" manual page, but it does document what appears to be the "traditional" .\" libmp interface. .\" .\" $FreeBSD$ .\" .Dd August 6, 2018 .Dt LIBBE 3 .Os .Sh NAME .Nm libbe .Nd library for creating, destroying and modifying ZFS boot environments. .Sh SYNOPSIS .In be.h .Pp Function prototypes are given in the main body of the text. .Pp Applications using this interface must be linked with .Fl l Ns Ar be .Sh DESCRIPTION .Pp .Nm interfaces with libzfs to provide a set of functions for various operations regarding ZFS boot environments including "deep" boot environments in which a boot environments has child datasets. .Pp A context structure is passed to each function, allowing for a small amount of state to be retained, such as errors from previous operations. .\" TODO: describe break on err functionality .Pp .Ft "libbe_handle_t *" Ns .Fn libbe_init "void" ; .Pp .Ft void .Fn libbe_close "libbe_handle_t *" ; .Pp .Ft "const char *" Ns .Fn be_active_name "libbe_handle_t *" ; .Pp .Ft "const char *" Ns .Fn be_active_path "libbe_handle_t *" ; .Pp .Ft "const char *" Ns .Fn be_root_path "libbe_handle_t *" ; .Pp .Ft "nvlist_t *" Ns .Fn libbe_handle_t "libbe_handle_t " ; .Pp .Ft int .Fn be_create "libbe_handle_t *, char *" ; .Pp .Ft int .Fn be_create_from_existing "libbe_handle_t *, const char *, const char *" ; .Pp .Ft int .Fn be_rename "libbe_handle_t *, char *, char *" ; .Pp .\" TODO: Write up of destroy options .\" typedef enum { .\" BE_DESTROY_FORCE = 1 << 0, .\" } be_destroy_opt_t; .Ft int .Fn be_destroy "libbe_handle_t *, char *, int" ; .Pp .Ft void .Fn be_nicenum "uint64_t, char *, size_t" ; .Pp .\" TODO: Write up of mount options .\" typedef enum { .\" BE_MNT_FORCE = 1 << 0, .\" BE_MNT_DEEP = 1 << 1, .\" } be_mount_opt_t; .Ft int .Fn be_mount "libbe_handle_t *, char *, char *, int" ; .Pp .Ft int .Fn be_mounted_at "libbe_handle_t *, const char *, nvlist_t" ; .Pp .Ft int .Fn be_unmount "libbe_handle_t *, char *, int" ; .Pp .Ft int .Fn libbe_errno "libbe_handle_t *" ; .Pp .Ft "const char *" Ns .Fn libbe_error_description "libbe_handle_t *" ; .Pp .Ft void .Fn libbe_print_on_error "libbe_handle_t *, bool" ; .Pp .Ft int .Fn be_root_concat "libbe_handle_t *, const char *, char *" ; .Pp .Ft int .Fn be_validate_name "libbe_handle_t *, const char *" ; .Pp .Ft int .Fn be_validate_snap "libbe_handle_t *, const char *" ; .Pp .Ft bool .Fn be_exists "libbe_handle_t *, char *" ; .Pp .Ft int .Fn be_export "libbe_handle_t *, char *, int fd" ; .Pp .Ft int .Fn be_import "libbe_handle_t *, char *, int fd" ; .Pp .Ft int .Fn be_add_child "libbe_handle_t *, char *, bool" ; .Pp .Ft int .Fn be_prop_list_alloc "nvlist_t **" ; .Pp .Ft int .Fn be_get_bootenv_props "libbe_handle_t *, nvlist_t *" ; .Pp .Ft int .Fn be_get_dataset_props "libbe_handle_t *, const char *, nvlist_t *" ; .Pp .Ft int .Fn be_get_dataset_snapshots "libbe_handle_t *, const char *, nvlist_t *" ; .Pp .Ft void .Fn be_prop_list_free "nvlist_t *" ; .\" .Ft void .\" .Fn mp_mfree "MINT *mp" ; .\" .Bd -ragged -offset indent .\" .Fn mp_itom .\" returns an .\" .Vt MINT .\" with the value of .\" .Fa n . .\" .Fn mp_xtom .\" returns an .\" .Vt MINT .\" with the value of .\" .Fa s , .\" which is treated to be in hexadecimal. .\" The return values from .\" .Fn mp_itom .\" and .\" .Fn mp_xtom .\" must be released with .\" .Fn mp_mfree .\" when they are no longer needed. .\" .Fn mp_mtox .\" returns a null-terminated hexadecimal string having the value of .\" .Fa mp ; .\" its return value must be released with .\" .Fn free .\" .Pq Xr free 3 .\" when it is no longer needed. .\" .Ed .\" .Pp .Sh DIAGNOSTICS Upon error, one of the following values will be returned. .\" TODO: make each entry on its own line. .Bd -ragged -offset indent BE_ERR_SUCCESS, BE_ERR_INVALIDNAME, BE_ERR_EXISTS, BE_ERR_NOENT, BE_ERR_PERMS, BE_ERR_DESTROYACT, BE_ERR_DESTROYMNT, BE_ERR_BADPATH, BE_ERR_PATHBUSY, BE_ERR_PATHLEN, BE_ERR_INVORIGIN, BE_ERR_NOORIGIN, BE_ERR_MOUNTED, BE_ERR_NOMOUNT, BE_ERR_ZFSOPEN, BE_ERR_ZFSCLONE, BE_ERR_IO, BE_ERR_UNKNOWN .Ed .Sh SEE ALSO .Xr be 1 , .Sh HISTORY .Nm and it's corresponding command, .Xr be 3 , were written as a 2017 Google Summer of Code project with Allan Jude serving as a mentor. .\" TODO: update when implementation complete. .\" .Sh BUGS Index: projects/bectl/sbin/bectl/bectl.8 =================================================================== --- projects/bectl/sbin/bectl/bectl.8 (revision 337413) +++ projects/bectl/sbin/bectl/bectl.8 (revision 337414) @@ -1,258 +1,261 @@ .\" -.\" be - Utility to manage Boot Environments on the ZFS filesystem +.\" SPDX-License-Identifier: BSD-2-Clause-FreeBSD +.\" +.\" Copyright (c) 2017 Kyle J. Kneitinger +.\" All rights reserved. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice, this list of conditions and the following disclaimer. .\" 2. Redistributions in binary form must reproduce the above copyright .\" notice, this list of conditions and the following disclaimer in the .\" documentation and/or other materials provided with the distribution. .\" .\" .\" @(#)be.1 .\" $FreeBSD$ .\" .Dd August 5, 2018 .Dt BECTL 8 .Os FreeBSD .Sh NAME .Nm bectl .Nd Utility to manage Boot Environments on ZFS .Sh SYNOPSIS .Nm activate .Op Fl t .Ao Ar beName Ac .Nm create .Op Fl r .Op Fl e Ar nonActiveBe | Fl e Ar beName@snapshot .Ao Ar beName Ac .Nm create .Op Fl r .Ao Ar beName@snapshot Ac .Nm destroy .Op Fl F .Ao Ar beName | beName@snapshot Ac .Nm jail .Oo Fl o Ar key Ns = Ns Ar value | Fl u Ar key Oc Ns ... .Ao Ar jailID | jailName Ac .Ao Ar bootenv Ac .Nm list .Op Fl a .Op Fl D .Op Fl H .Op Fl s .Nm mount .Ao Ar beName Ac .Op mountpoint .Nm rename .Ao Ar origBeName Ac .Ao Ar newBeName Ac .Nm { ujail | unjail } .Ao Ar jailID | jailName Ac .Ao Ar bootenv Ac .Nm { umount | unmount } .Op Fl f .Ao Ar beName Ac .Sh DESCRIPTION The .Nm command is used to setup and interact with ZFS boot environments, which are bootable clones of datasets. .Pp .Em Boot Environments allows the system to be upgraded, while preserving the old system environment in a separate ZFS dataset. .Pp .Sh COMMANDS The following commands are supported by .Nm : .Bl -tag -width activate .It Ic activate .Op Fl t .Ar .Pp Activate the given .Ar beName as the default boot filesystem. If the .Op Fl t flag is given, this takes effect only for the next boot. .Pp .It Ic create .Op Fl r .Op Fl e Ar nonActiveBe | Fl e Ar beName@snapshot .Ao Ar beName Ac .Pp Creates a new boot environment named .Ar beName . If the -e param is specified, the new environment will be cloned from the given .Ar nonActiveBe | Ar beName@snapshot . If the .Op Fl r flag is given, a recursive boot environment will be made. .Pp .It Ic create .Op Fl r .Ao Ar beName@snapshot Ac .Pp Creates a snapshot of the existing boot environment named .Ar beName . If the .Op Fl r flag is given, a recursive boot environment will be made. .Pp .It Ic destroy .Op Fl F .Ao Ar beName | beName@snapshot Ac .Pp Destroys the given .Ar beName boot environment or .Ar beName@snapshot snapshot. Specifying .Fl F will automatically unmount without confirmation. .Pp .It Ic jail .Oo Fl o Ar key Ns = Ns Ar value | Fl u Ar key Oc Ns ... .Ao Ar jailID | jailName Ac .Ao Ar bootenv Ac .Pp Creates a jail of the given boot environment. Multiple .Fl o and .Fl u arguments may be specified. .Fl o will set a jail parameter, and .Fl u will unset a jail parameter. .Pp The .Va name , .Va host.hostname , and .Va path may not actually be unset. Attempts to unset any of these will revert them to the default values specified below, if they have been overwritten by .Fl o . .Pp All .Ar key , .Ar value pairs are interpreted as jail parameters as described in .Xr jail 8 . The following default parameters are provided: .Bl -tag -width -indent .It Va allow.mount Ns = Ns Ar true .It Va allow.mount.devfs Ns = Ns Ar true .It Va enforce_statfs Ns = Ns Ar 1 .It Va name Ns = Ns Ar bootenv .It Va host.hostname Ns = Ns Ar bootenv .It Va path Set to a path in /tmp generated by .Xr libbe 8 . .El .Pp All default parameters may be overwritten. .It Ic list .Op Fl a .Op Fl D .Op Fl H .Op Fl s .Pp Displays all boot environments. The Active field indicates whether the boot environment is active now (N); active on reboot (R); or both (NR). .Pp If .Fl a is used, display all datasets. If .Fl D is used, display the full space usage for each boot environment, assuming all other boot environments were destroyed. The .Fl H option is used for scripting. It does not print headers and separate fields by a single tab instead of arbitrary white space. If .Fl s is used, display all snapshots as well. .Pp .It Ic mount .Ao Ar beName Ac .Op mountpoint .Pp Temporarily mount the boot environment. Mount at the specified .Ar mountpoint if provided. .Pp .It Ic rename Ao Ar origBeName Ac Ao Ar newBeName Ac .Pp Renames the given nonactive .Ar origBeName to the given .Ar newBeName .Pp .It Ic unmount .Op Fl f .Ao Ar beName Ac .Pp Unmount the given boot environment, if it is mounted. Specifying .Fl f will force the unmount if busy. .Pp .It Ic unjail Ao Ar jailID | jailName | beName Ac .Pp Destroys the jail created from the given boot environment. .Pp .El .Sh EXAMPLES .Bl -bullet .It To fill in with jail upgrade example when behavior is firm. .Pp .Sh SEE ALSO .Xr jail 8 , .Xr zfs 8 , .Xr zpool 8 .Sh HISTORY .Nm is based on .Xr beadm 1 and was implemented as a project for the 2017 Summer of Code, along with .Xr libbe 3 . .Sh AUTHORS .Bl -bullet .It Kyle Kneitinger (kneitinger) .Ar kyle@kneit.in .Pp Creator of .Nm . .It Slawomir Wojciech Wojtczak (vermaden) .Ar vermaden@interia.pl .Pp Creator and maintainer of .Xr beadm 1 . .It Bryan Drewery (bdrewery) .Ar bryan@shatow.net .Pp Wrote the original .Xr beadm 1 manual page that this one is derived from. .El Index: projects/bectl/sbin/bectl/bectl.c =================================================================== --- projects/bectl/sbin/bectl/bectl.c (revision 337413) +++ projects/bectl/sbin/bectl/bectl.c (revision 337414) @@ -1,503 +1,503 @@ -/* - * be.c +/*- + * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2017 Kyle J. Kneitinger * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "bectl.h" static int bectl_cmd_activate(int argc, char *argv[]); static int bectl_cmd_create(int argc, char *argv[]); static int bectl_cmd_destroy(int argc, char *argv[]); static int bectl_cmd_export(int argc, char *argv[]); static int bectl_cmd_import(int argc, char *argv[]); static int bectl_cmd_add(int argc, char *argv[]); static int bectl_cmd_mount(int argc, char *argv[]); static int bectl_cmd_rename(int argc, char *argv[]); static int bectl_cmd_unmount(int argc, char *argv[]); libbe_handle_t *be; int usage(bool explicit) { FILE *fp; fp = explicit ? stdout : stderr; fprintf(fp, "usage:\tbectl ( -h | -? | subcommand [args...] )\n" "\tbectl activate [-t] beName\n" "\tbectl create [-e nonActiveBe | -e beName@snapshot] beName\n" "\tbectl create beName@snapshot\n" "\tbectl destroy [-F] beName | beName@snapshot⟩\n" "\tbectl export sourceBe\n" "\tbectl import targetBe\n" "\tbectl add (path)*\n" "\tbectl jail [ -o key=value | -u key ]... bootenv\n" "\tbectl list [-a] [-D] [-H] [-s]\n" "\tbectl mount beName [mountpoint]\n" "\tbectl rename origBeName newBeName\n" "\tbectl { ujail | unjail } ⟨jailID | jailName | bootenv)\n" "\tbectl { umount | unmount } [-f] beName\n"); return (explicit ? 0 : EX_USAGE); } /* * Represents a relationship between the command name and the parser action * that handles it. */ struct command_map_entry { const char *command; int (*fn)(int argc, char *argv[]); }; static struct command_map_entry command_map[] = { { "activate", bectl_cmd_activate }, { "create", bectl_cmd_create }, { "destroy", bectl_cmd_destroy }, { "export", bectl_cmd_export }, { "import", bectl_cmd_import }, { "add", bectl_cmd_add }, { "jail", bectl_cmd_jail }, { "list", bectl_cmd_list }, { "mount", bectl_cmd_mount }, { "rename", bectl_cmd_rename }, { "unjail", bectl_cmd_unjail }, { "unmount", bectl_cmd_unmount }, }; static int get_cmd_index(const char *cmd, int *index) { int map_size; map_size = nitems(command_map); for (int i = 0; i < map_size; ++i) { if (strcmp(cmd, command_map[i].command) == 0) { *index = i; return (0); } } return (1); } static int bectl_cmd_activate(int argc, char *argv[]) { int err, opt; bool temp; temp = false; while ((opt = getopt(argc, argv, "t")) != -1) { switch (opt) { case 't': temp = true; break; default: fprintf(stderr, "bectl activate: unknown option '-%c'\n", optopt); return (usage(false)); } } argc -= optind; argv += optind; if (argc != 1) { fprintf(stderr, "bectl activate: wrong number of arguments\n"); return (usage(false)); } /* activate logic goes here */ if ((err = be_activate(be, argv[0], temp)) != 0) /* XXX TODO: more specific error msg based on err */ printf("did not successfully activate boot environment %s\n", argv[0]); else printf("successfully activated boot environment %s\n", argv[0]); if (temp) printf("for next boot\n"); return (err); } /* * TODO: when only one arg is given, and it contains an "@" the this should * create that snapshot */ static int bectl_cmd_create(int argc, char *argv[]) { char *bootenv, *snapname, *source; int err, opt; snapname = NULL; while ((opt = getopt(argc, argv, "e:")) != -1) { switch (opt) { case 'e': snapname = optarg; break; default: fprintf(stderr, "bectl create: unknown option '-%c'\n", optopt); return (usage(false)); } } argc -= optind; argv += optind; if (argc != 1) { fprintf(stderr, "bectl create: wrong number of arguments\n"); return (usage(false)); } bootenv = *argv; if (snapname != NULL) { if (strchr(snapname, '@') != NULL) err = be_create_from_existing_snap(be, bootenv, snapname); else err = be_create_from_existing(be, bootenv, snapname); } else { if ((snapname = strchr(bootenv, '@')) != NULL) { *(snapname++) = '\0'; if ((err = be_snapshot(be, be_active_path(be), snapname, true, NULL)) != BE_ERR_SUCCESS) fprintf(stderr, "failed to create snapshot\n"); asprintf(&source, "%s@%s", be_active_path(be), snapname); err = be_create_from_existing_snap(be, bootenv, source); return (err); } else err = be_create(be, bootenv); } switch (err) { case BE_ERR_SUCCESS: break; default: if (snapname == NULL) fprintf(stderr, "failed to create bootenv %s\n", bootenv); else fprintf(stderr, "failed to create bootenv %s from snapshot %s\n", bootenv, snapname); } return (err); } static int bectl_cmd_export(int argc, char *argv[]) { char *bootenv; if (argc == 1) { fprintf(stderr, "bectl export: missing boot environment name\n"); return (usage(false)); } if (argc > 2) { fprintf(stderr, "bectl export: extra arguments provided\n"); return (usage(false)); } bootenv = argv[1]; if (isatty(STDOUT_FILENO)) { fprintf(stderr, "bectl export: must redirect output\n"); return (EX_USAGE); } be_export(be, bootenv, STDOUT_FILENO); return (0); } static int bectl_cmd_import(int argc, char *argv[]) { char *bootenv; int err; if (argc == 1) { fprintf(stderr, "bectl import: missing boot environment name\n"); return (usage(false)); } if (argc > 2) { fprintf(stderr, "bectl import: extra arguments provided\n"); return (usage(false)); } bootenv = argv[1]; if (isatty(STDIN_FILENO)) { fprintf(stderr, "bectl import: input can not be from terminal\n"); return (EX_USAGE); } err = be_import(be, bootenv, STDIN_FILENO); return (err); } static int bectl_cmd_add(int argc, char *argv[]) { if (argc < 2) { fprintf(stderr, "bectl add: must provide at least one path\n"); return (usage(false)); } for (int i = 1; i < argc; ++i) { printf("arg %d: %s\n", i, argv[i]); /* XXX TODO catch err */ be_add_child(be, argv[i], true); } return (0); } static int bectl_cmd_destroy(int argc, char *argv[]) { char *target; int opt, err; bool force; force = false; while ((opt = getopt(argc, argv, "F")) != -1) { switch (opt) { case 'F': force = true; break; default: fprintf(stderr, "bectl destroy: unknown option '-%c'\n", optopt); return (usage(false)); } } argc -= optind; argv += optind; if (argc != 1) { fprintf(stderr, "bectl destroy: wrong number of arguments\n"); return (usage(false)); } target = argv[0]; err = be_destroy(be, target, force); return (err); } static int bectl_cmd_mount(int argc, char *argv[]) { char result_loc[BE_MAXPATHLEN]; char *bootenv, *mountpoint; int err; if (argc < 2) { fprintf(stderr, "bectl mount: missing argument(s)\n"); return (usage(false)); } if (argc > 3) { fprintf(stderr, "bectl mount: too many arguments\n"); return (usage(false)); } bootenv = argv[1]; mountpoint = ((argc == 3) ? argv[2] : NULL); err = be_mount(be, bootenv, mountpoint, 0, result_loc); switch (err) { case BE_ERR_SUCCESS: printf("successfully mounted %s at %s\n", bootenv, result_loc); break; default: fprintf(stderr, (argc == 3) ? "failed to mount bootenv %s at %s\n" : "failed to mount bootenv %s at temporary path %s\n", bootenv, mountpoint); } return (err); } static int bectl_cmd_rename(int argc, char *argv[]) { char *dest, *src; int err; if (argc < 3) { fprintf(stderr, "bectl rename: missing argument\n"); return (usage(false)); } if (argc > 3) { fprintf(stderr, "bectl rename: too many arguments\n"); return (usage(false)); } src = argv[1]; dest = argv[2]; err = be_rename(be, src, dest); switch (err) { case BE_ERR_SUCCESS: break; default: fprintf(stderr, "failed to rename bootenv %s to %s\n", src, dest); } return (0); } static int bectl_cmd_unmount(int argc, char *argv[]) { char *bootenv, *cmd; int err, flags, opt; /* Store alias used */ cmd = argv[0]; flags = 0; while ((opt = getopt(argc, argv, "f")) != -1) { switch (opt) { case 'f': flags |= BE_MNT_FORCE; break; default: fprintf(stderr, "bectl %s: unknown option '-%c'\n", cmd, optopt); return (usage(false)); } } argc -= optind; argv += optind; if (argc != 1) { fprintf(stderr, "bectl %s: wrong number of arguments\n", cmd); return (usage(false)); } bootenv = argv[0]; err = be_unmount(be, bootenv, flags); switch (err) { case BE_ERR_SUCCESS: break; default: fprintf(stderr, "failed to unmount bootenv %s\n", bootenv); } return (err); } int main(int argc, char *argv[]) { const char *command; int command_index, rc; if (argc < 2) { fprintf(stderr, "missing command\n"); return (usage(false)); } command = argv[1]; /* Handle command aliases */ if (strcmp(command, "umount") == 0) command = "unmount"; if (strcmp(command, "ujail") == 0) command = "unjail"; if ((strcmp(command, "-?") == 0) || (strcmp(command, "-h") == 0)) return (usage(true)); if (get_cmd_index(command, &command_index)) { fprintf(stderr, "unknown command: %s\n", command); return (usage(false)); } if ((be = libbe_init()) == NULL) return (-1); libbe_print_on_error(be, true); /* XXX TODO: can be simplified if offset by 2 instead of one */ rc = command_map[command_index].fn(argc-1, argv+1); libbe_close(be); return (rc); }