1337414Skevans/*- 2337414Skevans * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3336668Skevans * 4336668Skevans * Copyright (c) 2017 Kyle J. Kneitinger <kyle@kneit.in> 5336668Skevans * 6336668Skevans * Redistribution and use in source and binary forms, with or without 7336668Skevans * modification, are permitted provided that the following conditions 8336668Skevans * are met: 9336668Skevans * 1. Redistributions of source code must retain the above copyright 10336668Skevans * notice, this list of conditions and the following disclaimer. 11336668Skevans * 2. Redistributions in binary form must reproduce the above copyright 12336668Skevans * notice, this list of conditions and the following disclaimer in the 13336668Skevans * documentation and/or other materials provided with the distribution. 14336668Skevans * 15336668Skevans * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 16336668Skevans * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17336668Skevans * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18336668Skevans * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 19336668Skevans * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20336668Skevans * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21336668Skevans * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22336668Skevans * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23336668Skevans * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24336668Skevans * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25336668Skevans * SUCH DAMAGE. 26336668Skevans */ 27336668Skevans 28337416Skevans#include <sys/cdefs.h> 29337416Skevans__FBSDID("$FreeBSD: stable/11/lib/libbe/be.c 357667 2020-02-07 21:57:27Z kevans $"); 30337416Skevans 31346429Skevans#include <sys/param.h> 32346429Skevans#include <sys/mount.h> 33336668Skevans#include <sys/stat.h> 34346429Skevans#include <sys/ucred.h> 35356593Skevans#include <sys/queue.h> 36355662Skevans#include <sys/zfs_context.h> 37355662Skevans#include <sys/mntent.h> 38355662Skevans 39336668Skevans#include <ctype.h> 40336668Skevans#include <libgen.h> 41336668Skevans#include <libzfs_core.h> 42336668Skevans#include <stdio.h> 43336668Skevans#include <stdlib.h> 44336668Skevans#include <time.h> 45336668Skevans#include <unistd.h> 46336668Skevans 47336668Skevans#include "be.h" 48336668Skevans#include "be_impl.h" 49336668Skevans 50356593Skevansstruct promote_entry { 51356593Skevans char name[BE_MAXPATHLEN]; 52356593Skevans SLIST_ENTRY(promote_entry) link; 53356593Skevans}; 54356593Skevans 55346429Skevansstruct be_destroy_data { 56356593Skevans libbe_handle_t *lbh; 57356593Skevans char target_name[BE_MAXPATHLEN]; 58356593Skevans char *snapname; 59356593Skevans SLIST_HEAD(, promote_entry) promotelist; 60346429Skevans}; 61346429Skevans 62337596Skevans#if SOON 63337592Skevansstatic int be_create_child_noent(libbe_handle_t *lbh, const char *active, 64337592Skevans const char *child_path); 65337592Skevansstatic int be_create_child_cloned(libbe_handle_t *lbh, const char *active); 66337596Skevans#endif 67337592Skevans 68346429Skevans/* Arbitrary... should tune */ 69346429Skevans#define BE_SNAP_SERIAL_MAX 1024 70346429Skevans 71336668Skevans/* 72336699Skevans * Iterator function for locating the rootfs amongst the children of the 73336699Skevans * zfs_be_root set by loader(8). data is expected to be a libbe_handle_t *. 74336699Skevans */ 75336699Skevansstatic int 76346429Skevansbe_locate_rootfs(libbe_handle_t *lbh) 77336699Skevans{ 78346429Skevans struct statfs sfs; 79355662Skevans struct mnttab entry; 80346429Skevans zfs_handle_t *zfs; 81336699Skevans 82346429Skevans /* 83346429Skevans * Check first if root is ZFS; if not, we'll bail on rootfs capture. 84346429Skevans * Unfortunately needed because zfs_path_to_zhandle will emit to 85346429Skevans * stderr if / isn't actually a ZFS filesystem, which we'd like 86346429Skevans * to avoid. 87346429Skevans */ 88346429Skevans if (statfs("/", &sfs) == 0) { 89346429Skevans statfs2mnttab(&sfs, &entry); 90346429Skevans if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) 91346429Skevans return (1); 92346429Skevans } else 93336699Skevans return (1); 94346429Skevans zfs = zfs_path_to_zhandle(lbh->lzh, "/", ZFS_TYPE_FILESYSTEM); 95346429Skevans if (zfs == NULL) 96336699Skevans return (1); 97336699Skevans 98346429Skevans strlcpy(lbh->rootfs, zfs_get_name(zfs), sizeof(lbh->rootfs)); 99346429Skevans zfs_close(zfs); 100336699Skevans return (0); 101336699Skevans} 102336699Skevans 103336699Skevans/* 104336668Skevans * Initializes the libbe context to operate in the root boot environment 105336668Skevans * dataset, for example, zroot/ROOT. 106336668Skevans */ 107336668Skevanslibbe_handle_t * 108346429Skevanslibbe_init(const char *root) 109336668Skevans{ 110346429Skevans char altroot[MAXPATHLEN]; 111336668Skevans libbe_handle_t *lbh; 112336696Skevans char *poolname, *pos; 113336696Skevans int pnamelen; 114336668Skevans 115336696Skevans lbh = NULL; 116336696Skevans poolname = pos = NULL; 117336699Skevans 118336696Skevans if ((lbh = calloc(1, sizeof(libbe_handle_t))) == NULL) 119336696Skevans goto err; 120336668Skevans 121336696Skevans if ((lbh->lzh = libzfs_init()) == NULL) 122336696Skevans goto err; 123336668Skevans 124346429Skevans /* 125346429Skevans * Grab rootfs, we'll work backwards from there if an optional BE root 126346429Skevans * has not been passed in. 127346429Skevans */ 128346429Skevans if (be_locate_rootfs(lbh) != 0) { 129346429Skevans if (root == NULL) 130346429Skevans goto err; 131346429Skevans *lbh->rootfs = '\0'; 132346429Skevans } 133346429Skevans if (root == NULL) { 134346429Skevans /* Strip off the final slash from rootfs to get the be root */ 135346429Skevans strlcpy(lbh->root, lbh->rootfs, sizeof(lbh->root)); 136346429Skevans pos = strrchr(lbh->root, '/'); 137346429Skevans if (pos == NULL) 138346429Skevans goto err; 139346429Skevans *pos = '\0'; 140346429Skevans } else 141346429Skevans strlcpy(lbh->root, root, sizeof(lbh->root)); 142336668Skevans 143336696Skevans if ((pos = strchr(lbh->root, '/')) == NULL) 144336696Skevans goto err; 145336668Skevans 146336696Skevans pnamelen = pos - lbh->root; 147336696Skevans poolname = malloc(pnamelen + 1); 148336696Skevans if (poolname == NULL) 149336696Skevans goto err; 150336696Skevans 151346429Skevans strlcpy(poolname, lbh->root, pnamelen + 1); 152336696Skevans if ((lbh->active_phandle = zpool_open(lbh->lzh, poolname)) == NULL) 153336696Skevans goto err; 154346429Skevans free(poolname); 155346429Skevans poolname = NULL; 156336696Skevans 157336696Skevans if (zpool_get_prop(lbh->active_phandle, ZPOOL_PROP_BOOTFS, lbh->bootfs, 158346429Skevans sizeof(lbh->bootfs), NULL, true) != 0) 159336696Skevans goto err; 160336696Skevans 161346429Skevans if (zpool_get_prop(lbh->active_phandle, ZPOOL_PROP_ALTROOT, 162346429Skevans altroot, sizeof(altroot), NULL, true) == 0 && 163346429Skevans strcmp(altroot, "-") != 0) 164346429Skevans lbh->altroot_len = strlen(altroot); 165336696Skevans 166336668Skevans return (lbh); 167336696Skevanserr: 168336696Skevans if (lbh != NULL) { 169336696Skevans if (lbh->active_phandle != NULL) 170336696Skevans zpool_close(lbh->active_phandle); 171336696Skevans if (lbh->lzh != NULL) 172336696Skevans libzfs_fini(lbh->lzh); 173336696Skevans free(lbh); 174336696Skevans } 175336696Skevans free(poolname); 176336696Skevans return (NULL); 177336668Skevans} 178336668Skevans 179336668Skevans 180336668Skevans/* 181336668Skevans * Free memory allocated by libbe_init() 182336668Skevans */ 183336668Skevansvoid 184336668Skevanslibbe_close(libbe_handle_t *lbh) 185336668Skevans{ 186336701Skevans 187336696Skevans if (lbh->active_phandle != NULL) 188336696Skevans zpool_close(lbh->active_phandle); 189336668Skevans libzfs_fini(lbh->lzh); 190336668Skevans free(lbh); 191336668Skevans} 192336668Skevans 193337343Skevans/* 194337343Skevans * Proxy through to libzfs for the moment. 195337343Skevans */ 196337343Skevansvoid 197337343Skevansbe_nicenum(uint64_t num, char *buf, size_t buflen) 198337343Skevans{ 199336668Skevans 200337343Skevans zfs_nicenum(num, buf, buflen); 201337343Skevans} 202337343Skevans 203356593Skevansstatic bool 204356593Skevansbe_should_promote_clones(zfs_handle_t *zfs_hdl, struct be_destroy_data *bdd) 205356593Skevans{ 206356593Skevans char *atpos; 207356593Skevans 208356593Skevans if (zfs_get_type(zfs_hdl) != ZFS_TYPE_SNAPSHOT) 209356593Skevans return (false); 210356593Skevans 211356593Skevans /* 212356593Skevans * If we're deleting a snapshot, we need to make sure we only promote 213356593Skevans * clones that are derived from one of the snapshots we're deleting, 214356593Skevans * rather than that of a snapshot we're not touching. This keeps stuff 215356593Skevans * in a consistent state, making sure that we don't error out unless 216356593Skevans * we really need to. 217356593Skevans */ 218356593Skevans if (bdd->snapname == NULL) 219356593Skevans return (true); 220356593Skevans 221356593Skevans atpos = strchr(zfs_get_name(zfs_hdl), '@'); 222356593Skevans return (strcmp(atpos + 1, bdd->snapname) == 0); 223356593Skevans} 224356593Skevans 225356593Skevans/* 226356593Skevans * This is executed from be_promote_dependent_clones via zfs_iter_dependents, 227356593Skevans * It checks if the dependent type is a snapshot then attempts to find any 228356593Skevans * clones associated with it. Any clones not related to the destroy target are 229356593Skevans * added to the promote list. 230356593Skevans */ 231337409Skevansstatic int 232356593Skevansbe_dependent_clone_cb(zfs_handle_t *zfs_hdl, void *data) 233356593Skevans{ 234356593Skevans int err; 235356593Skevans bool found; 236356593Skevans char *name; 237356593Skevans struct nvlist *nvl; 238356593Skevans struct nvpair *nvp; 239356593Skevans struct be_destroy_data *bdd; 240356593Skevans struct promote_entry *entry, *newentry; 241356593Skevans 242356593Skevans nvp = NULL; 243356593Skevans err = 0; 244356593Skevans bdd = (struct be_destroy_data *)data; 245356593Skevans 246356593Skevans if (be_should_promote_clones(zfs_hdl, bdd) && 247356593Skevans (nvl = zfs_get_clones_nvl(zfs_hdl)) != NULL) { 248356593Skevans while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { 249356593Skevans name = nvpair_name(nvp); 250356593Skevans 251356593Skevans /* 252356593Skevans * Skip if the clone is equal to, or a child of, the 253356593Skevans * destroy target. 254356593Skevans */ 255356593Skevans if (strncmp(name, bdd->target_name, 256356593Skevans strlen(bdd->target_name)) == 0 || 257356593Skevans strstr(name, bdd->target_name) == name) { 258356593Skevans continue; 259356593Skevans } 260356593Skevans 261356593Skevans found = false; 262356593Skevans SLIST_FOREACH(entry, &bdd->promotelist, link) { 263356593Skevans if (strcmp(entry->name, name) == 0) { 264356593Skevans found = true; 265356593Skevans break; 266356593Skevans } 267356593Skevans } 268356593Skevans 269356593Skevans if (found) 270356593Skevans continue; 271356593Skevans 272356593Skevans newentry = malloc(sizeof(struct promote_entry)); 273356593Skevans if (newentry == NULL) { 274356593Skevans err = ENOMEM; 275356593Skevans break; 276356593Skevans } 277356593Skevans 278356593Skevans#define BE_COPY_NAME(entry, src) \ 279356593Skevans strlcpy((entry)->name, (src), sizeof((entry)->name)) 280356593Skevans if (BE_COPY_NAME(newentry, name) >= 281356593Skevans sizeof(newentry->name)) { 282356593Skevans /* Shouldn't happen. */ 283356593Skevans free(newentry); 284356593Skevans err = ENAMETOOLONG; 285356593Skevans break; 286356593Skevans } 287356593Skevans#undef BE_COPY_NAME 288356593Skevans 289356593Skevans /* 290356593Skevans * We're building up a SLIST here to make sure both that 291356593Skevans * we get the order right and so that we don't 292356593Skevans * inadvertently observe the wrong state by promoting 293356593Skevans * datasets while we're still walking the tree. The 294356593Skevans * latter can lead to situations where we promote a BE 295356593Skevans * then effectively demote it again. 296356593Skevans */ 297356593Skevans SLIST_INSERT_HEAD(&bdd->promotelist, newentry, link); 298356593Skevans } 299356593Skevans nvlist_free(nvl); 300356593Skevans } 301356593Skevans zfs_close(zfs_hdl); 302356593Skevans return (err); 303356593Skevans} 304356593Skevans 305356593Skevans/* 306356593Skevans * This is called before a destroy, so that any datasets(environments) that are 307356593Skevans * dependent on this one get promoted before destroying the target. 308356593Skevans */ 309356593Skevansstatic int 310356593Skevansbe_promote_dependent_clones(zfs_handle_t *zfs_hdl, struct be_destroy_data *bdd) 311356593Skevans{ 312356593Skevans int err; 313356593Skevans zfs_handle_t *clone; 314356593Skevans struct promote_entry *entry; 315356593Skevans 316356593Skevans snprintf(bdd->target_name, BE_MAXPATHLEN, "%s/", zfs_get_name(zfs_hdl)); 317356593Skevans err = zfs_iter_dependents(zfs_hdl, true, be_dependent_clone_cb, bdd); 318356593Skevans 319356593Skevans /* 320356593Skevans * Drain the list and walk away from it if we're only deleting a 321356593Skevans * snapshot. 322356593Skevans */ 323356593Skevans if (bdd->snapname != NULL && !SLIST_EMPTY(&bdd->promotelist)) 324356593Skevans err = BE_ERR_HASCLONES; 325356593Skevans while (!SLIST_EMPTY(&bdd->promotelist)) { 326356593Skevans entry = SLIST_FIRST(&bdd->promotelist); 327356593Skevans SLIST_REMOVE_HEAD(&bdd->promotelist, link); 328356593Skevans 329356593Skevans#define ZFS_GRAB_CLONE() \ 330356593Skevans zfs_open(bdd->lbh->lzh, entry->name, ZFS_TYPE_FILESYSTEM) 331356593Skevans /* 332356593Skevans * Just skip this part on error, we still want to clean up the 333356593Skevans * promotion list after the first error. We'll then preserve it 334356593Skevans * all the way back. 335356593Skevans */ 336356593Skevans if (err == 0 && (clone = ZFS_GRAB_CLONE()) != NULL) { 337356593Skevans err = zfs_promote(clone); 338356593Skevans if (err != 0) 339356593Skevans err = BE_ERR_DESTROYMNT; 340356593Skevans zfs_close(clone); 341356593Skevans } 342356593Skevans#undef ZFS_GRAB_CLONE 343356593Skevans free(entry); 344356593Skevans } 345356593Skevans 346356593Skevans return (err); 347356593Skevans} 348356593Skevans 349356593Skevansstatic int 350337409Skevansbe_destroy_cb(zfs_handle_t *zfs_hdl, void *data) 351337409Skevans{ 352346429Skevans char path[BE_MAXPATHLEN]; 353346429Skevans struct be_destroy_data *bdd; 354346429Skevans zfs_handle_t *snap; 355337409Skevans int err; 356337409Skevans 357346429Skevans bdd = (struct be_destroy_data *)data; 358346429Skevans if (bdd->snapname == NULL) { 359346429Skevans err = zfs_iter_children(zfs_hdl, be_destroy_cb, data); 360346429Skevans if (err != 0) 361346429Skevans return (err); 362346429Skevans return (zfs_destroy(zfs_hdl, false)); 363346429Skevans } 364346429Skevans /* If we're dealing with snapshots instead, delete that one alone */ 365346429Skevans err = zfs_iter_filesystems(zfs_hdl, be_destroy_cb, data); 366346429Skevans if (err != 0) 367337409Skevans return (err); 368346429Skevans /* 369346429Skevans * This part is intentionally glossing over any potential errors, 370346429Skevans * because there's a lot less potential for errors when we're cleaning 371346429Skevans * up snapshots rather than a full deep BE. The primary error case 372346429Skevans * here being if the snapshot doesn't exist in the first place, which 373346429Skevans * the caller will likely deem insignificant as long as it doesn't 374346429Skevans * exist after the call. Thus, such a missing snapshot shouldn't jam 375346429Skevans * up the destruction. 376346429Skevans */ 377346429Skevans snprintf(path, sizeof(path), "%s@%s", zfs_get_name(zfs_hdl), 378346429Skevans bdd->snapname); 379346429Skevans if (!zfs_dataset_exists(bdd->lbh->lzh, path, ZFS_TYPE_SNAPSHOT)) 380346429Skevans return (0); 381346429Skevans snap = zfs_open(bdd->lbh->lzh, path, ZFS_TYPE_SNAPSHOT); 382346429Skevans if (snap != NULL) 383346429Skevans zfs_destroy(snap, false); 384337409Skevans return (0); 385337409Skevans} 386337409Skevans 387353784Skevans#define BE_DESTROY_WANTORIGIN (BE_DESTROY_ORIGIN | BE_DESTROY_AUTOORIGIN) 388336668Skevans/* 389336668Skevans * Destroy the boot environment or snapshot specified by the name 390336668Skevans * parameter. Options are or'd together with the possible values: 391336668Skevans * BE_DESTROY_FORCE : forces operation on mounted datasets 392346429Skevans * BE_DESTROY_ORIGIN: destroy the origin snapshot as well 393336668Skevans */ 394356593Skevansstatic int 395356593Skevansbe_destroy_internal(libbe_handle_t *lbh, const char *name, int options, 396356593Skevans bool odestroyer) 397336668Skevans{ 398346429Skevans struct be_destroy_data bdd; 399346429Skevans char origin[BE_MAXPATHLEN], path[BE_MAXPATHLEN]; 400336668Skevans zfs_handle_t *fs; 401346429Skevans char *snapdelim; 402336701Skevans int err, force, mounted; 403346429Skevans size_t rootlen; 404336668Skevans 405346429Skevans bdd.lbh = lbh; 406346429Skevans bdd.snapname = NULL; 407356593Skevans SLIST_INIT(&bdd.promotelist); 408336701Skevans force = options & BE_DESTROY_FORCE; 409346429Skevans *origin = '\0'; 410336668Skevans 411336668Skevans be_root_concat(lbh, name, path); 412336668Skevans 413346429Skevans if ((snapdelim = strchr(path, '@')) == NULL) { 414336701Skevans if (!zfs_dataset_exists(lbh->lzh, path, ZFS_TYPE_FILESYSTEM)) 415336668Skevans return (set_error(lbh, BE_ERR_NOENT)); 416336668Skevans 417346429Skevans if (strcmp(path, lbh->rootfs) == 0 || 418346429Skevans strcmp(path, lbh->bootfs) == 0) 419336668Skevans return (set_error(lbh, BE_ERR_DESTROYACT)); 420336668Skevans 421346429Skevans fs = zfs_open(lbh->lzh, path, ZFS_TYPE_FILESYSTEM); 422346429Skevans if (fs == NULL) 423346429Skevans return (set_error(lbh, BE_ERR_ZFSOPEN)); 424346429Skevans 425346429Skevans /* Don't destroy a mounted dataset unless force is specified */ 426346429Skevans if ((mounted = zfs_is_mounted(fs, NULL)) != 0) { 427346429Skevans if (force) { 428346429Skevans zfs_unmount(fs, NULL, 0); 429346429Skevans } else { 430346429Skevans free(bdd.snapname); 431346429Skevans return (set_error(lbh, BE_ERR_DESTROYMNT)); 432346429Skevans } 433346429Skevans } 434336668Skevans } else { 435356593Skevans /* 436356593Skevans * If we're initially destroying a snapshot, origin options do 437356593Skevans * not make sense. If we're destroying the origin snapshot of 438356593Skevans * a BE, we want to maintain the options in case we need to 439356593Skevans * fake success after failing to promote. 440356593Skevans */ 441356593Skevans if (!odestroyer) 442356593Skevans options &= ~BE_DESTROY_WANTORIGIN; 443336701Skevans if (!zfs_dataset_exists(lbh->lzh, path, ZFS_TYPE_SNAPSHOT)) 444336668Skevans return (set_error(lbh, BE_ERR_NOENT)); 445336668Skevans 446346429Skevans bdd.snapname = strdup(snapdelim + 1); 447346429Skevans if (bdd.snapname == NULL) 448346429Skevans return (set_error(lbh, BE_ERR_NOMEM)); 449346429Skevans *snapdelim = '\0'; 450346429Skevans fs = zfs_open(lbh->lzh, path, ZFS_TYPE_DATASET); 451346429Skevans if (fs == NULL) { 452346429Skevans free(bdd.snapname); 453346429Skevans return (set_error(lbh, BE_ERR_ZFSOPEN)); 454346429Skevans } 455336668Skevans } 456336668Skevans 457356593Skevans /* 458356593Skevans * Whether we're destroying a BE or a single snapshot, we need to walk 459356593Skevans * the tree of what we're going to destroy and promote everything in our 460356593Skevans * path so that we can make it happen. 461356593Skevans */ 462356593Skevans if ((err = be_promote_dependent_clones(fs, &bdd)) != 0) { 463356593Skevans free(bdd.snapname); 464356593Skevans 465356593Skevans /* 466356593Skevans * If we're just destroying the origin of some other dataset 467356593Skevans * we were invoked to destroy, then we just ignore 468356593Skevans * BE_ERR_HASCLONES and return success unless the caller wanted 469356593Skevans * to force the issue. 470356593Skevans */ 471356593Skevans if (odestroyer && err == BE_ERR_HASCLONES && 472356593Skevans (options & BE_DESTROY_AUTOORIGIN) != 0) 473356593Skevans return (0); 474356593Skevans return (set_error(lbh, err)); 475356593Skevans } 476356593Skevans 477356593Skevans /* 478356593Skevans * This was deferred until after we promote all of the derivatives so 479356593Skevans * that we grab the new origin after everything's settled down. 480356593Skevans */ 481356593Skevans if ((options & BE_DESTROY_WANTORIGIN) != 0 && 482356593Skevans zfs_prop_get(fs, ZFS_PROP_ORIGIN, origin, sizeof(origin), 483356593Skevans NULL, NULL, 0, 1) != 0 && 484356593Skevans (options & BE_DESTROY_ORIGIN) != 0) 485356593Skevans return (set_error(lbh, BE_ERR_NOORIGIN)); 486356593Skevans 487356593Skevans /* 488356593Skevans * If the caller wants auto-origin destruction and the origin 489356593Skevans * name matches one of our automatically created snapshot names 490356593Skevans * (i.e. strftime("%F-%T") with a serial at the end), then 491356593Skevans * we'll set the DESTROY_ORIGIN flag and nuke it 492356593Skevans * be_is_auto_snapshot_name is exported from libbe(3) so that 493356593Skevans * the caller can determine if it needs to warn about the origin 494356593Skevans * not being destroyed or not. 495356593Skevans */ 496356593Skevans if ((options & BE_DESTROY_AUTOORIGIN) != 0 && *origin != '\0' && 497356593Skevans be_is_auto_snapshot_name(lbh, origin)) 498356593Skevans options |= BE_DESTROY_ORIGIN; 499356593Skevans 500346429Skevans err = be_destroy_cb(fs, &bdd); 501346429Skevans zfs_close(fs); 502346429Skevans free(bdd.snapname); 503346429Skevans if (err != 0) { 504337409Skevans /* Children are still present or the mount is referenced */ 505337409Skevans if (err == EBUSY) 506337409Skevans return (set_error(lbh, BE_ERR_DESTROYMNT)); 507337409Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 508337409Skevans } 509336668Skevans 510346429Skevans if ((options & BE_DESTROY_ORIGIN) == 0) 511346429Skevans return (0); 512346429Skevans 513346429Skevans /* The origin can't possibly be shorter than the BE root */ 514346429Skevans rootlen = strlen(lbh->root); 515346429Skevans if (*origin == '\0' || strlen(origin) <= rootlen + 1) 516346429Skevans return (set_error(lbh, BE_ERR_INVORIGIN)); 517346429Skevans 518346429Skevans /* 519346429Skevans * We'll be chopping off the BE root and running this back through 520346429Skevans * be_destroy, so that we properly handle the origin snapshot whether 521346429Skevans * it be that of a deep BE or not. 522346429Skevans */ 523346429Skevans if (strncmp(origin, lbh->root, rootlen) != 0 || origin[rootlen] != '/') 524346429Skevans return (0); 525346429Skevans 526356593Skevans return (be_destroy_internal(lbh, origin + rootlen + 1, 527356593Skevans options & ~BE_DESTROY_ORIGIN, true)); 528336668Skevans} 529336668Skevans 530356593Skevansint 531356593Skevansbe_destroy(libbe_handle_t *lbh, const char *name, int options) 532356593Skevans{ 533356593Skevans 534356593Skevans /* 535356593Skevans * The consumer must not set both BE_DESTROY_AUTOORIGIN and 536356593Skevans * BE_DESTROY_ORIGIN. Internally, we'll set the latter from the former. 537356593Skevans * The latter should imply that we must succeed at destroying the 538356593Skevans * origin, or complain otherwise. 539356593Skevans */ 540356593Skevans if ((options & BE_DESTROY_WANTORIGIN) == BE_DESTROY_WANTORIGIN) 541356593Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 542356593Skevans return (be_destroy_internal(lbh, name, options, false)); 543356593Skevans} 544356593Skevans 545346429Skevansstatic void 546346429Skevansbe_setup_snapshot_name(libbe_handle_t *lbh, char *buf, size_t buflen) 547346429Skevans{ 548346429Skevans time_t rawtime; 549346429Skevans int len, serial; 550336668Skevans 551346429Skevans time(&rawtime); 552346429Skevans len = strlen(buf); 553346429Skevans len += strftime(buf + len, buflen - len, "@%F-%T", localtime(&rawtime)); 554346429Skevans /* No room for serial... caller will do its best */ 555346429Skevans if (buflen - len < 2) 556346429Skevans return; 557346429Skevans 558346429Skevans for (serial = 0; serial < BE_SNAP_SERIAL_MAX; ++serial) { 559346429Skevans snprintf(buf + len, buflen - len, "-%d", serial); 560346429Skevans if (!zfs_dataset_exists(lbh->lzh, buf, ZFS_TYPE_SNAPSHOT)) 561346429Skevans return; 562346429Skevans } 563346429Skevans} 564346429Skevans 565353784Skevansbool 566353784Skevansbe_is_auto_snapshot_name(libbe_handle_t *lbh, const char *name) 567353784Skevans{ 568353784Skevans const char *snap; 569353784Skevans int day, hour, minute, month, second, serial, year; 570353784Skevans 571353784Skevans if ((snap = strchr(name, '@')) == NULL) 572353784Skevans return (false); 573353784Skevans ++snap; 574353784Skevans /* We'll grab the individual components and do some light validation. */ 575353784Skevans if (sscanf(snap, "%d-%d-%d-%d:%d:%d-%d", &year, &month, &day, &hour, 576353784Skevans &minute, &second, &serial) != 7) 577353784Skevans return (false); 578353784Skevans return (year >= 1970) && (month >= 1 && month <= 12) && 579353784Skevans (day >= 1 && day <= 31) && (hour >= 0 && hour <= 23) && 580353784Skevans (minute >= 0 && minute <= 59) && (second >= 0 && second <= 60) && 581353784Skevans serial >= 0; 582353784Skevans} 583353784Skevans 584336668Skevansint 585336710Skevansbe_snapshot(libbe_handle_t *lbh, const char *source, const char *snap_name, 586336668Skevans bool recursive, char *result) 587336668Skevans{ 588336668Skevans char buf[BE_MAXPATHLEN]; 589346429Skevans int err; 590336668Skevans 591336668Skevans be_root_concat(lbh, source, buf); 592336668Skevans 593346429Skevans if ((err = be_exists(lbh, buf)) != 0) 594346429Skevans return (set_error(lbh, err)); 595336668Skevans 596336668Skevans if (snap_name != NULL) { 597346429Skevans if (strlcat(buf, "@", sizeof(buf)) >= sizeof(buf)) 598346429Skevans return (set_error(lbh, BE_ERR_INVALIDNAME)); 599346429Skevans 600346429Skevans if (strlcat(buf, snap_name, sizeof(buf)) >= sizeof(buf)) 601346429Skevans return (set_error(lbh, BE_ERR_INVALIDNAME)); 602346429Skevans 603336701Skevans if (result != NULL) 604336668Skevans snprintf(result, BE_MAXPATHLEN, "%s@%s", source, 605336668Skevans snap_name); 606336668Skevans } else { 607346429Skevans be_setup_snapshot_name(lbh, buf, sizeof(buf)); 608346429Skevans 609346429Skevans if (result != NULL && strlcpy(result, strrchr(buf, '/') + 1, 610346429Skevans sizeof(buf)) >= sizeof(buf)) 611346429Skevans return (set_error(lbh, BE_ERR_INVALIDNAME)); 612336668Skevans } 613336710Skevans if ((err = zfs_snapshot(lbh->lzh, buf, recursive, NULL)) != 0) { 614336668Skevans switch (err) { 615336668Skevans case EZFS_INVALIDNAME: 616336668Skevans return (set_error(lbh, BE_ERR_INVALIDNAME)); 617336668Skevans 618336668Skevans default: 619337445Skevans /* 620337445Skevans * The other errors that zfs_ioc_snapshot might return 621337445Skevans * shouldn't happen if we've set things up properly, so 622337445Skevans * we'll gloss over them and call it UNKNOWN as it will 623337445Skevans * require further triage. 624337445Skevans */ 625337445Skevans if (errno == ENOTSUP) 626337445Skevans return (set_error(lbh, BE_ERR_NOPOOL)); 627336668Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 628336668Skevans } 629336668Skevans } 630336668Skevans 631336668Skevans return (BE_ERR_SUCCESS); 632336668Skevans} 633336668Skevans 634336668Skevans 635336668Skevans/* 636336668Skevans * Create the boot environment specified by the name parameter 637336668Skevans */ 638336668Skevansint 639337563Skevansbe_create(libbe_handle_t *lbh, const char *name) 640336668Skevans{ 641336668Skevans int err; 642336668Skevans 643336710Skevans err = be_create_from_existing(lbh, name, be_active_path(lbh)); 644336668Skevans 645336668Skevans return (set_error(lbh, err)); 646336668Skevans} 647336668Skevans 648336668Skevansstatic int 649336668Skevansbe_deep_clone_prop(int prop, void *cb) 650336668Skevans{ 651336668Skevans int err; 652336701Skevans struct libbe_dccb *dccb; 653336668Skevans zprop_source_t src; 654336668Skevans char pval[BE_MAXPATHLEN]; 655336668Skevans char source[BE_MAXPATHLEN]; 656346429Skevans char *val; 657336668Skevans 658336701Skevans dccb = cb; 659336668Skevans /* Skip some properties we don't want to touch */ 660337563Skevans if (prop == ZFS_PROP_CANMOUNT) 661337563Skevans return (ZPROP_CONT); 662336668Skevans 663336668Skevans /* Don't copy readonly properties */ 664336701Skevans if (zfs_prop_readonly(prop)) 665336668Skevans return (ZPROP_CONT); 666336668Skevans 667336668Skevans if ((err = zfs_prop_get(dccb->zhp, prop, (char *)&pval, 668336701Skevans sizeof(pval), &src, (char *)&source, sizeof(source), false))) 669336668Skevans /* Just continue if we fail to read a property */ 670336668Skevans return (ZPROP_CONT); 671336701Skevans 672346802Skevans /* 673346802Skevans * Only copy locally defined or received properties. This continues 674346802Skevans * to avoid temporary/default/local properties intentionally without 675346802Skevans * breaking received datasets. 676346802Skevans */ 677346802Skevans if (src != ZPROP_SRC_LOCAL && src != ZPROP_SRC_RECEIVED) 678336668Skevans return (ZPROP_CONT); 679336668Skevans 680346429Skevans /* Augment mountpoint with altroot, if needed */ 681346429Skevans val = pval; 682346429Skevans if (prop == ZFS_PROP_MOUNTPOINT) 683346429Skevans val = be_mountpoint_augmented(dccb->lbh, val); 684336668Skevans 685346429Skevans nvlist_add_string(dccb->props, zfs_prop_to_name(prop), val); 686346429Skevans 687336668Skevans return (ZPROP_CONT); 688336668Skevans} 689336668Skevans 690346802Skevans/* 691346802Skevans * Return the corresponding boot environment path for a given 692346802Skevans * dataset path, the constructed path is placed in 'result'. 693346802Skevans * 694346802Skevans * example: say our new boot environment name is 'bootenv' and 695346802Skevans * the dataset path is 'zroot/ROOT/default/data/set'. 696346802Skevans * 697346802Skevans * result should produce: 'zroot/ROOT/bootenv/data/set' 698346802Skevans */ 699336668Skevansstatic int 700346802Skevansbe_get_path(struct libbe_deep_clone *ldc, const char *dspath, char *result, int result_size) 701336668Skevans{ 702346802Skevans char *pos; 703346802Skevans char *child_dataset; 704346802Skevans 705346802Skevans /* match the root path for the boot environments */ 706346802Skevans pos = strstr(dspath, ldc->lbh->root); 707346802Skevans 708346802Skevans /* no match, different pools? */ 709346802Skevans if (pos == NULL) 710346802Skevans return (BE_ERR_BADPATH); 711346802Skevans 712346802Skevans /* root path of the new boot environment */ 713346802Skevans snprintf(result, result_size, "%s/%s", ldc->lbh->root, ldc->bename); 714346802Skevans 715346802Skevans /* gets us to the parent dataset, the +1 consumes a trailing slash */ 716346802Skevans pos += strlen(ldc->lbh->root) + 1; 717346802Skevans 718346802Skevans /* skip the parent dataset */ 719346802Skevans if ((child_dataset = strchr(pos, '/')) != NULL) 720346802Skevans strlcat(result, child_dataset, result_size); 721346802Skevans 722346802Skevans return (BE_ERR_SUCCESS); 723346802Skevans} 724346802Skevans 725346802Skevansstatic int 726346802Skevansbe_clone_cb(zfs_handle_t *ds, void *data) 727346802Skevans{ 728336668Skevans int err; 729336668Skevans char be_path[BE_MAXPATHLEN]; 730336668Skevans char snap_path[BE_MAXPATHLEN]; 731336668Skevans const char *dspath; 732336668Skevans zfs_handle_t *snap_hdl; 733336668Skevans nvlist_t *props; 734346802Skevans struct libbe_deep_clone *ldc; 735336668Skevans struct libbe_dccb dccb; 736336668Skevans 737346802Skevans ldc = (struct libbe_deep_clone *)data; 738336668Skevans dspath = zfs_get_name(ds); 739336701Skevans 740346802Skevans snprintf(snap_path, sizeof(snap_path), "%s@%s", dspath, ldc->snapname); 741336701Skevans 742346802Skevans /* construct the boot environment path from the dataset we're cloning */ 743346802Skevans if (be_get_path(ldc, dspath, be_path, sizeof(be_path)) != BE_ERR_SUCCESS) 744346802Skevans return (set_error(ldc->lbh, BE_ERR_UNKNOWN)); 745336668Skevans 746346802Skevans /* the dataset to be created (i.e. the boot environment) already exists */ 747346802Skevans if (zfs_dataset_exists(ldc->lbh->lzh, be_path, ZFS_TYPE_DATASET)) 748346802Skevans return (set_error(ldc->lbh, BE_ERR_EXISTS)); 749336668Skevans 750346802Skevans /* no snapshot found for this dataset, silently skip it */ 751346802Skevans if (!zfs_dataset_exists(ldc->lbh->lzh, snap_path, ZFS_TYPE_SNAPSHOT)) 752346802Skevans return (0); 753346802Skevans 754336668Skevans if ((snap_hdl = 755346802Skevans zfs_open(ldc->lbh->lzh, snap_path, ZFS_TYPE_SNAPSHOT)) == NULL) 756346802Skevans return (set_error(ldc->lbh, BE_ERR_ZFSOPEN)); 757336668Skevans 758336668Skevans nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP); 759336668Skevans nvlist_add_string(props, "canmount", "noauto"); 760336668Skevans 761346802Skevans dccb.lbh = ldc->lbh; 762336668Skevans dccb.zhp = ds; 763336668Skevans dccb.props = props; 764336668Skevans if (zprop_iter(be_deep_clone_prop, &dccb, B_FALSE, B_FALSE, 765336701Skevans ZFS_TYPE_FILESYSTEM) == ZPROP_INVAL) 766336668Skevans return (-1); 767336668Skevans 768346429Skevans if ((err = zfs_clone(snap_hdl, be_path, props)) != 0) 769346802Skevans return (set_error(ldc->lbh, BE_ERR_ZFSCLONE)); 770336668Skevans 771336668Skevans nvlist_free(props); 772336668Skevans zfs_close(snap_hdl); 773336668Skevans 774346802Skevans if (ldc->depth_limit == -1 || ldc->depth < ldc->depth_limit) { 775346802Skevans ldc->depth++; 776346802Skevans err = zfs_iter_filesystems(ds, be_clone_cb, ldc); 777346802Skevans ldc->depth--; 778346802Skevans } 779346429Skevans 780346802Skevans return (set_error(ldc->lbh, err)); 781336668Skevans} 782336668Skevans 783336668Skevans/* 784346802Skevans * Create a boot environment with a given name from a given snapshot. 785346802Skevans * Snapshots can be in the format 'zroot/ROOT/default@snapshot' or 786346802Skevans * 'default@snapshot'. In the latter case, 'default@snapshot' will be prepended 787346802Skevans * with the root path that libbe was initailized with. 788346802Skevans*/ 789346802Skevansstatic int 790346802Skevansbe_clone(libbe_handle_t *lbh, const char *bename, const char *snapshot, int depth) 791336668Skevans{ 792336668Skevans int err; 793336668Skevans char snap_path[BE_MAXPATHLEN]; 794336710Skevans char *parentname, *snapname; 795336668Skevans zfs_handle_t *parent_hdl; 796346802Skevans struct libbe_deep_clone ldc; 797336668Skevans 798346802Skevans /* ensure the boot environment name is valid */ 799346802Skevans if ((err = be_validate_name(lbh, bename)) != 0) 800336668Skevans return (set_error(lbh, err)); 801346802Skevans 802346802Skevans /* 803346802Skevans * prepend the boot environment root path if we're 804346802Skevans * given a partial snapshot name. 805346802Skevans */ 806346802Skevans if ((err = be_root_concat(lbh, snapshot, snap_path)) != 0) 807336668Skevans return (set_error(lbh, err)); 808346802Skevans 809346802Skevans /* ensure the snapshot exists */ 810336710Skevans if ((err = be_validate_snap(lbh, snap_path)) != 0) 811336668Skevans return (set_error(lbh, err)); 812336668Skevans 813346802Skevans /* get a copy of the snapshot path so we can disect it */ 814346429Skevans if ((parentname = strdup(snap_path)) == NULL) 815346429Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 816346429Skevans 817346802Skevans /* split dataset name from snapshot name */ 818336668Skevans snapname = strchr(parentname, '@'); 819336668Skevans if (snapname == NULL) { 820346429Skevans free(parentname); 821346429Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 822336668Skevans } 823336668Skevans *snapname = '\0'; 824336668Skevans snapname++; 825336668Skevans 826346802Skevans /* set-up the boot environment */ 827346802Skevans ldc.lbh = lbh; 828346802Skevans ldc.bename = bename; 829346802Skevans ldc.snapname = snapname; 830346802Skevans ldc.depth = 0; 831346802Skevans ldc.depth_limit = depth; 832336668Skevans 833346802Skevans /* the boot environment will be cloned from this dataset */ 834336668Skevans parent_hdl = zfs_open(lbh->lzh, parentname, ZFS_TYPE_DATASET); 835336668Skevans 836346802Skevans /* create the boot environment */ 837346802Skevans err = be_clone_cb(parent_hdl, &ldc); 838346802Skevans 839346429Skevans free(parentname); 840336668Skevans return (set_error(lbh, err)); 841336668Skevans} 842336668Skevans 843346802Skevans/* 844346802Skevans * Create a boot environment from pre-existing snapshot, specifying a depth. 845346802Skevans */ 846346802Skevansint be_create_depth(libbe_handle_t *lbh, const char *bename, 847346802Skevans const char *snap, int depth) 848346802Skevans{ 849346802Skevans return (be_clone(lbh, bename, snap, depth)); 850346802Skevans} 851336668Skevans 852336668Skevans/* 853346802Skevans * Create the boot environment from pre-existing snapshot 854346802Skevans */ 855346802Skevansint 856346802Skevansbe_create_from_existing_snap(libbe_handle_t *lbh, const char *bename, 857346802Skevans const char *snap) 858346802Skevans{ 859346802Skevans return (be_clone(lbh, bename, snap, -1)); 860346802Skevans} 861346802Skevans 862346802Skevans 863346802Skevans/* 864336668Skevans * Create a boot environment from an existing boot environment 865336668Skevans */ 866336668Skevansint 867346802Skevansbe_create_from_existing(libbe_handle_t *lbh, const char *bename, const char *old) 868336668Skevans{ 869336668Skevans int err; 870346802Skevans char snap[BE_MAXPATHLEN]; 871336668Skevans 872346802Skevans if ((err = be_snapshot(lbh, old, NULL, true, snap)) != 0) 873336668Skevans return (set_error(lbh, err)); 874336668Skevans 875346802Skevans err = be_clone(lbh, bename, snap, -1); 876336668Skevans 877336668Skevans return (set_error(lbh, err)); 878336668Skevans} 879336668Skevans 880336668Skevans 881336668Skevans/* 882336668Skevans * Verifies that a snapshot has a valid name, exists, and has a mountpoint of 883336668Skevans * '/'. Returns BE_ERR_SUCCESS (0), upon success, or the relevant BE_ERR_* upon 884336668Skevans * failure. Does not set the internal library error state. 885336668Skevans */ 886336668Skevansint 887336710Skevansbe_validate_snap(libbe_handle_t *lbh, const char *snap_name) 888336668Skevans{ 889336668Skevans 890336701Skevans if (strlen(snap_name) >= BE_MAXPATHLEN) 891336668Skevans return (BE_ERR_PATHLEN); 892336668Skevans 893346429Skevans if (!zfs_name_valid(snap_name, ZFS_TYPE_SNAPSHOT)) 894346429Skevans return (BE_ERR_INVALIDNAME); 895346429Skevans 896336668Skevans if (!zfs_dataset_exists(lbh->lzh, snap_name, 897336701Skevans ZFS_TYPE_SNAPSHOT)) 898336668Skevans return (BE_ERR_NOENT); 899336668Skevans 900346429Skevans return (BE_ERR_SUCCESS); 901336668Skevans} 902336668Skevans 903336668Skevans 904336668Skevans/* 905336668Skevans * Idempotently appends the name argument to the root boot environment path 906336668Skevans * and copies the resulting string into the result buffer (which is assumed 907336668Skevans * to be at least BE_MAXPATHLEN characters long. Returns BE_ERR_SUCCESS upon 908336668Skevans * success, BE_ERR_PATHLEN if the resulting path is longer than BE_MAXPATHLEN, 909336668Skevans * or BE_ERR_INVALIDNAME if the name is a path that does not begin with 910336668Skevans * zfs_be_root. Does not set internal library error state. 911336668Skevans */ 912336668Skevansint 913336710Skevansbe_root_concat(libbe_handle_t *lbh, const char *name, char *result) 914336668Skevans{ 915336668Skevans size_t name_len, root_len; 916336668Skevans 917336668Skevans name_len = strlen(name); 918336668Skevans root_len = strlen(lbh->root); 919336668Skevans 920336668Skevans /* Act idempotently; return be name if it is already a full path */ 921336668Skevans if (strrchr(name, '/') != NULL) { 922336701Skevans if (strstr(name, lbh->root) != name) 923336668Skevans return (BE_ERR_INVALIDNAME); 924336668Skevans 925336701Skevans if (name_len >= BE_MAXPATHLEN) 926336668Skevans return (BE_ERR_PATHLEN); 927336668Skevans 928346429Skevans strlcpy(result, name, BE_MAXPATHLEN); 929336668Skevans return (BE_ERR_SUCCESS); 930336668Skevans } else if (name_len + root_len + 1 < BE_MAXPATHLEN) { 931336668Skevans snprintf(result, BE_MAXPATHLEN, "%s/%s", lbh->root, 932336668Skevans name); 933336668Skevans return (BE_ERR_SUCCESS); 934336668Skevans } 935336668Skevans 936336668Skevans return (BE_ERR_PATHLEN); 937336668Skevans} 938336668Skevans 939336668Skevans 940336668Skevans/* 941336668Skevans * Verifies the validity of a boot environment name (A-Za-z0-9-_.). Returns 942346429Skevans * BE_ERR_SUCCESS (0) if name is valid, otherwise returns BE_ERR_INVALIDNAME 943346429Skevans * or BE_ERR_PATHLEN. 944336668Skevans * Does not set internal library error state. 945336668Skevans */ 946336668Skevansint 947346429Skevansbe_validate_name(libbe_handle_t *lbh, const char *name) 948336668Skevans{ 949346429Skevans 950346429Skevans /* 951346429Skevans * Impose the additional restriction that the entire dataset name must 952346429Skevans * not exceed the maximum length of a dataset, i.e. MAXNAMELEN. 953346429Skevans */ 954346429Skevans if (strlen(lbh->root) + 1 + strlen(name) > MAXNAMELEN) 955346429Skevans return (BE_ERR_PATHLEN); 956346429Skevans 957346429Skevans if (!zfs_name_valid(name, ZFS_TYPE_DATASET)) 958336668Skevans return (BE_ERR_INVALIDNAME); 959336668Skevans 960336668Skevans return (BE_ERR_SUCCESS); 961336668Skevans} 962336668Skevans 963336668Skevans 964336668Skevans/* 965336668Skevans * usage 966336668Skevans */ 967336668Skevansint 968337563Skevansbe_rename(libbe_handle_t *lbh, const char *old, const char *new) 969336668Skevans{ 970336668Skevans char full_old[BE_MAXPATHLEN]; 971336668Skevans char full_new[BE_MAXPATHLEN]; 972336668Skevans zfs_handle_t *zfs_hdl; 973336668Skevans int err; 974336668Skevans 975346429Skevans /* 976346429Skevans * be_validate_name is documented not to set error state, so we should 977346429Skevans * do so here. 978346429Skevans */ 979346429Skevans if ((err = be_validate_name(lbh, new)) != 0) 980346429Skevans return (set_error(lbh, err)); 981336710Skevans if ((err = be_root_concat(lbh, old, full_old)) != 0) 982336668Skevans return (set_error(lbh, err)); 983336710Skevans if ((err = be_root_concat(lbh, new, full_new)) != 0) 984336668Skevans return (set_error(lbh, err)); 985336668Skevans 986336701Skevans if (!zfs_dataset_exists(lbh->lzh, full_old, ZFS_TYPE_DATASET)) 987337445Skevans return (set_error(lbh, BE_ERR_NOENT)); 988336668Skevans 989336701Skevans if (zfs_dataset_exists(lbh->lzh, full_new, ZFS_TYPE_DATASET)) 990337445Skevans return (set_error(lbh, BE_ERR_EXISTS)); 991336668Skevans 992336668Skevans if ((zfs_hdl = zfs_open(lbh->lzh, full_old, 993336701Skevans ZFS_TYPE_FILESYSTEM)) == NULL) 994337445Skevans return (set_error(lbh, BE_ERR_ZFSOPEN)); 995336668Skevans 996336701Skevans /* recurse, nounmount, forceunmount */ 997346429Skevans struct renameflags flags = { 998346429Skevans .nounmount = 1, 999346429Skevans }; 1000336668Skevans 1001336668Skevans err = zfs_rename(zfs_hdl, NULL, full_new, flags); 1002336668Skevans 1003336668Skevans zfs_close(zfs_hdl); 1004346429Skevans if (err != 0) 1005346429Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 1006346429Skevans return (0); 1007336668Skevans} 1008336668Skevans 1009336668Skevans 1010336668Skevansint 1011337563Skevansbe_export(libbe_handle_t *lbh, const char *bootenv, int fd) 1012336668Skevans{ 1013336668Skevans char snap_name[BE_MAXPATHLEN]; 1014336668Skevans char buf[BE_MAXPATHLEN]; 1015336668Skevans zfs_handle_t *zfs; 1016352598Savg sendflags_t flags = { 0 }; 1017336668Skevans int err; 1018336668Skevans 1019336710Skevans if ((err = be_snapshot(lbh, bootenv, NULL, true, snap_name)) != 0) 1020337564Skevans /* Use the error set by be_snapshot */ 1021337564Skevans return (err); 1022336668Skevans 1023336668Skevans be_root_concat(lbh, snap_name, buf); 1024336668Skevans 1025336701Skevans if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_DATASET)) == NULL) 1026337446Skevans return (set_error(lbh, BE_ERR_ZFSOPEN)); 1027336668Skevans 1028352598Savg err = zfs_send_one(zfs, NULL, fd, flags); 1029337564Skevans zfs_close(zfs); 1030337564Skevans 1031336668Skevans return (err); 1032336668Skevans} 1033336668Skevans 1034336668Skevans 1035336668Skevansint 1036337563Skevansbe_import(libbe_handle_t *lbh, const char *bootenv, int fd) 1037336668Skevans{ 1038336668Skevans char buf[BE_MAXPATHLEN]; 1039336668Skevans nvlist_t *props; 1040336668Skevans zfs_handle_t *zfs; 1041346429Skevans recvflags_t flags = { .nomount = 1 }; 1042346429Skevans int err; 1043336668Skevans 1044346429Skevans be_root_concat(lbh, bootenv, buf); 1045336668Skevans 1046346429Skevans if ((err = zfs_receive(lbh->lzh, buf, NULL, &flags, fd, NULL)) != 0) { 1047337446Skevans switch (err) { 1048337446Skevans case EINVAL: 1049337446Skevans return (set_error(lbh, BE_ERR_NOORIGIN)); 1050337446Skevans case ENOENT: 1051337446Skevans return (set_error(lbh, BE_ERR_NOENT)); 1052337446Skevans case EIO: 1053337446Skevans return (set_error(lbh, BE_ERR_IO)); 1054337446Skevans default: 1055337446Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 1056337446Skevans } 1057336668Skevans } 1058336668Skevans 1059346429Skevans if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_FILESYSTEM)) == NULL) 1060337446Skevans return (set_error(lbh, BE_ERR_ZFSOPEN)); 1061336668Skevans 1062336668Skevans nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP); 1063336668Skevans nvlist_add_string(props, "canmount", "noauto"); 1064347170Skevans nvlist_add_string(props, "mountpoint", "none"); 1065336668Skevans 1066346429Skevans err = zfs_prop_set_list(zfs, props); 1067346429Skevans nvlist_free(props); 1068336668Skevans 1069336668Skevans zfs_close(zfs); 1070336668Skevans 1071346429Skevans if (err != 0) 1072346429Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 1073336668Skevans 1074346429Skevans return (0); 1075336668Skevans} 1076336668Skevans 1077337596Skevans#if SOON 1078337592Skevansstatic int 1079337592Skevansbe_create_child_noent(libbe_handle_t *lbh, const char *active, 1080337592Skevans const char *child_path) 1081337592Skevans{ 1082337592Skevans nvlist_t *props; 1083337592Skevans zfs_handle_t *zfs; 1084337592Skevans int err; 1085336668Skevans 1086337592Skevans nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP); 1087337592Skevans nvlist_add_string(props, "canmount", "noauto"); 1088337592Skevans nvlist_add_string(props, "mountpoint", child_path); 1089337592Skevans 1090337592Skevans /* Create */ 1091337592Skevans if ((err = zfs_create(lbh->lzh, active, ZFS_TYPE_DATASET, 1092337592Skevans props)) != 0) { 1093337592Skevans switch (err) { 1094337592Skevans case EZFS_EXISTS: 1095337592Skevans return (set_error(lbh, BE_ERR_EXISTS)); 1096337592Skevans case EZFS_NOENT: 1097337592Skevans return (set_error(lbh, BE_ERR_NOENT)); 1098337592Skevans case EZFS_BADTYPE: 1099337592Skevans case EZFS_BADVERSION: 1100337592Skevans return (set_error(lbh, BE_ERR_NOPOOL)); 1101337592Skevans case EZFS_BADPROP: 1102337592Skevans default: 1103337592Skevans /* We set something up wrong, probably... */ 1104337592Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 1105337592Skevans } 1106337592Skevans } 1107337592Skevans nvlist_free(props); 1108337592Skevans 1109337592Skevans if ((zfs = zfs_open(lbh->lzh, active, ZFS_TYPE_DATASET)) == NULL) 1110337592Skevans return (set_error(lbh, BE_ERR_ZFSOPEN)); 1111337592Skevans 1112337592Skevans /* Set props */ 1113337592Skevans if ((err = zfs_prop_set(zfs, "canmount", "noauto")) != 0) { 1114337592Skevans zfs_close(zfs); 1115337592Skevans /* 1116337592Skevans * Similar to other cases, this shouldn't fail unless we've 1117337592Skevans * done something wrong. This is a new dataset that shouldn't 1118337592Skevans * have been mounted anywhere between creation and now. 1119337592Skevans */ 1120337592Skevans if (err == EZFS_NOMEM) 1121337592Skevans return (set_error(lbh, BE_ERR_NOMEM)); 1122337592Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 1123337592Skevans } 1124337592Skevans zfs_close(zfs); 1125337592Skevans return (BE_ERR_SUCCESS); 1126337592Skevans} 1127337592Skevans 1128337592Skevansstatic int 1129337592Skevansbe_create_child_cloned(libbe_handle_t *lbh, const char *active) 1130337592Skevans{ 1131337596Skevans char buf[BE_MAXPATHLEN], tmp[BE_MAXPATHLEN];; 1132337592Skevans zfs_handle_t *zfs; 1133337592Skevans int err; 1134337592Skevans 1135337592Skevans /* XXX TODO ? */ 1136337592Skevans 1137337592Skevans /* 1138337592Skevans * Establish if the existing path is a zfs dataset or just 1139337592Skevans * the subdirectory of one 1140337592Skevans */ 1141337596Skevans strlcpy(tmp, "tmp/be_snap.XXXXX", sizeof(tmp)); 1142337596Skevans if (mktemp(tmp) == NULL) 1143337592Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 1144337592Skevans 1145337596Skevans be_root_concat(lbh, tmp, buf); 1146337596Skevans printf("Here %s?\n", buf); 1147337592Skevans if ((err = zfs_snapshot(lbh->lzh, buf, false, NULL)) != 0) { 1148337592Skevans switch (err) { 1149337592Skevans case EZFS_INVALIDNAME: 1150337592Skevans return (set_error(lbh, BE_ERR_INVALIDNAME)); 1151337592Skevans 1152337592Skevans default: 1153337592Skevans /* 1154337592Skevans * The other errors that zfs_ioc_snapshot might return 1155337592Skevans * shouldn't happen if we've set things up properly, so 1156337592Skevans * we'll gloss over them and call it UNKNOWN as it will 1157337592Skevans * require further triage. 1158337592Skevans */ 1159337592Skevans if (errno == ENOTSUP) 1160337592Skevans return (set_error(lbh, BE_ERR_NOPOOL)); 1161337592Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 1162337592Skevans } 1163337592Skevans } 1164337592Skevans 1165337592Skevans /* Clone */ 1166337592Skevans if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_SNAPSHOT)) == NULL) 1167337592Skevans return (BE_ERR_ZFSOPEN); 1168337592Skevans 1169337592Skevans if ((err = zfs_clone(zfs, active, NULL)) != 0) 1170337592Skevans /* XXX TODO correct error */ 1171337592Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 1172337592Skevans 1173337592Skevans /* set props */ 1174337592Skevans zfs_close(zfs); 1175337592Skevans return (BE_ERR_SUCCESS); 1176337592Skevans} 1177337592Skevans 1178336668Skevansint 1179337563Skevansbe_add_child(libbe_handle_t *lbh, const char *child_path, bool cp_if_exists) 1180336668Skevans{ 1181337563Skevans struct stat sb; 1182337592Skevans char active[BE_MAXPATHLEN], buf[BE_MAXPATHLEN]; 1183336668Skevans nvlist_t *props; 1184337563Skevans const char *s; 1185336668Skevans 1186336668Skevans /* Require absolute paths */ 1187336701Skevans if (*child_path != '/') 1188337564Skevans return (set_error(lbh, BE_ERR_BADPATH)); 1189336668Skevans 1190337564Skevans strlcpy(active, be_active_path(lbh), BE_MAXPATHLEN); 1191336668Skevans strcpy(buf, active); 1192336668Skevans 1193336668Skevans /* Create non-mountable parent dataset(s) */ 1194337563Skevans s = child_path; 1195336668Skevans for (char *p; (p = strchr(s+1, '/')) != NULL; s = p) { 1196336668Skevans size_t len = p - s; 1197336668Skevans strncat(buf, s, len); 1198336668Skevans 1199336668Skevans nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP); 1200336668Skevans nvlist_add_string(props, "canmount", "off"); 1201336668Skevans nvlist_add_string(props, "mountpoint", "none"); 1202336668Skevans zfs_create(lbh->lzh, buf, ZFS_TYPE_DATASET, props); 1203336668Skevans nvlist_free(props); 1204336668Skevans } 1205336668Skevans 1206336668Skevans /* Path does not exist as a descendent of / yet */ 1207337564Skevans if (strlcat(active, child_path, BE_MAXPATHLEN) >= BE_MAXPATHLEN) 1208337564Skevans return (set_error(lbh, BE_ERR_PATHLEN)); 1209336668Skevans 1210336668Skevans if (stat(child_path, &sb) != 0) { 1211336668Skevans /* Verify that error is ENOENT */ 1212337564Skevans if (errno != ENOENT) 1213337564Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 1214337592Skevans return (be_create_child_noent(lbh, active, child_path)); 1215337592Skevans } else if (cp_if_exists) 1216336668Skevans /* Path is already a descendent of / and should be copied */ 1217337592Skevans return (be_create_child_cloned(lbh, active)); 1218337592Skevans return (set_error(lbh, BE_ERR_EXISTS)); 1219336668Skevans} 1220337596Skevans#endif /* SOON */ 1221336668Skevans 1222337402Skevansstatic int 1223337402Skevansbe_set_nextboot(libbe_handle_t *lbh, nvlist_t *config, uint64_t pool_guid, 1224337402Skevans const char *zfsdev) 1225337402Skevans{ 1226337402Skevans nvlist_t **child; 1227337402Skevans uint64_t vdev_guid; 1228337402Skevans int c, children; 1229336668Skevans 1230337402Skevans if (nvlist_lookup_nvlist_array(config, ZPOOL_CONFIG_CHILDREN, &child, 1231337402Skevans &children) == 0) { 1232337402Skevans for (c = 0; c < children; ++c) 1233337402Skevans if (be_set_nextboot(lbh, child[c], pool_guid, zfsdev) != 0) 1234337402Skevans return (1); 1235337402Skevans return (0); 1236337402Skevans } 1237337402Skevans 1238337402Skevans if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID, 1239337402Skevans &vdev_guid) != 0) { 1240337402Skevans return (1); 1241337402Skevans } 1242337402Skevans 1243337402Skevans if (zpool_nextboot(lbh->lzh, pool_guid, vdev_guid, zfsdev) != 0) { 1244337402Skevans perror("ZFS_IOC_NEXTBOOT failed"); 1245337402Skevans return (1); 1246337402Skevans } 1247337402Skevans 1248337402Skevans return (0); 1249337402Skevans} 1250337402Skevans 1251346429Skevans/* 1252346429Skevans * Deactivate old BE dataset; currently just sets canmount=noauto 1253346429Skevans */ 1254346429Skevansstatic int 1255346429Skevansbe_deactivate(libbe_handle_t *lbh, const char *ds) 1256346429Skevans{ 1257346429Skevans zfs_handle_t *zfs; 1258337402Skevans 1259346429Skevans if ((zfs = zfs_open(lbh->lzh, ds, ZFS_TYPE_DATASET)) == NULL) 1260346429Skevans return (1); 1261346429Skevans if (zfs_prop_set(zfs, "canmount", "noauto") != 0) 1262346429Skevans return (1); 1263346429Skevans zfs_close(zfs); 1264346429Skevans return (0); 1265346429Skevans} 1266346429Skevans 1267336668Skevansint 1268337563Skevansbe_activate(libbe_handle_t *lbh, const char *bootenv, bool temporary) 1269336668Skevans{ 1270336668Skevans char be_path[BE_MAXPATHLEN]; 1271336668Skevans char buf[BE_MAXPATHLEN]; 1272346429Skevans nvlist_t *config, *dsprops, *vdevs; 1273346429Skevans char *origin; 1274336668Skevans uint64_t pool_guid; 1275346429Skevans zfs_handle_t *zhp; 1276336668Skevans int err; 1277336668Skevans 1278336668Skevans be_root_concat(lbh, bootenv, be_path); 1279336668Skevans 1280336668Skevans /* Note: be_exists fails if mountpoint is not / */ 1281346429Skevans if ((err = be_exists(lbh, be_path)) != 0) 1282346429Skevans return (set_error(lbh, err)); 1283336668Skevans 1284336668Skevans if (temporary) { 1285337402Skevans config = zpool_get_config(lbh->active_phandle, NULL); 1286337592Skevans if (config == NULL) 1287337592Skevans /* config should be fetchable... */ 1288337592Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 1289336668Skevans 1290337402Skevans if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, 1291337402Skevans &pool_guid) != 0) 1292337592Skevans /* Similarly, it shouldn't be possible */ 1293337592Skevans return (set_error(lbh, BE_ERR_UNKNOWN)); 1294336668Skevans 1295336668Skevans /* Expected format according to zfsbootcfg(8) man */ 1296346429Skevans snprintf(buf, sizeof(buf), "zfs:%s:", be_path); 1297336668Skevans 1298337592Skevans /* We have no config tree */ 1299337592Skevans if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, 1300337592Skevans &vdevs) != 0) 1301337592Skevans return (set_error(lbh, BE_ERR_NOPOOL)); 1302336668Skevans 1303337402Skevans return (be_set_nextboot(lbh, vdevs, pool_guid, buf)); 1304336668Skevans } else { 1305346429Skevans if (be_deactivate(lbh, lbh->bootfs) != 0) 1306346429Skevans return (-1); 1307346429Skevans 1308336668Skevans /* Obtain bootenv zpool */ 1309336696Skevans err = zpool_set_prop(lbh->active_phandle, "bootfs", be_path); 1310346429Skevans if (err) 1311346429Skevans return (-1); 1312336668Skevans 1313346429Skevans zhp = zfs_open(lbh->lzh, be_path, ZFS_TYPE_FILESYSTEM); 1314346429Skevans if (zhp == NULL) 1315346429Skevans return (-1); 1316336668Skevans 1317346429Skevans if (be_prop_list_alloc(&dsprops) != 0) 1318336668Skevans return (-1); 1319346429Skevans 1320346429Skevans if (be_get_dataset_props(lbh, be_path, dsprops) != 0) { 1321346429Skevans nvlist_free(dsprops); 1322346429Skevans return (-1); 1323336668Skevans } 1324346429Skevans 1325346429Skevans if (nvlist_lookup_string(dsprops, "origin", &origin) == 0) 1326346429Skevans err = zfs_promote(zhp); 1327346429Skevans nvlist_free(dsprops); 1328346429Skevans 1329346429Skevans zfs_close(zhp); 1330346429Skevans 1331346429Skevans if (err) 1332346429Skevans return (-1); 1333336668Skevans } 1334346429Skevans 1335346429Skevans return (BE_ERR_SUCCESS); 1336336668Skevans} 1337