stand/libsa/zfs/zfs.c

   1 /*-
   2  * Copyright (c) 2007 Doug Rabson
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  *      $FreeBSD$
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 /*
  33  *      Stand-alone file reading package.
  34  */
  35
  36 #include <stand.h>
  37 #include <sys/disk.h>
  38 #include <sys/param.h>
  39 #include <sys/time.h>
  40 #include <sys/queue.h>
  41 #include <part.h>
  42 #include <stddef.h>
  43 #include <stdarg.h>
  44 #include <string.h>
  45 #include <bootstrap.h>
  46
  47 #include "libzfs.h"
  48
  49 #include "zfsimpl.c"
  50
  51 /* Define the range of indexes to be populated with ZFS Boot Environments */
  52 #define         ZFS_BE_FIRST    4
  53 #define         ZFS_BE_LAST     8
  54
  55 static int      zfs_open(const char *path, struct open_file *f);
  56 static int      zfs_close(struct open_file *f);
  57 static int      zfs_read(struct open_file *f, void *buf, size_t size, size_t *resid);
  58 static off_t    zfs_seek(struct open_file *f, off_t offset, int where);
  59 static int      zfs_stat(struct open_file *f, struct stat *sb);
  60 static int      zfs_readdir(struct open_file *f, struct dirent *d);
  61 static int      zfs_mount(const char *dev, const char *path, void **data);
  62 static int      zfs_unmount(const char *dev, void *data);
  63
  64 static void     zfs_bootenv_initial(const char *envname, spa_t *spa,
  65                     const char *name, const char *dsname, int checkpoint);
  66 static void     zfs_checkpoints_initial(spa_t *spa, const char *name,
  67                     const char *dsname);
  68
  69 static int      zfs_parsedev(struct devdesc **idev, const char *devspec,
  70                     const char **path);
  71
  72 struct devsw zfs_dev;
  73
  74 struct fs_ops zfs_fsops = {
  75         .fs_name = "zfs",
  76         .fo_open = zfs_open,
  77         .fo_close = zfs_close,
  78         .fo_read = zfs_read,
  79         .fo_write = null_write,
  80         .fo_seek = zfs_seek,
  81         .fo_stat = zfs_stat,
  82         .fo_readdir = zfs_readdir,
  83         .fo_mount = zfs_mount,
  84         .fo_unmount = zfs_unmount
  85 };
  86
  87 /*
  88  * In-core open file.
  89  */
  90 struct file {
  91         off_t           f_seekp;        /* seek pointer */
  92         dnode_phys_t    f_dnode;
  93         uint64_t        f_zap_type;     /* zap type for readdir */
  94         uint64_t        f_num_leafs;    /* number of fzap leaf blocks */
  95         zap_leaf_phys_t *f_zap_leaf;    /* zap leaf buffer */
  96 };
  97
  98 static int      zfs_env_index;
  99 static int      zfs_env_count;
 100
 101 SLIST_HEAD(zfs_be_list, zfs_be_entry) zfs_be_head = SLIST_HEAD_INITIALIZER(zfs_be_head);
 102 struct zfs_be_list *zfs_be_headp;
 103 struct zfs_be_entry {
 104         char *name;
 105         SLIST_ENTRY(zfs_be_entry) entries;
 106 } *zfs_be, *zfs_be_tmp;
 107
 108 /*
 109  * Open a file.
 110  */
 111 static int
 112 zfs_open(const char *upath, struct open_file *f)
 113 {
 114         struct devdesc *dev = f->f_devdata;
 115         struct zfsmount *mount = dev->d_opendata;
 116         struct file *fp;
 117         int rc;
 118
 119         if (f->f_dev != &zfs_dev)
 120                 return (EINVAL);
 121
 122         /* allocate file system specific data structure */
 123         fp = calloc(1, sizeof(struct file));
 124         if (fp == NULL)
 125                 return (ENOMEM);
 126         f->f_fsdata = fp;
 127
 128         rc = zfs_lookup(mount, upath, &fp->f_dnode);
 129         fp->f_seekp = 0;
 130         if (rc) {
 131                 f->f_fsdata = NULL;
 132                 free(fp);
 133         }
 134         return (rc);
 135 }
 136
 137 static int
 138 zfs_close(struct open_file *f)
 139 {
 140         struct file *fp = (struct file *)f->f_fsdata;
 141
 142         dnode_cache_obj = NULL;
 143         f->f_fsdata = NULL;
 144
 145         free(fp);
 146         return (0);
 147 }
 148
 149 /*
 150  * Copy a portion of a file into kernel memory.
 151  * Cross block boundaries when necessary.
 152  */
 153 static int
 154 zfs_read(struct open_file *f, void *start, size_t size, size_t *resid   /* out */)
 155 {
 156         struct devdesc *dev = f->f_devdata;
 157         const spa_t *spa = ((struct zfsmount *)dev->d_opendata)->spa;
 158         struct file *fp = (struct file *)f->f_fsdata;
 159         struct stat sb;
 160         size_t n;
 161         int rc;
 162
 163         rc = zfs_stat(f, &sb);
 164         if (rc)
 165                 return (rc);
 166         n = size;
 167         if (fp->f_seekp + n > sb.st_size)
 168                 n = sb.st_size - fp->f_seekp;
 169
 170         rc = dnode_read(spa, &fp->f_dnode, fp->f_seekp, start, n);
 171         if (rc)
 172                 return (rc);
 173
 174         if (0) {
 175             int i;
 176             for (i = 0; i < n; i++)
 177                 putchar(((char*) start)[i]);
 178         }
 179         fp->f_seekp += n;
 180         if (resid)
 181                 *resid = size - n;
 182
 183         return (0);
 184 }
 185
 186 static off_t
 187 zfs_seek(struct open_file *f, off_t offset, int where)
 188 {
 189         struct file *fp = (struct file *)f->f_fsdata;
 190
 191         switch (where) {
 192         case SEEK_SET:
 193                 fp->f_seekp = offset;
 194                 break;
 195         case SEEK_CUR:
 196                 fp->f_seekp += offset;
 197                 break;
 198         case SEEK_END:
 199             {
 200                 struct stat sb;
 201                 int error;
 202
 203                 error = zfs_stat(f, &sb);
 204                 if (error != 0) {
 205                         errno = error;
 206                         return (-1);
 207                 }
 208                 fp->f_seekp = sb.st_size - offset;
 209                 break;
 210             }
 211         default:
 212                 errno = EINVAL;
 213                 return (-1);
 214         }
 215         return (fp->f_seekp);
 216 }
 217
 218 static int
 219 zfs_stat(struct open_file *f, struct stat *sb)
 220 {
 221         struct devdesc *dev = f->f_devdata;
 222         const spa_t *spa = ((struct zfsmount *)dev->d_opendata)->spa;
 223         struct file *fp = (struct file *)f->f_fsdata;
 224
 225         return (zfs_dnode_stat(spa, &fp->f_dnode, sb));
 226 }
 227
 228 static int
 229 zfs_readdir(struct open_file *f, struct dirent *d)
 230 {
 231         struct devdesc *dev = f->f_devdata;
 232         const spa_t *spa = ((struct zfsmount *)dev->d_opendata)->spa;
 233         struct file *fp = (struct file *)f->f_fsdata;
 234         mzap_ent_phys_t mze;
 235         struct stat sb;
 236         size_t bsize = fp->f_dnode.dn_datablkszsec << SPA_MINBLOCKSHIFT;
 237         int rc;
 238
 239         rc = zfs_stat(f, &sb);
 240         if (rc)
 241                 return (rc);
 242         if (!S_ISDIR(sb.st_mode))
 243                 return (ENOTDIR);
 244
 245         /*
 246          * If this is the first read, get the zap type.
 247          */
 248         if (fp->f_seekp == 0) {
 249                 rc = dnode_read(spa, &fp->f_dnode,
 250                                 0, &fp->f_zap_type, sizeof(fp->f_zap_type));
 251                 if (rc)
 252                         return (rc);
 253
 254                 if (fp->f_zap_type == ZBT_MICRO) {
 255                         fp->f_seekp = offsetof(mzap_phys_t, mz_chunk);
 256                 } else {
 257                         rc = dnode_read(spa, &fp->f_dnode,
 258                                         offsetof(zap_phys_t, zap_num_leafs),
 259                                         &fp->f_num_leafs,
 260                                         sizeof(fp->f_num_leafs));
 261                         if (rc)
 262                                 return (rc);
 263
 264                         fp->f_seekp = bsize;
 265                         fp->f_zap_leaf = malloc(bsize);
 266                         if (fp->f_zap_leaf == NULL)
 267                                 return (ENOMEM);
 268                         rc = dnode_read(spa, &fp->f_dnode,
 269                                         fp->f_seekp,
 270                                         fp->f_zap_leaf,
 271                                         bsize);
 272                         if (rc)
 273                                 return (rc);
 274                 }
 275         }
 276
 277         if (fp->f_zap_type == ZBT_MICRO) {
 278         mzap_next:
 279                 if (fp->f_seekp >= bsize)
 280                         return (ENOENT);
 281
 282                 rc = dnode_read(spa, &fp->f_dnode,
 283                                 fp->f_seekp, &mze, sizeof(mze));
 284                 if (rc)
 285                         return (rc);
 286                 fp->f_seekp += sizeof(mze);
 287
 288                 if (!mze.mze_name[0])
 289                         goto mzap_next;
 290
 291                 d->d_fileno = ZFS_DIRENT_OBJ(mze.mze_value);
 292                 d->d_type = ZFS_DIRENT_TYPE(mze.mze_value);
 293                 strcpy(d->d_name, mze.mze_name);
 294                 d->d_namlen = strlen(d->d_name);
 295                 return (0);
 296         } else {
 297                 zap_leaf_t zl;
 298                 zap_leaf_chunk_t *zc, *nc;
 299                 int chunk;
 300                 size_t namelen;
 301                 char *p;
 302                 uint64_t value;
 303
 304                 /*
 305                  * Initialise this so we can use the ZAP size
 306                  * calculating macros.
 307                  */
 308                 zl.l_bs = ilog2(bsize);
 309                 zl.l_phys = fp->f_zap_leaf;
 310
 311                 /*
 312                  * Figure out which chunk we are currently looking at
 313                  * and consider seeking to the next leaf. We use the
 314                  * low bits of f_seekp as a simple chunk index.
 315                  */
 316         fzap_next:
 317                 chunk = fp->f_seekp & (bsize - 1);
 318                 if (chunk == ZAP_LEAF_NUMCHUNKS(&zl)) {
 319                         fp->f_seekp = rounddown2(fp->f_seekp, bsize) + bsize;
 320                         chunk = 0;
 321
 322                         /*
 323                          * Check for EOF and read the new leaf.
 324                          */
 325                         if (fp->f_seekp >= bsize * fp->f_num_leafs)
 326                                 return (ENOENT);
 327
 328                         rc = dnode_read(spa, &fp->f_dnode,
 329                                         fp->f_seekp,
 330                                         fp->f_zap_leaf,
 331                                         bsize);
 332                         if (rc)
 333                                 return (rc);
 334                 }
 335
 336                 zc = &ZAP_LEAF_CHUNK(&zl, chunk);
 337                 fp->f_seekp++;
 338                 if (zc->l_entry.le_type != ZAP_CHUNK_ENTRY)
 339                         goto fzap_next;
 340
 341                 namelen = zc->l_entry.le_name_numints;
 342                 if (namelen > sizeof(d->d_name))
 343                         namelen = sizeof(d->d_name);
 344
 345                 /*
 346                  * Paste the name back together.
 347                  */
 348                 nc = &ZAP_LEAF_CHUNK(&zl, zc->l_entry.le_name_chunk);
 349                 p = d->d_name;
 350                 while (namelen > 0) {
 351                         int len;
 352                         len = namelen;
 353                         if (len > ZAP_LEAF_ARRAY_BYTES)
 354                                 len = ZAP_LEAF_ARRAY_BYTES;
 355                         memcpy(p, nc->l_array.la_array, len);
 356                         p += len;
 357                         namelen -= len;
 358                         nc = &ZAP_LEAF_CHUNK(&zl, nc->l_array.la_next);
 359                 }
 360                 d->d_name[sizeof(d->d_name) - 1] = 0;
 361
 362                 /*
 363                  * Assume the first eight bytes of the value are
 364                  * a uint64_t.
 365                  */
 366                 value = fzap_leaf_value(&zl, zc);
 367
 368                 d->d_fileno = ZFS_DIRENT_OBJ(value);
 369                 d->d_type = ZFS_DIRENT_TYPE(value);
 370                 d->d_namlen = strlen(d->d_name);
 371
 372                 return (0);
 373         }
 374 }
 375
 376 static spa_t *
 377 spa_find_by_dev(struct zfs_devdesc *dev)
 378 {
 379
 380         if (dev->dd.d_dev->dv_type != DEVT_ZFS)
 381                 return (NULL);
 382
 383         if (dev->pool_guid == 0)
 384                 return (STAILQ_FIRST(&zfs_pools));
 385
 386         return (spa_find_by_guid(dev->pool_guid));
 387 }
 388
 389 /*
 390  * if path is NULL, create mount structure, but do not add it to list.
 391  */
 392 static int
 393 zfs_mount(const char *dev, const char *path, void **data)
 394 {
 395         struct zfs_devdesc *zfsdev = NULL;
 396         spa_t *spa;
 397         struct zfsmount *mnt = NULL;
 398         int rv;
 399
 400         errno = 0;
 401         rv = zfs_parsedev((struct devdesc **)&zfsdev, dev, NULL);
 402         if (rv != 0) {
 403                 return (rv);
 404         }
 405
 406         spa = spa_find_by_dev(zfsdev);
 407         if (spa == NULL) {
 408                 rv = ENXIO;
 409                 goto err;
 410         }
 411
 412         mnt = calloc(1, sizeof(*mnt));
 413         if (mnt == NULL) {
 414                 rv = ENOMEM;
 415                 goto err;
 416         }
 417
 418         if (mnt->path != NULL) {
 419                 mnt->path = strdup(path);
 420                 if (mnt->path == NULL) {
 421                         rv = ENOMEM;
 422                         goto err;
 423                 }
 424         }
 425
 426         rv = zfs_mount_impl(spa, zfsdev->root_guid, mnt);
 427
 428         if (rv == 0 && mnt->objset.os_type != DMU_OST_ZFS) {
 429                 printf("Unexpected object set type %ju\n",
 430                     (uintmax_t)mnt->objset.os_type);
 431                 rv = EIO;
 432         }
 433 err:
 434         if (rv != 0) {
 435                 if (mnt != NULL)
 436                         free(mnt->path);
 437                 free(mnt);
 438                 free(zfsdev);
 439                 return (rv);
 440         }
 441
 442         *data = mnt;
 443         if (path != NULL)
 444                 STAILQ_INSERT_TAIL(&zfsmount, mnt, next);
 445
 446         free(zfsdev);
 447
 448         return (rv);
 449 }
 450
 451 static int
 452 zfs_unmount(const char *dev, void *data)
 453 {
 454         struct zfsmount *mnt = data;
 455
 456         STAILQ_REMOVE(&zfsmount, mnt, zfsmount, next);
 457         free(mnt->path);
 458         free(mnt);
 459         return (0);
 460 }
 461
 462 static int
 463 vdev_read(vdev_t *vdev, void *priv, off_t offset, void *buf, size_t bytes)
 464 {
 465         int fd, ret;
 466         size_t res, head, tail, total_size, full_sec_size;
 467         unsigned secsz, do_tail_read;
 468         off_t start_sec;
 469         char *outbuf, *bouncebuf;
 470
 471         fd = (uintptr_t) priv;
 472         outbuf = (char *) buf;
 473         bouncebuf = NULL;
 474
 475         ret = ioctl(fd, DIOCGSECTORSIZE, &secsz);
 476         if (ret != 0)
 477                 return (ret);
 478
 479         /*
 480          * Handling reads of arbitrary offset and size - multi-sector case
 481          * and single-sector case.
 482          *
 483          *                        Multi-sector Case
 484          *                (do_tail_read = true if tail > 0)
 485          *
 486          *   |<----------------------total_size--------------------->|
 487          *   |                                                       |
 488          *   |<--head-->|<--------------bytes------------>|<--tail-->|
 489          *   |          |                                 |          |
 490          *   |          |       |<~full_sec_size~>|       |          |
 491          *   +------------------+                 +------------------+
 492          *   |          |0101010|     .  .  .     |0101011|          |
 493          *   +------------------+                 +------------------+
 494          *         start_sec                         start_sec + n
 495          *
 496          *
 497          *                      Single-sector Case
 498          *                    (do_tail_read = false)
 499          *
 500          *              |<------total_size = secsz----->|
 501          *              |                               |
 502          *              |<-head->|<---bytes--->|<-tail->|
 503          *              +-------------------------------+
 504          *              |        |0101010101010|        |
 505          *              +-------------------------------+
 506          *                          start_sec
 507          */
 508         start_sec = offset / secsz;
 509         head = offset % secsz;
 510         total_size = roundup2(head + bytes, secsz);
 511         tail = total_size - (head + bytes);
 512         do_tail_read = ((tail > 0) && (head + bytes > secsz));
 513         full_sec_size = total_size;
 514         if (head > 0)
 515                 full_sec_size -= secsz;
 516         if (do_tail_read)
 517                 full_sec_size -= secsz;
 518
 519         /* Return of partial sector data requires a bounce buffer. */
 520         if ((head > 0) || do_tail_read || bytes < secsz) {
 521                 bouncebuf = malloc(secsz);
 522                 if (bouncebuf == NULL) {
 523                         printf("vdev_read: out of memory\n");
 524                         return (ENOMEM);
 525                 }
 526         }
 527
 528         if (lseek(fd, start_sec * secsz, SEEK_SET) == -1) {
 529                 ret = errno;
 530                 goto error;
 531         }
 532
 533         /* Partial data return from first sector */
 534         if (head > 0) {
 535                 res = read(fd, bouncebuf, secsz);
 536                 if (res != secsz) {
 537                         ret = EIO;
 538                         goto error;
 539                 }
 540                 memcpy(outbuf, bouncebuf + head, min(secsz - head, bytes));
 541                 outbuf += min(secsz - head, bytes);
 542         }
 543
 544         /*
 545          * Full data return from read sectors.
 546          * Note, there is still corner case where we read
 547          * from sector boundary, but less than sector size, e.g. reading 512B
 548          * from 4k sector.
 549          */
 550         if (full_sec_size > 0) {
 551                 if (bytes < full_sec_size) {
 552                         res = read(fd, bouncebuf, secsz);
 553                         if (res != secsz) {
 554                                 ret = EIO;
 555                                 goto error;
 556                         }
 557                         memcpy(outbuf, bouncebuf, bytes);
 558                 } else {
 559                         res = read(fd, outbuf, full_sec_size);
 560                         if (res != full_sec_size) {
 561                                 ret = EIO;
 562                                 goto error;
 563                         }
 564                         outbuf += full_sec_size;
 565                 }
 566         }
 567
 568         /* Partial data return from last sector */
 569         if (do_tail_read) {
 570                 res = read(fd, bouncebuf, secsz);
 571                 if (res != secsz) {
 572                         ret = EIO;
 573                         goto error;
 574                 }
 575                 memcpy(outbuf, bouncebuf, secsz - tail);
 576         }
 577
 578         ret = 0;
 579 error:
 580         free(bouncebuf);
 581         return (ret);
 582 }
 583
 584 static int
 585 vdev_write(vdev_t *vdev, off_t offset, void *buf, size_t bytes)
 586 {
 587         int fd, ret;
 588         size_t head, tail, total_size, full_sec_size;
 589         unsigned secsz, do_tail_write;
 590         off_t start_sec;
 591         ssize_t res;
 592         char *outbuf, *bouncebuf;
 593
 594         fd = (uintptr_t)vdev->v_priv;
 595         outbuf = (char *)buf;
 596         bouncebuf = NULL;
 597
 598         ret = ioctl(fd, DIOCGSECTORSIZE, &secsz);
 599         if (ret != 0)
 600                 return (ret);
 601
 602         start_sec = offset / secsz;
 603         head = offset % secsz;
 604         total_size = roundup2(head + bytes, secsz);
 605         tail = total_size - (head + bytes);
 606         do_tail_write = ((tail > 0) && (head + bytes > secsz));
 607         full_sec_size = total_size;
 608         if (head > 0)
 609                 full_sec_size -= secsz;
 610         if (do_tail_write)
 611                 full_sec_size -= secsz;
 612
 613         /* Partial sector write requires a bounce buffer. */
 614         if ((head > 0) || do_tail_write || bytes < secsz) {
 615                 bouncebuf = malloc(secsz);
 616                 if (bouncebuf == NULL) {
 617                         printf("vdev_write: out of memory\n");
 618                         return (ENOMEM);
 619                 }
 620         }
 621
 622         if (lseek(fd, start_sec * secsz, SEEK_SET) == -1) {
 623                 ret = errno;
 624                 goto error;
 625         }
 626
 627         /* Partial data for first sector */
 628         if (head > 0) {
 629                 res = read(fd, bouncebuf, secsz);
 630                 if ((unsigned)res != secsz) {
 631                         ret = EIO;
 632                         goto error;
 633                 }
 634                 memcpy(bouncebuf + head, outbuf, min(secsz - head, bytes));
 635                 (void) lseek(fd, -secsz, SEEK_CUR);
 636                 res = write(fd, bouncebuf, secsz);
 637                 if ((unsigned)res != secsz) {
 638                         ret = EIO;
 639                         goto error;
 640                 }
 641                 outbuf += min(secsz - head, bytes);
 642         }
 643
 644         /*
 645          * Full data write to sectors.
 646          * Note, there is still corner case where we write
 647          * to sector boundary, but less than sector size, e.g. write 512B
 648          * to 4k sector.
 649          */
 650         if (full_sec_size > 0) {
 651                 if (bytes < full_sec_size) {
 652                         res = read(fd, bouncebuf, secsz);
 653                         if ((unsigned)res != secsz) {
 654                                 ret = EIO;
 655                                 goto error;
 656                         }
 657                         memcpy(bouncebuf, outbuf, bytes);
 658                         (void) lseek(fd, -secsz, SEEK_CUR);
 659                         res = write(fd, bouncebuf, secsz);
 660                         if ((unsigned)res != secsz) {
 661                                 ret = EIO;
 662                                 goto error;
 663                         }
 664                 } else {
 665                         res = write(fd, outbuf, full_sec_size);
 666                         if ((unsigned)res != full_sec_size) {
 667                                 ret = EIO;
 668                                 goto error;
 669                         }
 670                         outbuf += full_sec_size;
 671                 }
 672         }
 673
 674         /* Partial data write to last sector */
 675         if (do_tail_write) {
 676                 res = read(fd, bouncebuf, secsz);
 677                 if ((unsigned)res != secsz) {
 678                         ret = EIO;
 679                         goto error;
 680                 }
 681                 memcpy(bouncebuf, outbuf, secsz - tail);
 682                 (void) lseek(fd, -secsz, SEEK_CUR);
 683                 res = write(fd, bouncebuf, secsz);
 684                 if ((unsigned)res != secsz) {
 685                         ret = EIO;
 686                         goto error;
 687                 }
 688         }
 689
 690         ret = 0;
 691 error:
 692         free(bouncebuf);
 693         return (ret);
 694 }
 695
 696 static int
 697 zfs_dev_init(void)
 698 {
 699         spa_t *spa;
 700         spa_t *next;
 701         spa_t *prev;
 702
 703         zfs_init();
 704         if (archsw.arch_zfs_probe == NULL)
 705                 return (ENXIO);
 706         archsw.arch_zfs_probe();
 707
 708         prev = NULL;
 709         spa = STAILQ_FIRST(&zfs_pools);
 710         while (spa != NULL) {
 711                 next = STAILQ_NEXT(spa, spa_link);
 712                 if (zfs_spa_init(spa)) {
 713                         if (prev == NULL)
 714                                 STAILQ_REMOVE_HEAD(&zfs_pools, spa_link);
 715                         else
 716                                 STAILQ_REMOVE_AFTER(&zfs_pools, prev, spa_link);
 717                 } else
 718                         prev = spa;
 719                 spa = next;
 720         }
 721         return (0);
 722 }
 723
 724 struct zfs_probe_args {
 725         int             fd;
 726         const char      *devname;
 727         uint64_t        *pool_guid;
 728         u_int           secsz;
 729 };
 730
 731 static int
 732 zfs_diskread(void *arg, void *buf, size_t blocks, uint64_t offset)
 733 {
 734         struct zfs_probe_args *ppa;
 735
 736         ppa = (struct zfs_probe_args *)arg;
 737         return (vdev_read(NULL, (void *)(uintptr_t)ppa->fd,
 738             offset * ppa->secsz, buf, blocks * ppa->secsz));
 739 }
 740
 741 static int
 742 zfs_probe(int fd, uint64_t *pool_guid)
 743 {
 744         spa_t *spa;
 745         int ret;
 746
 747         spa = NULL;
 748         ret = vdev_probe(vdev_read, vdev_write, (void *)(uintptr_t)fd, &spa);
 749         if (ret == 0 && pool_guid != NULL)
 750                 if (*pool_guid == 0)
 751                         *pool_guid = spa->spa_guid;
 752         return (ret);
 753 }
 754
 755 static int
 756 zfs_probe_partition(void *arg, const char *partname,
 757     const struct ptable_entry *part)
 758 {
 759         struct zfs_probe_args *ppa, pa;
 760         struct ptable *table;
 761         char devname[32];
 762         int ret;
 763
 764         /* Probe only freebsd-zfs and freebsd partitions */
 765         if (part->type != PART_FREEBSD &&
 766             part->type != PART_FREEBSD_ZFS)
 767                 return (0);
 768
 769         ppa = (struct zfs_probe_args *)arg;
 770         strncpy(devname, ppa->devname, strlen(ppa->devname) - 1);
 771         devname[strlen(ppa->devname) - 1] = '\0';
 772         snprintf(devname, sizeof(devname), "%s%s:", devname, partname);
 773         pa.fd = open(devname, O_RDWR);
 774         if (pa.fd == -1)
 775                 return (0);
 776         ret = zfs_probe(pa.fd, ppa->pool_guid);
 777         if (ret == 0)
 778                 return (0);
 779         /* Do we have BSD label here? */
 780         if (part->type == PART_FREEBSD) {
 781                 pa.devname = devname;
 782                 pa.pool_guid = ppa->pool_guid;
 783                 pa.secsz = ppa->secsz;
 784                 table = ptable_open(&pa, part->end - part->start + 1,
 785                     ppa->secsz, zfs_diskread);
 786                 if (table != NULL) {
 787                         ptable_iterate(table, &pa, zfs_probe_partition);
 788                         ptable_close(table);
 789                 }
 790         }
 791         close(pa.fd);
 792         return (0);
 793 }
 794
 795 /*
 796  * Return bootenv nvlist from pool label.
 797  */
 798 int
 799 zfs_get_bootenv(void *vdev, nvlist_t **benvp)
 800 {
 801         spa_t *spa;
 802
 803         if ((spa = spa_find_by_dev((struct zfs_devdesc *)vdev)) == NULL)
 804                 return (ENXIO);
 805
 806         return (zfs_get_bootenv_spa(spa, benvp));
 807 }
 808
 809 /*
 810  * Store nvlist to pool label bootenv area. Also updates cached pointer in spa.
 811  */
 812 int
 813 zfs_set_bootenv(void *vdev, nvlist_t *benv)
 814 {
 815         spa_t *spa;
 816
 817         if ((spa = spa_find_by_dev((struct zfs_devdesc *)vdev)) == NULL)
 818                 return (ENXIO);
 819
 820         return (zfs_set_bootenv_spa(spa, benv));
 821 }
 822
 823 /*
 824  * Get bootonce value by key. The bootonce <key, value> pair is removed
 825  * from the bootenv nvlist and the remaining nvlist is committed back to disk.
 826  */
 827 int
 828 zfs_get_bootonce(void *vdev, const char *key, char *buf, size_t size)
 829 {
 830         nvlist_t *benv;
 831         char *result = NULL;
 832         int result_size, rv;
 833
 834         if ((rv = zfs_get_bootenv(vdev, &benv)) != 0)
 835                 return (rv);
 836
 837         if ((rv = nvlist_find(benv, key, DATA_TYPE_STRING, NULL,
 838             &result, &result_size)) == 0) {
 839                 if (result_size == 0) {
 840                         /* ignore empty string */
 841                         rv = ENOENT;
 842                 } else {
 843                         size = MIN((size_t)result_size + 1, size);
 844                         strlcpy(buf, result, size);
 845                 }
 846                 (void) nvlist_remove(benv, key, DATA_TYPE_STRING);
 847                 (void) zfs_set_bootenv(vdev, benv);
 848         }
 849
 850         return (rv);
 851 }
 852
 853 /*
 854  * nvstore backend.
 855  */
 856
 857 static int zfs_nvstore_setter(void *, int, const char *,
 858     const void *, size_t);
 859 static int zfs_nvstore_setter_str(void *, const char *, const char *,
 860     const char *);
 861 static int zfs_nvstore_unset_impl(void *, const char *, bool);
 862 static int zfs_nvstore_setenv(void *, void *);
 863
 864 /*
 865  * nvstore is only present for current rootfs pool.
 866  */
 867 static int
 868 zfs_nvstore_sethook(struct env_var *ev, int flags __unused, const void *value)
 869 {
 870         struct zfs_devdesc *dev;
 871         int rv;
 872
 873         archsw.arch_getdev((void **)&dev, NULL, NULL);
 874         if (dev == NULL)
 875                 return (ENXIO);
 876
 877         rv = zfs_nvstore_setter_str(dev, NULL, ev->ev_name, value);
 878
 879         free(dev);
 880         return (rv);
 881 }
 882
 883 /*
 884  * nvstore is only present for current rootfs pool.
 885  */
 886 static int
 887 zfs_nvstore_unsethook(struct env_var *ev)
 888 {
 889         struct zfs_devdesc *dev;
 890         int rv;
 891
 892         archsw.arch_getdev((void **)&dev, NULL, NULL);
 893         if (dev == NULL)
 894                 return (ENXIO);
 895
 896         rv = zfs_nvstore_unset_impl(dev, ev->ev_name, false);
 897
 898         free(dev);
 899         return (rv);
 900 }
 901
 902 static int
 903 zfs_nvstore_getter(void *vdev, const char *name, void **data)
 904 {
 905         struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
 906         spa_t *spa;
 907         nvlist_t *nv;
 908         char *str, **ptr;
 909         int size;
 910         int rv;
 911
 912         if (dev->dd.d_dev->dv_type != DEVT_ZFS)
 913                 return (ENOTSUP);
 914
 915         if ((spa = spa_find_by_dev(dev)) == NULL)
 916                 return (ENXIO);
 917
 918         if (spa->spa_bootenv == NULL)
 919                 return (ENXIO);
 920
 921         if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
 922             NULL, &nv, NULL) != 0)
 923                 return (ENOENT);
 924
 925         rv = nvlist_find(nv, name, DATA_TYPE_STRING, NULL, &str, &size);
 926         if (rv == 0) {
 927                 ptr = (char **)data;
 928                 asprintf(ptr, "%.*s", size, str);
 929                 if (*data == NULL)
 930                         rv = ENOMEM;
 931         }
 932         nvlist_destroy(nv);
 933         return (rv);
 934 }
 935
 936 static int
 937 zfs_nvstore_setter(void *vdev, int type, const char *name,
 938     const void *data, size_t size)
 939 {
 940         struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
 941         spa_t *spa;
 942         nvlist_t *nv;
 943         int rv;
 944         bool env_set = true;
 945
 946         if (dev->dd.d_dev->dv_type != DEVT_ZFS)
 947                 return (ENOTSUP);
 948
 949         if ((spa = spa_find_by_dev(dev)) == NULL)
 950                 return (ENXIO);
 951
 952         if (spa->spa_bootenv == NULL)
 953                 return (ENXIO);
 954
 955         if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
 956             NULL, &nv, NULL) != 0) {
 957                 nv = nvlist_create(NV_UNIQUE_NAME);
 958                 if (nv == NULL)
 959                         return (ENOMEM);
 960         }
 961
 962         rv = 0;
 963         switch (type) {
 964         case DATA_TYPE_INT8:
 965                 if (size != sizeof (int8_t)) {
 966                         rv = EINVAL;
 967                         break;
 968                 }
 969                 rv = nvlist_add_int8(nv, name, *(int8_t *)data);
 970                 break;
 971
 972         case DATA_TYPE_INT16:
 973                 if (size != sizeof (int16_t)) {
 974                         rv = EINVAL;
 975                         break;
 976                 }
 977                 rv = nvlist_add_int16(nv, name, *(int16_t *)data);
 978                 break;
 979
 980         case DATA_TYPE_INT32:
 981                 if (size != sizeof (int32_t)) {
 982                         rv = EINVAL;
 983                         break;
 984                 }
 985                 rv = nvlist_add_int32(nv, name, *(int32_t *)data);
 986                 break;
 987
 988         case DATA_TYPE_INT64:
 989                 if (size != sizeof (int64_t)) {
 990                         rv = EINVAL;
 991                         break;
 992                 }
 993                 rv = nvlist_add_int64(nv, name, *(int64_t *)data);
 994                 break;
 995
 996         case DATA_TYPE_BYTE:
 997                 if (size != sizeof (uint8_t)) {
 998                         rv = EINVAL;
 999                         break;
1000                 }
1001                 rv = nvlist_add_byte(nv, name, *(int8_t *)data);
1002                 break;
1003
1004         case DATA_TYPE_UINT8:
1005                 if (size != sizeof (uint8_t)) {
1006                         rv = EINVAL;
1007                         break;
1008                 }
1009                 rv = nvlist_add_uint8(nv, name, *(int8_t *)data);
1010                 break;
1011
1012         case DATA_TYPE_UINT16:
1013                 if (size != sizeof (uint16_t)) {
1014                         rv = EINVAL;
1015                         break;
1016                 }
1017                 rv = nvlist_add_uint16(nv, name, *(uint16_t *)data);
1018                 break;
1019
1020         case DATA_TYPE_UINT32:
1021                 if (size != sizeof (uint32_t)) {
1022                         rv = EINVAL;
1023                         break;
1024                 }
1025                 rv = nvlist_add_uint32(nv, name, *(uint32_t *)data);
1026                 break;
1027
1028         case DATA_TYPE_UINT64:
1029                 if (size != sizeof (uint64_t)) {
1030                         rv = EINVAL;
1031                         break;
1032                 }
1033                 rv = nvlist_add_uint64(nv, name, *(uint64_t *)data);
1034                 break;
1035
1036         case DATA_TYPE_STRING:
1037                 rv = nvlist_add_string(nv, name, data);
1038                 break;
1039
1040         case DATA_TYPE_BOOLEAN_VALUE:
1041                 if (size != sizeof (boolean_t)) {
1042                         rv = EINVAL;
1043                         break;
1044                 }
1045                 rv = nvlist_add_boolean_value(nv, name, *(boolean_t *)data);
1046                 break;
1047
1048         default:
1049                 rv = EINVAL;
1050                 break;
1051         }
1052
1053         if (rv == 0) {
1054                 rv = nvlist_add_nvlist(spa->spa_bootenv, OS_NVSTORE, nv);
1055                 if (rv == 0) {
1056                         rv = zfs_set_bootenv(vdev, spa->spa_bootenv);
1057                 }
1058                 if (rv == 0) {
1059                         if (env_set) {
1060                                 rv = zfs_nvstore_setenv(vdev,
1061                                     nvpair_find(nv, name));
1062                         } else {
1063                                 env_discard(env_getenv(name));
1064                                 rv = 0;
1065                         }
1066                 }
1067         }
1068
1069         nvlist_destroy(nv);
1070         return (rv);
1071 }
1072
1073 static int
1074 get_int64(const char *data, int64_t *ip)
1075 {
1076         char *end;
1077         int64_t val;
1078
1079         errno = 0;
1080         val = strtoll(data, &end, 0);
1081         if (errno != 0 || *data == '\0' || *end != '\0')
1082                 return (EINVAL);
1083
1084         *ip = val;
1085         return (0);
1086 }
1087
1088 static int
1089 get_uint64(const char *data, uint64_t *ip)
1090 {
1091         char *end;
1092         uint64_t val;
1093
1094         errno = 0;
1095         val = strtoull(data, &end, 0);
1096         if (errno != 0 || *data == '\0' || *end != '\0')
1097                 return (EINVAL);
1098
1099         *ip = val;
1100         return (0);
1101 }
1102
1103 /*
1104  * Translate textual data to data type. If type is not set, and we are
1105  * creating new pair, use DATA_TYPE_STRING.
1106  */
1107 static int
1108 zfs_nvstore_setter_str(void *vdev, const char *type, const char *name,
1109     const char *data)
1110 {
1111         struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
1112         spa_t *spa;
1113         nvlist_t *nv;
1114         int rv;
1115         data_type_t dt;
1116         int64_t val;
1117         uint64_t uval;
1118
1119         if (dev->dd.d_dev->dv_type != DEVT_ZFS)
1120                 return (ENOTSUP);
1121
1122         if ((spa = spa_find_by_dev(dev)) == NULL)
1123                 return (ENXIO);
1124
1125         if (spa->spa_bootenv == NULL)
1126                 return (ENXIO);
1127
1128         if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
1129             NULL, &nv, NULL) != 0) {
1130                 nv = NULL;
1131         }
1132
1133         if (type == NULL) {
1134                 nvp_header_t *nvh;
1135
1136                 /*
1137                  * if there is no existing pair, default to string.
1138                  * Otherwise, use type from existing pair.
1139                  */
1140                 nvh = nvpair_find(nv, name);
1141                 if (nvh == NULL) {
1142                         dt = DATA_TYPE_STRING;
1143                 } else {
1144                         nv_string_t *nvp_name;
1145                         nv_pair_data_t *nvp_data;
1146
1147                         nvp_name = (nv_string_t *)(nvh + 1);
1148                         nvp_data = (nv_pair_data_t *)(&nvp_name->nv_data[0] +
1149                             NV_ALIGN4(nvp_name->nv_size));
1150                         dt = nvp_data->nv_type;
1151                 }
1152         } else {
1153                 dt = nvpair_type_from_name(type);
1154         }
1155         nvlist_destroy(nv);
1156
1157         rv = 0;
1158         switch (dt) {
1159         case DATA_TYPE_INT8:
1160                 rv = get_int64(data, &val);
1161                 if (rv == 0) {
1162                         int8_t v = val;
1163
1164                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1165                 }
1166                 break;
1167         case DATA_TYPE_INT16:
1168                 rv = get_int64(data, &val);
1169                 if (rv == 0) {
1170                         int16_t v = val;
1171
1172                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1173                 }
1174                 break;
1175         case DATA_TYPE_INT32:
1176                 rv = get_int64(data, &val);
1177                 if (rv == 0) {
1178                         int32_t v = val;
1179
1180                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1181                 }
1182                 break;
1183         case DATA_TYPE_INT64:
1184                 rv = get_int64(data, &val);
1185                 if (rv == 0) {
1186                         rv = zfs_nvstore_setter(vdev, dt, name, &val,
1187                             sizeof (val));
1188                 }
1189                 break;
1190
1191         case DATA_TYPE_BYTE:
1192                 rv = get_uint64(data, &uval);
1193                 if (rv == 0) {
1194                         uint8_t v = uval;
1195
1196                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1197                 }
1198                 break;
1199
1200         case DATA_TYPE_UINT8:
1201                 rv = get_uint64(data, &uval);
1202                 if (rv == 0) {
1203                         uint8_t v = uval;
1204
1205                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1206                 }
1207                 break;
1208
1209         case DATA_TYPE_UINT16:
1210                 rv = get_uint64(data, &uval);
1211                 if (rv == 0) {
1212                         uint16_t v = uval;
1213
1214                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1215                 }
1216                 break;
1217
1218         case DATA_TYPE_UINT32:
1219                 rv = get_uint64(data, &uval);
1220                 if (rv == 0) {
1221                         uint32_t v = uval;
1222
1223                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1224                 }
1225                 break;
1226
1227         case DATA_TYPE_UINT64:
1228                 rv = get_uint64(data, &uval);
1229                 if (rv == 0) {
1230                         rv = zfs_nvstore_setter(vdev, dt, name, &uval,
1231                             sizeof (uval));
1232                 }
1233                 break;
1234
1235         case DATA_TYPE_STRING:
1236                 rv = zfs_nvstore_setter(vdev, dt, name, data, strlen(data) + 1);
1237                 break;
1238
1239         case DATA_TYPE_BOOLEAN_VALUE:
1240                 rv = get_int64(data, &val);
1241                 if (rv == 0) {
1242                         boolean_t v = val;
1243
1244                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1245                 }
1246
1247         default:
1248                 rv = EINVAL;
1249         }
1250         return (rv);
1251 }
1252
1253 static int
1254 zfs_nvstore_unset_impl(void *vdev, const char *name, bool unset_env)
1255 {
1256         struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
1257         spa_t *spa;
1258         nvlist_t *nv;
1259         int rv;
1260
1261         if (dev->dd.d_dev->dv_type != DEVT_ZFS)
1262                 return (ENOTSUP);
1263
1264         if ((spa = spa_find_by_dev(dev)) == NULL)
1265                 return (ENXIO);
1266
1267         if (spa->spa_bootenv == NULL)
1268                 return (ENXIO);
1269
1270         if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
1271             NULL, &nv, NULL) != 0)
1272                 return (ENOENT);
1273
1274         rv = nvlist_remove(nv, name, DATA_TYPE_UNKNOWN);
1275         if (rv == 0) {
1276                 if (nvlist_next_nvpair(nv, NULL) == NULL) {
1277                         rv = nvlist_remove(spa->spa_bootenv, OS_NVSTORE,
1278                             DATA_TYPE_NVLIST);
1279                 } else {
1280                         rv = nvlist_add_nvlist(spa->spa_bootenv,
1281                             OS_NVSTORE, nv);
1282                 }
1283                 if (rv == 0)
1284                         rv = zfs_set_bootenv(vdev, spa->spa_bootenv);
1285         }
1286
1287         if (unset_env)
1288                 env_discard(env_getenv(name));
1289         return (rv);
1290 }
1291
1292 static int
1293 zfs_nvstore_unset(void *vdev, const char *name)
1294 {
1295         return (zfs_nvstore_unset_impl(vdev, name, true));
1296 }
1297
1298 static int
1299 zfs_nvstore_print(void *vdev __unused, void *ptr)
1300 {
1301
1302         nvpair_print(ptr, 0);
1303         return (0);
1304 }
1305
1306 /*
1307  * Create environment variable from nvpair.
1308  * set hook will update nvstore with new value, unset hook will remove
1309  * variable from nvstore.
1310  */
1311 static int
1312 zfs_nvstore_setenv(void *vdev __unused, void *ptr)
1313 {
1314         nvp_header_t *nvh = ptr;
1315         nv_string_t *nvp_name, *nvp_value;
1316         nv_pair_data_t *nvp_data;
1317         char *name, *value;
1318         int rv = 0;
1319
1320         if (nvh == NULL)
1321                 return (ENOENT);
1322
1323         nvp_name = (nv_string_t *)(nvh + 1);
1324         nvp_data = (nv_pair_data_t *)(&nvp_name->nv_data[0] +
1325             NV_ALIGN4(nvp_name->nv_size));
1326
1327         if ((name = nvstring_get(nvp_name)) == NULL)
1328                 return (ENOMEM);
1329
1330         value = NULL;
1331         switch (nvp_data->nv_type) {
1332         case DATA_TYPE_BYTE:
1333         case DATA_TYPE_UINT8:
1334                 (void) asprintf(&value, "%uc",
1335                     *(unsigned *)&nvp_data->nv_data[0]);
1336                 if (value == NULL)
1337                         rv = ENOMEM;
1338                 break;
1339
1340         case DATA_TYPE_INT8:
1341                 (void) asprintf(&value, "%c", *(int *)&nvp_data->nv_data[0]);
1342                 if (value == NULL)
1343                         rv = ENOMEM;
1344                 break;
1345
1346         case DATA_TYPE_INT16:
1347                 (void) asprintf(&value, "%hd", *(short *)&nvp_data->nv_data[0]);
1348                 if (value == NULL)
1349                         rv = ENOMEM;
1350                 break;
1351
1352         case DATA_TYPE_UINT16:
1353                 (void) asprintf(&value, "%hu",
1354                     *(unsigned short *)&nvp_data->nv_data[0]);
1355                 if (value == NULL)
1356                         rv = ENOMEM;
1357                 break;
1358
1359         case DATA_TYPE_BOOLEAN_VALUE:
1360         case DATA_TYPE_INT32:
1361                 (void) asprintf(&value, "%d", *(int *)&nvp_data->nv_data[0]);
1362                 if (value == NULL)
1363                         rv = ENOMEM;
1364                 break;
1365
1366         case DATA_TYPE_UINT32:
1367                 (void) asprintf(&value, "%u",
1368                     *(unsigned *)&nvp_data->nv_data[0]);
1369                 if (value == NULL)
1370                         rv = ENOMEM;
1371                 break;
1372
1373         case DATA_TYPE_INT64:
1374                 (void) asprintf(&value, "%jd",
1375                     (intmax_t)*(int64_t *)&nvp_data->nv_data[0]);
1376                 if (value == NULL)
1377                         rv = ENOMEM;
1378                 break;
1379
1380         case DATA_TYPE_UINT64:
1381                 (void) asprintf(&value, "%ju",
1382                     (uintmax_t)*(uint64_t *)&nvp_data->nv_data[0]);
1383                 if (value == NULL)
1384                         rv = ENOMEM;
1385                 break;
1386
1387         case DATA_TYPE_STRING:
1388                 nvp_value = (nv_string_t *)&nvp_data->nv_data[0];
1389                 if ((value = nvstring_get(nvp_value)) == NULL) {
1390                         rv = ENOMEM;
1391                         break;
1392                 }
1393                 break;
1394
1395         default:
1396                 rv = EINVAL;
1397                 break;
1398         }
1399
1400         if (value != NULL) {
1401                 rv = env_setenv(name, EV_VOLATILE | EV_NOHOOK, value,
1402                     zfs_nvstore_sethook, zfs_nvstore_unsethook);
1403                 free(value);
1404         }
1405         free(name);
1406         return (rv);
1407 }
1408
1409 static int
1410 zfs_nvstore_iterate(void *vdev, int (*cb)(void *, void *))
1411 {
1412         struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
1413         spa_t *spa;
1414         nvlist_t *nv;
1415         nvp_header_t *nvh;
1416         int rv;
1417
1418         if (dev->dd.d_dev->dv_type != DEVT_ZFS)
1419                 return (ENOTSUP);
1420
1421         if ((spa = spa_find_by_dev(dev)) == NULL)
1422                 return (ENXIO);
1423
1424         if (spa->spa_bootenv == NULL)
1425                 return (ENXIO);
1426
1427         if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
1428             NULL, &nv, NULL) != 0)
1429                 return (ENOENT);
1430
1431         rv = 0;
1432         nvh = NULL;
1433         while ((nvh = nvlist_next_nvpair(nv, nvh)) != NULL) {
1434                 rv = cb(vdev, nvh);
1435                 if (rv != 0)
1436                         break;
1437         }
1438         return (rv);
1439 }
1440
1441 nvs_callbacks_t nvstore_zfs_cb = {
1442         .nvs_getter = zfs_nvstore_getter,
1443         .nvs_setter = zfs_nvstore_setter,
1444         .nvs_setter_str = zfs_nvstore_setter_str,
1445         .nvs_unset = zfs_nvstore_unset,
1446         .nvs_print = zfs_nvstore_print,
1447         .nvs_iterate = zfs_nvstore_iterate
1448 };
1449
1450 int
1451 zfs_attach_nvstore(void *vdev)
1452 {
1453         struct zfs_devdesc *dev = vdev;
1454         spa_t *spa;
1455         uint64_t version;
1456         int rv;
1457
1458         if (dev->dd.d_dev->dv_type != DEVT_ZFS)
1459                 return (ENOTSUP);
1460
1461         if ((spa = spa_find_by_dev(dev)) == NULL)
1462                 return (ENXIO);
1463
1464         rv = nvlist_find(spa->spa_bootenv, BOOTENV_VERSION, DATA_TYPE_UINT64,
1465             NULL, &version, NULL);
1466
1467         if (rv != 0 || version != VB_NVLIST) {
1468                 return (ENXIO);
1469         }
1470
1471         dev = malloc(sizeof (*dev));
1472         if (dev == NULL)
1473                 return (ENOMEM);
1474         memcpy(dev, vdev, sizeof (*dev));
1475
1476         rv = nvstore_init(spa->spa_name, &nvstore_zfs_cb, dev);
1477         if (rv != 0)
1478                 free(dev);
1479         else
1480                 rv = zfs_nvstore_iterate(dev, zfs_nvstore_setenv);
1481         return (rv);
1482 }
1483
1484 int
1485 zfs_probe_dev(const char *devname, uint64_t *pool_guid, bool parts_too)
1486 {
1487         struct ptable *table;
1488         struct zfs_probe_args pa;
1489         uint64_t mediasz;
1490         int ret;
1491
1492         if (pool_guid)
1493                 *pool_guid = 0;
1494         pa.fd = open(devname, O_RDWR);
1495         if (pa.fd == -1)
1496                 return (ENXIO);
1497         /* Probe the whole disk */
1498         ret = zfs_probe(pa.fd, pool_guid);
1499         if (ret == 0)
1500                 return (0);
1501         if (!parts_too)
1502                 return (ENXIO);
1503
1504         /* Probe each partition */
1505         ret = ioctl(pa.fd, DIOCGMEDIASIZE, &mediasz);
1506         if (ret == 0)
1507                 ret = ioctl(pa.fd, DIOCGSECTORSIZE, &pa.secsz);
1508         if (ret == 0) {
1509                 pa.devname = devname;
1510                 pa.pool_guid = pool_guid;
1511                 table = ptable_open(&pa, mediasz / pa.secsz, pa.secsz,
1512                     zfs_diskread);
1513                 if (table != NULL) {
1514                         ptable_iterate(table, &pa, zfs_probe_partition);
1515                         ptable_close(table);
1516                 }
1517         }
1518         close(pa.fd);
1519         if (pool_guid && *pool_guid == 0)
1520                 ret = ENXIO;
1521         return (ret);
1522 }
1523
1524 /*
1525  * Print information about ZFS pools
1526  */
1527 static int
1528 zfs_dev_print(int verbose)
1529 {
1530         spa_t *spa;
1531         char line[80];
1532         int ret = 0;
1533
1534         if (STAILQ_EMPTY(&zfs_pools))
1535                 return (0);
1536
1537         printf("%s devices:", zfs_dev.dv_name);
1538         if ((ret = pager_output("\n")) != 0)
1539                 return (ret);
1540
1541         if (verbose) {
1542                 return (spa_all_status());
1543         }
1544         STAILQ_FOREACH(spa, &zfs_pools, spa_link) {
1545                 snprintf(line, sizeof(line), "    zfs:%s\n", spa->spa_name);
1546                 ret = pager_output(line);
1547                 if (ret != 0)
1548                         break;
1549         }
1550         return (ret);
1551 }
1552
1553 /*
1554  * Attempt to open the pool described by (dev) for use by (f).
1555  */
1556 static int
1557 zfs_dev_open(struct open_file *f, ...)
1558 {
1559         va_list         args;
1560         struct zfs_devdesc      *dev;
1561         struct zfsmount *mount;
1562         spa_t           *spa;
1563         int             rv;
1564
1565         va_start(args, f);
1566         dev = va_arg(args, struct zfs_devdesc *);
1567         va_end(args);
1568
1569         if ((spa = spa_find_by_dev(dev)) == NULL)
1570                 return (ENXIO);
1571
1572         STAILQ_FOREACH(mount, &zfsmount, next) {
1573                 if (spa->spa_guid == mount->spa->spa_guid)
1574                         break;
1575         }
1576
1577         rv = 0;
1578         /* This device is not set as currdev, mount us private copy. */
1579         if (mount == NULL)
1580                 rv = zfs_mount(devformat(&dev->dd), NULL, (void **)&mount);
1581
1582         if (rv == 0) {
1583                 dev->dd.d_opendata = mount;
1584         }
1585         return (rv);
1586 }
1587
1588 static int
1589 zfs_dev_close(struct open_file *f)
1590 {
1591         struct devdesc *dev;
1592         struct zfsmount *mnt, *mount;
1593
1594         dev = f->f_devdata;
1595         mnt = dev->d_opendata;
1596
1597         STAILQ_FOREACH(mount, &zfsmount, next) {
1598                 if (mnt->spa->spa_guid == mount->spa->spa_guid)
1599                         break;
1600         }
1601
1602         /* XXX */
1603         return (0);
1604 }
1605
1606 static int
1607 zfs_dev_strategy(void *devdata, int rw, daddr_t dblk, size_t size, char *buf, size_t *rsize)
1608 {
1609
1610         return (ENOSYS);
1611 }
1612
1613 struct devsw zfs_dev = {
1614         .dv_name = "zfs",
1615         .dv_type = DEVT_ZFS,
1616         .dv_init = zfs_dev_init,
1617         .dv_strategy = zfs_dev_strategy,
1618         .dv_open = zfs_dev_open,
1619         .dv_close = zfs_dev_close,
1620         .dv_ioctl = noioctl,
1621         .dv_print = zfs_dev_print,
1622         .dv_cleanup = nullsys,
1623         .dv_fmtdev = zfs_fmtdev,
1624         .dv_parsedev = zfs_parsedev,
1625 };
1626
1627 static int
1628 zfs_parsedev(struct devdesc **idev, const char *devspec, const char **path)
1629 {
1630         static char     rootname[ZFS_MAXNAMELEN];
1631         static char     poolname[ZFS_MAXNAMELEN];
1632         spa_t           *spa;
1633         const char      *end;
1634         const char      *np;
1635         const char      *sep;
1636         int             rv;
1637         struct zfs_devdesc *dev;
1638
1639         np = devspec + 3;                       /* Skip the leading 'zfs' */
1640         if (*np != ':')
1641                 return (EINVAL);
1642         np++;
1643         end = strrchr(np, ':');
1644         if (end == NULL)
1645                 return (EINVAL);
1646         sep = strchr(np, '/');
1647         if (sep == NULL || sep >= end)
1648                 sep = end;
1649         memcpy(poolname, np, sep - np);
1650         poolname[sep - np] = '\0';
1651         if (sep < end) {
1652                 sep++;
1653                 memcpy(rootname, sep, end - sep);
1654                 rootname[end - sep] = '\0';
1655         }
1656         else
1657                 rootname[0] = '\0';
1658
1659         spa = spa_find_by_name(poolname);
1660         if (!spa)
1661                 return (ENXIO);
1662         dev = malloc(sizeof(*dev));
1663         if (dev == NULL)
1664                 return (ENOMEM);
1665         dev->pool_guid = spa->spa_guid;
1666         rv = zfs_lookup_dataset(spa, rootname, &dev->root_guid);
1667         if (rv != 0) {
1668                 free(dev);
1669                 return (rv);
1670         }
1671         if (path != NULL)
1672                 *path = (*end == '\0') ? end : end + 1;
1673         dev->dd.d_dev = &zfs_dev;
1674         *idev = &dev->dd;
1675         return (0);
1676 }
1677
1678 char *
1679 zfs_fmtdev(struct devdesc *vdev)
1680 {
1681         static char             rootname[ZFS_MAXNAMELEN];
1682         static char             buf[2 * ZFS_MAXNAMELEN + 8];
1683         struct zfs_devdesc      *dev = (struct zfs_devdesc *)vdev;
1684         spa_t                   *spa;
1685
1686         buf[0] = '\0';
1687         if (vdev->d_dev->dv_type != DEVT_ZFS)
1688                 return (buf);
1689
1690         /* Do we have any pools? */
1691         spa = STAILQ_FIRST(&zfs_pools);
1692         if (spa == NULL)
1693                 return (buf);
1694
1695         if (dev->pool_guid == 0)
1696                 dev->pool_guid = spa->spa_guid;
1697         else
1698                 spa = spa_find_by_guid(dev->pool_guid);
1699
1700         if (spa == NULL) {
1701                 printf("ZFS: can't find pool by guid\n");
1702                 return (buf);
1703         }
1704         if (dev->root_guid == 0 && zfs_get_root(spa, &dev->root_guid)) {
1705                 printf("ZFS: can't find root filesystem\n");
1706                 return (buf);
1707         }
1708         if (zfs_rlookup(spa, dev->root_guid, rootname)) {
1709                 printf("ZFS: can't find filesystem by guid\n");
1710                 return (buf);
1711         }
1712
1713         if (rootname[0] == '\0')
1714                 snprintf(buf, sizeof(buf), "%s:%s:", dev->dd.d_dev->dv_name,
1715                     spa->spa_name);
1716         else
1717                 snprintf(buf, sizeof(buf), "%s:%s/%s:", dev->dd.d_dev->dv_name,
1718                     spa->spa_name, rootname);
1719         return (buf);
1720 }
1721
1722 static int
1723 split_devname(const char *name, char *poolname, size_t size,
1724     const char **dsnamep)
1725 {
1726         const char *dsname;
1727         size_t len;
1728
1729         ASSERT(name != NULL);
1730         ASSERT(poolname != NULL);
1731
1732         len = strlen(name);
1733         dsname = strchr(name, '/');
1734         if (dsname != NULL) {
1735                 len = dsname - name;
1736                 dsname++;
1737         } else
1738                 dsname = "";
1739
1740         if (len + 1 > size)
1741                 return (EINVAL);
1742
1743         strlcpy(poolname, name, len + 1);
1744
1745         if (dsnamep != NULL)
1746                 *dsnamep = dsname;
1747
1748         return (0);
1749 }
1750
1751 int
1752 zfs_list(const char *name)
1753 {
1754         static char     poolname[ZFS_MAXNAMELEN];
1755         uint64_t        objid;
1756         spa_t           *spa;
1757         const char      *dsname;
1758         int             rv;
1759
1760         if (split_devname(name, poolname, sizeof(poolname), &dsname) != 0)
1761                 return (EINVAL);
1762
1763         spa = spa_find_by_name(poolname);
1764         if (!spa)
1765                 return (ENXIO);
1766         rv = zfs_lookup_dataset(spa, dsname, &objid);
1767         if (rv != 0)
1768                 return (rv);
1769
1770         return (zfs_list_dataset(spa, objid));
1771 }
1772
1773 void
1774 init_zfs_boot_options(const char *currdev_in)
1775 {
1776         char poolname[ZFS_MAXNAMELEN];
1777         char *beroot, *currdev;
1778         spa_t *spa;
1779         int currdev_len;
1780         const char *dsname;
1781
1782         currdev = NULL;
1783         currdev_len = strlen(currdev_in);
1784         if (currdev_len == 0)
1785                 return;
1786         if (strncmp(currdev_in, "zfs:", 4) != 0)
1787                 return;
1788         currdev = strdup(currdev_in);
1789         if (currdev == NULL)
1790                 return;
1791         /* Remove the trailing : */
1792         currdev[currdev_len - 1] = '\0';
1793
1794         setenv("zfs_be_active", currdev, 1);
1795         setenv("zfs_be_currpage", "1", 1);
1796         /* Remove the last element (current bootenv) */
1797         beroot = strrchr(currdev, '/');
1798         if (beroot != NULL)
1799                 beroot[0] = '\0';
1800         beroot = strchr(currdev, ':') + 1;
1801         setenv("zfs_be_root", beroot, 1);
1802
1803         if (split_devname(beroot, poolname, sizeof(poolname), &dsname) != 0)
1804                 return;
1805
1806         spa = spa_find_by_name(poolname);
1807         if (spa == NULL)
1808                 return;
1809
1810         zfs_bootenv_initial("bootenvs", spa, beroot, dsname, 0);
1811         zfs_checkpoints_initial(spa, beroot, dsname);
1812
1813         free(currdev);
1814 }
1815
1816 static void
1817 zfs_checkpoints_initial(spa_t *spa, const char *name, const char *dsname)
1818 {
1819         char envname[32];
1820
1821         if (spa->spa_uberblock_checkpoint.ub_checkpoint_txg != 0) {
1822                 snprintf(envname, sizeof(envname), "zpool_checkpoint");
1823                 setenv(envname, name, 1);
1824
1825                 spa->spa_uberblock = &spa->spa_uberblock_checkpoint;
1826                 spa->spa_mos = &spa->spa_mos_checkpoint;
1827
1828                 zfs_bootenv_initial("bootenvs_check", spa, name, dsname, 1);
1829
1830                 spa->spa_uberblock = &spa->spa_uberblock_master;
1831                 spa->spa_mos = &spa->spa_mos_master;
1832         }
1833 }
1834
1835 static void
1836 zfs_bootenv_initial(const char *envprefix, spa_t *spa, const char *rootname,
1837    const char *dsname, int checkpoint)
1838 {
1839         char            envname[32], envval[256];
1840         uint64_t        objid;
1841         int             bootenvs_idx, rv;
1842
1843         SLIST_INIT(&zfs_be_head);
1844         zfs_env_count = 0;
1845
1846         rv = zfs_lookup_dataset(spa, dsname, &objid);
1847         if (rv != 0)
1848                 return;
1849
1850         rv = zfs_callback_dataset(spa, objid, zfs_belist_add);
1851         bootenvs_idx = 0;
1852         /* Populate the initial environment variables */
1853         SLIST_FOREACH_SAFE(zfs_be, &zfs_be_head, entries, zfs_be_tmp) {
1854                 /* Enumerate all bootenvs for general usage */
1855                 snprintf(envname, sizeof(envname), "%s[%d]",
1856                     envprefix, bootenvs_idx);
1857                 snprintf(envval, sizeof(envval), "zfs:%s%s/%s",
1858                     checkpoint ? "!" : "", rootname, zfs_be->name);
1859                 rv = setenv(envname, envval, 1);
1860                 if (rv != 0)
1861                         break;
1862                 bootenvs_idx++;
1863         }
1864         snprintf(envname, sizeof(envname), "%s_count", envprefix);
1865         snprintf(envval, sizeof(envval), "%d", bootenvs_idx);
1866         setenv(envname, envval, 1);
1867
1868         /* Clean up the SLIST of ZFS BEs */
1869         while (!SLIST_EMPTY(&zfs_be_head)) {
1870                 zfs_be = SLIST_FIRST(&zfs_be_head);
1871                 SLIST_REMOVE_HEAD(&zfs_be_head, entries);
1872                 free(zfs_be->name);
1873                 free(zfs_be);
1874         }
1875 }
1876
1877 int
1878 zfs_bootenv(const char *name)
1879 {
1880         char            poolname[ZFS_MAXNAMELEN], *root;
1881         const char      *dsname;
1882         char            becount[4];
1883         uint64_t        objid;
1884         spa_t           *spa;
1885         int             rv, pages, perpage, currpage;
1886
1887         if (name == NULL)
1888                 return (EINVAL);
1889         if ((root = getenv("zfs_be_root")) == NULL)
1890                 return (EINVAL);
1891
1892         if (strcmp(name, root) != 0) {
1893                 if (setenv("zfs_be_root", name, 1) != 0)
1894                         return (ENOMEM);
1895         }
1896
1897         SLIST_INIT(&zfs_be_head);
1898         zfs_env_count = 0;
1899
1900         if (split_devname(name, poolname, sizeof(poolname), &dsname) != 0)
1901                 return (EINVAL);
1902
1903         spa = spa_find_by_name(poolname);
1904         if (!spa)
1905                 return (ENXIO);
1906         rv = zfs_lookup_dataset(spa, dsname, &objid);
1907         if (rv != 0)
1908                 return (rv);
1909         rv = zfs_callback_dataset(spa, objid, zfs_belist_add);
1910
1911         /* Calculate and store the number of pages of BEs */
1912         perpage = (ZFS_BE_LAST - ZFS_BE_FIRST + 1);
1913         pages = (zfs_env_count / perpage) + ((zfs_env_count % perpage) > 0 ? 1 : 0);
1914         snprintf(becount, 4, "%d", pages);
1915         if (setenv("zfs_be_pages", becount, 1) != 0)
1916                 return (ENOMEM);
1917
1918         /* Roll over the page counter if it has exceeded the maximum */
1919         currpage = strtol(getenv("zfs_be_currpage"), NULL, 10);
1920         if (currpage > pages) {
1921                 if (setenv("zfs_be_currpage", "1", 1) != 0)
1922                         return (ENOMEM);
1923         }
1924
1925         /* Populate the menu environment variables */
1926         zfs_set_env();
1927
1928         /* Clean up the SLIST of ZFS BEs */
1929         while (!SLIST_EMPTY(&zfs_be_head)) {
1930                 zfs_be = SLIST_FIRST(&zfs_be_head);
1931                 SLIST_REMOVE_HEAD(&zfs_be_head, entries);
1932                 free(zfs_be->name);
1933                 free(zfs_be);
1934         }
1935
1936         return (rv);
1937 }
1938
1939 int
1940 zfs_belist_add(const char *name, uint64_t value __unused)
1941 {
1942
1943         /* Skip special datasets that start with a $ character */
1944         if (strncmp(name, "$", 1) == 0) {
1945                 return (0);
1946         }
1947         /* Add the boot environment to the head of the SLIST */
1948         zfs_be = malloc(sizeof(struct zfs_be_entry));
1949         if (zfs_be == NULL) {
1950                 return (ENOMEM);
1951         }
1952         zfs_be->name = strdup(name);
1953         if (zfs_be->name == NULL) {
1954                 free(zfs_be);
1955                 return (ENOMEM);
1956         }
1957         SLIST_INSERT_HEAD(&zfs_be_head, zfs_be, entries);
1958         zfs_env_count++;
1959
1960         return (0);
1961 }
1962
1963 int
1964 zfs_set_env(void)
1965 {
1966         char envname[32], envval[256];
1967         char *beroot, *pagenum;
1968         int rv, page, ctr;
1969
1970         beroot = getenv("zfs_be_root");
1971         if (beroot == NULL) {
1972                 return (1);
1973         }
1974
1975         pagenum = getenv("zfs_be_currpage");
1976         if (pagenum != NULL) {
1977                 page = strtol(pagenum, NULL, 10);
1978         } else {
1979                 page = 1;
1980         }
1981
1982         ctr = 1;
1983         rv = 0;
1984         zfs_env_index = ZFS_BE_FIRST;
1985         SLIST_FOREACH_SAFE(zfs_be, &zfs_be_head, entries, zfs_be_tmp) {
1986                 /* Skip to the requested page number */
1987                 if (ctr <= ((ZFS_BE_LAST - ZFS_BE_FIRST + 1) * (page - 1))) {
1988                         ctr++;
1989                         continue;
1990                 }
1991
1992                 snprintf(envname, sizeof(envname), "bootenvmenu_caption[%d]", zfs_env_index);
1993                 snprintf(envval, sizeof(envval), "%s", zfs_be->name);
1994                 rv = setenv(envname, envval, 1);
1995                 if (rv != 0) {
1996                         break;
1997                 }
1998
1999                 snprintf(envname, sizeof(envname), "bootenvansi_caption[%d]", zfs_env_index);
2000                 rv = setenv(envname, envval, 1);
2001                 if (rv != 0){
2002                         break;
2003                 }
2004
2005                 snprintf(envname, sizeof(envname), "bootenvmenu_command[%d]", zfs_env_index);
2006                 rv = setenv(envname, "set_bootenv", 1);
2007                 if (rv != 0){
2008                         break;
2009                 }
2010
2011                 snprintf(envname, sizeof(envname), "bootenv_root[%d]", zfs_env_index);
2012                 snprintf(envval, sizeof(envval), "zfs:%s/%s", beroot, zfs_be->name);
2013                 rv = setenv(envname, envval, 1);
2014                 if (rv != 0){
2015                         break;
2016                 }
2017
2018                 zfs_env_index++;
2019                 if (zfs_env_index > ZFS_BE_LAST) {
2020                         break;
2021                 }
2022
2023         }
2024
2025         for (; zfs_env_index <= ZFS_BE_LAST; zfs_env_index++) {
2026                 snprintf(envname, sizeof(envname), "bootenvmenu_caption[%d]", zfs_env_index);
2027                 (void)unsetenv(envname);
2028                 snprintf(envname, sizeof(envname), "bootenvansi_caption[%d]", zfs_env_index);
2029                 (void)unsetenv(envname);
2030                 snprintf(envname, sizeof(envname), "bootenvmenu_command[%d]", zfs_env_index);
2031                 (void)unsetenv(envname);
2032                 snprintf(envname, sizeof(envname), "bootenv_root[%d]", zfs_env_index);
2033                 (void)unsetenv(envname);
2034         }
2035
2036         return (rv);
2037 }