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>
|
|
|
|
*
|
|
|
|
* 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>
|
2020-01-02 18:46:33 +00:00
|
|
|
#include <sys/queue.h>
|
2019-12-06 19:33:39 +00:00
|
|
|
#include <sys/zfs_context.h>
|
|
|
|
#include <sys/mntent.h>
|
Merge OpenZFS support in to HEAD.
The primary benefit is maintaining a completely shared
code base with the community allowing FreeBSD to receive
new features sooner and with less effort.
I would advise against doing 'zpool upgrade'
or creating indispensable pools using new
features until this change has had a month+
to soak.
Work on merging FreeBSD support in to what was
at the time "ZFS on Linux" began in August 2018.
I first publicly proposed transitioning FreeBSD
to (new) OpenZFS on December 18th, 2018. FreeBSD
support in OpenZFS was finally completed in December
2019. A CFT for downstreaming OpenZFS support in
to FreeBSD was first issued on July 8th. All issues
that were reported have been addressed or, for
a couple of less critical matters there are
pull requests in progress with OpenZFS. iXsystems
has tested and dogfooded extensively internally.
The TrueNAS 12 release is based on OpenZFS with
some additional features that have not yet made
it upstream.
Improvements include:
project quotas, encrypted datasets,
allocation classes, vectorized raidz,
vectorized checksums, various command line
improvements, zstd compression.
Thanks to those who have helped along the way:
Ryan Moeller, Allan Jude, Zack Welch, and many
others.
Sponsored by: iXsystems, Inc.
Differential Revision: https://reviews.freebsd.org/D25872
2020-08-25 02:21:27 +00:00
|
|
|
#include <sys/zfs_ioctl.h>
|
2019-12-06 19:33:39 +00:00
|
|
|
|
Merge OpenZFS support in to HEAD.
The primary benefit is maintaining a completely shared
code base with the community allowing FreeBSD to receive
new features sooner and with less effort.
I would advise against doing 'zpool upgrade'
or creating indispensable pools using new
features until this change has had a month+
to soak.
Work on merging FreeBSD support in to what was
at the time "ZFS on Linux" began in August 2018.
I first publicly proposed transitioning FreeBSD
to (new) OpenZFS on December 18th, 2018. FreeBSD
support in OpenZFS was finally completed in December
2019. A CFT for downstreaming OpenZFS support in
to FreeBSD was first issued on July 8th. All issues
that were reported have been addressed or, for
a couple of less critical matters there are
pull requests in progress with OpenZFS. iXsystems
has tested and dogfooded extensively internally.
The TrueNAS 12 release is based on OpenZFS with
some additional features that have not yet made
it upstream.
Improvements include:
project quotas, encrypted datasets,
allocation classes, vectorized raidz,
vectorized checksums, various command line
improvements, zstd compression.
Thanks to those who have helped along the way:
Ryan Moeller, Allan Jude, Zack Welch, and many
others.
Sponsored by: iXsystems, Inc.
Differential Revision: https://reviews.freebsd.org/D25872
2020-08-25 02:21:27 +00:00
|
|
|
#include <libzutil.h>
|
2018-07-24 13:17:40 +00:00
|
|
|
#include <ctype.h>
|
|
|
|
#include <libgen.h>
|
|
|
|
#include <libzfs_core.h>
|
Merge OpenZFS support in to HEAD.
The primary benefit is maintaining a completely shared
code base with the community allowing FreeBSD to receive
new features sooner and with less effort.
I would advise against doing 'zpool upgrade'
or creating indispensable pools using new
features until this change has had a month+
to soak.
Work on merging FreeBSD support in to what was
at the time "ZFS on Linux" began in August 2018.
I first publicly proposed transitioning FreeBSD
to (new) OpenZFS on December 18th, 2018. FreeBSD
support in OpenZFS was finally completed in December
2019. A CFT for downstreaming OpenZFS support in
to FreeBSD was first issued on July 8th. All issues
that were reported have been addressed or, for
a couple of less critical matters there are
pull requests in progress with OpenZFS. iXsystems
has tested and dogfooded extensively internally.
The TrueNAS 12 release is based on OpenZFS with
some additional features that have not yet made
it upstream.
Improvements include:
project quotas, encrypted datasets,
allocation classes, vectorized raidz,
vectorized checksums, various command line
improvements, zstd compression.
Thanks to those who have helped along the way:
Ryan Moeller, Allan Jude, Zack Welch, and many
others.
Sponsored by: iXsystems, Inc.
Differential Revision: https://reviews.freebsd.org/D25872
2020-08-25 02:21:27 +00:00
|
|
|
#include <libzfs_impl.h>
|
2018-07-24 13:17:40 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <unistd.h>
|
loader: zfs should support bootonce an nextboot
bootonce feature is temporary, one time boot, activated by
"bectl activate -t BE", "bectl activate -T BE" will reset the bootonce flag.
By default, the bootonce setting is reset on attempt to boot and the next
boot will use previously active BE.
By setting zfs_bootonce_activate="YES" in rc.conf, the bootonce BE will
be set permanently active.
bootonce dataset name is recorded in boot pool labels, bootenv area.
in case of nextboot, the nextboot_enable boolean variable is recorded in
freebsd:nvstore nvlist, also stored in boot pool label bootenv area.
On boot, the loader will process /boot/nextboot.conf if nextboot_enable
is "YES", and will set nextboot_enable to "NO", preventing /boot/nextboot.conf
processing on next boot.
bootonce and nextboot features are usable in both UEFI and BIOS boot.
To use bootonce/nextboot features, the boot loader needs to be updated on disk;
if loader.efi is stored on ESP, then ESP needs to be updated and
for BIOS boot, stage2 (zfsboot or gptzfsboot) needs to be updated
(gpart or other tools).
At this time, only lua loader is updated.
Sponsored by: Netflix, Klara Inc.
Differential Revision: https://reviews.freebsd.org/D25512
2020-09-21 09:01:10 +00:00
|
|
|
#include <libzfsbootenv.h>
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
#include "be.h"
|
|
|
|
#include "be_impl.h"
|
|
|
|
|
2020-01-02 18:46:33 +00:00
|
|
|
struct promote_entry {
|
|
|
|
char name[BE_MAXPATHLEN];
|
|
|
|
SLIST_ENTRY(promote_entry) link;
|
|
|
|
};
|
|
|
|
|
2019-02-13 04:19:08 +00:00
|
|
|
struct be_destroy_data {
|
2020-01-02 18:46:33 +00:00
|
|
|
libbe_handle_t *lbh;
|
|
|
|
char target_name[BE_MAXPATHLEN];
|
|
|
|
char *snapname;
|
|
|
|
SLIST_HEAD(, promote_entry) promotelist;
|
2019-02-13 04:19:08 +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);
|
|
|
|
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
|
|
|
|
2019-04-03 17:04:38 +00:00
|
|
|
/* Arbitrary... should tune */
|
|
|
|
#define BE_SNAP_SERIAL_MAX 1024
|
|
|
|
|
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;
|
2019-12-06 19:33:39 +00:00
|
|
|
struct mnttab 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
|
|
|
{
|
2019-01-09 22:31:10 +00:00
|
|
|
char altroot[MAXPATHLEN];
|
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;
|
|
|
|
|
2019-01-09 22:31:10 +00:00
|
|
|
if (zpool_get_prop(lbh->active_phandle, ZPOOL_PROP_ALTROOT,
|
|
|
|
altroot, sizeof(altroot), NULL, true) == 0 &&
|
|
|
|
strcmp(altroot, "-") != 0)
|
|
|
|
lbh->altroot_len = strlen(altroot);
|
|
|
|
|
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
|
|
|
|
2020-01-02 18:46:33 +00:00
|
|
|
static bool
|
|
|
|
be_should_promote_clones(zfs_handle_t *zfs_hdl, struct be_destroy_data *bdd)
|
|
|
|
{
|
|
|
|
char *atpos;
|
|
|
|
|
|
|
|
if (zfs_get_type(zfs_hdl) != ZFS_TYPE_SNAPSHOT)
|
|
|
|
return (false);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we're deleting a snapshot, we need to make sure we only promote
|
|
|
|
* clones that are derived from one of the snapshots we're deleting,
|
|
|
|
* rather than that of a snapshot we're not touching. This keeps stuff
|
|
|
|
* in a consistent state, making sure that we don't error out unless
|
|
|
|
* we really need to.
|
|
|
|
*/
|
|
|
|
if (bdd->snapname == NULL)
|
|
|
|
return (true);
|
|
|
|
|
|
|
|
atpos = strchr(zfs_get_name(zfs_hdl), '@');
|
|
|
|
return (strcmp(atpos + 1, bdd->snapname) == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is executed from be_promote_dependent_clones via zfs_iter_dependents,
|
|
|
|
* It checks if the dependent type is a snapshot then attempts to find any
|
|
|
|
* clones associated with it. Any clones not related to the destroy target are
|
|
|
|
* added to the promote list.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
be_dependent_clone_cb(zfs_handle_t *zfs_hdl, void *data)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
bool found;
|
|
|
|
char *name;
|
|
|
|
struct nvlist *nvl;
|
|
|
|
struct nvpair *nvp;
|
|
|
|
struct be_destroy_data *bdd;
|
|
|
|
struct promote_entry *entry, *newentry;
|
|
|
|
|
|
|
|
nvp = NULL;
|
|
|
|
err = 0;
|
|
|
|
bdd = (struct be_destroy_data *)data;
|
|
|
|
|
|
|
|
if (be_should_promote_clones(zfs_hdl, bdd) &&
|
|
|
|
(nvl = zfs_get_clones_nvl(zfs_hdl)) != NULL) {
|
|
|
|
while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
|
|
|
|
name = nvpair_name(nvp);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Skip if the clone is equal to, or a child of, the
|
|
|
|
* destroy target.
|
|
|
|
*/
|
|
|
|
if (strncmp(name, bdd->target_name,
|
|
|
|
strlen(bdd->target_name)) == 0 ||
|
|
|
|
strstr(name, bdd->target_name) == name) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
found = false;
|
|
|
|
SLIST_FOREACH(entry, &bdd->promotelist, link) {
|
|
|
|
if (strcmp(entry->name, name) == 0) {
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (found)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
newentry = malloc(sizeof(struct promote_entry));
|
|
|
|
if (newentry == NULL) {
|
|
|
|
err = ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define BE_COPY_NAME(entry, src) \
|
|
|
|
strlcpy((entry)->name, (src), sizeof((entry)->name))
|
|
|
|
if (BE_COPY_NAME(newentry, name) >=
|
|
|
|
sizeof(newentry->name)) {
|
|
|
|
/* Shouldn't happen. */
|
|
|
|
free(newentry);
|
|
|
|
err = ENAMETOOLONG;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#undef BE_COPY_NAME
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We're building up a SLIST here to make sure both that
|
|
|
|
* we get the order right and so that we don't
|
|
|
|
* inadvertently observe the wrong state by promoting
|
|
|
|
* datasets while we're still walking the tree. The
|
|
|
|
* latter can lead to situations where we promote a BE
|
|
|
|
* then effectively demote it again.
|
|
|
|
*/
|
|
|
|
SLIST_INSERT_HEAD(&bdd->promotelist, newentry, link);
|
|
|
|
}
|
|
|
|
nvlist_free(nvl);
|
|
|
|
}
|
|
|
|
zfs_close(zfs_hdl);
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called before a destroy, so that any datasets(environments) that are
|
|
|
|
* dependent on this one get promoted before destroying the target.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
be_promote_dependent_clones(zfs_handle_t *zfs_hdl, struct be_destroy_data *bdd)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
zfs_handle_t *clone;
|
|
|
|
struct promote_entry *entry;
|
|
|
|
|
|
|
|
snprintf(bdd->target_name, BE_MAXPATHLEN, "%s/", zfs_get_name(zfs_hdl));
|
|
|
|
err = zfs_iter_dependents(zfs_hdl, true, be_dependent_clone_cb, bdd);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Drain the list and walk away from it if we're only deleting a
|
|
|
|
* snapshot.
|
|
|
|
*/
|
|
|
|
if (bdd->snapname != NULL && !SLIST_EMPTY(&bdd->promotelist))
|
|
|
|
err = BE_ERR_HASCLONES;
|
|
|
|
while (!SLIST_EMPTY(&bdd->promotelist)) {
|
|
|
|
entry = SLIST_FIRST(&bdd->promotelist);
|
|
|
|
SLIST_REMOVE_HEAD(&bdd->promotelist, link);
|
|
|
|
|
|
|
|
#define ZFS_GRAB_CLONE() \
|
|
|
|
zfs_open(bdd->lbh->lzh, entry->name, ZFS_TYPE_FILESYSTEM)
|
|
|
|
/*
|
|
|
|
* Just skip this part on error, we still want to clean up the
|
|
|
|
* promotion list after the first error. We'll then preserve it
|
|
|
|
* all the way back.
|
|
|
|
*/
|
|
|
|
if (err == 0 && (clone = ZFS_GRAB_CLONE()) != NULL) {
|
|
|
|
err = zfs_promote(clone);
|
|
|
|
if (err != 0)
|
|
|
|
err = BE_ERR_DESTROYMNT;
|
|
|
|
zfs_close(clone);
|
|
|
|
}
|
|
|
|
#undef ZFS_GRAB_CLONE
|
|
|
|
free(entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (err);
|
|
|
|
}
|
|
|
|
|
2018-08-07 03:39:29 +00:00
|
|
|
static int
|
|
|
|
be_destroy_cb(zfs_handle_t *zfs_hdl, void *data)
|
|
|
|
{
|
2019-02-13 04:19:08 +00:00
|
|
|
char path[BE_MAXPATHLEN];
|
|
|
|
struct be_destroy_data *bdd;
|
|
|
|
zfs_handle_t *snap;
|
2018-08-07 03:39:29 +00:00
|
|
|
int err;
|
|
|
|
|
2019-02-13 04:19:08 +00:00
|
|
|
bdd = (struct be_destroy_data *)data;
|
|
|
|
if (bdd->snapname == NULL) {
|
|
|
|
err = zfs_iter_children(zfs_hdl, be_destroy_cb, data);
|
|
|
|
if (err != 0)
|
|
|
|
return (err);
|
|
|
|
return (zfs_destroy(zfs_hdl, false));
|
|
|
|
}
|
|
|
|
/* If we're dealing with snapshots instead, delete that one alone */
|
|
|
|
err = zfs_iter_filesystems(zfs_hdl, be_destroy_cb, data);
|
|
|
|
if (err != 0)
|
2018-08-07 03:39:29 +00:00
|
|
|
return (err);
|
2019-02-13 04:19:08 +00:00
|
|
|
/*
|
|
|
|
* This part is intentionally glossing over any potential errors,
|
|
|
|
* because there's a lot less potential for errors when we're cleaning
|
|
|
|
* up snapshots rather than a full deep BE. The primary error case
|
|
|
|
* here being if the snapshot doesn't exist in the first place, which
|
|
|
|
* the caller will likely deem insignificant as long as it doesn't
|
|
|
|
* exist after the call. Thus, such a missing snapshot shouldn't jam
|
|
|
|
* up the destruction.
|
|
|
|
*/
|
|
|
|
snprintf(path, sizeof(path), "%s@%s", zfs_get_name(zfs_hdl),
|
|
|
|
bdd->snapname);
|
|
|
|
if (!zfs_dataset_exists(bdd->lbh->lzh, path, ZFS_TYPE_SNAPSHOT))
|
|
|
|
return (0);
|
|
|
|
snap = zfs_open(bdd->lbh->lzh, path, ZFS_TYPE_SNAPSHOT);
|
|
|
|
if (snap != NULL)
|
|
|
|
zfs_destroy(snap, false);
|
2018-08-07 03:39:29 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2019-10-16 18:33:31 +00:00
|
|
|
#define BE_DESTROY_WANTORIGIN (BE_DESTROY_ORIGIN | BE_DESTROY_AUTOORIGIN)
|
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
|
2019-02-13 04:19:08 +00:00
|
|
|
* BE_DESTROY_ORIGIN: destroy the origin snapshot as well
|
2018-07-24 13:17:40 +00:00
|
|
|
*/
|
2020-01-02 18:46:33 +00:00
|
|
|
static int
|
|
|
|
be_destroy_internal(libbe_handle_t *lbh, const char *name, int options,
|
|
|
|
bool odestroyer)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
2019-02-13 04:19:08 +00:00
|
|
|
struct be_destroy_data bdd;
|
2019-02-10 21:19:09 +00:00
|
|
|
char origin[BE_MAXPATHLEN], path[BE_MAXPATHLEN];
|
2018-07-24 13:17:40 +00:00
|
|
|
zfs_handle_t *fs;
|
2019-02-13 04:19:08 +00:00
|
|
|
char *snapdelim;
|
2018-07-25 03:50:01 +00:00
|
|
|
int err, force, mounted;
|
2019-02-13 04:19:08 +00:00
|
|
|
size_t rootlen;
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2019-02-13 04:19:08 +00:00
|
|
|
bdd.lbh = lbh;
|
|
|
|
bdd.snapname = NULL;
|
2020-01-02 18:46:33 +00:00
|
|
|
SLIST_INIT(&bdd.promotelist);
|
2018-07-25 03:50:01 +00:00
|
|
|
force = options & BE_DESTROY_FORCE;
|
2019-02-10 21:19:09 +00:00
|
|
|
*origin = '\0';
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
be_root_concat(lbh, name, path);
|
|
|
|
|
2019-02-13 04:19:08 +00:00
|
|
|
if ((snapdelim = strchr(path, '@')) == 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));
|
|
|
|
|
2019-01-07 16:16:47 +00:00
|
|
|
if (strcmp(path, lbh->rootfs) == 0 ||
|
|
|
|
strcmp(path, lbh->bootfs) == 0)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, BE_ERR_DESTROYACT));
|
|
|
|
|
2019-02-13 04:19:08 +00:00
|
|
|
fs = zfs_open(lbh->lzh, path, ZFS_TYPE_FILESYSTEM);
|
2019-02-10 21:19:09 +00:00
|
|
|
if (fs == NULL)
|
|
|
|
return (set_error(lbh, BE_ERR_ZFSOPEN));
|
2019-02-13 04:19:08 +00:00
|
|
|
|
2019-04-01 17:44:20 +00:00
|
|
|
/* Don't destroy a mounted dataset unless force is specified */
|
|
|
|
if ((mounted = zfs_is_mounted(fs, NULL)) != 0) {
|
|
|
|
if (force) {
|
|
|
|
zfs_unmount(fs, NULL, 0);
|
|
|
|
} else {
|
|
|
|
free(bdd.snapname);
|
|
|
|
return (set_error(lbh, BE_ERR_DESTROYMNT));
|
|
|
|
}
|
|
|
|
}
|
2018-07-24 13:17:40 +00:00
|
|
|
} else {
|
2020-01-02 18:46:33 +00:00
|
|
|
/*
|
|
|
|
* If we're initially destroying a snapshot, origin options do
|
|
|
|
* not make sense. If we're destroying the origin snapshot of
|
|
|
|
* a BE, we want to maintain the options in case we need to
|
|
|
|
* fake success after failing to promote.
|
|
|
|
*/
|
|
|
|
if (!odestroyer)
|
|
|
|
options &= ~BE_DESTROY_WANTORIGIN;
|
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));
|
|
|
|
|
2019-02-13 04:19:08 +00:00
|
|
|
bdd.snapname = strdup(snapdelim + 1);
|
|
|
|
if (bdd.snapname == NULL)
|
|
|
|
return (set_error(lbh, BE_ERR_NOMEM));
|
|
|
|
*snapdelim = '\0';
|
|
|
|
fs = zfs_open(lbh->lzh, path, ZFS_TYPE_DATASET);
|
|
|
|
if (fs == NULL) {
|
|
|
|
free(bdd.snapname);
|
2019-02-10 21:19:09 +00:00
|
|
|
return (set_error(lbh, BE_ERR_ZFSOPEN));
|
2019-02-13 04:19:08 +00:00
|
|
|
}
|
2018-07-24 13:17:40 +00:00
|
|
|
}
|
|
|
|
|
2020-01-02 18:46:33 +00:00
|
|
|
/*
|
|
|
|
* Whether we're destroying a BE or a single snapshot, we need to walk
|
|
|
|
* the tree of what we're going to destroy and promote everything in our
|
|
|
|
* path so that we can make it happen.
|
|
|
|
*/
|
|
|
|
if ((err = be_promote_dependent_clones(fs, &bdd)) != 0) {
|
|
|
|
free(bdd.snapname);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we're just destroying the origin of some other dataset
|
|
|
|
* we were invoked to destroy, then we just ignore
|
|
|
|
* BE_ERR_HASCLONES and return success unless the caller wanted
|
|
|
|
* to force the issue.
|
|
|
|
*/
|
|
|
|
if (odestroyer && err == BE_ERR_HASCLONES &&
|
|
|
|
(options & BE_DESTROY_AUTOORIGIN) != 0)
|
|
|
|
return (0);
|
|
|
|
return (set_error(lbh, err));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This was deferred until after we promote all of the derivatives so
|
|
|
|
* that we grab the new origin after everything's settled down.
|
|
|
|
*/
|
|
|
|
if ((options & BE_DESTROY_WANTORIGIN) != 0 &&
|
|
|
|
zfs_prop_get(fs, ZFS_PROP_ORIGIN, origin, sizeof(origin),
|
|
|
|
NULL, NULL, 0, 1) != 0 &&
|
|
|
|
(options & BE_DESTROY_ORIGIN) != 0)
|
|
|
|
return (set_error(lbh, BE_ERR_NOORIGIN));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the caller wants auto-origin destruction and the origin
|
|
|
|
* name matches one of our automatically created snapshot names
|
|
|
|
* (i.e. strftime("%F-%T") with a serial at the end), then
|
|
|
|
* we'll set the DESTROY_ORIGIN flag and nuke it
|
|
|
|
* be_is_auto_snapshot_name is exported from libbe(3) so that
|
|
|
|
* the caller can determine if it needs to warn about the origin
|
|
|
|
* not being destroyed or not.
|
|
|
|
*/
|
|
|
|
if ((options & BE_DESTROY_AUTOORIGIN) != 0 && *origin != '\0' &&
|
|
|
|
be_is_auto_snapshot_name(lbh, origin))
|
|
|
|
options |= BE_DESTROY_ORIGIN;
|
|
|
|
|
2019-02-13 04:19:08 +00:00
|
|
|
err = be_destroy_cb(fs, &bdd);
|
|
|
|
zfs_close(fs);
|
|
|
|
free(bdd.snapname);
|
|
|
|
if (err != 0) {
|
2018-08-07 03:39:29 +00:00
|
|
|
/* 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
|
|
|
|
2019-02-13 04:19:08 +00:00
|
|
|
if ((options & BE_DESTROY_ORIGIN) == 0)
|
|
|
|
return (0);
|
2019-02-10 21:19:09 +00:00
|
|
|
|
2019-02-13 04:19:08 +00:00
|
|
|
/* The origin can't possibly be shorter than the BE root */
|
|
|
|
rootlen = strlen(lbh->root);
|
|
|
|
if (*origin == '\0' || strlen(origin) <= rootlen + 1)
|
|
|
|
return (set_error(lbh, BE_ERR_INVORIGIN));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2019-02-13 04:19:08 +00:00
|
|
|
/*
|
|
|
|
* We'll be chopping off the BE root and running this back through
|
|
|
|
* be_destroy, so that we properly handle the origin snapshot whether
|
|
|
|
* it be that of a deep BE or not.
|
|
|
|
*/
|
|
|
|
if (strncmp(origin, lbh->root, rootlen) != 0 || origin[rootlen] != '/')
|
|
|
|
return (0);
|
|
|
|
|
2020-01-02 18:46:33 +00:00
|
|
|
return (be_destroy_internal(lbh, origin + rootlen + 1,
|
|
|
|
options & ~BE_DESTROY_ORIGIN, true));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
be_destroy(libbe_handle_t *lbh, const char *name, int options)
|
|
|
|
{
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The consumer must not set both BE_DESTROY_AUTOORIGIN and
|
|
|
|
* BE_DESTROY_ORIGIN. Internally, we'll set the latter from the former.
|
|
|
|
* The latter should imply that we must succeed at destroying the
|
|
|
|
* origin, or complain otherwise.
|
|
|
|
*/
|
|
|
|
if ((options & BE_DESTROY_WANTORIGIN) == BE_DESTROY_WANTORIGIN)
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
|
|
|
return (be_destroy_internal(lbh, name, options, false));
|
2019-02-13 04:19:08 +00:00
|
|
|
}
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2019-04-03 17:04:38 +00:00
|
|
|
static void
|
|
|
|
be_setup_snapshot_name(libbe_handle_t *lbh, char *buf, size_t buflen)
|
|
|
|
{
|
|
|
|
time_t rawtime;
|
|
|
|
int len, serial;
|
|
|
|
|
|
|
|
time(&rawtime);
|
|
|
|
len = strlen(buf);
|
|
|
|
len += strftime(buf + len, buflen - len, "@%F-%T", localtime(&rawtime));
|
|
|
|
/* No room for serial... caller will do its best */
|
|
|
|
if (buflen - len < 2)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (serial = 0; serial < BE_SNAP_SERIAL_MAX; ++serial) {
|
|
|
|
snprintf(buf + len, buflen - len, "-%d", serial);
|
|
|
|
if (!zfs_dataset_exists(lbh->lzh, buf, ZFS_TYPE_SNAPSHOT))
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-16 14:43:05 +00:00
|
|
|
bool
|
2020-07-22 02:09:10 +00:00
|
|
|
be_is_auto_snapshot_name(libbe_handle_t *lbh __unused, const char *name)
|
2019-10-16 14:43:05 +00:00
|
|
|
{
|
|
|
|
const char *snap;
|
|
|
|
int day, hour, minute, month, second, serial, year;
|
|
|
|
|
|
|
|
if ((snap = strchr(name, '@')) == NULL)
|
|
|
|
return (false);
|
|
|
|
++snap;
|
|
|
|
/* We'll grab the individual components and do some light validation. */
|
|
|
|
if (sscanf(snap, "%d-%d-%d-%d:%d:%d-%d", &year, &month, &day, &hour,
|
|
|
|
&minute, &second, &serial) != 7)
|
|
|
|
return (false);
|
|
|
|
return (year >= 1970) && (month >= 1 && month <= 12) &&
|
|
|
|
(day >= 1 && day <= 31) && (hour >= 0 && hour <= 23) &&
|
|
|
|
(minute >= 0 && minute <= 59) && (second >= 0 && second <= 60) &&
|
|
|
|
serial >= 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];
|
2019-04-03 17:04:38 +00:00
|
|
|
int err;
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
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 {
|
2019-04-03 17:04:38 +00:00
|
|
|
be_setup_snapshot_name(lbh, buf, sizeof(buf));
|
|
|
|
|
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
|
|
|
|
2019-04-25 15:51:09 +00:00
|
|
|
/*
|
|
|
|
* Only copy locally defined or received properties. This continues
|
|
|
|
* to avoid temporary/default/local properties intentionally without
|
|
|
|
* breaking received datasets.
|
|
|
|
*/
|
|
|
|
if (src != ZPROP_SRC_LOCAL && src != ZPROP_SRC_RECEIVED)
|
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;
|
2019-01-09 22:31:10 +00:00
|
|
|
if (prop == ZFS_PROP_MOUNTPOINT)
|
|
|
|
val = be_mountpoint_augmented(dccb->lbh, val);
|
|
|
|
|
2018-11-19 02:16:20 +00:00
|
|
|
nvlist_add_string(dccb->props, zfs_prop_to_name(prop), val);
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
return (ZPROP_CONT);
|
|
|
|
}
|
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
/*
|
|
|
|
* Return the corresponding boot environment path for a given
|
|
|
|
* dataset path, the constructed path is placed in 'result'.
|
|
|
|
*
|
|
|
|
* example: say our new boot environment name is 'bootenv' and
|
|
|
|
* the dataset path is 'zroot/ROOT/default/data/set'.
|
|
|
|
*
|
|
|
|
* result should produce: 'zroot/ROOT/bootenv/data/set'
|
|
|
|
*/
|
2018-07-24 13:17:40 +00:00
|
|
|
static int
|
2019-04-22 13:43:38 +00:00
|
|
|
be_get_path(struct libbe_deep_clone *ldc, const char *dspath, char *result, int result_size)
|
|
|
|
{
|
|
|
|
char *pos;
|
|
|
|
char *child_dataset;
|
|
|
|
|
|
|
|
/* match the root path for the boot environments */
|
|
|
|
pos = strstr(dspath, ldc->lbh->root);
|
|
|
|
|
|
|
|
/* no match, different pools? */
|
|
|
|
if (pos == NULL)
|
|
|
|
return (BE_ERR_BADPATH);
|
|
|
|
|
|
|
|
/* root path of the new boot environment */
|
|
|
|
snprintf(result, result_size, "%s/%s", ldc->lbh->root, ldc->bename);
|
|
|
|
|
|
|
|
/* gets us to the parent dataset, the +1 consumes a trailing slash */
|
|
|
|
pos += strlen(ldc->lbh->root) + 1;
|
|
|
|
|
|
|
|
/* skip the parent dataset */
|
|
|
|
if ((child_dataset = strchr(pos, '/')) != NULL)
|
|
|
|
strlcat(result, child_dataset, result_size);
|
|
|
|
|
|
|
|
return (BE_ERR_SUCCESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
be_clone_cb(zfs_handle_t *ds, void *data)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
char be_path[BE_MAXPATHLEN];
|
|
|
|
char snap_path[BE_MAXPATHLEN];
|
|
|
|
const char *dspath;
|
|
|
|
zfs_handle_t *snap_hdl;
|
|
|
|
nvlist_t *props;
|
2019-04-22 13:43:38 +00:00
|
|
|
struct libbe_deep_clone *ldc;
|
2018-07-24 13:17:40 +00:00
|
|
|
struct libbe_dccb dccb;
|
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
ldc = (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
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
snprintf(snap_path, sizeof(snap_path), "%s@%s", dspath, ldc->snapname);
|
2018-07-25 03:50:01 +00:00
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
/* construct the boot environment path from the dataset we're cloning */
|
|
|
|
if (be_get_path(ldc, dspath, be_path, sizeof(be_path)) != BE_ERR_SUCCESS)
|
|
|
|
return (set_error(ldc->lbh, BE_ERR_UNKNOWN));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
/* the dataset to be created (i.e. the boot environment) already exists */
|
|
|
|
if (zfs_dataset_exists(ldc->lbh->lzh, be_path, ZFS_TYPE_DATASET))
|
|
|
|
return (set_error(ldc->lbh, BE_ERR_EXISTS));
|
|
|
|
|
|
|
|
/* no snapshot found for this dataset, silently skip it */
|
|
|
|
if (!zfs_dataset_exists(ldc->lbh->lzh, snap_path, ZFS_TYPE_SNAPSHOT))
|
|
|
|
return (0);
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
if ((snap_hdl =
|
2019-04-22 13:43:38 +00:00
|
|
|
zfs_open(ldc->lbh->lzh, snap_path, ZFS_TYPE_SNAPSHOT)) == NULL)
|
|
|
|
return (set_error(ldc->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");
|
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
dccb.lbh = ldc->lbh;
|
2018-07-24 13:17:40 +00:00
|
|
|
dccb.zhp = ds;
|
|
|
|
dccb.props = props;
|
|
|
|
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)
|
2019-04-22 13:43:38 +00:00
|
|
|
return (set_error(ldc->lbh, BE_ERR_ZFSCLONE));
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
nvlist_free(props);
|
|
|
|
zfs_close(snap_hdl);
|
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
if (ldc->depth_limit == -1 || ldc->depth < ldc->depth_limit) {
|
|
|
|
ldc->depth++;
|
|
|
|
err = zfs_iter_filesystems(ds, be_clone_cb, ldc);
|
|
|
|
ldc->depth--;
|
|
|
|
}
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
return (set_error(ldc->lbh, err));
|
2018-07-24 13:17:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2019-04-22 13:43:38 +00:00
|
|
|
* Create a boot environment with a given name from a given snapshot.
|
|
|
|
* Snapshots can be in the format 'zroot/ROOT/default@snapshot' or
|
|
|
|
* 'default@snapshot'. In the latter case, 'default@snapshot' will be prepended
|
|
|
|
* with the root path that libbe was initailized with.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
be_clone(libbe_handle_t *lbh, const char *bename, const char *snapshot, int depth)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
char snap_path[BE_MAXPATHLEN];
|
2018-07-25 15:14:35 +00:00
|
|
|
char *parentname, *snapname;
|
2018-07-24 13:17:40 +00:00
|
|
|
zfs_handle_t *parent_hdl;
|
2019-04-22 13:43:38 +00:00
|
|
|
struct libbe_deep_clone ldc;
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
/* ensure the boot environment name is valid */
|
|
|
|
if ((err = be_validate_name(lbh, bename)) != 0)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, err));
|
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
/*
|
|
|
|
* prepend the boot environment root path if we're
|
|
|
|
* given a partial snapshot name.
|
|
|
|
*/
|
|
|
|
if ((err = be_root_concat(lbh, snapshot, snap_path)) != 0)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, err));
|
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
/* ensure the snapshot exists */
|
|
|
|
if ((err = be_validate_snap(lbh, snap_path)) != 0)
|
|
|
|
return (set_error(lbh, err));
|
2018-07-25 03:50:01 +00:00
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
/* get a copy of the snapshot path so we can disect it */
|
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));
|
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
/* split dataset name from snapshot name */
|
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++;
|
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
/* set-up the boot environment */
|
|
|
|
ldc.lbh = lbh;
|
|
|
|
ldc.bename = bename;
|
|
|
|
ldc.snapname = snapname;
|
|
|
|
ldc.depth = 0;
|
|
|
|
ldc.depth_limit = depth;
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
/* the boot environment will be cloned from this dataset */
|
2018-07-24 13:17:40 +00:00
|
|
|
parent_hdl = zfs_open(lbh->lzh, parentname, ZFS_TYPE_DATASET);
|
2019-04-22 13:43:38 +00:00
|
|
|
|
|
|
|
/* create the boot environment */
|
|
|
|
err = be_clone_cb(parent_hdl, &ldc);
|
2018-07-24 13:17:40 +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
|
|
|
free(parentname);
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, err));
|
|
|
|
}
|
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
/*
|
|
|
|
* Create a boot environment from pre-existing snapshot, specifying a depth.
|
|
|
|
*/
|
|
|
|
int be_create_depth(libbe_handle_t *lbh, const char *bename,
|
|
|
|
const char *snap, int depth)
|
|
|
|
{
|
|
|
|
return (be_clone(lbh, bename, snap, depth));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create the boot environment from pre-existing snapshot
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
be_create_from_existing_snap(libbe_handle_t *lbh, const char *bename,
|
|
|
|
const char *snap)
|
|
|
|
{
|
|
|
|
return (be_clone(lbh, bename, snap, -1));
|
|
|
|
}
|
|
|
|
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a boot environment from an existing boot environment
|
|
|
|
*/
|
|
|
|
int
|
2019-04-22 13:43:38 +00:00
|
|
|
be_create_from_existing(libbe_handle_t *lbh, const char *bename, const char *old)
|
2018-07-24 13:17:40 +00:00
|
|
|
{
|
|
|
|
int err;
|
2019-04-22 13:43:38 +00:00
|
|
|
char snap[BE_MAXPATHLEN];
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
if ((err = be_snapshot(lbh, old, NULL, true, snap)) != 0)
|
2018-07-24 13:17:40 +00:00
|
|
|
return (set_error(lbh, err));
|
|
|
|
|
2019-04-22 13:43:38 +00:00
|
|
|
err = be_clone(lbh, bename, snap, -1);
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
2019-04-10 14:00:03 +00:00
|
|
|
if (!zfs_name_valid(snap_name, ZFS_TYPE_SNAPSHOT))
|
|
|
|
return (BE_ERR_INVALIDNAME);
|
|
|
|
|
2018-07-24 13:17:40 +00:00
|
|
|
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
|
|
|
{
|
|
|
|
|
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);
|
2019-04-10 14:00:03 +00:00
|
|
|
|
|
|
|
if (!zfs_name_valid(name, ZFS_TYPE_DATASET))
|
|
|
|
return (BE_ERR_INVALIDNAME);
|
2022-04-03 02:04:31 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* ZFS allows spaces in boot environment names, but the kernel can't
|
|
|
|
* handle booting from such a dataset right now. vfs.root.mountfrom
|
|
|
|
* is defined to be a space-separated list, and there's no protocol for
|
|
|
|
* escaping whitespace in the path component of a dev:path spec. So
|
|
|
|
* while loader can handle this situation alright, it can't safely pass
|
|
|
|
* it on to mountroot.
|
|
|
|
*/
|
|
|
|
if (strchr(name, ' ') != NULL)
|
|
|
|
return (BE_ERR_INVALIDNAME);
|
2019-04-10 14:00:03 +00:00
|
|
|
|
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
|
|
|
|
2020-09-04 22:25:14 +00:00
|
|
|
/* recurse, nounmount, forceunmount */
|
|
|
|
struct renameflags flags = {
|
|
|
|
.nounmount = 1,
|
|
|
|
};
|
|
|
|
err = zfs_rename(zfs_hdl, full_new, flags);
|
2018-07-24 13:17:40 +00:00
|
|
|
|
|
|
|
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;
|
2019-09-17 14:15:48 +00:00
|
|
|
sendflags_t flags = { 0 };
|
2018-07-24 13:17:40 +00:00
|
|
|
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
|
|
|
|
Merge OpenZFS support in to HEAD.
The primary benefit is maintaining a completely shared
code base with the community allowing FreeBSD to receive
new features sooner and with less effort.
I would advise against doing 'zpool upgrade'
or creating indispensable pools using new
features until this change has had a month+
to soak.
Work on merging FreeBSD support in to what was
at the time "ZFS on Linux" began in August 2018.
I first publicly proposed transitioning FreeBSD
to (new) OpenZFS on December 18th, 2018. FreeBSD
support in OpenZFS was finally completed in December
2019. A CFT for downstreaming OpenZFS support in
to FreeBSD was first issued on July 8th. All issues
that were reported have been addressed or, for
a couple of less critical matters there are
pull requests in progress with OpenZFS. iXsystems
has tested and dogfooded extensively internally.
The TrueNAS 12 release is based on OpenZFS with
some additional features that have not yet made
it upstream.
Improvements include:
project quotas, encrypted datasets,
allocation classes, vectorized raidz,
vectorized checksums, various command line
improvements, zstd compression.
Thanks to those who have helped along the way:
Ryan Moeller, Allan Jude, Zack Welch, and many
others.
Sponsored by: iXsystems, Inc.
Differential Revision: https://reviews.freebsd.org/D25872
2020-08-25 02:21:27 +00:00
|
|
|
err = zfs_send_one(zfs, NULL, fd, &flags, /* redactbook */ NULL);
|
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];
|
|
|
|
nvlist_t *props;
|
|
|
|
zfs_handle_t *zfs;
|
2019-01-23 02:09:15 +00:00
|
|
|
recvflags_t flags = { .nomount = 1 };
|
|
|
|
int err;
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2019-01-23 02:09:15 +00:00
|
|
|
be_root_concat(lbh, bootenv, buf);
|
|
|
|
|
|
|
|
if ((err = zfs_receive(lbh->lzh, buf, NULL, &flags, fd, NULL)) != 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
|
|
|
}
|
|
|
|
|
2019-01-23 02:09:15 +00:00
|
|
|
if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_FILESYSTEM)) == 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");
|
2019-05-02 17:50:56 +00:00
|
|
|
nvlist_add_string(props, "mountpoint", "none");
|
2018-07-24 13:17:40 +00:00
|
|
|
|
2019-01-23 02:09:15 +00:00
|
|
|
err = zfs_prop_set_list(zfs, props);
|
2018-07-24 13:17:40 +00:00
|
|
|
nvlist_free(props);
|
|
|
|
|
2018-08-13 03:42:14 +00:00
|
|
|
zfs_close(zfs);
|
|
|
|
|
|
|
|
if (err != 0)
|
|
|
|
return (set_error(lbh, BE_ERR_UNKNOWN));
|
|
|
|
|
2019-01-23 02:09:15 +00:00
|
|
|
return (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-11-10 20:42:29 +00:00
|
|
|
/*
|
loader: zfs should support bootonce an nextboot
bootonce feature is temporary, one time boot, activated by
"bectl activate -t BE", "bectl activate -T BE" will reset the bootonce flag.
By default, the bootonce setting is reset on attempt to boot and the next
boot will use previously active BE.
By setting zfs_bootonce_activate="YES" in rc.conf, the bootonce BE will
be set permanently active.
bootonce dataset name is recorded in boot pool labels, bootenv area.
in case of nextboot, the nextboot_enable boolean variable is recorded in
freebsd:nvstore nvlist, also stored in boot pool label bootenv area.
On boot, the loader will process /boot/nextboot.conf if nextboot_enable
is "YES", and will set nextboot_enable to "NO", preventing /boot/nextboot.conf
processing on next boot.
bootonce and nextboot features are usable in both UEFI and BIOS boot.
To use bootonce/nextboot features, the boot loader needs to be updated on disk;
if loader.efi is stored on ESP, then ESP needs to be updated and
for BIOS boot, stage2 (zfsboot or gptzfsboot) needs to be updated
(gpart or other tools).
At this time, only lua loader is updated.
Sponsored by: Netflix, Klara Inc.
Differential Revision: https://reviews.freebsd.org/D25512
2020-09-21 09:01:10 +00:00
|
|
|
* Deactivate old BE dataset; currently just sets canmount=noauto or
|
|
|
|
* resets boot once configuration.
|
2018-11-10 20:42:29 +00:00
|
|
|
*/
|
loader: zfs should support bootonce an nextboot
bootonce feature is temporary, one time boot, activated by
"bectl activate -t BE", "bectl activate -T BE" will reset the bootonce flag.
By default, the bootonce setting is reset on attempt to boot and the next
boot will use previously active BE.
By setting zfs_bootonce_activate="YES" in rc.conf, the bootonce BE will
be set permanently active.
bootonce dataset name is recorded in boot pool labels, bootenv area.
in case of nextboot, the nextboot_enable boolean variable is recorded in
freebsd:nvstore nvlist, also stored in boot pool label bootenv area.
On boot, the loader will process /boot/nextboot.conf if nextboot_enable
is "YES", and will set nextboot_enable to "NO", preventing /boot/nextboot.conf
processing on next boot.
bootonce and nextboot features are usable in both UEFI and BIOS boot.
To use bootonce/nextboot features, the boot loader needs to be updated on disk;
if loader.efi is stored on ESP, then ESP needs to be updated and
for BIOS boot, stage2 (zfsboot or gptzfsboot) needs to be updated
(gpart or other tools).
At this time, only lua loader is updated.
Sponsored by: Netflix, Klara Inc.
Differential Revision: https://reviews.freebsd.org/D25512
2020-09-21 09:01:10 +00:00
|
|
|
int
|
|
|
|
be_deactivate(libbe_handle_t *lbh, const char *ds, bool temporary)
|
2018-11-10 20:42:29 +00:00
|
|
|
{
|
|
|
|
zfs_handle_t *zfs;
|
|
|
|
|
loader: zfs should support bootonce an nextboot
bootonce feature is temporary, one time boot, activated by
"bectl activate -t BE", "bectl activate -T BE" will reset the bootonce flag.
By default, the bootonce setting is reset on attempt to boot and the next
boot will use previously active BE.
By setting zfs_bootonce_activate="YES" in rc.conf, the bootonce BE will
be set permanently active.
bootonce dataset name is recorded in boot pool labels, bootenv area.
in case of nextboot, the nextboot_enable boolean variable is recorded in
freebsd:nvstore nvlist, also stored in boot pool label bootenv area.
On boot, the loader will process /boot/nextboot.conf if nextboot_enable
is "YES", and will set nextboot_enable to "NO", preventing /boot/nextboot.conf
processing on next boot.
bootonce and nextboot features are usable in both UEFI and BIOS boot.
To use bootonce/nextboot features, the boot loader needs to be updated on disk;
if loader.efi is stored on ESP, then ESP needs to be updated and
for BIOS boot, stage2 (zfsboot or gptzfsboot) needs to be updated
(gpart or other tools).
At this time, only lua loader is updated.
Sponsored by: Netflix, Klara Inc.
Differential Revision: https://reviews.freebsd.org/D25512
2020-09-21 09:01:10 +00:00
|
|
|
if (temporary) {
|
|
|
|
return (lzbe_set_boot_device(
|
|
|
|
zpool_get_name(lbh->active_phandle), lzbe_add, NULL));
|
|
|
|
}
|
|
|
|
|
2018-11-10 20:42:29 +00:00
|
|
|
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];
|
loader: zfs should support bootonce an nextboot
bootonce feature is temporary, one time boot, activated by
"bectl activate -t BE", "bectl activate -T BE" will reset the bootonce flag.
By default, the bootonce setting is reset on attempt to boot and the next
boot will use previously active BE.
By setting zfs_bootonce_activate="YES" in rc.conf, the bootonce BE will
be set permanently active.
bootonce dataset name is recorded in boot pool labels, bootenv area.
in case of nextboot, the nextboot_enable boolean variable is recorded in
freebsd:nvstore nvlist, also stored in boot pool label bootenv area.
On boot, the loader will process /boot/nextboot.conf if nextboot_enable
is "YES", and will set nextboot_enable to "NO", preventing /boot/nextboot.conf
processing on next boot.
bootonce and nextboot features are usable in both UEFI and BIOS boot.
To use bootonce/nextboot features, the boot loader needs to be updated on disk;
if loader.efi is stored on ESP, then ESP needs to be updated and
for BIOS boot, stage2 (zfsboot or gptzfsboot) needs to be updated
(gpart or other tools).
At this time, only lua loader is updated.
Sponsored by: Netflix, Klara Inc.
Differential Revision: https://reviews.freebsd.org/D25512
2020-09-21 09:01:10 +00:00
|
|
|
nvlist_t *dsprops;
|
2018-11-01 14:00:56 +00:00
|
|
|
char *origin;
|
2018-10-01 14:57:33 +00:00
|
|
|
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) {
|
loader: zfs should support bootonce an nextboot
bootonce feature is temporary, one time boot, activated by
"bectl activate -t BE", "bectl activate -T BE" will reset the bootonce flag.
By default, the bootonce setting is reset on attempt to boot and the next
boot will use previously active BE.
By setting zfs_bootonce_activate="YES" in rc.conf, the bootonce BE will
be set permanently active.
bootonce dataset name is recorded in boot pool labels, bootenv area.
in case of nextboot, the nextboot_enable boolean variable is recorded in
freebsd:nvstore nvlist, also stored in boot pool label bootenv area.
On boot, the loader will process /boot/nextboot.conf if nextboot_enable
is "YES", and will set nextboot_enable to "NO", preventing /boot/nextboot.conf
processing on next boot.
bootonce and nextboot features are usable in both UEFI and BIOS boot.
To use bootonce/nextboot features, the boot loader needs to be updated on disk;
if loader.efi is stored on ESP, then ESP needs to be updated and
for BIOS boot, stage2 (zfsboot or gptzfsboot) needs to be updated
(gpart or other tools).
At this time, only lua loader is updated.
Sponsored by: Netflix, Klara Inc.
Differential Revision: https://reviews.freebsd.org/D25512
2020-09-21 09:01:10 +00:00
|
|
|
return (lzbe_set_boot_device(
|
|
|
|
zpool_get_name(lbh->active_phandle), lzbe_add, be_path));
|
2018-07-24 13:17:40 +00:00
|
|
|
} else {
|
2021-01-08 17:23:16 +00:00
|
|
|
if (strncmp(lbh->bootfs, "-", 1) != 0 &&
|
|
|
|
be_deactivate(lbh, lbh->bootfs, false) != 0)
|
2018-11-10 20:42:29 +00:00
|
|
|
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
|
|
|
}
|