lib/libbe/be.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2017 Kyle J. Kneitinger <kyle@kneit.in>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/stat.h>
  33 #include <sys/types.h>
  34
  35 #include <ctype.h>
  36 #include <kenv.h>
  37 #include <libgen.h>
  38 #include <libzfs_core.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <time.h>
  42 #include <unistd.h>
  43
  44 #include "be.h"
  45 #include "be_impl.h"
  46
  47 #if SOON
  48 static int be_create_child_noent(libbe_handle_t *lbh, const char *active,
  49     const char *child_path);
  50 static int be_create_child_cloned(libbe_handle_t *lbh, const char *active);
  51 #endif
  52
  53 /*
  54  * Iterator function for locating the rootfs amongst the children of the
  55  * zfs_be_root set by loader(8).  data is expected to be a libbe_handle_t *.
  56  */
  57 static int
  58 be_locate_rootfs(zfs_handle_t *chkds, void *data)
  59 {
  60         libbe_handle_t *lbh;
  61         char *mntpoint;
  62
  63         lbh = (libbe_handle_t *)data;
  64         if (lbh == NULL)
  65                 return (1);
  66
  67         mntpoint = NULL;
  68         if (zfs_is_mounted(chkds, &mntpoint) && strcmp(mntpoint, "/") == 0) {
  69                 strlcpy(lbh->rootfs, zfs_get_name(chkds), sizeof(lbh->rootfs));
  70                 free(mntpoint);
  71                 return (1);
  72         } else if(mntpoint != NULL)
  73                 free(mntpoint);
  74
  75         return (0);
  76 }
  77
  78 /*
  79  * Initializes the libbe context to operate in the root boot environment
  80  * dataset, for example, zroot/ROOT.
  81  */
  82 libbe_handle_t *
  83 libbe_init(void)
  84 {
  85         struct stat sb;
  86         dev_t root_dev, boot_dev;
  87         libbe_handle_t *lbh;
  88         zfs_handle_t *rootds;
  89         char *poolname, *pos;
  90         int pnamelen;
  91
  92         lbh = NULL;
  93         poolname = pos = NULL;
  94         rootds = NULL;
  95
  96         /* Verify that /boot and / are mounted on the same filesystem */
  97         /* TODO: use errno here?? */
  98         if (stat("/", &sb) != 0)
  99                 goto err;
 100
 101         root_dev = sb.st_dev;
 102
 103         if (stat("/boot", &sb) != 0)
 104                 goto err;
 105
 106         boot_dev = sb.st_dev;
 107
 108         if (root_dev != boot_dev) {
 109                 fprintf(stderr, "/ and /boot not on same device, quitting\n");
 110                 goto err;
 111         }
 112
 113         if ((lbh = calloc(1, sizeof(libbe_handle_t))) == NULL)
 114                 goto err;
 115
 116         if ((lbh->lzh = libzfs_init()) == NULL)
 117                 goto err;
 118
 119         /* Obtain path to boot environment root */
 120         if ((kenv(KENV_GET, "zfs_be_root", lbh->root,
 121             sizeof(lbh->root))) == -1)
 122                 goto err;
 123
 124         /* Remove leading 'zfs:' if present, otherwise use value as-is */
 125         if (strcmp(lbh->root, "zfs:") == 0)
 126                 strlcpy(lbh->root, strchr(lbh->root, ':') + sizeof(char),
 127                     sizeof(lbh->root));
 128
 129         if ((pos = strchr(lbh->root, '/')) == NULL)
 130                 goto err;
 131
 132         pnamelen = pos - lbh->root;
 133         poolname = malloc(pnamelen + 1);
 134         if (poolname == NULL)
 135                 goto err;
 136
 137         strlcpy(poolname, lbh->root, pnamelen + 1);
 138         if ((lbh->active_phandle = zpool_open(lbh->lzh, poolname)) == NULL)
 139                 goto err;
 140         free(poolname);
 141         poolname = NULL;
 142
 143         if (zpool_get_prop(lbh->active_phandle, ZPOOL_PROP_BOOTFS, lbh->bootfs,
 144             sizeof(lbh->bootfs), NULL, true) != 0)
 145                 goto err;
 146
 147         /* Obtain path to boot environment rootfs (currently booted) */
 148         /* XXX Get dataset mounted at / by kenv/GUID from mountroot? */
 149         if ((rootds = zfs_open(lbh->lzh, lbh->root, ZFS_TYPE_DATASET)) == NULL)
 150                 goto err;
 151
 152         zfs_iter_filesystems(rootds, be_locate_rootfs, lbh);
 153         zfs_close(rootds);
 154         rootds = NULL;
 155         if (*lbh->rootfs == '\0')
 156                 goto err;
 157
 158         return (lbh);
 159 err:
 160         if (lbh != NULL) {
 161                 if (lbh->active_phandle != NULL)
 162                         zpool_close(lbh->active_phandle);
 163                 if (lbh->lzh != NULL)
 164                         libzfs_fini(lbh->lzh);
 165                 free(lbh);
 166         }
 167         free(poolname);
 168         return (NULL);
 169 }
 170
 171
 172 /*
 173  * Free memory allocated by libbe_init()
 174  */
 175 void
 176 libbe_close(libbe_handle_t *lbh)
 177 {
 178
 179         if (lbh->active_phandle != NULL)
 180                 zpool_close(lbh->active_phandle);
 181         libzfs_fini(lbh->lzh);
 182         free(lbh);
 183 }
 184
 185 /*
 186  * Proxy through to libzfs for the moment.
 187  */
 188 void
 189 be_nicenum(uint64_t num, char *buf, size_t buflen)
 190 {
 191
 192         zfs_nicenum(num, buf, buflen);
 193 }
 194
 195 static int
 196 be_destroy_cb(zfs_handle_t *zfs_hdl, void *data)
 197 {
 198         int err;
 199
 200         if ((err = zfs_iter_children(zfs_hdl, be_destroy_cb, data)) != 0)
 201                 return (err);
 202         if ((err = zfs_destroy(zfs_hdl, false)) != 0)
 203                 return (err);
 204         return (0);
 205 }
 206
 207 /*
 208  * Destroy the boot environment or snapshot specified by the name
 209  * parameter. Options are or'd together with the possible values:
 210  * BE_DESTROY_FORCE : forces operation on mounted datasets
 211  */
 212 int
 213 be_destroy(libbe_handle_t *lbh, const char *name, int options)
 214 {
 215         zfs_handle_t *fs;
 216         char path[BE_MAXPATHLEN];
 217         char *p;
 218         int err, force, mounted;
 219
 220         p = path;
 221         force = options & BE_DESTROY_FORCE;
 222
 223         be_root_concat(lbh, name, path);
 224
 225         if (strchr(name, '@') == NULL) {
 226                 if (!zfs_dataset_exists(lbh->lzh, path, ZFS_TYPE_FILESYSTEM))
 227                         return (set_error(lbh, BE_ERR_NOENT));
 228
 229                 if (strcmp(path, lbh->rootfs) == 0)
 230                         return (set_error(lbh, BE_ERR_DESTROYACT));
 231
 232                 fs = zfs_open(lbh->lzh, p, ZFS_TYPE_FILESYSTEM);
 233         } else {
 234
 235                 if (!zfs_dataset_exists(lbh->lzh, path, ZFS_TYPE_SNAPSHOT))
 236                         return (set_error(lbh, BE_ERR_NOENT));
 237
 238                 fs = zfs_open(lbh->lzh, p, ZFS_TYPE_SNAPSHOT);
 239         }
 240
 241         if (fs == NULL)
 242                 return (set_error(lbh, BE_ERR_ZFSOPEN));
 243
 244         /* Check if mounted, unmount if force is specified */
 245         if ((mounted = zfs_is_mounted(fs, NULL)) != 0) {
 246                 if (force)
 247                         zfs_unmount(fs, NULL, 0);
 248                 else
 249                         return (set_error(lbh, BE_ERR_DESTROYMNT));
 250         }
 251
 252         if ((err = be_destroy_cb(fs, NULL)) != 0) {
 253                 /* Children are still present or the mount is referenced */
 254                 if (err == EBUSY)
 255                         return (set_error(lbh, BE_ERR_DESTROYMNT));
 256                 return (set_error(lbh, BE_ERR_UNKNOWN));
 257         }
 258
 259         return (0);
 260 }
 261
 262
 263 int
 264 be_snapshot(libbe_handle_t *lbh, const char *source, const char *snap_name,
 265     bool recursive, char *result)
 266 {
 267         char buf[BE_MAXPATHLEN];
 268         time_t rawtime;
 269         int len, err;
 270
 271         be_root_concat(lbh, source, buf);
 272
 273         if ((err = be_exists(lbh, buf)) != 0)
 274                 return (set_error(lbh, err));
 275
 276         if (snap_name != NULL) {
 277                 if (strlcat(buf, "@", sizeof(buf)) >= sizeof(buf))
 278                         return (set_error(lbh, BE_ERR_INVALIDNAME));
 279
 280                 if (strlcat(buf, snap_name, sizeof(buf)) >= sizeof(buf))
 281                         return (set_error(lbh, BE_ERR_INVALIDNAME));
 282
 283                 if (result != NULL)
 284                         snprintf(result, BE_MAXPATHLEN, "%s@%s", source,
 285                             snap_name);
 286         } else {
 287                 time(&rawtime);
 288                 len = strlen(buf);
 289                 strftime(buf + len, sizeof(buf) - len,
 290                     "@%F-%T", localtime(&rawtime));
 291                 if (result != NULL && strlcpy(result, strrchr(buf, '/') + 1,
 292                     sizeof(buf)) >= sizeof(buf))
 293                         return (set_error(lbh, BE_ERR_INVALIDNAME));
 294         }
 295
 296         if ((err = zfs_snapshot(lbh->lzh, buf, recursive, NULL)) != 0) {
 297                 switch (err) {
 298                 case EZFS_INVALIDNAME:
 299                         return (set_error(lbh, BE_ERR_INVALIDNAME));
 300
 301                 default:
 302                         /*
 303                          * The other errors that zfs_ioc_snapshot might return
 304                          * shouldn't happen if we've set things up properly, so
 305                          * we'll gloss over them and call it UNKNOWN as it will
 306                          * require further triage.
 307                          */
 308                         if (errno == ENOTSUP)
 309                                 return (set_error(lbh, BE_ERR_NOPOOL));
 310                         return (set_error(lbh, BE_ERR_UNKNOWN));
 311                 }
 312         }
 313
 314         return (BE_ERR_SUCCESS);
 315 }
 316
 317
 318 /*
 319  * Create the boot environment specified by the name parameter
 320  */
 321 int
 322 be_create(libbe_handle_t *lbh, const char *name)
 323 {
 324         int err;
 325
 326         err = be_create_from_existing(lbh, name, be_active_path(lbh));
 327
 328         return (set_error(lbh, err));
 329 }
 330
 331
 332 static int
 333 be_deep_clone_prop(int prop, void *cb)
 334 {
 335         int err;
 336         struct libbe_dccb *dccb;
 337         zprop_source_t src;
 338         char pval[BE_MAXPATHLEN];
 339         char source[BE_MAXPATHLEN];
 340
 341         dccb = cb;
 342         /* Skip some properties we don't want to touch */
 343         if (prop == ZFS_PROP_CANMOUNT)
 344                 return (ZPROP_CONT);
 345
 346         /* Don't copy readonly properties */
 347         if (zfs_prop_readonly(prop))
 348                 return (ZPROP_CONT);
 349
 350         if ((err = zfs_prop_get(dccb->zhp, prop, (char *)&pval,
 351             sizeof(pval), &src, (char *)&source, sizeof(source), false)))
 352                 /* Just continue if we fail to read a property */
 353                 return (ZPROP_CONT);
 354
 355         /* Only copy locally defined properties */
 356         if (src != ZPROP_SRC_LOCAL)
 357                 return (ZPROP_CONT);
 358
 359         nvlist_add_string(dccb->props, zfs_prop_to_name(prop), (char *)pval);
 360
 361         return (ZPROP_CONT);
 362 }
 363
 364 static int
 365 be_deep_clone(zfs_handle_t *ds, void *data)
 366 {
 367         int err;
 368         char be_path[BE_MAXPATHLEN];
 369         char snap_path[BE_MAXPATHLEN];
 370         const char *dspath;
 371         char *dsname;
 372         zfs_handle_t *snap_hdl;
 373         nvlist_t *props;
 374         struct libbe_deep_clone *isdc, sdc;
 375         struct libbe_dccb dccb;
 376
 377         isdc = (struct libbe_deep_clone *)data;
 378         dspath = zfs_get_name(ds);
 379         if ((dsname = strrchr(dspath, '/')) == NULL)
 380                 return (BE_ERR_UNKNOWN);
 381         dsname++;
 382
 383         if (isdc->bename == NULL)
 384                 snprintf(be_path, sizeof(be_path), "%s/%s", isdc->be_root, dsname);
 385         else
 386                 snprintf(be_path, sizeof(be_path), "%s/%s", isdc->be_root, isdc->bename);
 387
 388         snprintf(snap_path, sizeof(snap_path), "%s@%s", dspath, isdc->snapname);
 389
 390         if (zfs_dataset_exists(isdc->lbh->lzh, be_path, ZFS_TYPE_DATASET))
 391                 return (set_error(isdc->lbh, BE_ERR_EXISTS));
 392
 393         if ((snap_hdl =
 394             zfs_open(isdc->lbh->lzh, snap_path, ZFS_TYPE_SNAPSHOT)) == NULL)
 395                 return (set_error(isdc->lbh, BE_ERR_ZFSOPEN));
 396
 397         nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP);
 398         nvlist_add_string(props, "canmount", "noauto");
 399
 400         dccb.zhp = ds;
 401         dccb.props = props;
 402         if (zprop_iter(be_deep_clone_prop, &dccb, B_FALSE, B_FALSE,
 403             ZFS_TYPE_FILESYSTEM) == ZPROP_INVAL)
 404                 return (-1);
 405
 406         if ((err = zfs_clone(snap_hdl, be_path, props)) != 0)
 407                 err = BE_ERR_ZFSCLONE;
 408
 409         nvlist_free(props);
 410         zfs_close(snap_hdl);
 411
 412         /* Failed to clone */
 413         if (err != BE_ERR_SUCCESS)
 414                 return (set_error(isdc->lbh, err));
 415
 416         sdc.lbh = isdc->lbh;
 417         sdc.bename = NULL;
 418         sdc.snapname = isdc->snapname;
 419         sdc.be_root = (char *)&be_path;
 420
 421         err = zfs_iter_filesystems(ds, be_deep_clone, &sdc);
 422
 423         return (err);
 424 }
 425
 426 /*
 427  * Create the boot environment from pre-existing snapshot
 428  */
 429 int
 430 be_create_from_existing_snap(libbe_handle_t *lbh, const char *name,
 431     const char *snap)
 432 {
 433         int err;
 434         char be_path[BE_MAXPATHLEN];
 435         char snap_path[BE_MAXPATHLEN];
 436         const char *bename;
 437         char *parentname, *snapname;
 438         zfs_handle_t *parent_hdl;
 439         struct libbe_deep_clone sdc;
 440
 441         if ((err = be_validate_name(lbh, name)) != 0)
 442                 return (set_error(lbh, err));
 443         if ((err = be_root_concat(lbh, snap, snap_path)) != 0)
 444                 return (set_error(lbh, err));
 445         if ((err = be_validate_snap(lbh, snap_path)) != 0)
 446                 return (set_error(lbh, err));
 447
 448         if ((err = be_root_concat(lbh, name, be_path)) != 0)
 449                 return (set_error(lbh, err));
 450
 451         if ((bename = strrchr(name, '/')) == NULL)
 452                 bename = name;
 453         else
 454                 bename++;
 455
 456         if ((parentname = strdup(snap_path)) == NULL)
 457                 return (set_error(lbh, BE_ERR_UNKNOWN));
 458
 459         snapname = strchr(parentname, '@');
 460         if (snapname == NULL) {
 461                 free(parentname);
 462                 return (set_error(lbh, BE_ERR_UNKNOWN));
 463         }
 464         *snapname = '\0';
 465         snapname++;
 466
 467         sdc.lbh = lbh;
 468         sdc.bename = bename;
 469         sdc.snapname = snapname;
 470         sdc.be_root = lbh->root;
 471
 472         parent_hdl = zfs_open(lbh->lzh, parentname, ZFS_TYPE_DATASET);
 473         err = be_deep_clone(parent_hdl, &sdc);
 474
 475         free(parentname);
 476         return (set_error(lbh, err));
 477 }
 478
 479
 480 /*
 481  * Create a boot environment from an existing boot environment
 482  */
 483 int
 484 be_create_from_existing(libbe_handle_t *lbh, const char *name, const char *old)
 485 {
 486         int err;
 487         char buf[BE_MAXPATHLEN];
 488
 489         if ((err = be_snapshot(lbh, old, NULL, true, (char *)&buf)) != 0)
 490                 return (set_error(lbh, err));
 491
 492         err = be_create_from_existing_snap(lbh, name, (char *)buf);
 493
 494         return (set_error(lbh, err));
 495 }
 496
 497
 498 /*
 499  * Verifies that a snapshot has a valid name, exists, and has a mountpoint of
 500  * '/'. Returns BE_ERR_SUCCESS (0), upon success, or the relevant BE_ERR_* upon
 501  * failure. Does not set the internal library error state.
 502  */
 503 int
 504 be_validate_snap(libbe_handle_t *lbh, const char *snap_name)
 505 {
 506         zfs_handle_t *zfs_hdl;
 507         char buf[BE_MAXPATHLEN];
 508         char *delim_pos;
 509         int err = BE_ERR_SUCCESS;
 510
 511         if (strlen(snap_name) >= BE_MAXPATHLEN)
 512                 return (BE_ERR_PATHLEN);
 513
 514         if (!zfs_dataset_exists(lbh->lzh, snap_name,
 515             ZFS_TYPE_SNAPSHOT))
 516                 return (BE_ERR_NOENT);
 517
 518         strlcpy(buf, snap_name, sizeof(buf));
 519
 520         /* Find the base filesystem of the snapshot */
 521         if ((delim_pos = strchr(buf, '@')) == NULL)
 522                 return (BE_ERR_INVALIDNAME);
 523         *delim_pos = '\0';
 524
 525         if ((zfs_hdl =
 526             zfs_open(lbh->lzh, buf, ZFS_TYPE_DATASET)) == NULL)
 527                 return (BE_ERR_NOORIGIN);
 528
 529         if ((err = zfs_prop_get(zfs_hdl, ZFS_PROP_MOUNTPOINT, buf,
 530             sizeof(buf), NULL, NULL, 0, 1)) != 0)
 531                 err = BE_ERR_BADMOUNT;
 532
 533         if ((err != 0) && (strncmp(buf, "/", sizeof(buf)) != 0))
 534                 err = BE_ERR_BADMOUNT;
 535
 536         zfs_close(zfs_hdl);
 537
 538         return (err);
 539 }
 540
 541
 542 /*
 543  * Idempotently appends the name argument to the root boot environment path
 544  * and copies the resulting string into the result buffer (which is assumed
 545  * to be at least BE_MAXPATHLEN characters long. Returns BE_ERR_SUCCESS upon
 546  * success, BE_ERR_PATHLEN if the resulting path is longer than BE_MAXPATHLEN,
 547  * or BE_ERR_INVALIDNAME if the name is a path that does not begin with
 548  * zfs_be_root. Does not set internal library error state.
 549  */
 550 int
 551 be_root_concat(libbe_handle_t *lbh, const char *name, char *result)
 552 {
 553         size_t name_len, root_len;
 554
 555         name_len = strlen(name);
 556         root_len = strlen(lbh->root);
 557
 558         /* Act idempotently; return be name if it is already a full path */
 559         if (strrchr(name, '/') != NULL) {
 560                 if (strstr(name, lbh->root) != name)
 561                         return (BE_ERR_INVALIDNAME);
 562
 563                 if (name_len >= BE_MAXPATHLEN)
 564                         return (BE_ERR_PATHLEN);
 565
 566                 strlcpy(result, name, BE_MAXPATHLEN);
 567                 return (BE_ERR_SUCCESS);
 568         } else if (name_len + root_len + 1 < BE_MAXPATHLEN) {
 569                 snprintf(result, BE_MAXPATHLEN, "%s/%s", lbh->root,
 570                     name);
 571                 return (BE_ERR_SUCCESS);
 572         }
 573
 574         return (BE_ERR_PATHLEN);
 575 }
 576
 577
 578 /*
 579  * Verifies the validity of a boot environment name (A-Za-z0-9-_.). Returns
 580  * BE_ERR_SUCCESS (0) if name is valid, otherwise returns BE_ERR_INVALIDNAME
 581  * or BE_ERR_PATHLEN.
 582  * Does not set internal library error state.
 583  */
 584 int
 585 be_validate_name(libbe_handle_t *lbh, const char *name)
 586 {
 587         for (int i = 0; *name; i++) {
 588                 char c = *(name++);
 589                 if (isalnum(c) || (c == '-') || (c == '_') || (c == '.'))
 590                         continue;
 591                 return (BE_ERR_INVALIDNAME);
 592         }
 593
 594         /*
 595          * Impose the additional restriction that the entire dataset name must
 596          * not exceed the maximum length of a dataset, i.e. MAXNAMELEN.
 597          */
 598         if (strlen(lbh->root) + 1 + strlen(name) > MAXNAMELEN)
 599                 return (BE_ERR_PATHLEN);
 600         return (BE_ERR_SUCCESS);
 601 }
 602
 603
 604 /*
 605  * usage
 606  */
 607 int
 608 be_rename(libbe_handle_t *lbh, const char *old, const char *new)
 609 {
 610         char full_old[BE_MAXPATHLEN];
 611         char full_new[BE_MAXPATHLEN];
 612         zfs_handle_t *zfs_hdl;
 613         int err;
 614
 615         /*
 616          * be_validate_name is documented not to set error state, so we should
 617          * do so here.
 618          */
 619         if ((err = be_validate_name(lbh, new)) != 0)
 620                 return (set_error(lbh, err));
 621         if ((err = be_root_concat(lbh, old, full_old)) != 0)
 622                 return (set_error(lbh, err));
 623         if ((err = be_root_concat(lbh, new, full_new)) != 0)
 624                 return (set_error(lbh, err));
 625
 626         if (!zfs_dataset_exists(lbh->lzh, full_old, ZFS_TYPE_DATASET))
 627                 return (set_error(lbh, BE_ERR_NOENT));
 628
 629         if (zfs_dataset_exists(lbh->lzh, full_new, ZFS_TYPE_DATASET))
 630                 return (set_error(lbh, BE_ERR_EXISTS));
 631
 632         if ((zfs_hdl = zfs_open(lbh->lzh, full_old,
 633             ZFS_TYPE_FILESYSTEM)) == NULL)
 634                 return (set_error(lbh, BE_ERR_ZFSOPEN));
 635
 636         /* recurse, nounmount, forceunmount */
 637         struct renameflags flags = {
 638                 .nounmount = 1,
 639         };
 640
 641         err = zfs_rename(zfs_hdl, NULL, full_new, flags);
 642
 643         zfs_close(zfs_hdl);
 644         if (err != 0)
 645                 return (set_error(lbh, BE_ERR_UNKNOWN));
 646         return (0);
 647 }
 648
 649
 650 int
 651 be_export(libbe_handle_t *lbh, const char *bootenv, int fd)
 652 {
 653         char snap_name[BE_MAXPATHLEN];
 654         char buf[BE_MAXPATHLEN];
 655         zfs_handle_t *zfs;
 656         int err;
 657
 658         if ((err = be_snapshot(lbh, bootenv, NULL, true, snap_name)) != 0)
 659                 /* Use the error set by be_snapshot */
 660                 return (err);
 661
 662         be_root_concat(lbh, snap_name, buf);
 663
 664         if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_DATASET)) == NULL)
 665                 return (set_error(lbh, BE_ERR_ZFSOPEN));
 666
 667         err = zfs_send_one(zfs, NULL, fd, 0);
 668         zfs_close(zfs);
 669
 670         return (err);
 671 }
 672
 673
 674 int
 675 be_import(libbe_handle_t *lbh, const char *bootenv, int fd)
 676 {
 677         char buf[BE_MAXPATHLEN];
 678         time_t rawtime;
 679         nvlist_t *props;
 680         zfs_handle_t *zfs;
 681         int err, len;
 682         char nbuf[24];
 683
 684         /*
 685          * We don't need this to be incredibly random, just unique enough that
 686          * it won't conflict with an existing dataset name.  Chopping time
 687          * down to 32 bits is probably good enough for this.
 688          */
 689         snprintf(nbuf, 24, "tmp%u",
 690             (uint32_t)(time(NULL) & 0xFFFFFFFF));
 691         if ((err = be_root_concat(lbh, nbuf, buf)) != 0)
 692                 /*
 693                  * Technically this is our problem, but we try to use short
 694                  * enough names that we won't run into problems except in
 695                  * worst-case BE root approaching MAXPATHLEN.
 696                  */
 697                 return (set_error(lbh, BE_ERR_PATHLEN));
 698
 699         time(&rawtime);
 700         len = strlen(buf);
 701         strftime(buf + len, sizeof(buf) - len, "@%F-%T", localtime(&rawtime));
 702
 703         if ((err = lzc_receive(buf, NULL, NULL, false, fd)) != 0) {
 704                 switch (err) {
 705                 case EINVAL:
 706                         return (set_error(lbh, BE_ERR_NOORIGIN));
 707                 case ENOENT:
 708                         return (set_error(lbh, BE_ERR_NOENT));
 709                 case EIO:
 710                         return (set_error(lbh, BE_ERR_IO));
 711                 default:
 712                         return (set_error(lbh, BE_ERR_UNKNOWN));
 713                 }
 714         }
 715
 716         if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_SNAPSHOT)) == NULL)
 717                 return (set_error(lbh, BE_ERR_ZFSOPEN));
 718
 719         nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP);
 720         nvlist_add_string(props, "canmount", "noauto");
 721         nvlist_add_string(props, "mountpoint", "/");
 722
 723         be_root_concat(lbh, bootenv, buf);
 724
 725         err = zfs_clone(zfs, buf, props);
 726         zfs_close(zfs);
 727         nvlist_free(props);
 728
 729         if (err != 0)
 730                 return (set_error(lbh, BE_ERR_UNKNOWN));
 731
 732         /*
 733          * Finally, we open up the dataset we just cloned the snapshot so that
 734          * we may promote it.  This is necessary in order to clean up the ghost
 735          * snapshot that doesn't need to be seen after the operation is
 736          * complete.
 737          */
 738         if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_DATASET)) == NULL)
 739                 return (set_error(lbh, BE_ERR_ZFSOPEN));
 740
 741         err = zfs_promote(zfs);
 742         zfs_close(zfs);
 743
 744         if (err != 0)
 745                 return (set_error(lbh, BE_ERR_UNKNOWN));
 746
 747         /* Clean up the temporary snapshot */
 748         return (be_destroy(lbh, nbuf, 0));
 749 }
 750
 751 #if SOON
 752 static int
 753 be_create_child_noent(libbe_handle_t *lbh, const char *active,
 754     const char *child_path)
 755 {
 756         nvlist_t *props;
 757         zfs_handle_t *zfs;
 758         int err;
 759
 760         nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP);
 761         nvlist_add_string(props, "canmount", "noauto");
 762         nvlist_add_string(props, "mountpoint", child_path);
 763
 764         /* Create */
 765         if ((err = zfs_create(lbh->lzh, active, ZFS_TYPE_DATASET,
 766             props)) != 0) {
 767                 switch (err) {
 768                 case EZFS_EXISTS:
 769                         return (set_error(lbh, BE_ERR_EXISTS));
 770                 case EZFS_NOENT:
 771                         return (set_error(lbh, BE_ERR_NOENT));
 772                 case EZFS_BADTYPE:
 773                 case EZFS_BADVERSION:
 774                         return (set_error(lbh, BE_ERR_NOPOOL));
 775                 case EZFS_BADPROP:
 776                 default:
 777                         /* We set something up wrong, probably... */
 778                         return (set_error(lbh, BE_ERR_UNKNOWN));
 779                 }
 780         }
 781         nvlist_free(props);
 782
 783         if ((zfs = zfs_open(lbh->lzh, active, ZFS_TYPE_DATASET)) == NULL)
 784                 return (set_error(lbh, BE_ERR_ZFSOPEN));
 785
 786         /* Set props */
 787         if ((err = zfs_prop_set(zfs, "canmount", "noauto")) != 0) {
 788                 zfs_close(zfs);
 789                 /*
 790                  * Similar to other cases, this shouldn't fail unless we've
 791                  * done something wrong.  This is a new dataset that shouldn't
 792                  * have been mounted anywhere between creation and now.
 793                  */
 794                 if (err == EZFS_NOMEM)
 795                         return (set_error(lbh, BE_ERR_NOMEM));
 796                 return (set_error(lbh, BE_ERR_UNKNOWN));
 797         }
 798         zfs_close(zfs);
 799         return (BE_ERR_SUCCESS);
 800 }
 801
 802 static int
 803 be_create_child_cloned(libbe_handle_t *lbh, const char *active)
 804 {
 805         char buf[BE_MAXPATHLEN], tmp[BE_MAXPATHLEN];;
 806         zfs_handle_t *zfs;
 807         int err;
 808
 809         /* XXX TODO ? */
 810
 811         /*
 812          * Establish if the existing path is a zfs dataset or just
 813          * the subdirectory of one
 814          */
 815         strlcpy(tmp, "tmp/be_snap.XXXXX", sizeof(tmp));
 816         if (mktemp(tmp) == NULL)
 817                 return (set_error(lbh, BE_ERR_UNKNOWN));
 818
 819         be_root_concat(lbh, tmp, buf);
 820         printf("Here %s?\n", buf);
 821         if ((err = zfs_snapshot(lbh->lzh, buf, false, NULL)) != 0) {
 822                 switch (err) {
 823                 case EZFS_INVALIDNAME:
 824                         return (set_error(lbh, BE_ERR_INVALIDNAME));
 825
 826                 default:
 827                         /*
 828                          * The other errors that zfs_ioc_snapshot might return
 829                          * shouldn't happen if we've set things up properly, so
 830                          * we'll gloss over them and call it UNKNOWN as it will
 831                          * require further triage.
 832                          */
 833                         if (errno == ENOTSUP)
 834                                 return (set_error(lbh, BE_ERR_NOPOOL));
 835                         return (set_error(lbh, BE_ERR_UNKNOWN));
 836                 }
 837         }
 838
 839         /* Clone */
 840         if ((zfs = zfs_open(lbh->lzh, buf, ZFS_TYPE_SNAPSHOT)) == NULL)
 841                 return (BE_ERR_ZFSOPEN);
 842
 843         if ((err = zfs_clone(zfs, active, NULL)) != 0)
 844                 /* XXX TODO correct error */
 845                 return (set_error(lbh, BE_ERR_UNKNOWN));
 846
 847         /* set props */
 848         zfs_close(zfs);
 849         return (BE_ERR_SUCCESS);
 850 }
 851
 852 int
 853 be_add_child(libbe_handle_t *lbh, const char *child_path, bool cp_if_exists)
 854 {
 855         struct stat sb;
 856         char active[BE_MAXPATHLEN], buf[BE_MAXPATHLEN];
 857         nvlist_t *props;
 858         const char *s;
 859
 860         /* Require absolute paths */
 861         if (*child_path != '/')
 862                 return (set_error(lbh, BE_ERR_BADPATH));
 863
 864         strlcpy(active, be_active_path(lbh), BE_MAXPATHLEN);
 865         strcpy(buf, active);
 866
 867         /* Create non-mountable parent dataset(s) */
 868         s = child_path;
 869         for (char *p; (p = strchr(s+1, '/')) != NULL; s = p) {
 870                 size_t len = p - s;
 871                 strncat(buf, s, len);
 872
 873                 nvlist_alloc(&props, NV_UNIQUE_NAME, KM_SLEEP);
 874                 nvlist_add_string(props, "canmount", "off");
 875                 nvlist_add_string(props, "mountpoint", "none");
 876                 zfs_create(lbh->lzh, buf, ZFS_TYPE_DATASET, props);
 877                 nvlist_free(props);
 878         }
 879
 880         /* Path does not exist as a descendent of / yet */
 881         if (strlcat(active, child_path, BE_MAXPATHLEN) >= BE_MAXPATHLEN)
 882                 return (set_error(lbh, BE_ERR_PATHLEN));
 883
 884         if (stat(child_path, &sb) != 0) {
 885                 /* Verify that error is ENOENT */
 886                 if (errno != ENOENT)
 887                         return (set_error(lbh, BE_ERR_UNKNOWN));
 888                 return (be_create_child_noent(lbh, active, child_path));
 889         } else if (cp_if_exists)
 890                 /* Path is already a descendent of / and should be copied */
 891                 return (be_create_child_cloned(lbh, active));
 892         return (set_error(lbh, BE_ERR_EXISTS));
 893 }
 894 #endif  /* SOON */
 895
 896 static int
 897 be_set_nextboot(libbe_handle_t *lbh, nvlist_t *config, uint64_t pool_guid,
 898     const char *zfsdev)
 899 {
 900         nvlist_t **child;
 901         uint64_t vdev_guid;
 902         int c, children;
 903
 904         if (nvlist_lookup_nvlist_array(config, ZPOOL_CONFIG_CHILDREN, &child,
 905             &children) == 0) {
 906                 for (c = 0; c < children; ++c)
 907                         if (be_set_nextboot(lbh, child[c], pool_guid, zfsdev) != 0)
 908                                 return (1);
 909                 return (0);
 910         }
 911
 912         if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID,
 913             &vdev_guid) != 0) {
 914                 return (1);
 915         }
 916
 917         if (zpool_nextboot(lbh->lzh, pool_guid, vdev_guid, zfsdev) != 0) {
 918                 perror("ZFS_IOC_NEXTBOOT failed");
 919                 return (1);
 920         }
 921
 922         return (0);
 923 }
 924
 925
 926 int
 927 be_activate(libbe_handle_t *lbh, const char *bootenv, bool temporary)
 928 {
 929         char be_path[BE_MAXPATHLEN];
 930         char buf[BE_MAXPATHLEN];
 931         nvlist_t *config, *vdevs;
 932         uint64_t pool_guid;
 933         zfs_handle_t *zhp;
 934         int err;
 935
 936         be_root_concat(lbh, bootenv, be_path);
 937
 938         /* Note: be_exists fails if mountpoint is not / */
 939         if ((err = be_exists(lbh, be_path)) != 0)
 940                 return (set_error(lbh, err));
 941
 942         if (temporary) {
 943                 config = zpool_get_config(lbh->active_phandle, NULL);
 944                 if (config == NULL)
 945                         /* config should be fetchable... */
 946                         return (set_error(lbh, BE_ERR_UNKNOWN));
 947
 948                 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
 949                     &pool_guid) != 0)
 950                         /* Similarly, it shouldn't be possible */
 951                         return (set_error(lbh, BE_ERR_UNKNOWN));
 952
 953                 /* Expected format according to zfsbootcfg(8) man */
 954                 snprintf(buf, sizeof(buf), "zfs:%s:", be_path);
 955
 956                 /* We have no config tree */
 957                 if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
 958                     &vdevs) != 0)
 959                         return (set_error(lbh, BE_ERR_NOPOOL));
 960
 961                 return (be_set_nextboot(lbh, vdevs, pool_guid, buf));
 962         } else {
 963                 /* Obtain bootenv zpool */
 964                 err = zpool_set_prop(lbh->active_phandle, "bootfs", be_path);
 965                 if (err)
 966                         return (-1);
 967
 968                 zhp = zfs_open(lbh->lzh, be_path, ZFS_TYPE_FILESYSTEM);
 969                 if (zhp == NULL)
 970                         return (-1);
 971
 972                 err = zfs_promote(zhp);
 973                 zfs_close(zhp);
 974
 975                 if (err)
 976                         return (-1);
 977         }
 978
 979         return (BE_ERR_SUCCESS);
 980 }