Index: projects/bectl/lib/libbe/be.h =================================================================== --- projects/bectl/lib/libbe/be.h (revision 336707) +++ projects/bectl/lib/libbe/be.h (revision 336708) @@ -1,113 +1,114 @@ /* * be.h * * 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_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_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_root_path(libbe_handle_t *); -/* nvlist_t *be_get_bootenv_props(libbe_handle_t *); */ +int be_get_bootenv_props(libbe_handle_t *, nvlist_t *); 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 *, char *, char *); int be_create_from_existing_snap(libbe_handle_t *, char *, char *); int be_snapshot(libbe_handle_t *, char *, 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); /* 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 *, char *, char *); int be_validate_name(libbe_handle_t *, char *); int be_validate_snap(libbe_handle_t *, 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); #endif /* _LIBBE_H */ Index: projects/bectl/lib/libbe/be_info.c =================================================================== --- projects/bectl/lib/libbe/be_info.c (revision 336707) +++ projects/bectl/lib/libbe/be_info.c (revision 336708) @@ -1,232 +1,227 @@ /* * be_info.c * * 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" typedef struct prop_data { nvlist_t *list; libbe_handle_t *lbh; } prop_data_t; static int prop_list_builder_cb(zfs_handle_t *, void *); static int prop_list_builder(prop_data_t *); /* * 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 path of the boot environment root dataset */ const char * be_root_path(libbe_handle_t *lbh) { return (lbh->root); } /* - * Returns an nvlist of the bootenv's properties - * TODO: the nvlist should be passed as a param and ints should return status + * Populates dsnvl with one nvlist per bootenv dataset describing the properties + * of that dataset that we've declared ourselves to care about. */ -nvlist_t * -be_get_bootenv_props(libbe_handle_t *lbh) +int +be_get_bootenv_props(libbe_handle_t *lbh, nvlist_t *dsnvl) { prop_data_t data; data.lbh = lbh; - prop_list_builder(&data); - - return (data.list); + data.list = dsnvl; + return (prop_list_builder(&data)); } /* * Internal callback function used by zfs_iter_filesystems. For each dataset in * the bootenv root, populate an nvlist_t of its relevant properties. * TODO: should any other properties be included? */ static int prop_list_builder_cb(zfs_handle_t *zfs_hdl, void *data_p) { char buf[512]; prop_data_t *data; libbe_handle_t *lbh; nvlist_t *props; const char *dataset, *name; boolean_t mounted, active, nextboot; /* * XXX TODO: * some system for defining constants for the nvlist keys * error checking */ data = (prop_data_t *)data_p; lbh = data->lbh; 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_prop_get_int(zfs_hdl, ZFS_PROP_MOUNTED); nvlist_add_boolean_value(props, "mounted", mounted); /* XXX TODO: NOT CORRECT! Must use is_mounted */ if (mounted) { zfs_prop_get(zfs_hdl, ZFS_PROP_MOUNTPOINT, buf, 512, NULL, NULL, 0, 1); nvlist_add_string(props, "mountpoint", buf); } if (zfs_prop_get(zfs_hdl, ZFS_PROP_ORIGIN, buf, 512, NULL, NULL, 0, 1)) nvlist_add_string(props, "origin", buf); if (zfs_prop_get(zfs_hdl, ZFS_PROP_CREATION, buf, 512, NULL, NULL, 0, 1)) 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)) nvlist_add_string(props, "used", buf); if (zfs_prop_get(zfs_hdl, ZFS_PROP_USEDDS, buf, 512, NULL, NULL, 0, 1)) nvlist_add_string(props, "usedds", buf); if (zfs_prop_get(zfs_hdl, ZFS_PROP_USEDSNAP, buf, 512, NULL, NULL, 0, 1)) nvlist_add_string(props, "usedsnap", buf); if (zfs_prop_get(zfs_hdl, ZFS_PROP_USEDREFRESERV, buf, 512, NULL, NULL, 0, 1)) nvlist_add_string(props, "usedrefreserv", buf); if (zfs_prop_get(zfs_hdl, ZFS_PROP_REFERENCED, buf, 512, NULL, NULL, 0, 1)) nvlist_add_string(props, "referenced", buf); /* XXX TODO: Add bootfs info */ nvlist_add_nvlist(data->list, name, props); return (0); } /* * Updates the properties of each bootenv in the libbe handle * XXX TODO: rename to be_proplist_update * XXX TODO: ensure that this is always consistent (run after adds, deletes, * renames,etc */ static int prop_list_builder(prop_data_t *data) { zfs_handle_t *root_hdl; - - if (nvlist_alloc(&(data->list), NV_UNIQUE_NAME, KM_SLEEP) != 0) - /* XXX TODO: actually handle error */ - return (1); 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); } /* * 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]; be_root_concat(lbh, be, buf); /* * XXX TODO: check mountpoint prop and see if its /, AND that result * with below expression. */ return (zfs_dataset_exists(lbh->lzh, buf, ZFS_TYPE_DATASET)); } Index: projects/bectl/sbin/bectl/Makefile =================================================================== --- projects/bectl/sbin/bectl/Makefile (revision 336707) +++ projects/bectl/sbin/bectl/Makefile (revision 336708) @@ -1,10 +1,16 @@ # $FreeBSD$ PROG= bectl WARNS?= 1 MAN= bectl.8 LIBADD+= be LIBADD+= nvpair +CFLAGS+= -I${SRCTOP}/cddl/contrib/opensolaris/lib/libzfs/common +CFLAGS+= -I${SRCTOP}/sys/cddl/compat/opensolaris +CFLAGS+= -I${SRCTOP}/sys/cddl/contrib/opensolaris/uts/common + +CFLAGS+= -DNEED_SOLARIS_BOOLEAN + .include Index: projects/bectl/sbin/bectl/bectl.c =================================================================== --- projects/bectl/sbin/bectl/bectl.c (revision 336707) +++ projects/bectl/sbin/bectl/bectl.c (revision 336708) @@ -1,651 +1,664 @@ /* * be.c * * 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 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_jail(int argc, char *argv[]); static int bectl_cmd_list(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_unjail(int argc, char *argv[]); static int bectl_cmd_unmount(int argc, char *argv[]); libbe_handle_t *be; static 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 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(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[]) { char *bootenv; 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, (char *)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; int opt; 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[]) { char *bootenv; 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_jail(int argc, char *argv[]) { char *bootenv; char mnt_loc[BE_MAXPATHLEN]; char buf[BE_MAXPATHLEN*2]; int err, jid; /* struct jail be_jail = { 0 }; */ if (argc == 1) { fprintf(stderr, "bectl jail: missing boot environment name\n"); return (usage(false)); } if (argc > 2) { fprintf(stderr, "bectl jail: too many arguments\n"); return (usage(false)); } bootenv = argv[1]; /* * XXX TODO: if its already mounted, perhaps there should be a flag to * indicate its okay to proceed?? */ if ((err = be_mount(be, bootenv, NULL, 0, mnt_loc)) != BE_ERR_SUCCESS) fprintf(stderr, "could not mount bootenv\n"); /* * NOTE: this is not quite functional: * see https://github.com/vermaden/beadm/blob/master/HOWTO.htm on * neccesary modifications to correctly boot the jail */ /* * snprintf(buf, BE_MAXPATHLEN*2, "jail %s %s %s /bin/sh /etc/rc", * mnt_loc, bootenv, "192.168.1.123"); */ snprintf(buf, BE_MAXPATHLEN*2, "jail %s %s %s /bin/sh", mnt_loc, bootenv, "192.168.1.123"); system(buf); unmount(mnt_loc, 0); /* * be_jail.version = JAIL_API_VERSION; * be_jail.path = "/tmp/be_mount.hCCk"; * be_jail.jailname = "sdfs"; * * if ((jid = jail(&be_jail)) != -1) { * printf("jail %d created at %s\n", jid, mnt_loc); * err = 0; * } else { * fprintf(stderr, "unable to create jail. error: %d\n", errno); * err = errno; * } */ return (0); } static int bectl_cmd_list(int argc, char *argv[]) { - char *bootenv; nvlist_t *props; + char *bootenv; int opt; bool show_all_datasets, show_space, hide_headers, show_snaps; show_all_datasets = show_space = hide_headers = show_snaps = false; while ((opt = getopt(argc, argv, "aDHs")) != -1) { switch (opt) { case 'a': show_all_datasets = true; break; case 'D': show_space = true; break; case 'H': hide_headers = true; break; case 's': show_space = true; break; default: fprintf(stderr, "bectl list: unknown option '-%c'\n", optopt); return (usage(false)); } } argc -= optind; if (argc != 0) { fprintf(stderr, "bectl list: extra argument provided\n"); return (usage(false)); } - /* props = be_get_bootenv_props(be); */ + + if (nvlist_alloc(&props, NV_UNIQUE_NAME, M_WAITOK) != 0) { + fprintf(stderr, "bectl list: failed to allocate prop nvlist\n"); + return (1); + } + if (be_get_bootenv_props(be, props) != 0) { + /* XXX TODO: Real errors */ + fprintf(stderr, "bectl list: failed to fetch boot environments\n"); + return (1); + } + + dump_nvlist(props, 0); + nvlist_free(props); + return (0); } 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_unjail(int argc, char *argv[]) { char *cmd, *target; int opt; bool force; /* Store alias used */ cmd = argv[0]; force = false; while ((opt = getopt(argc, argv, "f")) != -1) { switch (opt) { case 'f': force = true; 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)); } target = argv[0]; /* unjail logic goes here */ 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[]) { 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); }