2018-08-07 13:46:06 +00:00
|
|
|
/*-
|
|
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
2018-07-24 13:17:40 +00:00
|
|
|
*
|
|
|
|
* Copyright (c) 2017 Kyle J. Kneitinger <kyle@kneit.in>
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2018-08-07 14:02:41 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
libbe(3): rewrite init to support chroot usage
libbe(3) currently uses zfs_be_root and locates which of its children is
currently mounted at "/". This is reasonable, but not correct in the case of
a chroot, for two reasons:
- chroot root may be of a different zpool than zfs_be_root
- chroot root will not show up as mounted at "/"
Fix both of these by rewriting libbe_init to work from the rootfs down.
zfs_path_to_zhandle on / will resolve to the dataset mounted at the new
root, rather than the real root. From there, we can derive the BE root/pool
and grab the bootfs off of the new pool. This does no harm in the average
case, and opens up bectl to operating on different pools for scenarios where
one may be, for instance, updating a pool that generally gets re-rooted into
from a separate UFS root or zfs bootpool.
While here, I've also:
- Eliminated the check for /boot and / to be on the same partition. This
leaves one open to a setup where /boot (and consequently, kernel/modules)
are not included in the boot environment. This may very well be an
intentional setup done by someone that knows what they're doing, we should
not kill BE usage because of it.
- Eliminated the validation bits of BEs and snapshots that enforced
'mountpoint' to be "/" -- this broke when trying to operate on an imported
pool with an altroot, but we need not be this picky.
Reported by: philip
Reviewed by: philip, allanjude (previous version)
Tested by: philip
MFC after: 3 days
Differential Revision: https://reviews.freebsd.org/D18012
2018-11-17 19:15:29 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/mount.h>
|
2018-07-24 13:17:40 +00:00
|
|
|
#include <sys/stat.h>
|
libbe(3): rewrite init to support chroot usage
libbe(3) currently uses zfs_be_root and locates which of its children is
currently mounted at "/". This is reasonable, but not correct in the case of
a chroot, for two reasons:
- chroot root may be of a different zpool than zfs_be_root
- chroot root will not show up as mounted at "/"
Fix both of these by rewriting libbe_init to work from the rootfs down.
zfs_path_to_zhandle on / will resolve to the dataset mounted at the new
root, rather than the real root. From there, we can derive the BE root/pool
and grab the bootfs off of the new pool. This does no harm in the average
case, and opens up bectl to operating on different pools for scenarios where
one may be, for instance, updating a pool that generally gets re-rooted into
from a separate UFS root or zfs bootpool.
While here, I've also:
- Eliminated the check for /boot and / to be on the same partition. This
leaves one open to a setup where /boot (and consequently, kernel/modules)
are not included in the boot environment. This may very well be an
intentional setup done by someone that knows what they're doing, we should
not kill BE usage because of it.
- Eliminated the validation bits of BEs and snapshots that enforced
'mountpoint' to be "/" -- this broke when trying to operate on an imported
pool with an altroot, but we need not be this picky.
Reported by: philip
Reviewed by: philip, allanjude (previous version)
Tested by: philip
MFC after: 3 days
Differential Revision: https://reviews.freebsd.org/D18012
2018-11-17 19:15:29 +00:00
|
|
|
#include <sys/ucred.h>
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <libgen.h>
|
|
|
|
#include <libzfs_core.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#include "be.h"
|
|
|
|
#include "be_impl.h"
|
|
|
|
|
2018-08-11 01:02:27 +00:00
|
|
|
#if SOON
|
2018-08-10 21:23:56 +00:00
|
|
|
static int be_create_child_noent(libbe_handle_t *lbh, const char *active,
|
|
|
|
const char *child_path);
|
|
|
|
static int be_create_child_cloned(libbe_handle_t *lbh, const char *active);
|
2018-08-11 01:02:27 +00:00
|
|
|
#endif
|
2018-08-10 21:23:56 +00:00
|
|
|
|
2018-07-25 03:30:01 +00:00
|
|
|
/*
|
|
|
|
* 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
|
libbe(3): rewrite init to support chroot usage
libbe(3) currently uses zfs_be_root and locates which of its children is
currently mounted at "/". This is reasonable, but not correct in the case of
a chroot, for two reasons:
- chroot root may be of a different zpool than zfs_be_root
- chroot root will not show up as mounted at "/"
Fix both of these by rewriting libbe_init to work from the rootfs down.
zfs_path_to_zhandle on / will resolve to the dataset mounted at the new
root, rather than the real root. From there, we can derive the BE root/pool
and grab the bootfs off of the new pool. This does no harm in the average
case, and opens up bectl to operating on different pools for scenarios where
one may be, for instance, updating a pool that generally gets re-rooted into
from a separate UFS root or zfs bootpool.
While here, I've also:
- Eliminated the check for /boot and / to be on the same partition. This
leaves one open to a setup where /boot (and consequently, kernel/modules)
are not included in the boot environment. This may very well be an
intentional setup done by someone that knows what they're doing, we should
not kill BE usage because of it.
- Eliminated the validation bits of BEs and snapshots that enforced
'mountpoint' to be "/" -- this broke when trying to operate on an imported
pool with an altroot, but we need not be this picky.
Reported by: philip
Reviewed by: philip, allanjude (previous version)
Tested by: philip
MFC after: 3 days
Differential Revision: https://reviews.freebsd.org/D18012
2018-11-17 19:15:29 +00:00
|
|
|
be_locate_rootfs(libbe_handle_t *lbh)
|
2018-07-25 03:30:01 +00:00
|
|
|
{
|
2018-11-19 16:47:21 +00:00
|
|
|
struct statfs sfs;
|
|
|
|
struct extmnttab entry;
|
libbe(3): rewrite init to support chroot usage
libbe(3) currently uses zfs_be_root and locates which of its children is
currently mounted at "/". This is reasonable, but not correct in the case of
a chroot, for two reasons:
- chroot root may be of a different zpool than zfs_be_root
- chroot root will not show up as mounted at "/"
Fix both of these by rewriting libbe_init to work from the rootfs down.
zfs_path_to_zhandle on / will resolve to the dataset mounted at the new
root, rather than the real root. From there, we can derive the BE root/pool
and grab the bootfs off of the new pool. This does no harm in the average
case, and opens up bectl to operating on different pools for scenarios where
one may be, for instance, updating a pool that generally gets re-rooted into
from a separate UFS root or zfs bootpool.
While here, I've also:
- Eliminated the check for /boot and / to be on the same partition. This
leaves one open to a setup where /boot (and consequently, kernel/modules)
are not included in the boot environment. This may very well be an
intentional setup done by someone that knows what they're doing, we should
not kill BE usage because of it.
- Eliminated the validation bits of BEs and snapshots that enforced
'mountpoint' to be "/" -- this broke when trying to operate on an imported
pool with an altroot, but we need not be this picky.
Reported by: philip
Reviewed by: philip, allanjude (previous version)
Tested by: philip
MFC after: 3 days
Differential Revision: https://reviews.freebsd.org/D18012
2018-11-17 19:15:29 +00:00
|
|
|
zfs_handle_t *zfs;
|
2018-07-25 03:30:01 +00:00
|
|
|
|
2018-11-19 16:47:21 +00:00
|
|
|
/*
|
|
|
|
* Check first if root is ZFS; if not, we'll bail on rootfs capture.
|
|
|
|
* Unfortunately needed because zfs_path_to_zhandle will emit to
|
|
|
|
* stderr if / isn't actually a ZFS filesystem, which we'd like
|
|
|
|
* to avoid.
|
|
|
|
*/
|
|
|
|
if (statfs("/", &sfs) == 0) {
|
|
|
|
statfs2mnttab(&sfs, &entry);
|
|
|
|
if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
|
|
|
|
return (1);
|
|
|
|
} else
|
|
|
|
return (1);
|
libbe(3): rewrite init to support chroot usage
libbe(3) currently uses zfs_be_root and locates which of its children is
currently mounted at "/". This is reasonable, but not correct in the case of
a chroot, for two reasons:
- chroot root may be of a different zpool than zfs_be_root
- chroot root will not show up as mounted at "/"
Fix both of these by rewriting libbe_init to work from the rootfs down.
zfs_path_to_zhandle on / will resolve to the dataset mounted at the new
root, rather than the real root. From there, we can derive the BE root/pool
and grab the bootfs off of the new pool. This does no harm in the average
case, and opens up bectl to operating on different pools for scenarios where
one may be, for instance, updating a pool that generally gets re-rooted into
from a separate UFS root or zfs bootpool.
While here, I've also:
- Eliminated the check for /boot and / to be on the same partition. This
leaves one open to a setup where /boot (and consequently, kernel/modules)
are not included in the boot environment. This may very well be an
intentional setup done by someone that knows what they're doing, we should
not kill BE usage because of it.
- Eliminated the validation bits of BEs and snapshots that enforced
'mountpoint' to be "/" -- this broke when trying to operate on an imported
pool with an altroot, but we need not be this picky.
Reported by: philip
Reviewed by: philip, allanjude (previous version)
Tested by: philip
MFC after: 3 days
Differential Revision: https://reviews.freebsd.org/D18012
2018-11-17 19:15:29 +00:00
|
|
|
zfs = zfs_path_to_zhandle(lbh->lzh, "/", ZFS_TYPE_FILESYSTEM);
|
|
|
|
if (zfs == NULL)
|
2018-07-25 03:30:01 +00:00
|
|
|
return (1);
|
|
|
|
|
libbe(3): rewrite init to support chroot usage
libbe(3) currently uses zfs_be_root and locates which of its children is
currently mounted at "/". This is reasonable, but not correct in the case of
a chroot, for two reasons:
- chroot root may be of a different zpool than zfs_be_root
- chroot root will not show up as mounted at "/"
Fix both of these by rewriting libbe_init to work from the rootfs down.
zfs_path_to_zhandle on / will resolve to the dataset mounted at the new
root, rather than the real root. From there, we can derive the BE root/pool
and grab the bootfs off of the new pool. This does no harm in the average
case, and opens up bectl to operating on different pools for scenarios where
one may be, for instance, updating a pool that generally gets re-rooted into
from a separate UFS root or zfs bootpool.
While here, I've also:
- Eliminated the check for /boot and / to be on the same partition. This
leaves one open to a setup where /boot (and consequently, kernel/modules)
are not included in the boot environment. This may very well be an
intentional setup done by someone that knows what they're doing, we should
not kill BE usage because of it.
- Eliminated the validation bits of BEs and snapshots that enforced
'mountpoint' to be "/" -- this broke when trying to operate on an imported
pool with an altroot, but we need not be this picky.
Reported by: philip
Reviewed by: philip, allanjude (previous version)
Tested by: philip
MFC after: 3 days
Differential Revision: https://reviews.freebsd.org/D18012
2018-11-17 19:15:29 +00:00
|
|
|
strlcpy(lbh->rootfs, zfs_get_name(zfs), sizeof(lbh->rootfs));
|
|
|
|
zfs_close(zfs);
|
2018-07-25 03:30:01 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2018-07-24 13:17:40 +00:00
|
|
|
/*
|
|
|
|
* Initializes the libbe context to operate in the root boot environment
|
|
|
|
* dataset, for example, zroot/ROOT.
|
|
|
|
*/
|
|
|
|
libbe_handle_t *
|
2018-11-19 02:12:08 +00:00
|
|
|
libbe_init(const char *root)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
libbe_handle_t *lbh;
|
2018-07-25 03:08:11 +00:00
|
|
|
char *poolname, *pos;
|
|
|
|
int pnamelen;
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-07-25 03:08:11 +00:00
|
|
|
lbh = NULL;
|
|
|
|
poolname = pos = NULL;
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-07-25 03:08:11 +00:00
|
|
|
if ((lbh = calloc(1, sizeof(libbe_handle_t))) == NULL)
|
|
|
|
goto err;
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-07-25 03:08:11 +00:00
|
|
|
if ((lbh->lzh = libzfs_init()) == NULL)
|
|
|
|
goto err;
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-11-19 02:12:08 +00:00
|
|
|
/*
|
|
|
|
* Grab rootfs, we'll work backwards from there if an optional BE root
|
|
|
|
* has not been passed in.
|
|
|
|
*/
|
2018-11-19 16:47:21 +00:00
|
|
|
if (be_locate_rootfs(lbh) != 0) {
|
|
|
|
if (root == NULL)
|
|
|
|
goto err;
|
|
|
|
*lbh->rootfs = '\0';
|
|
|
|
}
|
2018-11-19 02:12:08 +00:00
|
|
|
if (root == NULL) {
|
|
|
|
/* Strip off the final slash from rootfs to get the be root */
|
|
|
|
strlcpy(lbh->root, lbh->rootfs, sizeof(lbh->root));
|
|
|
|
pos = strrchr(lbh->root, '/');
|
|
|
|
if (pos == NULL)
|
|
|
|
goto err;
|
|
|
|
*pos = '\0';
|
|
|
|
} else
|
|
|
|
strlcpy(lbh->root, root, sizeof(lbh->root));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-07-25 03:08:11 +00:00
|
|
|
if ((pos = strchr(lbh->root, '/')) == NULL)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
pnamelen = pos - lbh->root;
|
|
|
|
poolname = malloc(pnamelen + 1);
|
|
|
|
if (poolname == NULL)
|
|
|
|
goto err;
|
|
|
|
|
2018-08-16 17:56:03 +00:00
|
|
|
strlcpy(poolname, lbh->root, pnamelen + 1);
|
2018-07-25 03:08:11 +00:00
|
|
|
if ((lbh->active_phandle = zpool_open(lbh->lzh, poolname)) == NULL)
|
|
|
|
goto err;
|
2018-08-16 18:37:47 +00:00
|
|
|
free(poolname);
|
|
|
|
poolname = NULL;
|
2018-07-25 03:08:11 +00:00
|
|
|
|
|
|
|
if (zpool_get_prop(lbh->active_phandle, ZPOOL_PROP_BOOTFS, lbh->bootfs,
|
2018-08-16 17:56:03 +00:00
|
|
|
sizeof(lbh->bootfs), NULL, true) != 0)
|
2018-07-25 03:08:11 +00:00
|
|
|
goto err;
|
|
|
|
|
2018-07-24 13:17:40 +00:00
|
|
|
return (lbh);
|
2018-07-25 03:08:11 +00:00
|
|
|
err:
|
|
|
|
if (lbh != NULL) {
|
|
|
|
if (lbh->active_phandle != NULL)
|
|
|
|
zpool_close(lbh->active_phandle);
|
|
|
|
if (lbh->lzh != NULL)
|
|
|
|
libzfs_fini(lbh->lzh);
|
|
|
|
free(lbh);
|
|
|
|
}
|
|
|
|
free(poolname);
|
|
|
|
return (NULL);
|
2018-07-24 13:17:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Free memory allocated by libbe_init()
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
libbe_close(libbe_handle_t *lbh)
|
|
|
|
{
|
2018-07-25 03:50:01 +00:00
|
|
|
|
2018-07-25 03:08:11 +00:00
|
|
|
if (lbh->active_phandle != NULL)
|
|
|
|
zpool_close(lbh->active_phandle);
|
2018-07-24 13:17:40 +00:00
|
|
|
libzfs_fini(lbh->lzh);
|
|
|
|
free(lbh);
|
|
|
|
}
|
|
|
|
|
2018-08-05 04:40:13 +00:00
|
|
|
/*
|
|
|
|
* Proxy through to libzfs for the moment.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
be_nicenum(uint64_t num, char *buf, size_t buflen)
|
|
|
|
{
|
|
|
|
|
|
|
|
zfs_nicenum(num, buf, buflen);
|
|
|
|
}
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-08-07 03:39:29 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2018-07-24 13:17:40 +00:00
|
|
|
/*
|
|
|
|
* 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
|
2018-08-10 04:01:40 +00:00
|
|
|
be_destroy(libbe_handle_t *lbh, const char *name, int options)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
zfs_handle_t *fs;
|
|
|
|
char path[BE_MAXPATHLEN];
|
2018-07-25 03:50:01 +00:00
|
|
|
char *p;
|
|
|
|
int err, force, mounted;
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
p = path;
|
|
|
|
force = options & BE_DESTROY_FORCE;
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
be_root_concat(lbh, name, path);
|
|
|
|
|
|
|
|
if (strchr(name, '@') == NULL) {
|
2018-07-25 03:50:01 +00:00
|
|
|
if (!zfs_dataset_exists(lbh->lzh, path, ZFS_TYPE_FILESYSTEM))
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, BE_ERR_NOENT));
|
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
if (strcmp(path, lbh->rootfs) == 0)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, BE_ERR_DESTROYACT));
|
|
|
|
|
|
|
|
fs = zfs_open(lbh->lzh, p, ZFS_TYPE_FILESYSTEM);
|
|
|
|
} else {
|
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
if (!zfs_dataset_exists(lbh->lzh, path, ZFS_TYPE_SNAPSHOT))
|
2018-07-24 13:17:40 +00:00
|
|
|
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 */
|
2018-07-25 15:14:35 +00:00
|
|
|
if ((mounted = zfs_is_mounted(fs, NULL)) != 0) {
|
2018-07-25 03:50:01 +00:00
|
|
|
if (force)
|
2018-07-24 13:17:40 +00:00
|
|
|
zfs_unmount(fs, NULL, 0);
|
2018-07-25 03:50:01 +00:00
|
|
|
else
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, BE_ERR_DESTROYMNT));
|
|
|
|
}
|
|
|
|
|
2018-08-07 03:39:29 +00:00
|
|
|
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));
|
|
|
|
}
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-08-07 03:39:29 +00:00
|
|
|
return (0);
|
2018-07-24 13:17:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int
|
2018-07-25 15:14:35 +00:00
|
|
|
be_snapshot(libbe_handle_t *lbh, const char *source, const char *snap_name,
|
2018-07-24 13:17:40 +00:00
|
|
|
bool recursive, char *result)
|
|
|
|
{
|
|
|
|
char buf[BE_MAXPATHLEN];
|
|
|
|
time_t rawtime;
|
|
|
|
int len, err;
|
|
|
|
|
|
|
|
be_root_concat(lbh, source, buf);
|
|
|
|
|
2018-09-01 02:22:26 +00:00
|
|
|
if ((err = be_exists(lbh, buf)) != 0)
|
|
|
|
return (set_error(lbh, err));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
if (snap_name != NULL) {
|
2018-08-16 18:37:47 +00:00
|
|
|
if (strlcat(buf, "@", sizeof(buf)) >= sizeof(buf))
|
|
|
|
return (set_error(lbh, BE_ERR_INVALIDNAME));
|
|
|
|
|
|
|
|
if (strlcat(buf, snap_name, sizeof(buf)) >= sizeof(buf))
|
|
|
|
return (set_error(lbh, BE_ERR_INVALIDNAME));
|
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
if (result != NULL)
|
2018-07-24 13:17:40 +00:00
|
|
|
snprintf(result, BE_MAXPATHLEN, "%s@%s", source,
|
|
|
|
snap_name);
|
|
|
|
} else {
|
|
|
|
time(&rawtime);
|
|
|
|
len = strlen(buf);
|
2018-08-16 17:56:03 +00:00
|
|
|
strftime(buf + len, sizeof(buf) - len,
|
2018-07-24 13:17:40 +00:00
|
|
|
"@%F-%T", localtime(&rawtime));
|
2018-08-16 18:37:47 +00:00
|
|
|
if (result != NULL && strlcpy(result, strrchr(buf, '/') + 1,
|
|
|
|
sizeof(buf)) >= sizeof(buf))
|
|
|
|
return (set_error(lbh, BE_ERR_INVALIDNAME));
|
2018-07-24 13:17:40 +00:00
|
|
|
}
|
|
|
|
|
2018-07-25 15:14:35 +00:00
|
|
|
if ((err = zfs_snapshot(lbh->lzh, buf, recursive, NULL)) != 0) {
|
2018-07-24 13:17:40 +00:00
|
|
|
switch (err) {
|
|
|
|
case EZFS_INVALIDNAME:
|
|
|
|
return (set_error(lbh, BE_ERR_INVALIDNAME));
|
|
|
|
|
|
|
|
default:
|
2018-08-08 03:25:10 +00:00
|
|
|
/*
|
|
|
|
* The other errors that zfs_ioc_snapshot might return
|
|
|
|
* shouldn't happen if we've set things up properly, so
|
|
|
|
* we'll gloss over them and call it UNKNOWN as it will
|
|
|
|
* require further triage.
|
|
|
|
*/
|
|
|
|
if (errno == ENOTSUP)
|
|
|
|
return (set_error(lbh, BE_ERR_NOPOOL));
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return (BE_ERR_SUCCESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create the boot environment specified by the name parameter
|
|
|
|
*/
|
|
|
|
int
|
2018-08-10 04:01:40 +00:00
|
|
|
be_create(libbe_handle_t *lbh, const char *name)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2018-07-25 15:14:35 +00:00
|
|
|
err = be_create_from_existing(lbh, name, be_active_path(lbh));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
return (set_error(lbh, err));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
be_deep_clone_prop(int prop, void *cb)
|
|
|
|
{
|
|
|
|
int err;
|
2018-07-25 03:50:01 +00:00
|
|
|
struct libbe_dccb *dccb;
|
2018-07-24 13:17:40 +00:00
|
|
|
zprop_source_t src;
|
|
|
|
char pval[BE_MAXPATHLEN];
|
|
|
|
char source[BE_MAXPATHLEN];
|
2018-11-19 02:16:20 +00:00
|
|
|
char *val;
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
dccb = cb;
|
2018-07-24 13:17:40 +00:00
|
|
|
/* Skip some properties we don't want to touch */
|
2018-08-10 04:01:40 +00:00
|
|
|
if (prop == ZFS_PROP_CANMOUNT)
|
|
|
|
return (ZPROP_CONT);
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
/* Don't copy readonly properties */
|
2018-07-25 03:50:01 +00:00
|
|
|
if (zfs_prop_readonly(prop))
|
2018-07-24 13:17:40 +00:00
|
|
|
return (ZPROP_CONT);
|
|
|
|
|
|
|
|
if ((err = zfs_prop_get(dccb->zhp, prop, (char *)&pval,
|
2018-07-25 03:50:01 +00:00
|
|
|
sizeof(pval), &src, (char *)&source, sizeof(source), false)))
|
2018-07-24 13:17:40 +00:00
|
|
|
/* Just continue if we fail to read a property */
|
|
|
|
return (ZPROP_CONT);
|
2018-07-25 03:50:01 +00:00
|
|
|
|
2018-07-24 13:17:40 +00:00
|
|
|
/* Only copy locally defined properties */
|
2018-07-25 03:50:01 +00:00
|
|
|
if (src != ZPROP_SRC_LOCAL)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (ZPROP_CONT);
|
|
|
|
|
2018-11-19 02:16:20 +00:00
|
|
|
/* Augment mountpoint with altroot, if needed */
|
|
|
|
val = pval;
|
|
|
|
if (prop == ZFS_PROP_MOUNTPOINT && *dccb->altroot != '\0') {
|
|
|
|
if (pval[strlen(dccb->altroot)] == '\0')
|
|
|
|
strlcpy(pval, "/", sizeof(pval));
|
|
|
|
else
|
|
|
|
val = pval + strlen(dccb->altroot);
|
|
|
|
}
|
|
|
|
nvlist_add_string(dccb->props, zfs_prop_to_name(prop), val);
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
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;
|
2018-07-25 03:50:01 +00:00
|
|
|
struct libbe_deep_clone *isdc, sdc;
|
2018-07-24 13:17:40 +00:00
|
|
|
struct libbe_dccb dccb;
|
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
isdc = (struct libbe_deep_clone *)data;
|
2018-07-24 13:17:40 +00:00
|
|
|
dspath = zfs_get_name(ds);
|
2018-07-25 03:50:01 +00:00
|
|
|
if ((dsname = strrchr(dspath, '/')) == NULL)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (BE_ERR_UNKNOWN);
|
|
|
|
dsname++;
|
2018-07-25 03:50:01 +00:00
|
|
|
|
|
|
|
if (isdc->bename == NULL)
|
2018-07-24 13:17:40 +00:00
|
|
|
snprintf(be_path, sizeof(be_path), "%s/%s", isdc->be_root, dsname);
|
2018-07-25 03:50:01 +00:00
|
|
|
else
|
2018-07-24 13:17:40 +00:00
|
|
|
snprintf(be_path, sizeof(be_path), "%s/%s", isdc->be_root, isdc->bename);
|
2018-07-25 03:50:01 +00:00
|
|
|
|
2018-07-24 13:17:40 +00:00
|
|
|
snprintf(snap_path, sizeof(snap_path), "%s@%s", dspath, isdc->snapname);
|
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
if (zfs_dataset_exists(isdc->lbh->lzh, be_path, ZFS_TYPE_DATASET))
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(isdc->lbh, BE_ERR_EXISTS));
|
|
|
|
|
|
|
|
if ((snap_hdl =
|
2018-07-25 03:50:01 +00:00
|
|
|
zfs_open(isdc->lbh->lzh, snap_path, ZFS_TYPE_SNAPSHOT)) == NULL)
|
2018-07-24 13:17:40 +00:00
|
|
|
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;
|
2018-11-19 02:16:20 +00:00
|
|
|
if (zpool_get_prop(isdc->lbh->active_phandle, ZPOOL_PROP_ALTROOT,
|
|
|
|
dccb.altroot, sizeof(dccb.altroot), NULL, true) != 0 ||
|
|
|
|
strcmp(dccb.altroot, "-") == 0)
|
|
|
|
*dccb.altroot = '\0';
|
2018-07-24 13:17:40 +00:00
|
|
|
if (zprop_iter(be_deep_clone_prop, &dccb, B_FALSE, B_FALSE,
|
2018-07-25 03:50:01 +00:00
|
|
|
ZFS_TYPE_FILESYSTEM) == ZPROP_INVAL)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (-1);
|
|
|
|
|
libbe(3): Fix leaky faucets
Amongst them:
- Resource leaks
- Logically dead code
- Unused values
- Null termination issues
Reported by: asomers (pointer to Coverity), Coverity
CID: 1394777, 1394791, 1394830, 1394844, 1394872, 1394894,
CID: 1394900, 1394907, 1394950, 1394965
2018-08-14 18:11:06 +00:00
|
|
|
if ((err = zfs_clone(snap_hdl, be_path, props)) != 0)
|
|
|
|
err = BE_ERR_ZFSCLONE;
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
nvlist_free(props);
|
|
|
|
zfs_close(snap_hdl);
|
|
|
|
|
libbe(3): Fix leaky faucets
Amongst them:
- Resource leaks
- Logically dead code
- Unused values
- Null termination issues
Reported by: asomers (pointer to Coverity), Coverity
CID: 1394777, 1394791, 1394830, 1394844, 1394872, 1394894,
CID: 1394900, 1394907, 1394950, 1394965
2018-08-14 18:11:06 +00:00
|
|
|
/* Failed to clone */
|
|
|
|
if (err != BE_ERR_SUCCESS)
|
|
|
|
return (set_error(isdc->lbh, err));
|
|
|
|
|
2018-07-24 13:17:40 +00:00
|
|
|
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
|
2018-07-25 15:14:35 +00:00
|
|
|
be_create_from_existing_snap(libbe_handle_t *lbh, const char *name,
|
|
|
|
const char *snap)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
char be_path[BE_MAXPATHLEN];
|
|
|
|
char snap_path[BE_MAXPATHLEN];
|
2018-07-25 15:14:35 +00:00
|
|
|
const char *bename;
|
|
|
|
char *parentname, *snapname;
|
2018-07-24 13:17:40 +00:00
|
|
|
zfs_handle_t *parent_hdl;
|
|
|
|
struct libbe_deep_clone sdc;
|
|
|
|
|
2018-07-25 15:14:35 +00:00
|
|
|
if ((err = be_validate_name(lbh, name)) != 0)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, err));
|
2018-07-25 15:14:35 +00:00
|
|
|
if ((err = be_root_concat(lbh, snap, snap_path)) != 0)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, err));
|
2018-07-25 15:14:35 +00:00
|
|
|
if ((err = be_validate_snap(lbh, snap_path)) != 0)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, err));
|
|
|
|
|
2018-07-25 15:14:35 +00:00
|
|
|
if ((err = be_root_concat(lbh, name, be_path)) != 0)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, err));
|
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
if ((bename = strrchr(name, '/')) == NULL)
|
2018-07-24 13:17:40 +00:00
|
|
|
bename = name;
|
2018-07-25 03:50:01 +00:00
|
|
|
else
|
2018-07-24 13:17:40 +00:00
|
|
|
bename++;
|
2018-07-25 03:50:01 +00:00
|
|
|
|
libbe(3): Fix leaky faucets
Amongst them:
- Resource leaks
- Logically dead code
- Unused values
- Null termination issues
Reported by: asomers (pointer to Coverity), Coverity
CID: 1394777, 1394791, 1394830, 1394844, 1394872, 1394894,
CID: 1394900, 1394907, 1394950, 1394965
2018-08-14 18:11:06 +00:00
|
|
|
if ((parentname = strdup(snap_path)) == NULL)
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
|
|
|
|
2018-07-24 13:17:40 +00:00
|
|
|
snapname = strchr(parentname, '@');
|
|
|
|
if (snapname == NULL) {
|
libbe(3): Fix leaky faucets
Amongst them:
- Resource leaks
- Logically dead code
- Unused values
- Null termination issues
Reported by: asomers (pointer to Coverity), Coverity
CID: 1394777, 1394791, 1394830, 1394844, 1394872, 1394894,
CID: 1394900, 1394907, 1394950, 1394965
2018-08-14 18:11:06 +00:00
|
|
|
free(parentname);
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
2018-07-24 13:17:40 +00:00
|
|
|
}
|
|
|
|
*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);
|
|
|
|
|
libbe(3): Fix leaky faucets
Amongst them:
- Resource leaks
- Logically dead code
- Unused values
- Null termination issues
Reported by: asomers (pointer to Coverity), Coverity
CID: 1394777, 1394791, 1394830, 1394844, 1394872, 1394894,
CID: 1394900, 1394907, 1394950, 1394965
2018-08-14 18:11:06 +00:00
|
|
|
free(parentname);
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, err));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a boot environment from an existing boot environment
|
|
|
|
*/
|
|
|
|
int
|
2018-07-25 15:14:35 +00:00
|
|
|
be_create_from_existing(libbe_handle_t *lbh, const char *name, const char *old)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
char buf[BE_MAXPATHLEN];
|
|
|
|
|
2018-08-16 18:58:34 +00:00
|
|
|
if ((err = be_snapshot(lbh, old, NULL, true, (char *)&buf)) != 0)
|
2018-07-24 13:17:40 +00:00
|
|
|
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
|
2018-07-25 15:14:35 +00:00
|
|
|
be_validate_snap(libbe_handle_t *lbh, const char *snap_name)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
if (strlen(snap_name) >= BE_MAXPATHLEN)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (BE_ERR_PATHLEN);
|
|
|
|
|
|
|
|
if (!zfs_dataset_exists(lbh->lzh, snap_name,
|
2018-07-25 03:50:01 +00:00
|
|
|
ZFS_TYPE_SNAPSHOT))
|
2018-07-24 13:17:40 +00:00
|
|
|
return (BE_ERR_NOENT);
|
|
|
|
|
libbe(3): rewrite init to support chroot usage
libbe(3) currently uses zfs_be_root and locates which of its children is
currently mounted at "/". This is reasonable, but not correct in the case of
a chroot, for two reasons:
- chroot root may be of a different zpool than zfs_be_root
- chroot root will not show up as mounted at "/"
Fix both of these by rewriting libbe_init to work from the rootfs down.
zfs_path_to_zhandle on / will resolve to the dataset mounted at the new
root, rather than the real root. From there, we can derive the BE root/pool
and grab the bootfs off of the new pool. This does no harm in the average
case, and opens up bectl to operating on different pools for scenarios where
one may be, for instance, updating a pool that generally gets re-rooted into
from a separate UFS root or zfs bootpool.
While here, I've also:
- Eliminated the check for /boot and / to be on the same partition. This
leaves one open to a setup where /boot (and consequently, kernel/modules)
are not included in the boot environment. This may very well be an
intentional setup done by someone that knows what they're doing, we should
not kill BE usage because of it.
- Eliminated the validation bits of BEs and snapshots that enforced
'mountpoint' to be "/" -- this broke when trying to operate on an imported
pool with an altroot, but we need not be this picky.
Reported by: philip
Reviewed by: philip, allanjude (previous version)
Tested by: philip
MFC after: 3 days
Differential Revision: https://reviews.freebsd.org/D18012
2018-11-17 19:15:29 +00:00
|
|
|
return (BE_ERR_SUCCESS);
|
2018-07-24 13:17:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
2018-07-25 15:14:35 +00:00
|
|
|
be_root_concat(libbe_handle_t *lbh, const char *name, char *result)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
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) {
|
2018-07-25 03:50:01 +00:00
|
|
|
if (strstr(name, lbh->root) != name)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (BE_ERR_INVALIDNAME);
|
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
if (name_len >= BE_MAXPATHLEN)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (BE_ERR_PATHLEN);
|
|
|
|
|
2018-08-16 17:56:03 +00:00
|
|
|
strlcpy(result, name, BE_MAXPATHLEN);
|
2018-07-24 13:17:40 +00:00
|
|
|
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
|
2018-08-16 18:58:34 +00:00
|
|
|
* BE_ERR_SUCCESS (0) if name is valid, otherwise returns BE_ERR_INVALIDNAME
|
|
|
|
* or BE_ERR_PATHLEN.
|
2018-07-24 13:17:40 +00:00
|
|
|
* Does not set internal library error state.
|
|
|
|
*/
|
|
|
|
int
|
2018-08-16 18:58:34 +00:00
|
|
|
be_validate_name(libbe_handle_t *lbh, const char *name)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
for (int i = 0; *name; i++) {
|
|
|
|
char c = *(name++);
|
2018-07-25 03:50:01 +00:00
|
|
|
if (isalnum(c) || (c == '-') || (c == '_') || (c == '.'))
|
2018-07-24 13:17:40 +00:00
|
|
|
continue;
|
|
|
|
return (BE_ERR_INVALIDNAME);
|
|
|
|
}
|
|
|
|
|
2018-08-16 18:58:34 +00:00
|
|
|
/*
|
|
|
|
* Impose the additional restriction that the entire dataset name must
|
|
|
|
* not exceed the maximum length of a dataset, i.e. MAXNAMELEN.
|
|
|
|
*/
|
|
|
|
if (strlen(lbh->root) + 1 + strlen(name) > MAXNAMELEN)
|
|
|
|
return (BE_ERR_PATHLEN);
|
2018-07-24 13:17:40 +00:00
|
|
|
return (BE_ERR_SUCCESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* usage
|
|
|
|
*/
|
|
|
|
int
|
2018-08-10 04:01:40 +00:00
|
|
|
be_rename(libbe_handle_t *lbh, const char *old, const char *new)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
char full_old[BE_MAXPATHLEN];
|
|
|
|
char full_new[BE_MAXPATHLEN];
|
|
|
|
zfs_handle_t *zfs_hdl;
|
|
|
|
int err;
|
|
|
|
|
2018-08-16 18:58:34 +00:00
|
|
|
/*
|
|
|
|
* be_validate_name is documented not to set error state, so we should
|
|
|
|
* do so here.
|
|
|
|
*/
|
|
|
|
if ((err = be_validate_name(lbh, new)) != 0)
|
|
|
|
return (set_error(lbh, err));
|
2018-07-25 15:14:35 +00:00
|
|
|
if ((err = be_root_concat(lbh, old, full_old)) != 0)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, err));
|
2018-07-25 15:14:35 +00:00
|
|
|
if ((err = be_root_concat(lbh, new, full_new)) != 0)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, err));
|
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
if (!zfs_dataset_exists(lbh->lzh, full_old, ZFS_TYPE_DATASET))
|
2018-08-08 03:25:10 +00:00
|
|
|
return (set_error(lbh, BE_ERR_NOENT));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
if (zfs_dataset_exists(lbh->lzh, full_new, ZFS_TYPE_DATASET))
|
2018-08-08 03:25:10 +00:00
|
|
|
return (set_error(lbh, BE_ERR_EXISTS));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
if ((zfs_hdl = zfs_open(lbh->lzh, full_old,
|
2018-07-25 03:50:01 +00:00
|
|
|
ZFS_TYPE_FILESYSTEM)) == NULL)
|
2018-08-08 03:25:10 +00:00
|
|
|
return (set_error(lbh, BE_ERR_ZFSOPEN));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
/* recurse, nounmount, forceunmount */
|
2018-08-24 20:44:58 +00:00
|
|
|
struct renameflags flags = {
|
|
|
|
.nounmount = 1,
|
|
|
|
};
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
err = zfs_rename(zfs_hdl, NULL, full_new, flags);
|
|
|
|
|
|
|
|
zfs_close(zfs_hdl);
|
2018-08-16 18:58:34 +00:00
|
|
|
if (err != 0)
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
|
|
|
return (0);
|
2018-07-24 13:17:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int
|
2018-08-10 04:01:40 +00:00
|
|
|
be_export(libbe_handle_t *lbh, const char *bootenv, int fd)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
char snap_name[BE_MAXPATHLEN];
|
|
|
|
char buf[BE_MAXPATHLEN];
|
|
|
|
zfs_handle_t *zfs;
|
|
|
|
int err;
|
|
|
|
|
2018-07-25 15:14:35 +00:00
|
|
|
if ((err = be_snapshot(lbh, bootenv, NULL, true, snap_name)) != 0)
|
2018-08-10 04:23:13 +00:00
|
|
|
/* Use the error set by be_snapshot */
|
|
|
|
return (err);
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
be_root_concat(lbh, snap_name, buf);
|
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_DATASET)) == NULL)
|
2018-08-08 03:46:12 +00:00
|
|
|
return (set_error(lbh, BE_ERR_ZFSOPEN));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
err = zfs_send_one(zfs, NULL, fd, 0);
|
2018-08-10 04:23:13 +00:00
|
|
|
zfs_close(zfs);
|
|
|
|
|
2018-07-24 13:17:40 +00:00
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int
|
2018-08-10 04:01:40 +00:00
|
|
|
be_import(libbe_handle_t *lbh, const char *bootenv, int fd)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
char buf[BE_MAXPATHLEN];
|
|
|
|
time_t rawtime;
|
|
|
|
nvlist_t *props;
|
|
|
|
zfs_handle_t *zfs;
|
|
|
|
int err, len;
|
2018-08-08 03:46:12 +00:00
|
|
|
char nbuf[24];
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
/*
|
2018-08-08 03:46:12 +00:00
|
|
|
* We don't need this to be incredibly random, just unique enough that
|
|
|
|
* it won't conflict with an existing dataset name. Chopping time
|
|
|
|
* down to 32 bits is probably good enough for this.
|
2018-07-25 03:50:01 +00:00
|
|
|
*/
|
2018-08-08 03:46:12 +00:00
|
|
|
snprintf(nbuf, 24, "tmp%u",
|
|
|
|
(uint32_t)(time(NULL) & 0xFFFFFFFF));
|
|
|
|
if ((err = be_root_concat(lbh, nbuf, buf)) != 0)
|
|
|
|
/*
|
|
|
|
* Technically this is our problem, but we try to use short
|
|
|
|
* enough names that we won't run into problems except in
|
|
|
|
* worst-case BE root approaching MAXPATHLEN.
|
|
|
|
*/
|
|
|
|
return (set_error(lbh, BE_ERR_PATHLEN));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
time(&rawtime);
|
|
|
|
len = strlen(buf);
|
2018-08-16 17:56:03 +00:00
|
|
|
strftime(buf + len, sizeof(buf) - len, "@%F-%T", localtime(&rawtime));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-07-25 15:14:35 +00:00
|
|
|
if ((err = lzc_receive(buf, NULL, NULL, false, fd)) != 0) {
|
2018-08-08 03:46:12 +00:00
|
|
|
switch (err) {
|
|
|
|
case EINVAL:
|
|
|
|
return (set_error(lbh, BE_ERR_NOORIGIN));
|
|
|
|
case ENOENT:
|
|
|
|
return (set_error(lbh, BE_ERR_NOENT));
|
|
|
|
case EIO:
|
|
|
|
return (set_error(lbh, BE_ERR_IO));
|
|
|
|
default:
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
|
|
|
}
|
2018-07-24 13:17:40 +00:00
|
|
|
}
|
|
|
|
|
2018-07-25 03:50:01 +00:00
|
|
|
if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_SNAPSHOT)) == NULL)
|
2018-08-08 03:46:12 +00:00
|
|
|
return (set_error(lbh, BE_ERR_ZFSOPEN));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2018-08-13 03:42:14 +00:00
|
|
|
if (err != 0)
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
|
|
|
|
|
|
|
/*
|
2018-08-13 03:43:49 +00:00
|
|
|
* Finally, we open up the dataset we just cloned the snapshot so that
|
2018-08-13 03:42:14 +00:00
|
|
|
* we may promote it. This is necessary in order to clean up the ghost
|
2018-08-13 03:43:49 +00:00
|
|
|
* snapshot that doesn't need to be seen after the operation is
|
|
|
|
* complete.
|
2018-08-13 03:42:14 +00:00
|
|
|
*/
|
|
|
|
if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_DATASET)) == NULL)
|
|
|
|
return (set_error(lbh, BE_ERR_ZFSOPEN));
|
|
|
|
|
|
|
|
err = zfs_promote(zfs);
|
|
|
|
zfs_close(zfs);
|
|
|
|
|
|
|
|
if (err != 0)
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
|
|
|
|
|
|
|
/* Clean up the temporary snapshot */
|
|
|
|
return (be_destroy(lbh, nbuf, 0));
|
2018-07-24 13:17:40 +00:00
|
|
|
}
|
|
|
|
|
2018-08-11 01:02:27 +00:00
|
|
|
#if SOON
|
2018-08-10 21:23:56 +00:00
|
|
|
static int
|
|
|
|
be_create_child_noent(libbe_handle_t *lbh, const char *active,
|
|
|
|
const char *child_path)
|
|
|
|
{
|
|
|
|
nvlist_t *props;
|
|
|
|
zfs_handle_t *zfs;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
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) {
|
|
|
|
switch (err) {
|
|
|
|
case EZFS_EXISTS:
|
|
|
|
return (set_error(lbh, BE_ERR_EXISTS));
|
|
|
|
case EZFS_NOENT:
|
|
|
|
return (set_error(lbh, BE_ERR_NOENT));
|
|
|
|
case EZFS_BADTYPE:
|
|
|
|
case EZFS_BADVERSION:
|
|
|
|
return (set_error(lbh, BE_ERR_NOPOOL));
|
|
|
|
case EZFS_BADPROP:
|
|
|
|
default:
|
|
|
|
/* We set something up wrong, probably... */
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
nvlist_free(props);
|
|
|
|
|
|
|
|
if ((zfs = zfs_open(lbh->lzh, active, ZFS_TYPE_DATASET)) == NULL)
|
|
|
|
return (set_error(lbh, BE_ERR_ZFSOPEN));
|
|
|
|
|
|
|
|
/* Set props */
|
|
|
|
if ((err = zfs_prop_set(zfs, "canmount", "noauto")) != 0) {
|
|
|
|
zfs_close(zfs);
|
|
|
|
/*
|
|
|
|
* Similar to other cases, this shouldn't fail unless we've
|
|
|
|
* done something wrong. This is a new dataset that shouldn't
|
|
|
|
* have been mounted anywhere between creation and now.
|
|
|
|
*/
|
|
|
|
if (err == EZFS_NOMEM)
|
|
|
|
return (set_error(lbh, BE_ERR_NOMEM));
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
|
|
|
}
|
|
|
|
zfs_close(zfs);
|
|
|
|
return (BE_ERR_SUCCESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
be_create_child_cloned(libbe_handle_t *lbh, const char *active)
|
|
|
|
{
|
2018-08-11 01:02:27 +00:00
|
|
|
char buf[BE_MAXPATHLEN], tmp[BE_MAXPATHLEN];;
|
2018-08-10 21:23:56 +00:00
|
|
|
zfs_handle_t *zfs;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/* XXX TODO ? */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Establish if the existing path is a zfs dataset or just
|
|
|
|
* the subdirectory of one
|
|
|
|
*/
|
2018-08-11 01:02:27 +00:00
|
|
|
strlcpy(tmp, "tmp/be_snap.XXXXX", sizeof(tmp));
|
|
|
|
if (mktemp(tmp) == NULL)
|
2018-08-10 21:23:56 +00:00
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
|
|
|
|
2018-08-11 01:02:27 +00:00
|
|
|
be_root_concat(lbh, tmp, buf);
|
|
|
|
printf("Here %s?\n", buf);
|
2018-08-10 21:23:56 +00:00
|
|
|
if ((err = zfs_snapshot(lbh->lzh, buf, false, NULL)) != 0) {
|
|
|
|
switch (err) {
|
|
|
|
case EZFS_INVALIDNAME:
|
|
|
|
return (set_error(lbh, BE_ERR_INVALIDNAME));
|
|
|
|
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* The other errors that zfs_ioc_snapshot might return
|
|
|
|
* shouldn't happen if we've set things up properly, so
|
|
|
|
* we'll gloss over them and call it UNKNOWN as it will
|
|
|
|
* require further triage.
|
|
|
|
*/
|
|
|
|
if (errno == ENOTSUP)
|
|
|
|
return (set_error(lbh, BE_ERR_NOPOOL));
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Clone */
|
|
|
|
if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_SNAPSHOT)) == NULL)
|
|
|
|
return (BE_ERR_ZFSOPEN);
|
|
|
|
|
|
|
|
if ((err = zfs_clone(zfs, active, NULL)) != 0)
|
|
|
|
/* XXX TODO correct error */
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
|
|
|
|
|
|
|
/* set props */
|
|
|
|
zfs_close(zfs);
|
|
|
|
return (BE_ERR_SUCCESS);
|
|
|
|
}
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
int
|
2018-08-10 04:01:40 +00:00
|
|
|
be_add_child(libbe_handle_t *lbh, const char *child_path, bool cp_if_exists)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
2018-08-10 04:01:40 +00:00
|
|
|
struct stat sb;
|
2018-08-10 21:23:56 +00:00
|
|
|
char active[BE_MAXPATHLEN], buf[BE_MAXPATHLEN];
|
2018-07-24 13:17:40 +00:00
|
|
|
nvlist_t *props;
|
2018-08-10 04:01:40 +00:00
|
|
|
const char *s;
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
/* Require absolute paths */
|
2018-07-25 03:50:01 +00:00
|
|
|
if (*child_path != '/')
|
2018-08-10 04:23:13 +00:00
|
|
|
return (set_error(lbh, BE_ERR_BADPATH));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-08-10 04:23:13 +00:00
|
|
|
strlcpy(active, be_active_path(lbh), BE_MAXPATHLEN);
|
2018-07-24 13:17:40 +00:00
|
|
|
strcpy(buf, active);
|
|
|
|
|
|
|
|
/* Create non-mountable parent dataset(s) */
|
2018-08-10 04:01:40 +00:00
|
|
|
s = child_path;
|
2018-07-24 13:17:40 +00:00
|
|
|
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 */
|
2018-08-10 04:23:13 +00:00
|
|
|
if (strlcat(active, child_path, BE_MAXPATHLEN) >= BE_MAXPATHLEN)
|
|
|
|
return (set_error(lbh, BE_ERR_PATHLEN));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
if (stat(child_path, &sb) != 0) {
|
|
|
|
/* Verify that error is ENOENT */
|
2018-08-10 04:23:13 +00:00
|
|
|
if (errno != ENOENT)
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
2018-08-10 21:23:56 +00:00
|
|
|
return (be_create_child_noent(lbh, active, child_path));
|
|
|
|
} else if (cp_if_exists)
|
2018-07-24 13:17:40 +00:00
|
|
|
/* Path is already a descendent of / and should be copied */
|
2018-08-10 21:23:56 +00:00
|
|
|
return (be_create_child_cloned(lbh, active));
|
|
|
|
return (set_error(lbh, BE_ERR_EXISTS));
|
2018-07-24 13:17:40 +00:00
|
|
|
}
|
2018-08-11 01:02:27 +00:00
|
|
|
#endif /* SOON */
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-08-07 01:56:37 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2018-11-10 20:42:29 +00:00
|
|
|
/*
|
|
|
|
* Deactivate old BE dataset; currently just sets canmount=noauto
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
be_deactivate(libbe_handle_t *lbh, const char *ds)
|
|
|
|
{
|
|
|
|
zfs_handle_t *zfs;
|
|
|
|
|
|
|
|
if ((zfs = zfs_open(lbh->lzh, ds, ZFS_TYPE_DATASET)) == NULL)
|
|
|
|
return (1);
|
|
|
|
if (zfs_prop_set(zfs, "canmount", "noauto") != 0)
|
|
|
|
return (1);
|
|
|
|
zfs_close(zfs);
|
|
|
|
return (0);
|
|
|
|
}
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
int
|
2018-08-10 04:01:40 +00:00
|
|
|
be_activate(libbe_handle_t *lbh, const char *bootenv, bool temporary)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
char be_path[BE_MAXPATHLEN];
|
|
|
|
char buf[BE_MAXPATHLEN];
|
2018-11-01 14:00:56 +00:00
|
|
|
nvlist_t *config, *dsprops, *vdevs;
|
|
|
|
char *origin;
|
2018-10-01 14:57:33 +00:00
|
|
|
uint64_t pool_guid;
|
|
|
|
zfs_handle_t *zhp;
|
2018-07-24 13:17:40 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
be_root_concat(lbh, bootenv, be_path);
|
|
|
|
|
|
|
|
/* Note: be_exists fails if mountpoint is not / */
|
2018-09-01 02:22:26 +00:00
|
|
|
if ((err = be_exists(lbh, be_path)) != 0)
|
|
|
|
return (set_error(lbh, err));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
if (temporary) {
|
2018-08-07 01:56:37 +00:00
|
|
|
config = zpool_get_config(lbh->active_phandle, NULL);
|
2018-08-10 21:23:56 +00:00
|
|
|
if (config == NULL)
|
|
|
|
/* config should be fetchable... */
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-08-07 01:56:37 +00:00
|
|
|
if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
|
|
|
|
&pool_guid) != 0)
|
2018-08-10 21:23:56 +00:00
|
|
|
/* Similarly, it shouldn't be possible */
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
/* Expected format according to zfsbootcfg(8) man */
|
2018-08-16 18:37:47 +00:00
|
|
|
snprintf(buf, sizeof(buf), "zfs:%s:", be_path);
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-08-10 21:23:56 +00:00
|
|
|
/* We have no config tree */
|
|
|
|
if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
|
|
|
|
&vdevs) != 0)
|
|
|
|
return (set_error(lbh, BE_ERR_NOPOOL));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-08-07 01:56:37 +00:00
|
|
|
return (be_set_nextboot(lbh, vdevs, pool_guid, buf));
|
2018-07-24 13:17:40 +00:00
|
|
|
} else {
|
2018-11-10 20:42:29 +00:00
|
|
|
if (be_deactivate(lbh, lbh->bootfs) != 0)
|
|
|
|
return (-1);
|
|
|
|
|
2018-07-24 13:17:40 +00:00
|
|
|
/* Obtain bootenv zpool */
|
2018-07-25 03:08:11 +00:00
|
|
|
err = zpool_set_prop(lbh->active_phandle, "bootfs", be_path);
|
2018-10-01 14:57:33 +00:00
|
|
|
if (err)
|
|
|
|
return (-1);
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-10-01 14:57:33 +00:00
|
|
|
zhp = zfs_open(lbh->lzh, be_path, ZFS_TYPE_FILESYSTEM);
|
|
|
|
if (zhp == NULL)
|
|
|
|
return (-1);
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2018-11-01 14:00:56 +00:00
|
|
|
if (be_prop_list_alloc(&dsprops) != 0)
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
if (be_get_dataset_props(lbh, be_path, dsprops) != 0) {
|
|
|
|
nvlist_free(dsprops);
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nvlist_lookup_string(dsprops, "origin", &origin) == 0)
|
|
|
|
err = zfs_promote(zhp);
|
|
|
|
nvlist_free(dsprops);
|
|
|
|
|
2018-10-01 14:57:33 +00:00
|
|
|
zfs_close(zhp);
|
|
|
|
|
|
|
|
if (err)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (-1);
|
|
|
|
}
|
2018-10-01 14:57:33 +00:00
|
|
|
|
|
|
|
return (BE_ERR_SUCCESS);
|
2018-07-24 13:17:40 +00:00
|
|
|
}
|