lib/libbe/be.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2017 Kyle J. Kneitinger <kyle@kneit.in>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/param.h>
  29 #include <sys/module.h>
  30 #include <sys/mount.h>
  31 #include <sys/stat.h>
  32 #include <sys/ucred.h>
  33 #include <sys/queue.h>
  34 #include <sys/zfs_context.h>
  35 #include <sys/mntent.h>
  36 #include <sys/zfs_ioctl.h>
  37
  38 #include <libzutil.h>
  39 #include <ctype.h>
  40 #include <libgen.h>
  41 #include <libzfs_core.h>
  42 #include <libzfs_impl.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <time.h>
  46 #include <unistd.h>
  47 #include <libzfsbootenv.h>
  48
  49 #include "be.h"
  50 #include "be_impl.h"
  51
  52 struct promote_entry {
  53         char                            name[BE_MAXPATHLEN];
  54         SLIST_ENTRY(promote_entry)      link;
  55 };
  56
  57 struct be_destroy_data {
  58         libbe_handle_t                  *lbh;
  59         char                            target_name[BE_MAXPATHLEN];
  60         char                            *snapname;
  61         SLIST_HEAD(, promote_entry)     promotelist;
  62 };
  63
  64 #if SOON
  65 static int be_create_child_noent(libbe_handle_t *lbh, const char *active,
  66     const char *child_path);
  67 static int be_create_child_cloned(libbe_handle_t *lbh, const char *active);
  68 #endif
  69
  70 /* Arbitrary... should tune */
  71 #define BE_SNAP_SERIAL_MAX      1024
  72
  73 /*
  74  * Iterator function for locating the rootfs amongst the children of the
  75  * zfs_be_root set by loader(8).  data is expected to be a libbe_handle_t *.
  76  */
  77 static int
  78 be_locate_rootfs(libbe_handle_t *lbh)
  79 {
  80         struct statfs sfs;
  81         struct mnttab entry;
  82         zfs_handle_t *zfs;
  83
  84         /*
  85          * Check first if root is ZFS; if not, we'll bail on rootfs capture.
  86          * Unfortunately needed because zfs_path_to_zhandle will emit to
  87          * stderr if / isn't actually a ZFS filesystem, which we'd like
  88          * to avoid.
  89          */
  90         if (statfs("/", &sfs) == 0) {
  91                 statfs2mnttab(&sfs, &entry);
  92                 if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
  93                         return (1);
  94         } else
  95                 return (1);
  96         zfs = zfs_path_to_zhandle(lbh->lzh, "/", ZFS_TYPE_FILESYSTEM);
  97         if (zfs == NULL)
  98                 return (1);
  99
 100         strlcpy(lbh->rootfs, zfs_get_name(zfs), sizeof(lbh->rootfs));
 101         zfs_close(zfs);
 102         return (0);
 103 }
 104
 105 /*
 106  * Initializes the libbe context to operate in the root boot environment
 107  * dataset, for example, zroot/ROOT.
 108  */
 109 libbe_handle_t *
 110 libbe_init(const char *root)
 111 {
 112         char altroot[MAXPATHLEN];
 113         libbe_handle_t *lbh;
 114         char *poolname, *pos;
 115         int pnamelen;
 116
 117         lbh = NULL;
 118         poolname = pos = NULL;
 119
 120         /*
 121          * If the zfs kmod's not loaded then the later libzfs_init() will load
 122          * the module for us, but that's not desirable for a couple reasons.  If
 123          * the module's not loaded, there's no pool imported and we're going to
 124          * fail anyways.  We also don't really want libbe consumers to have that
 125          * kind of side-effect (module loading) in the general case.
 126          */
 127         if (modfind("zfs") < 0)
 128                 goto err;
 129
 130         if ((lbh = calloc(1, sizeof(libbe_handle_t))) == NULL)
 131                 goto err;
 132
 133         if ((lbh->lzh = libzfs_init()) == NULL)
 134                 goto err;
 135
 136         /*
 137          * Grab rootfs, we'll work backwards from there if an optional BE root
 138          * has not been passed in.
 139          */
 140         if (be_locate_rootfs(lbh) != 0) {
 141                 if (root == NULL)
 142                         goto err;
 143                 *lbh->rootfs = '\0';
 144         }
 145         if (root == NULL) {
 146                 /* Strip off the final slash from rootfs to get the be root */
 147                 strlcpy(lbh->root, lbh->rootfs, sizeof(lbh->root));
 148                 pos = strrchr(lbh->root, '/');
 149                 if (pos == NULL)
 150                         goto err;
 151                 *pos = '\0';
 152         } else
 153                 strlcpy(lbh->root, root, sizeof(lbh->root));
 154
 155         if ((pos = strchr(lbh->root, '/')) == NULL)
 156                 goto err;
 157
 158         pnamelen = pos - lbh->root;
 159         poolname = malloc(pnamelen + 1);
 160         if (poolname == NULL)
 161                 goto err;
 162
 163         strlcpy(poolname, lbh->root, pnamelen + 1);
 164         if ((lbh->active_phandle = zpool_open(lbh->lzh, poolname)) == NULL)
 165                 goto err;
 166         free(poolname);
 167         poolname = NULL;
 168
 169         if (zpool_get_prop(lbh->active_phandle, ZPOOL_PROP_BOOTFS, lbh->bootfs,
 170             sizeof(lbh->bootfs), NULL, true) != 0)
 171                 goto err;
 172
 173         if (zpool_get_prop(lbh->active_phandle, ZPOOL_PROP_ALTROOT,
 174             altroot, sizeof(altroot), NULL, true) == 0 &&
 175             strcmp(altroot, "-") != 0)
 176                 lbh->altroot_len = strlen(altroot);
 177
 178         (void) lzbe_get_boot_device(zpool_get_name(lbh->active_phandle),
 179             &lbh->bootonce);
 180
 181         return (lbh);
 182 err:
 183         if (lbh != NULL) {
 184                 if (lbh->active_phandle != NULL)
 185                         zpool_close(lbh->active_phandle);
 186                 if (lbh->lzh != NULL)
 187                         libzfs_fini(lbh->lzh);
 188                 free(lbh);
 189         }
 190         free(poolname);
 191         return (NULL);
 192 }
 193
 194
 195 /*
 196  * Free memory allocated by libbe_init()
 197  */
 198 void
 199 libbe_close(libbe_handle_t *lbh)
 200 {
 201
 202         if (lbh->active_phandle != NULL)
 203                 zpool_close(lbh->active_phandle);
 204         libzfs_fini(lbh->lzh);
 205
 206         free(lbh->bootonce);
 207         free(lbh);
 208 }
 209
 210 /*
 211  * Proxy through to libzfs for the moment.
 212  */
 213 void
 214 be_nicenum(uint64_t num, char *buf, size_t buflen)
 215 {
 216
 217         zfs_nicenum(num, buf, buflen);
 218 }
 219
 220 static bool
 221 be_should_promote_clones(zfs_handle_t *zfs_hdl, struct be_destroy_data *bdd)
 222 {
 223         char *atpos;
 224
 225         if (zfs_get_type(zfs_hdl) != ZFS_TYPE_SNAPSHOT)
 226                 return (false);
 227
 228         /*
 229          * If we're deleting a snapshot, we need to make sure we only promote
 230          * clones that are derived from one of the snapshots we're deleting,
 231          * rather than that of a snapshot we're not touching.  This keeps stuff
 232          * in a consistent state, making sure that we don't error out unless
 233          * we really need to.
 234          */
 235         if (bdd->snapname == NULL)
 236                 return (true);
 237
 238         atpos = strchr(zfs_get_name(zfs_hdl), '@');
 239         return (strcmp(atpos + 1, bdd->snapname) == 0);
 240 }
 241
 242 /*
 243  * This is executed from be_promote_dependent_clones via zfs_iter_dependents,
 244  * It checks if the dependent type is a snapshot then attempts to find any
 245  * clones associated with it. Any clones not related to the destroy target are
 246  * added to the promote list.
 247  */
 248 static int
 249 be_dependent_clone_cb(zfs_handle_t *zfs_hdl, void *data)
 250 {
 251         int err;
 252         bool found;
 253         const char *name;
 254         struct nvlist *nvl;
 255         struct nvpair *nvp;
 256         struct be_destroy_data *bdd;
 257         struct promote_entry *entry, *newentry;
 258
 259         nvp = NULL;
 260         err = 0;
 261         bdd = (struct be_destroy_data *)data;
 262
 263         if (be_should_promote_clones(zfs_hdl, bdd) &&
 264             (nvl = zfs_get_clones_nvl(zfs_hdl)) != NULL) {
 265                 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
 266                         name = nvpair_name(nvp);
 267
 268                         /*
 269                          * Skip if the clone is equal to, or a child of, the
 270                          * destroy target.
 271                          */
 272                         if (strncmp(name, bdd->target_name,
 273                             strlen(bdd->target_name)) == 0 ||
 274                             strstr(name, bdd->target_name) == name) {
 275                                 continue;
 276                         }
 277
 278                         found = false;
 279                         SLIST_FOREACH(entry, &bdd->promotelist, link) {
 280                                 if (strcmp(entry->name, name) == 0) {
 281                                         found = true;
 282                                         break;
 283                                 }
 284                         }
 285
 286                         if (found)
 287                                 continue;
 288
 289                         newentry = malloc(sizeof(struct promote_entry));
 290                         if (newentry == NULL) {
 291                                 err = ENOMEM;
 292                                 break;
 293                         }
 294
 295 #define BE_COPY_NAME(entry, src)        \
 296         strlcpy((entry)->name, (src), sizeof((entry)->name))
 297                         if (BE_COPY_NAME(newentry, name) >=
 298                             sizeof(newentry->name)) {
 299                                 /* Shouldn't happen. */
 300                                 free(newentry);
 301                                 err = ENAMETOOLONG;
 302                                 break;
 303                         }
 304 #undef BE_COPY_NAME
 305
 306                         /*
 307                          * We're building up a SLIST here to make sure both that
 308                          * we get the order right and so that we don't
 309                          * inadvertently observe the wrong state by promoting
 310                          * datasets while we're still walking the tree.  The
 311                          * latter can lead to situations where we promote a BE
 312                          * then effectively demote it again.
 313                          */
 314                         SLIST_INSERT_HEAD(&bdd->promotelist, newentry, link);
 315                 }
 316                 nvlist_free(nvl);
 317         }
 318         zfs_close(zfs_hdl);
 319         return (err);
 320 }
 321
 322 /*
 323  * This is called before a destroy, so that any datasets(environments) that are
 324  * dependent on this one get promoted before destroying the target.
 325  */
 326 static int
 327 be_promote_dependent_clones(zfs_handle_t *zfs_hdl, struct be_destroy_data *bdd)
 328 {
 329         int err;
 330         zfs_handle_t *clone;
 331         struct promote_entry *entry;
 332
 333         snprintf(bdd->target_name, BE_MAXPATHLEN, "%s/", zfs_get_name(zfs_hdl));
 334         err = zfs_iter_dependents(zfs_hdl, true, be_dependent_clone_cb, bdd);
 335
 336         /*
 337          * Drain the list and walk away from it if we're only deleting a
 338          * snapshot.
 339          */
 340         if (bdd->snapname != NULL && !SLIST_EMPTY(&bdd->promotelist))
 341                 err = BE_ERR_HASCLONES;
 342         while (!SLIST_EMPTY(&bdd->promotelist)) {
 343                 entry = SLIST_FIRST(&bdd->promotelist);
 344                 SLIST_REMOVE_HEAD(&bdd->promotelist, link);
 345
 346 #define ZFS_GRAB_CLONE()        \
 347         zfs_open(bdd->lbh->lzh, entry->name, ZFS_TYPE_FILESYSTEM)
 348                 /*
 349                  * Just skip this part on error, we still want to clean up the
 350                  * promotion list after the first error.  We'll then preserve it
 351                  * all the way back.
 352                  */
 353                 if (err == 0 && (clone = ZFS_GRAB_CLONE()) != NULL) {
 354                         err = zfs_promote(clone);
 355                         if (err != 0)
 356                                 err = BE_ERR_DESTROYMNT;
 357                         zfs_close(clone);
 358                 }
 359 #undef ZFS_GRAB_CLONE
 360                 free(entry);
 361         }
 362
 363         return (err);
 364 }
 365
 366 static int
 367 be_destroy_cb(zfs_handle_t *zfs_hdl, void *data)
 368 {
 369         char path[BE_MAXPATHLEN];
 370         struct be_destroy_data *bdd;
 371         zfs_handle_t *snap;
 372         int err;
 373
 374         bdd = (struct be_destroy_data *)data;
 375         if (bdd->snapname == NULL) {
 376                 err = zfs_iter_children(zfs_hdl, be_destroy_cb, data);
 377                 if (err != 0)
 378                         return (err);
 379                 return (zfs_destroy(zfs_hdl, false));
 380         }
 381         /* If we're dealing with snapshots instead, delete that one alone */
 382         err = zfs_iter_filesystems(zfs_hdl, be_destroy_cb, data);
 383         if (err != 0)
 384                 return (err);
 385         /*
 386          * This part is intentionally glossing over any potential errors,
 387          * because there's a lot less potential for errors when we're cleaning
 388          * up snapshots rather than a full deep BE.  The primary error case
 389          * here being if the snapshot doesn't exist in the first place, which
 390          * the caller will likely deem insignificant as long as it doesn't
 391          * exist after the call.  Thus, such a missing snapshot shouldn't jam
 392          * up the destruction.
 393          */
 394         snprintf(path, sizeof(path), "%s@%s", zfs_get_name(zfs_hdl),
 395             bdd->snapname);
 396         if (!zfs_dataset_exists(bdd->lbh->lzh, path, ZFS_TYPE_SNAPSHOT))
 397                 return (0);
 398         snap = zfs_open(bdd->lbh->lzh, path, ZFS_TYPE_SNAPSHOT);
 399         if (snap != NULL)
 400                 zfs_destroy(snap, false);
 401         return (0);
 402 }
 403
 404 #define BE_DESTROY_WANTORIGIN   (BE_DESTROY_ORIGIN | BE_DESTROY_AUTOORIGIN)
 405 /*
 406  * Destroy the boot environment or snapshot specified by the name
 407  * parameter. Options are or'd together with the possible values:
 408  * BE_DESTROY_FORCE : forces operation on mounted datasets
 409  * BE_DESTROY_ORIGIN: destroy the origin snapshot as well
 410  */
 411 static int
 412 be_destroy_internal(libbe_handle_t *lbh, const char *name, int options,
 413     bool odestroyer)
 414 {
 415         struct be_destroy_data bdd;
 416         char origin[BE_MAXPATHLEN], path[BE_MAXPATHLEN];
 417         zfs_handle_t *fs;
 418         char *snapdelim;
 419         int err, force, mounted;
 420         size_t rootlen;
 421
 422         bdd.lbh = lbh;
 423         bdd.snapname = NULL;
 424         SLIST_INIT(&bdd.promotelist);
 425         force = options & BE_DESTROY_FORCE;
 426         *origin = '\0';
 427
 428         be_root_concat(lbh, name, path);
 429
 430         if ((snapdelim = strchr(path, '@')) == NULL) {
 431                 if (!zfs_dataset_exists(lbh->lzh, path, ZFS_TYPE_FILESYSTEM))
 432                         return (set_error(lbh, BE_ERR_NOENT));
 433
 434                 if (strcmp(path, lbh->rootfs) == 0 ||
 435                     strcmp(path, lbh->bootfs) == 0)
 436                         return (set_error(lbh, BE_ERR_DESTROYACT));
 437
 438                 fs = zfs_open(lbh->lzh, path, ZFS_TYPE_FILESYSTEM);
 439                 if (fs == NULL)
 440                         return (set_error(lbh, BE_ERR_ZFSOPEN));
 441
 442                 /* Don't destroy a mounted dataset unless force is specified */
 443                 if ((mounted = zfs_is_mounted(fs, NULL)) != 0) {
 444                         if (force) {
 445                                 zfs_unmount(fs, NULL, 0);
 446                         } else {
 447                                 free(bdd.snapname);
 448                                 return (set_error(lbh, BE_ERR_DESTROYMNT));
 449                         }
 450                 }
 451
 452                 /* Handle destroying bootonce */
 453                 if (lbh->bootonce != NULL &&
 454                     strcmp(path, lbh->bootonce) == 0)
 455                         (void) lzbe_set_boot_device(
 456                             zpool_get_name(lbh->active_phandle), lzbe_add, NULL);
 457         } else {
 458                 /*
 459                  * If we're initially destroying a snapshot, origin options do
 460                  * not make sense.  If we're destroying the origin snapshot of
 461                  * a BE, we want to maintain the options in case we need to
 462                  * fake success after failing to promote.
 463                  */
 464                 if (!odestroyer)
 465                         options &= ~BE_DESTROY_WANTORIGIN;
 466                 if (!zfs_dataset_exists(lbh->lzh, path, ZFS_TYPE_SNAPSHOT))
 467                         return (set_error(lbh, BE_ERR_NOENT));
 468
 469                 bdd.snapname = strdup(snapdelim + 1);
 470                 if (bdd.snapname == NULL)
 471                         return (set_error(lbh, BE_ERR_NOMEM));
 472                 *snapdelim = '\0';
 473                 fs = zfs_open(lbh->lzh, path, ZFS_TYPE_DATASET);
 474                 if (fs == NULL) {
 475                         free(bdd.snapname);
 476                         return (set_error(lbh, BE_ERR_ZFSOPEN));
 477                 }
 478         }
 479
 480         /*
 481          * Whether we're destroying a BE or a single snapshot, we need to walk
 482          * the tree of what we're going to destroy and promote everything in our
 483          * path so that we can make it happen.
 484          */
 485         if ((err = be_promote_dependent_clones(fs, &bdd)) != 0) {
 486                 free(bdd.snapname);
 487
 488                 /*
 489                  * If we're just destroying the origin of some other dataset
 490                  * we were invoked to destroy, then we just ignore
 491                  * BE_ERR_HASCLONES and return success unless the caller wanted
 492                  * to force the issue.
 493                  */
 494                 if (odestroyer && err == BE_ERR_HASCLONES &&
 495                     (options & BE_DESTROY_AUTOORIGIN) != 0)
 496                         return (0);
 497                 return (set_error(lbh, err));
 498         }
 499
 500         /*
 501          * This was deferred until after we promote all of the derivatives so
 502          * that we grab the new origin after everything's settled down.
 503          */
 504         if ((options & BE_DESTROY_WANTORIGIN) != 0 &&
 505             zfs_prop_get(fs, ZFS_PROP_ORIGIN, origin, sizeof(origin),
 506             NULL, NULL, 0, 1) != 0 &&
 507             (options & BE_DESTROY_ORIGIN) != 0)
 508                 return (set_error(lbh, BE_ERR_NOORIGIN));
 509
 510         /*
 511          * If the caller wants auto-origin destruction and the origin
 512          * name matches one of our automatically created snapshot names
 513          * (i.e. strftime("%F-%T") with a serial at the end), then
 514          * we'll set the DESTROY_ORIGIN flag and nuke it
 515          * be_is_auto_snapshot_name is exported from libbe(3) so that
 516          * the caller can determine if it needs to warn about the origin
 517          * not being destroyed or not.
 518          */
 519         if ((options & BE_DESTROY_AUTOORIGIN) != 0 && *origin != '\0' &&
 520             be_is_auto_snapshot_name(lbh, origin))
 521                 options |= BE_DESTROY_ORIGIN;
 522
 523         err = be_destroy_cb(fs, &bdd);
 524         zfs_close(fs);
 525         free(bdd.snapname);
 526         if (err != 0) {
 527                 /* Children are still present or the mount is referenced */
 528                 if (err == EBUSY)
 529                         return (set_error(lbh, BE_ERR_DESTROYMNT));
 530                 return (set_error(lbh, BE_ERR_UNKNOWN));
 531         }
 532
 533         if ((options & BE_DESTROY_ORIGIN) == 0)
 534                 return (0);
 535
 536         /* The origin can't possibly be shorter than the BE root */
 537         rootlen = strlen(lbh->root);
 538         if (*origin == '\0' || strlen(origin) <= rootlen + 1)
 539                 return (set_error(lbh, BE_ERR_INVORIGIN));
 540
 541         /*
 542          * We'll be chopping off the BE root and running this back through
 543          * be_destroy, so that we properly handle the origin snapshot whether
 544          * it be that of a deep BE or not.
 545          */
 546         if (strncmp(origin, lbh->root, rootlen) != 0 || origin[rootlen] != '/')
 547                 return (0);
 548
 549         return (be_destroy_internal(lbh, origin + rootlen + 1,
 550             options & ~BE_DESTROY_ORIGIN, true));
 551 }
 552
 553 int
 554 be_destroy(libbe_handle_t *lbh, const char *name, int options)
 555 {
 556
 557         /*
 558          * The consumer must not set both BE_DESTROY_AUTOORIGIN and
 559          * BE_DESTROY_ORIGIN.  Internally, we'll set the latter from the former.
 560          * The latter should imply that we must succeed at destroying the
 561          * origin, or complain otherwise.
 562          */
 563         if ((options & BE_DESTROY_WANTORIGIN) == BE_DESTROY_WANTORIGIN)
 564                 return (set_error(lbh, BE_ERR_UNKNOWN));
 565         return (be_destroy_internal(lbh, name, options, false));
 566 }
 567
 568 static void
 569 be_setup_snapshot_name(libbe_handle_t *lbh, char *buf, size_t buflen)
 570 {
 571         time_t rawtime;
 572         int len, serial;
 573
 574         time(&rawtime);
 575         len = strlen(buf);
 576         len += strftime(buf + len, buflen - len, "@%F-%T", localtime(&rawtime));
 577         /* No room for serial... caller will do its best */
 578         if (buflen - len < 2)
 579                 return;
 580
 581         for (serial = 0; serial < BE_SNAP_SERIAL_MAX; ++serial) {
 582                 snprintf(buf + len, buflen - len, "-%d", serial);
 583                 if (!zfs_dataset_exists(lbh->lzh, buf, ZFS_TYPE_SNAPSHOT))
 584                         return;
 585         }
 586 }
 587
 588 bool
 589 be_is_auto_snapshot_name(libbe_handle_t *lbh __unused, const char *name)
 590 {
 591         const char *snap;
 592         int day, hour, minute, month, second, serial, year;
 593
 594         if ((snap = strchr(name, '@')) == NULL)
 595                 return (false);
 596         ++snap;
 597         /* We'll grab the individual components and do some light validation. */
 598         if (sscanf(snap, "%d-%d-%d-%d:%d:%d-%d", &year, &month, &day, &hour,
 599             &minute, &second, &serial) != 7)
 600                 return (false);
 601         return (year >= 1970) && (month >= 1 && month <= 12) &&
 602             (day >= 1 && day <= 31) && (hour >= 0 && hour <= 23) &&
 603             (minute >= 0 && minute <= 59) && (second >= 0 && second <= 60) &&
 604             serial >= 0;
 605 }
 606
 607 int
 608 be_snapshot(libbe_handle_t *lbh, const char *source, const char *snap_name,
 609     bool recursive, char *result)
 610 {
 611         char buf[BE_MAXPATHLEN];
 612         int err;
 613
 614         be_root_concat(lbh, source, buf);
 615
 616         if ((err = be_exists(lbh, buf)) != 0)
 617                 return (set_error(lbh, err));
 618
 619         if (snap_name != NULL) {
 620                 if (strlcat(buf, "@", sizeof(buf)) >= sizeof(buf))
 621                         return (set_error(lbh, BE_ERR_INVALIDNAME));
 622
 623                 if (strlcat(buf, snap_name, sizeof(buf)) >= sizeof(buf))
 624                         return (set_error(lbh, BE_ERR_INVALIDNAME));
 625
 626                 if (result != NULL)
 627                         snprintf(result, BE_MAXPATHLEN, "%s@%s", source,
 628                             snap_name);
 629         } else {
 630                 be_setup_snapshot_name(lbh, buf, sizeof(buf));
 631
 632                 if (result != NULL && strlcpy(result, strrchr(buf, '/') + 1,
 633                     sizeof(buf)) >= sizeof(buf))
 634                         return (set_error(lbh, BE_ERR_INVALIDNAME));
 635         }
 636         if ((err = zfs_snapshot(lbh->lzh, buf, recursive, NULL)) != 0) {
 637                 switch (err) {
 638                 case EZFS_INVALIDNAME:
 639                         return (set_error(lbh, BE_ERR_INVALIDNAME));
 640
 641                 default:
 642                         /*
 643                          * The other errors that zfs_ioc_snapshot might return
 644                          * shouldn't happen if we've set things up properly, so
 645                          * we'll gloss over them and call it UNKNOWN as it will
 646                          * require further triage.
 647                          */
 648                         if (errno == ENOTSUP)
 649                                 return (set_error(lbh, BE_ERR_NOPOOL));
 650                         return (set_error(lbh, BE_ERR_UNKNOWN));
 651                 }
 652         }
 653
 654         return (BE_ERR_SUCCESS);
 655 }
 656
 657
 658 /*
 659  * Create the boot environment specified by the name parameter
 660  */
 661 int
 662 be_create(libbe_handle_t *lbh, const char *name)
 663 {
 664         int err;
 665
 666         err = be_create_from_existing(lbh, name, be_active_path(lbh));
 667
 668         return (set_error(lbh, err));
 669 }
 670
 671 static int
 672 be_deep_clone_prop(int prop, void *cb)
 673 {
 674         int err;
 675         struct libbe_dccb *dccb;
 676         zprop_source_t src;
 677         char pval[BE_MAXPATHLEN];
 678         char source[BE_MAXPATHLEN];
 679         char *val;
 680
 681         dccb = cb;
 682         /* Skip some properties we don't want to touch */
 683         if (prop == ZFS_PROP_CANMOUNT)
 684                 return (ZPROP_CONT);
 685
 686         /* Don't copy readonly properties */
 687         if (zfs_prop_readonly(prop))
 688                 return (ZPROP_CONT);
 689
 690         if ((err = zfs_prop_get(dccb->zhp, prop, (char *)&pval,
 691             sizeof(pval), &src, (char *)&source, sizeof(source), false)))
 692                 /* Just continue if we fail to read a property */
 693                 return (ZPROP_CONT);
 694
 695         /*
 696          * Only copy locally defined or received properties.  This continues
 697          * to avoid temporary/default/local properties intentionally without
 698          * breaking received datasets.
 699          */
 700         if (src != ZPROP_SRC_LOCAL && src != ZPROP_SRC_RECEIVED)
 701                 return (ZPROP_CONT);
 702
 703         /* Augment mountpoint with altroot, if needed */
 704         val = pval;
 705         if (prop == ZFS_PROP_MOUNTPOINT)
 706                 val = be_mountpoint_augmented(dccb->lbh, val);
 707
 708         nvlist_add_string(dccb->props, zfs_prop_to_name(prop), val);
 709
 710         return (ZPROP_CONT);
 711 }
 712
 713 /*
 714  * Return the corresponding boot environment path for a given
 715  * dataset path, the constructed path is placed in 'result'.
 716  *
 717  * example: say our new boot environment name is 'bootenv' and
 718  *          the dataset path is 'zroot/ROOT/default/data/set'.
 719  *
 720  * result should produce: 'zroot/ROOT/bootenv/data/set'
 721  */
 722 static int
 723 be_get_path(struct libbe_deep_clone *ldc, const char *dspath, char *result, int result_size)
 724 {
 725         char *pos;
 726         char *child_dataset;
 727
 728         /* match the root path for the boot environments */
 729         pos = strstr(dspath, ldc->lbh->root);
 730
 731         /* no match, different pools? */
 732         if (pos == NULL)
 733                 return (BE_ERR_BADPATH);
 734
 735         /* root path of the new boot environment */
 736         snprintf(result, result_size, "%s/%s", ldc->lbh->root, ldc->bename);
 737
 738         /* gets us to the parent dataset, the +1 consumes a trailing slash */
 739         pos += strlen(ldc->lbh->root) + 1;
 740
 741         /* skip the parent dataset */
 742         if ((child_dataset = strchr(pos, '/')) != NULL)
 743                 strlcat(result, child_dataset, result_size);
 744
 745         return (BE_ERR_SUCCESS);
 746 }
 747
 748 static int
 749 be_clone_cb(zfs_handle_t *ds, void *data)
 750 {
 751         int err;
 752         char be_path[BE_MAXPATHLEN];
 753         char snap_path[BE_MAXPATHLEN];
 754         const char *dspath;
 755         zfs_handle_t *snap_hdl;
 756         nvlist_t *props;
 757         struct libbe_deep_clone *ldc;
 758         struct libbe_dccb dccb;
 759
 760         ldc = (struct libbe_deep_clone *)data;
 761         dspath = zfs_get_name(ds);
 762
 763         snprintf(snap_path, sizeof(snap_path), "%s@%s", dspath, ldc->snapname);
 764
 765         /* construct the boot environment path from the dataset we're cloning */
 766         if (be_get_path(ldc, dspath, be_path, sizeof(be_path)) != BE_ERR_SUCCESS)
 767                 return (BE_ERR_UNKNOWN);
 768
 769         /* the dataset to be created (i.e. the boot environment) already exists */
 770         if (zfs_dataset_exists(ldc->lbh->lzh, be_path, ZFS_TYPE_DATASET))
 771                 return (BE_ERR_EXISTS);
 772
 773         /* no snapshot found for this dataset, silently skip it */
 774         if (!zfs_dataset_exists(ldc->lbh->lzh, snap_path, ZFS_TYPE_SNAPSHOT))
 775                 return (0);
 776
 777         if ((snap_hdl =
 778             zfs_open(ldc->lbh->lzh, snap_path, ZFS_TYPE_SNAPSHOT)) == NULL)
 779                 return (BE_ERR_ZFSOPEN);
 780
 781         nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP);
 782         nvlist_add_string(props, "canmount", "noauto");
 783
 784         dccb.lbh = ldc->lbh;
 785         dccb.zhp = ds;
 786         dccb.props = props;
 787         if (zprop_iter(be_deep_clone_prop, &dccb, B_FALSE, B_FALSE,
 788             ZFS_TYPE_FILESYSTEM) == ZPROP_INVAL)
 789                 return (-1);
 790
 791         if ((err = zfs_clone(snap_hdl, be_path, props)) != 0)
 792                 return (BE_ERR_ZFSCLONE);
 793
 794         nvlist_free(props);
 795         zfs_close(snap_hdl);
 796
 797         if (ldc->depth_limit == -1 || ldc->depth < ldc->depth_limit) {
 798                 ldc->depth++;
 799                 err = zfs_iter_filesystems(ds, be_clone_cb, ldc);
 800                 ldc->depth--;
 801         }
 802
 803         return (err);
 804 }
 805
 806 /*
 807  * Create a boot environment with a given name from a given snapshot.
 808  * Snapshots can be in the format 'zroot/ROOT/default@snapshot' or
 809  * 'default@snapshot'. In the latter case, 'default@snapshot' will be prepended
 810  * with the root path that libbe was initailized with.
 811 */
 812 static int
 813 be_clone(libbe_handle_t *lbh, const char *bename, const char *snapshot, int depth)
 814 {
 815         int err;
 816         char snap_path[BE_MAXPATHLEN];
 817         char *parentname, *snapname;
 818         zfs_handle_t *parent_hdl;
 819         struct libbe_deep_clone ldc;
 820
 821         /* ensure the boot environment name is valid */
 822         if ((err = be_validate_name(lbh, bename)) != 0)
 823                 return (set_error(lbh, err));
 824
 825         /*
 826          * prepend the boot environment root path if we're
 827          * given a partial snapshot name.
 828          */
 829         if ((err = be_root_concat(lbh, snapshot, snap_path)) != 0)
 830                 return (set_error(lbh, err));
 831
 832         /* ensure the snapshot exists */
 833         if ((err = be_validate_snap(lbh, snap_path)) != 0)
 834                 return (set_error(lbh, err));
 835
 836         /* get a copy of the snapshot path so we can disect it */
 837         if ((parentname = strdup(snap_path)) == NULL)
 838                 return (set_error(lbh, BE_ERR_UNKNOWN));
 839
 840         /* split dataset name from snapshot name */
 841         snapname = strchr(parentname, '@');
 842         if (snapname == NULL) {
 843                 free(parentname);
 844                 return (set_error(lbh, BE_ERR_UNKNOWN));
 845         }
 846         *snapname = '\0';
 847         snapname++;
 848
 849         /* set-up the boot environment */
 850         ldc.lbh = lbh;
 851         ldc.bename = bename;
 852         ldc.snapname = snapname;
 853         ldc.depth = 0;
 854         ldc.depth_limit = depth;
 855
 856         /* the boot environment will be cloned from this dataset */
 857         parent_hdl = zfs_open(lbh->lzh, parentname, ZFS_TYPE_DATASET);
 858
 859         /* create the boot environment */
 860         err = be_clone_cb(parent_hdl, &ldc);
 861
 862         free(parentname);
 863         return (set_error(lbh, err));
 864 }
 865
 866 /*
 867  * Create a boot environment from pre-existing snapshot, specifying a depth.
 868  */
 869 int be_create_depth(libbe_handle_t *lbh, const char *bename,
 870                     const char *snap, int depth)
 871 {
 872         return (be_clone(lbh, bename, snap, depth));
 873 }
 874
 875 /*
 876  * Create the boot environment from pre-existing snapshot
 877  */
 878 int
 879 be_create_from_existing_snap(libbe_handle_t *lbh, const char *bename,
 880     const char *snap)
 881 {
 882         return (be_clone(lbh, bename, snap, -1));
 883 }
 884
 885
 886 /*
 887  * Create a boot environment from an existing boot environment
 888  */
 889 int
 890 be_create_from_existing(libbe_handle_t *lbh, const char *bename, const char *old)
 891 {
 892         int err;
 893         char snap[BE_MAXPATHLEN];
 894
 895         if ((err = be_snapshot(lbh, old, NULL, true, snap)) != 0)
 896                 return (set_error(lbh, err));
 897
 898         err = be_clone(lbh, bename, snap, -1);
 899
 900         return (set_error(lbh, err));
 901 }
 902
 903
 904 /*
 905  * Verifies that a snapshot has a valid name, exists, and has a mountpoint of
 906  * '/'. Returns BE_ERR_SUCCESS (0), upon success, or the relevant BE_ERR_* upon
 907  * failure. Does not set the internal library error state.
 908  */
 909 int
 910 be_validate_snap(libbe_handle_t *lbh, const char *snap_name)
 911 {
 912
 913         if (strlen(snap_name) >= BE_MAXPATHLEN)
 914                 return (BE_ERR_PATHLEN);
 915
 916         if (!zfs_name_valid(snap_name, ZFS_TYPE_SNAPSHOT))
 917                 return (BE_ERR_INVALIDNAME);
 918
 919         if (!zfs_dataset_exists(lbh->lzh, snap_name,
 920             ZFS_TYPE_SNAPSHOT))
 921                 return (BE_ERR_NOENT);
 922
 923         return (BE_ERR_SUCCESS);
 924 }
 925
 926
 927 /*
 928  * Idempotently appends the name argument to the root boot environment path
 929  * and copies the resulting string into the result buffer (which is assumed
 930  * to be at least BE_MAXPATHLEN characters long. Returns BE_ERR_SUCCESS upon
 931  * success, BE_ERR_PATHLEN if the resulting path is longer than BE_MAXPATHLEN,
 932  * or BE_ERR_INVALIDNAME if the name is a path that does not begin with
 933  * zfs_be_root. Does not set internal library error state.
 934  */
 935 int
 936 be_root_concat(libbe_handle_t *lbh, const char *name, char *result)
 937 {
 938         size_t name_len, root_len;
 939
 940         name_len = strlen(name);
 941         root_len = strlen(lbh->root);
 942
 943         /* Act idempotently; return be name if it is already a full path */
 944         if (strrchr(name, '/') != NULL) {
 945                 if (strstr(name, lbh->root) != name)
 946                         return (BE_ERR_INVALIDNAME);
 947
 948                 if (name_len >= BE_MAXPATHLEN)
 949                         return (BE_ERR_PATHLEN);
 950
 951                 strlcpy(result, name, BE_MAXPATHLEN);
 952                 return (BE_ERR_SUCCESS);
 953         } else if (name_len + root_len + 1 < BE_MAXPATHLEN) {
 954                 snprintf(result, BE_MAXPATHLEN, "%s/%s", lbh->root,
 955                     name);
 956                 return (BE_ERR_SUCCESS);
 957         }
 958
 959         return (BE_ERR_PATHLEN);
 960 }
 961
 962
 963 /*
 964  * Verifies the validity of a boot environment name (A-Za-z0-9-_.). Returns
 965  * BE_ERR_SUCCESS (0) if name is valid, otherwise returns BE_ERR_INVALIDNAME
 966  * or BE_ERR_PATHLEN.
 967  * Does not set internal library error state.
 968  */
 969 int
 970 be_validate_name(libbe_handle_t *lbh, const char *name)
 971 {
 972
 973         /*
 974          * Impose the additional restriction that the entire dataset name must
 975          * not exceed the maximum length of a dataset, i.e. MAXNAMELEN.
 976          */
 977         if (strlen(lbh->root) + 1 + strlen(name) > MAXNAMELEN)
 978                 return (BE_ERR_PATHLEN);
 979
 980         if (!zfs_name_valid(name, ZFS_TYPE_DATASET))
 981                 return (BE_ERR_INVALIDNAME);
 982
 983         /*
 984          * ZFS allows spaces in boot environment names, but the kernel can't
 985          * handle booting from such a dataset right now.  vfs.root.mountfrom
 986          * is defined to be a space-separated list, and there's no protocol for
 987          * escaping whitespace in the path component of a dev:path spec.  So
 988          * while loader can handle this situation alright, it can't safely pass
 989          * it on to mountroot.
 990          */
 991         if (strchr(name, ' ') != NULL)
 992                 return (BE_ERR_INVALIDNAME);
 993
 994         return (BE_ERR_SUCCESS);
 995 }
 996
 997
 998 /*
 999  * usage
1000  */
1001 int
1002 be_rename(libbe_handle_t *lbh, const char *old, const char *new)
1003 {
1004         char full_old[BE_MAXPATHLEN];
1005         char full_new[BE_MAXPATHLEN];
1006         zfs_handle_t *zfs_hdl;
1007         int err;
1008
1009         /*
1010          * be_validate_name is documented not to set error state, so we should
1011          * do so here.
1012          */
1013         if ((err = be_validate_name(lbh, new)) != 0)
1014                 return (set_error(lbh, err));
1015         if ((err = be_root_concat(lbh, old, full_old)) != 0)
1016                 return (set_error(lbh, err));
1017         if ((err = be_root_concat(lbh, new, full_new)) != 0)
1018                 return (set_error(lbh, err));
1019
1020         if (!zfs_dataset_exists(lbh->lzh, full_old, ZFS_TYPE_DATASET))
1021                 return (set_error(lbh, BE_ERR_NOENT));
1022
1023         if (zfs_dataset_exists(lbh->lzh, full_new, ZFS_TYPE_DATASET))
1024                 return (set_error(lbh, BE_ERR_EXISTS));
1025
1026         if ((zfs_hdl = zfs_open(lbh->lzh, full_old,
1027             ZFS_TYPE_FILESYSTEM)) == NULL)
1028                 return (set_error(lbh, BE_ERR_ZFSOPEN));
1029
1030         /* recurse, nounmount, forceunmount */
1031         struct renameflags flags = {
1032                 .nounmount = 1,
1033         };
1034         err = zfs_rename(zfs_hdl, full_new, flags);
1035         if (err != 0)
1036                 goto error;
1037
1038         /* handle renaming bootonce */
1039         if (lbh->bootonce != NULL &&
1040             strcmp(full_old, lbh->bootonce) == 0)
1041                 err = be_activate(lbh, new, true);
1042
1043 error:
1044         zfs_close(zfs_hdl);
1045         return (set_error(lbh, err));
1046 }
1047
1048
1049 int
1050 be_export(libbe_handle_t *lbh, const char *bootenv, int fd)
1051 {
1052         char snap_name[BE_MAXPATHLEN];
1053         char buf[BE_MAXPATHLEN];
1054         zfs_handle_t *zfs;
1055         sendflags_t flags = { 0 };
1056         int err;
1057
1058         if ((err = be_snapshot(lbh, bootenv, NULL, true, snap_name)) != 0)
1059                 /* Use the error set by be_snapshot */
1060                 return (err);
1061
1062         be_root_concat(lbh, snap_name, buf);
1063
1064         if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_DATASET)) == NULL)
1065                 return (set_error(lbh, BE_ERR_ZFSOPEN));
1066
1067         err = zfs_send_one(zfs, NULL, fd, &flags, /* redactbook */ NULL);
1068         zfs_close(zfs);
1069
1070         return (err);
1071 }
1072
1073
1074 int
1075 be_import(libbe_handle_t *lbh, const char *bootenv, int fd)
1076 {
1077         char buf[BE_MAXPATHLEN];
1078         nvlist_t *props;
1079         zfs_handle_t *zfs;
1080         recvflags_t flags = { .nomount = 1 };
1081         int err;
1082
1083         be_root_concat(lbh, bootenv, buf);
1084
1085         if ((err = zfs_receive(lbh->lzh, buf, NULL, &flags, fd, NULL)) != 0) {
1086                 switch (err) {
1087                 case EINVAL:
1088                         return (set_error(lbh, BE_ERR_NOORIGIN));
1089                 case ENOENT:
1090                         return (set_error(lbh, BE_ERR_NOENT));
1091                 case EIO:
1092                         return (set_error(lbh, BE_ERR_IO));
1093                 default:
1094                         return (set_error(lbh, BE_ERR_UNKNOWN));
1095                 }
1096         }
1097
1098         if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_FILESYSTEM)) == NULL)
1099                 return (set_error(lbh, BE_ERR_ZFSOPEN));
1100
1101         nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP);
1102         nvlist_add_string(props, "canmount", "noauto");
1103         nvlist_add_string(props, "mountpoint", "none");
1104
1105         err = zfs_prop_set_list(zfs, props);
1106         nvlist_free(props);
1107
1108         zfs_close(zfs);
1109
1110         if (err != 0)
1111                 return (set_error(lbh, BE_ERR_UNKNOWN));
1112
1113         return (0);
1114 }
1115
1116 #if SOON
1117 static int
1118 be_create_child_noent(libbe_handle_t *lbh, const char *active,
1119     const char *child_path)
1120 {
1121         nvlist_t *props;
1122         zfs_handle_t *zfs;
1123         int err;
1124
1125         nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP);
1126         nvlist_add_string(props, "canmount", "noauto");
1127         nvlist_add_string(props, "mountpoint", child_path);
1128
1129         /* Create */
1130         if ((err = zfs_create(lbh->lzh, active, ZFS_TYPE_DATASET,
1131             props)) != 0) {
1132                 switch (err) {
1133                 case EZFS_EXISTS:
1134                         return (set_error(lbh, BE_ERR_EXISTS));
1135                 case EZFS_NOENT:
1136                         return (set_error(lbh, BE_ERR_NOENT));
1137                 case EZFS_BADTYPE:
1138                 case EZFS_BADVERSION:
1139                         return (set_error(lbh, BE_ERR_NOPOOL));
1140                 case EZFS_BADPROP:
1141                 default:
1142                         /* We set something up wrong, probably... */
1143                         return (set_error(lbh, BE_ERR_UNKNOWN));
1144                 }
1145         }
1146         nvlist_free(props);
1147
1148         if ((zfs = zfs_open(lbh->lzh, active, ZFS_TYPE_DATASET)) == NULL)
1149                 return (set_error(lbh, BE_ERR_ZFSOPEN));
1150
1151         /* Set props */
1152         if ((err = zfs_prop_set(zfs, "canmount", "noauto")) != 0) {
1153                 zfs_close(zfs);
1154                 /*
1155                  * Similar to other cases, this shouldn't fail unless we've
1156                  * done something wrong.  This is a new dataset that shouldn't
1157                  * have been mounted anywhere between creation and now.
1158                  */
1159                 if (err == EZFS_NOMEM)
1160                         return (set_error(lbh, BE_ERR_NOMEM));
1161                 return (set_error(lbh, BE_ERR_UNKNOWN));
1162         }
1163         zfs_close(zfs);
1164         return (BE_ERR_SUCCESS);
1165 }
1166
1167 static int
1168 be_create_child_cloned(libbe_handle_t *lbh, const char *active)
1169 {
1170         char buf[BE_MAXPATHLEN], tmp[BE_MAXPATHLEN];;
1171         zfs_handle_t *zfs;
1172         int err;
1173
1174         /* XXX TODO ? */
1175
1176         /*
1177          * Establish if the existing path is a zfs dataset or just
1178          * the subdirectory of one
1179          */
1180         strlcpy(tmp, "tmp/be_snap.XXXXX", sizeof(tmp));
1181         if (mktemp(tmp) == NULL)
1182                 return (set_error(lbh, BE_ERR_UNKNOWN));
1183
1184         be_root_concat(lbh, tmp, buf);
1185         printf("Here %s?\n", buf);
1186         if ((err = zfs_snapshot(lbh->lzh, buf, false, NULL)) != 0) {
1187                 switch (err) {
1188                 case EZFS_INVALIDNAME:
1189                         return (set_error(lbh, BE_ERR_INVALIDNAME));
1190
1191                 default:
1192                         /*
1193                          * The other errors that zfs_ioc_snapshot might return
1194                          * shouldn't happen if we've set things up properly, so
1195                          * we'll gloss over them and call it UNKNOWN as it will
1196                          * require further triage.
1197                          */
1198                         if (errno == ENOTSUP)
1199                                 return (set_error(lbh, BE_ERR_NOPOOL));
1200                         return (set_error(lbh, BE_ERR_UNKNOWN));
1201                 }
1202         }
1203
1204         /* Clone */
1205         if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_SNAPSHOT)) == NULL)
1206                 return (BE_ERR_ZFSOPEN);
1207
1208         if ((err = zfs_clone(zfs, active, NULL)) != 0)
1209                 /* XXX TODO correct error */
1210                 return (set_error(lbh, BE_ERR_UNKNOWN));
1211
1212         /* set props */
1213         zfs_close(zfs);
1214         return (BE_ERR_SUCCESS);
1215 }
1216
1217 int
1218 be_add_child(libbe_handle_t *lbh, const char *child_path, bool cp_if_exists)
1219 {
1220         struct stat sb;
1221         char active[BE_MAXPATHLEN], buf[BE_MAXPATHLEN];
1222         nvlist_t *props;
1223         const char *s;
1224
1225         /* Require absolute paths */
1226         if (*child_path != '/')
1227                 return (set_error(lbh, BE_ERR_BADPATH));
1228
1229         strlcpy(active, be_active_path(lbh), BE_MAXPATHLEN);
1230         strcpy(buf, active);
1231
1232         /* Create non-mountable parent dataset(s) */
1233         s = child_path;
1234         for (char *p; (p = strchr(s+1, '/')) != NULL; s = p) {
1235                 size_t len = p - s;
1236                 strncat(buf, s, len);
1237
1238                 nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP);
1239                 nvlist_add_string(props, "canmount", "off");
1240                 nvlist_add_string(props, "mountpoint", "none");
1241                 zfs_create(lbh->lzh, buf, ZFS_TYPE_DATASET, props);
1242                 nvlist_free(props);
1243         }
1244
1245         /* Path does not exist as a descendent of / yet */
1246         if (strlcat(active, child_path, BE_MAXPATHLEN) >= BE_MAXPATHLEN)
1247                 return (set_error(lbh, BE_ERR_PATHLEN));
1248
1249         if (stat(child_path, &sb) != 0) {
1250                 /* Verify that error is ENOENT */
1251                 if (errno != ENOENT)
1252                         return (set_error(lbh, BE_ERR_UNKNOWN));
1253                 return (be_create_child_noent(lbh, active, child_path));
1254         } else if (cp_if_exists)
1255                 /* Path is already a descendent of / and should be copied */
1256                 return (be_create_child_cloned(lbh, active));
1257         return (set_error(lbh, BE_ERR_EXISTS));
1258 }
1259 #endif  /* SOON */
1260
1261 /*
1262  * Deactivate old BE dataset; currently just sets canmount=noauto or
1263  * resets boot once configuration.
1264  */
1265 int
1266 be_deactivate(libbe_handle_t *lbh, const char *ds, bool temporary)
1267 {
1268         zfs_handle_t *zfs;
1269
1270         if (temporary) {
1271                 return (lzbe_set_boot_device(
1272                     zpool_get_name(lbh->active_phandle), lzbe_add, NULL));
1273         }
1274
1275         if ((zfs = zfs_open(lbh->lzh, ds, ZFS_TYPE_DATASET)) == NULL)
1276                 return (1);
1277         if (zfs_prop_set(zfs, "canmount", "noauto") != 0)
1278                 return (1);
1279         zfs_close(zfs);
1280         return (0);
1281 }
1282
1283 static int
1284 be_zfs_promote_cb(zfs_handle_t *zhp, void *data)
1285 {
1286         char origin[BE_MAXPATHLEN];
1287         bool *found_origin = (bool *)data;
1288         int err;
1289
1290         if (zfs_prop_get(zhp, ZFS_PROP_ORIGIN, origin, sizeof(origin),
1291             NULL, NULL, 0, true) == 0) {
1292                 *found_origin = true;
1293                 err = zfs_promote(zhp);
1294                 if (err)
1295                         return (err);
1296         }
1297
1298         return (zfs_iter_filesystems(zhp, be_zfs_promote_cb, data));
1299 }
1300
1301 static int
1302 be_zfs_promote(zfs_handle_t *zhp, bool *found_origin)
1303 {
1304         *found_origin = false;
1305         return (be_zfs_promote_cb(zhp, (void *)found_origin));
1306 }
1307
1308 int
1309 be_activate(libbe_handle_t *lbh, const char *bootenv, bool temporary)
1310 {
1311         char be_path[BE_MAXPATHLEN];
1312         zfs_handle_t *zhp;
1313         int err;
1314         bool found_origin;
1315
1316         be_root_concat(lbh, bootenv, be_path);
1317
1318         /* Note: be_exists fails if mountpoint is not / */
1319         if ((err = be_exists(lbh, be_path)) != 0)
1320                 return (set_error(lbh, err));
1321
1322         if (temporary) {
1323                 return (lzbe_set_boot_device(
1324                     zpool_get_name(lbh->active_phandle), lzbe_add, be_path));
1325         } else {
1326                 if (strncmp(lbh->bootfs, "-", 1) != 0 &&
1327                     be_deactivate(lbh, lbh->bootfs, false) != 0)
1328                         return (-1);
1329
1330                 /* Obtain bootenv zpool */
1331                 err = zpool_set_prop(lbh->active_phandle, "bootfs", be_path);
1332                 if (err)
1333                         return (-1);
1334
1335                 for (;;) {
1336                         zhp = zfs_open(lbh->lzh, be_path, ZFS_TYPE_FILESYSTEM);
1337                         if (zhp == NULL)
1338                                 return (-1);
1339
1340                         err = be_zfs_promote(zhp, &found_origin);
1341
1342                         zfs_close(zhp);
1343                         if (!found_origin)
1344                                 break;
1345                         if (err)
1346                                 return (err);
1347                 }
1348
1349                 if (err)
1350                         return (-1);
1351         }
1352
1353         return (BE_ERR_SUCCESS);
1354 }