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         struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
 816         spa_t *spa;
 817         vdev_t *vd;
 818
 819         if (dev->dd.d_dev->dv_type != DEVT_ZFS)
 820                 return (ENOTSUP);
 821
 822         if ((spa = spa_find_by_dev(dev)) == NULL)
 823                 return (ENXIO);
 824
 825         STAILQ_FOREACH(vd, &spa->spa_root_vdev->v_children, v_childlink) {
 826                 vdev_write_bootenv(vd, benv);
 827         }
 828
 829         spa->spa_bootenv = benv;
 830         return (0);
 831 }
 832
 833 /*
 834  * Get bootonce value by key. The bootonce <key, value> pair is removed
 835  * from the bootenv nvlist and the remaining nvlist is committed back to disk.
 836  */
 837 int
 838 zfs_get_bootonce(void *vdev, const char *key, char *buf, size_t size)
 839 {
 840         nvlist_t *benv;
 841         char *result = NULL;
 842         int result_size, rv;
 843
 844         if ((rv = zfs_get_bootenv(vdev, &benv)) != 0)
 845                 return (rv);
 846
 847         if ((rv = nvlist_find(benv, key, DATA_TYPE_STRING, NULL,
 848             &result, &result_size)) == 0) {
 849                 if (result_size == 0) {
 850                         /* ignore empty string */
 851                         rv = ENOENT;
 852                 } else {
 853                         size = MIN((size_t)result_size + 1, size);
 854                         strlcpy(buf, result, size);
 855                 }
 856                 (void) nvlist_remove(benv, key, DATA_TYPE_STRING);
 857                 (void) zfs_set_bootenv(vdev, benv);
 858         }
 859
 860         return (rv);
 861 }
 862
 863 /*
 864  * nvstore backend.
 865  */
 866
 867 static int zfs_nvstore_setter(void *, int, const char *,
 868     const void *, size_t);
 869 static int zfs_nvstore_setter_str(void *, const char *, const char *,
 870     const char *);
 871 static int zfs_nvstore_unset_impl(void *, const char *, bool);
 872 static int zfs_nvstore_setenv(void *, void *);
 873
 874 /*
 875  * nvstore is only present for current rootfs pool.
 876  */
 877 static int
 878 zfs_nvstore_sethook(struct env_var *ev, int flags __unused, const void *value)
 879 {
 880         struct zfs_devdesc *dev;
 881         int rv;
 882
 883         archsw.arch_getdev((void **)&dev, NULL, NULL);
 884         if (dev == NULL)
 885                 return (ENXIO);
 886
 887         rv = zfs_nvstore_setter_str(dev, NULL, ev->ev_name, value);
 888
 889         free(dev);
 890         return (rv);
 891 }
 892
 893 /*
 894  * nvstore is only present for current rootfs pool.
 895  */
 896 static int
 897 zfs_nvstore_unsethook(struct env_var *ev)
 898 {
 899         struct zfs_devdesc *dev;
 900         int rv;
 901
 902         archsw.arch_getdev((void **)&dev, NULL, NULL);
 903         if (dev == NULL)
 904                 return (ENXIO);
 905
 906         rv = zfs_nvstore_unset_impl(dev, ev->ev_name, false);
 907
 908         free(dev);
 909         return (rv);
 910 }
 911
 912 static int
 913 zfs_nvstore_getter(void *vdev, const char *name, void **data)
 914 {
 915         struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
 916         spa_t *spa;
 917         nvlist_t *nv;
 918         char *str, **ptr;
 919         int size;
 920         int rv;
 921
 922         if (dev->dd.d_dev->dv_type != DEVT_ZFS)
 923                 return (ENOTSUP);
 924
 925         if ((spa = spa_find_by_dev(dev)) == NULL)
 926                 return (ENXIO);
 927
 928         if (spa->spa_bootenv == NULL)
 929                 return (ENXIO);
 930
 931         if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
 932             NULL, &nv, NULL) != 0)
 933                 return (ENOENT);
 934
 935         rv = nvlist_find(nv, name, DATA_TYPE_STRING, NULL, &str, &size);
 936         if (rv == 0) {
 937                 ptr = (char **)data;
 938                 asprintf(ptr, "%.*s", size, str);
 939                 if (*data == NULL)
 940                         rv = ENOMEM;
 941         }
 942         nvlist_destroy(nv);
 943         return (rv);
 944 }
 945
 946 static int
 947 zfs_nvstore_setter(void *vdev, int type, const char *name,
 948     const void *data, size_t size)
 949 {
 950         struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
 951         spa_t *spa;
 952         nvlist_t *nv;
 953         int rv;
 954         bool env_set = true;
 955
 956         if (dev->dd.d_dev->dv_type != DEVT_ZFS)
 957                 return (ENOTSUP);
 958
 959         if ((spa = spa_find_by_dev(dev)) == NULL)
 960                 return (ENXIO);
 961
 962         if (spa->spa_bootenv == NULL)
 963                 return (ENXIO);
 964
 965         if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
 966             NULL, &nv, NULL) != 0) {
 967                 nv = nvlist_create(NV_UNIQUE_NAME);
 968                 if (nv == NULL)
 969                         return (ENOMEM);
 970         }
 971
 972         rv = 0;
 973         switch (type) {
 974         case DATA_TYPE_INT8:
 975                 if (size != sizeof (int8_t)) {
 976                         rv = EINVAL;
 977                         break;
 978                 }
 979                 rv = nvlist_add_int8(nv, name, *(int8_t *)data);
 980                 break;
 981
 982         case DATA_TYPE_INT16:
 983                 if (size != sizeof (int16_t)) {
 984                         rv = EINVAL;
 985                         break;
 986                 }
 987                 rv = nvlist_add_int16(nv, name, *(int16_t *)data);
 988                 break;
 989
 990         case DATA_TYPE_INT32:
 991                 if (size != sizeof (int32_t)) {
 992                         rv = EINVAL;
 993                         break;
 994                 }
 995                 rv = nvlist_add_int32(nv, name, *(int32_t *)data);
 996                 break;
 997
 998         case DATA_TYPE_INT64:
 999                 if (size != sizeof (int64_t)) {
1000                         rv = EINVAL;
1001                         break;
1002                 }
1003                 rv = nvlist_add_int64(nv, name, *(int64_t *)data);
1004                 break;
1005
1006         case DATA_TYPE_BYTE:
1007                 if (size != sizeof (uint8_t)) {
1008                         rv = EINVAL;
1009                         break;
1010                 }
1011                 rv = nvlist_add_byte(nv, name, *(int8_t *)data);
1012                 break;
1013
1014         case DATA_TYPE_UINT8:
1015                 if (size != sizeof (uint8_t)) {
1016                         rv = EINVAL;
1017                         break;
1018                 }
1019                 rv = nvlist_add_uint8(nv, name, *(int8_t *)data);
1020                 break;
1021
1022         case DATA_TYPE_UINT16:
1023                 if (size != sizeof (uint16_t)) {
1024                         rv = EINVAL;
1025                         break;
1026                 }
1027                 rv = nvlist_add_uint16(nv, name, *(uint16_t *)data);
1028                 break;
1029
1030         case DATA_TYPE_UINT32:
1031                 if (size != sizeof (uint32_t)) {
1032                         rv = EINVAL;
1033                         break;
1034                 }
1035                 rv = nvlist_add_uint32(nv, name, *(uint32_t *)data);
1036                 break;
1037
1038         case DATA_TYPE_UINT64:
1039                 if (size != sizeof (uint64_t)) {
1040                         rv = EINVAL;
1041                         break;
1042                 }
1043                 rv = nvlist_add_uint64(nv, name, *(uint64_t *)data);
1044                 break;
1045
1046         case DATA_TYPE_STRING:
1047                 rv = nvlist_add_string(nv, name, data);
1048                 break;
1049
1050         case DATA_TYPE_BOOLEAN_VALUE:
1051                 if (size != sizeof (boolean_t)) {
1052                         rv = EINVAL;
1053                         break;
1054                 }
1055                 rv = nvlist_add_boolean_value(nv, name, *(boolean_t *)data);
1056                 break;
1057
1058         default:
1059                 rv = EINVAL;
1060                 break;
1061         }
1062
1063         if (rv == 0) {
1064                 rv = nvlist_add_nvlist(spa->spa_bootenv, OS_NVSTORE, nv);
1065                 if (rv == 0) {
1066                         rv = zfs_set_bootenv(vdev, spa->spa_bootenv);
1067                 }
1068                 if (rv == 0) {
1069                         if (env_set) {
1070                                 rv = zfs_nvstore_setenv(vdev,
1071                                     nvpair_find(nv, name));
1072                         } else {
1073                                 env_discard(env_getenv(name));
1074                                 rv = 0;
1075                         }
1076                 }
1077         }
1078
1079         nvlist_destroy(nv);
1080         return (rv);
1081 }
1082
1083 static int
1084 get_int64(const char *data, int64_t *ip)
1085 {
1086         char *end;
1087         int64_t val;
1088
1089         errno = 0;
1090         val = strtoll(data, &end, 0);
1091         if (errno != 0 || *data == '\0' || *end != '\0')
1092                 return (EINVAL);
1093
1094         *ip = val;
1095         return (0);
1096 }
1097
1098 static int
1099 get_uint64(const char *data, uint64_t *ip)
1100 {
1101         char *end;
1102         uint64_t val;
1103
1104         errno = 0;
1105         val = strtoull(data, &end, 0);
1106         if (errno != 0 || *data == '\0' || *end != '\0')
1107                 return (EINVAL);
1108
1109         *ip = val;
1110         return (0);
1111 }
1112
1113 /*
1114  * Translate textual data to data type. If type is not set, and we are
1115  * creating new pair, use DATA_TYPE_STRING.
1116  */
1117 static int
1118 zfs_nvstore_setter_str(void *vdev, const char *type, const char *name,
1119     const char *data)
1120 {
1121         struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
1122         spa_t *spa;
1123         nvlist_t *nv;
1124         int rv;
1125         data_type_t dt;
1126         int64_t val;
1127         uint64_t uval;
1128
1129         if (dev->dd.d_dev->dv_type != DEVT_ZFS)
1130                 return (ENOTSUP);
1131
1132         if ((spa = spa_find_by_dev(dev)) == NULL)
1133                 return (ENXIO);
1134
1135         if (spa->spa_bootenv == NULL)
1136                 return (ENXIO);
1137
1138         if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
1139             NULL, &nv, NULL) != 0) {
1140                 nv = NULL;
1141         }
1142
1143         if (type == NULL) {
1144                 nvp_header_t *nvh;
1145
1146                 /*
1147                  * if there is no existing pair, default to string.
1148                  * Otherwise, use type from existing pair.
1149                  */
1150                 nvh = nvpair_find(nv, name);
1151                 if (nvh == NULL) {
1152                         dt = DATA_TYPE_STRING;
1153                 } else {
1154                         nv_string_t *nvp_name;
1155                         nv_pair_data_t *nvp_data;
1156
1157                         nvp_name = (nv_string_t *)(nvh + 1);
1158                         nvp_data = (nv_pair_data_t *)(&nvp_name->nv_data[0] +
1159                             NV_ALIGN4(nvp_name->nv_size));
1160                         dt = nvp_data->nv_type;
1161                 }
1162         } else {
1163                 dt = nvpair_type_from_name(type);
1164         }
1165         nvlist_destroy(nv);
1166
1167         rv = 0;
1168         switch (dt) {
1169         case DATA_TYPE_INT8:
1170                 rv = get_int64(data, &val);
1171                 if (rv == 0) {
1172                         int8_t v = val;
1173
1174                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1175                 }
1176                 break;
1177         case DATA_TYPE_INT16:
1178                 rv = get_int64(data, &val);
1179                 if (rv == 0) {
1180                         int16_t v = val;
1181
1182                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1183                 }
1184                 break;
1185         case DATA_TYPE_INT32:
1186                 rv = get_int64(data, &val);
1187                 if (rv == 0) {
1188                         int32_t v = val;
1189
1190                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1191                 }
1192                 break;
1193         case DATA_TYPE_INT64:
1194                 rv = get_int64(data, &val);
1195                 if (rv == 0) {
1196                         rv = zfs_nvstore_setter(vdev, dt, name, &val,
1197                             sizeof (val));
1198                 }
1199                 break;
1200
1201         case DATA_TYPE_BYTE:
1202                 rv = get_uint64(data, &uval);
1203                 if (rv == 0) {
1204                         uint8_t v = uval;
1205
1206                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1207                 }
1208                 break;
1209
1210         case DATA_TYPE_UINT8:
1211                 rv = get_uint64(data, &uval);
1212                 if (rv == 0) {
1213                         uint8_t v = uval;
1214
1215                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1216                 }
1217                 break;
1218
1219         case DATA_TYPE_UINT16:
1220                 rv = get_uint64(data, &uval);
1221                 if (rv == 0) {
1222                         uint16_t v = uval;
1223
1224                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1225                 }
1226                 break;
1227
1228         case DATA_TYPE_UINT32:
1229                 rv = get_uint64(data, &uval);
1230                 if (rv == 0) {
1231                         uint32_t v = uval;
1232
1233                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1234                 }
1235                 break;
1236
1237         case DATA_TYPE_UINT64:
1238                 rv = get_uint64(data, &uval);
1239                 if (rv == 0) {
1240                         rv = zfs_nvstore_setter(vdev, dt, name, &uval,
1241                             sizeof (uval));
1242                 }
1243                 break;
1244
1245         case DATA_TYPE_STRING:
1246                 rv = zfs_nvstore_setter(vdev, dt, name, data, strlen(data) + 1);
1247                 break;
1248
1249         case DATA_TYPE_BOOLEAN_VALUE:
1250                 rv = get_int64(data, &val);
1251                 if (rv == 0) {
1252                         boolean_t v = val;
1253
1254                         rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v));
1255                 }
1256
1257         default:
1258                 rv = EINVAL;
1259         }
1260         return (rv);
1261 }
1262
1263 static int
1264 zfs_nvstore_unset_impl(void *vdev, const char *name, bool unset_env)
1265 {
1266         struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
1267         spa_t *spa;
1268         nvlist_t *nv;
1269         int rv;
1270
1271         if (dev->dd.d_dev->dv_type != DEVT_ZFS)
1272                 return (ENOTSUP);
1273
1274         if ((spa = spa_find_by_dev(dev)) == NULL)
1275                 return (ENXIO);
1276
1277         if (spa->spa_bootenv == NULL)
1278                 return (ENXIO);
1279
1280         if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
1281             NULL, &nv, NULL) != 0)
1282                 return (ENOENT);
1283
1284         rv = nvlist_remove(nv, name, DATA_TYPE_UNKNOWN);
1285         if (rv == 0) {
1286                 if (nvlist_next_nvpair(nv, NULL) == NULL) {
1287                         rv = nvlist_remove(spa->spa_bootenv, OS_NVSTORE,
1288                             DATA_TYPE_NVLIST);
1289                 } else {
1290                         rv = nvlist_add_nvlist(spa->spa_bootenv,
1291                             OS_NVSTORE, nv);
1292                 }
1293                 if (rv == 0)
1294                         rv = zfs_set_bootenv(vdev, spa->spa_bootenv);
1295         }
1296
1297         if (unset_env)
1298                 env_discard(env_getenv(name));
1299         return (rv);
1300 }
1301
1302 static int
1303 zfs_nvstore_unset(void *vdev, const char *name)
1304 {
1305         return (zfs_nvstore_unset_impl(vdev, name, true));
1306 }
1307
1308 static int
1309 zfs_nvstore_print(void *vdev __unused, void *ptr)
1310 {
1311
1312         nvpair_print(ptr, 0);
1313         return (0);
1314 }
1315
1316 /*
1317  * Create environment variable from nvpair.
1318  * set hook will update nvstore with new value, unset hook will remove
1319  * variable from nvstore.
1320  */
1321 static int
1322 zfs_nvstore_setenv(void *vdev __unused, void *ptr)
1323 {
1324         nvp_header_t *nvh = ptr;
1325         nv_string_t *nvp_name, *nvp_value;
1326         nv_pair_data_t *nvp_data;
1327         char *name, *value;
1328         int rv = 0;
1329
1330         if (nvh == NULL)
1331                 return (ENOENT);
1332
1333         nvp_name = (nv_string_t *)(nvh + 1);
1334         nvp_data = (nv_pair_data_t *)(&nvp_name->nv_data[0] +
1335             NV_ALIGN4(nvp_name->nv_size));
1336
1337         if ((name = nvstring_get(nvp_name)) == NULL)
1338                 return (ENOMEM);
1339
1340         value = NULL;
1341         switch (nvp_data->nv_type) {
1342         case DATA_TYPE_BYTE:
1343         case DATA_TYPE_UINT8:
1344                 (void) asprintf(&value, "%uc",
1345                     *(unsigned *)&nvp_data->nv_data[0]);
1346                 if (value == NULL)
1347                         rv = ENOMEM;
1348                 break;
1349
1350         case DATA_TYPE_INT8:
1351                 (void) asprintf(&value, "%c", *(int *)&nvp_data->nv_data[0]);
1352                 if (value == NULL)
1353                         rv = ENOMEM;
1354                 break;
1355
1356         case DATA_TYPE_INT16:
1357                 (void) asprintf(&value, "%hd", *(short *)&nvp_data->nv_data[0]);
1358                 if (value == NULL)
1359                         rv = ENOMEM;
1360                 break;
1361
1362         case DATA_TYPE_UINT16:
1363                 (void) asprintf(&value, "%hu",
1364                     *(unsigned short *)&nvp_data->nv_data[0]);
1365                 if (value == NULL)
1366                         rv = ENOMEM;
1367                 break;
1368
1369         case DATA_TYPE_BOOLEAN_VALUE:
1370         case DATA_TYPE_INT32:
1371                 (void) asprintf(&value, "%d", *(int *)&nvp_data->nv_data[0]);
1372                 if (value == NULL)
1373                         rv = ENOMEM;
1374                 break;
1375
1376         case DATA_TYPE_UINT32:
1377                 (void) asprintf(&value, "%u",
1378                     *(unsigned *)&nvp_data->nv_data[0]);
1379                 if (value == NULL)
1380                         rv = ENOMEM;
1381                 break;
1382
1383         case DATA_TYPE_INT64:
1384                 (void) asprintf(&value, "%jd",
1385                     (intmax_t)*(int64_t *)&nvp_data->nv_data[0]);
1386                 if (value == NULL)
1387                         rv = ENOMEM;
1388                 break;
1389
1390         case DATA_TYPE_UINT64:
1391                 (void) asprintf(&value, "%ju",
1392                     (uintmax_t)*(uint64_t *)&nvp_data->nv_data[0]);
1393                 if (value == NULL)
1394                         rv = ENOMEM;
1395                 break;
1396
1397         case DATA_TYPE_STRING:
1398                 nvp_value = (nv_string_t *)&nvp_data->nv_data[0];
1399                 if ((value = nvstring_get(nvp_value)) == NULL) {
1400                         rv = ENOMEM;
1401                         break;
1402                 }
1403                 break;
1404
1405         default:
1406                 rv = EINVAL;
1407                 break;
1408         }
1409
1410         if (value != NULL) {
1411                 rv = env_setenv(name, EV_VOLATILE | EV_NOHOOK, value,
1412                     zfs_nvstore_sethook, zfs_nvstore_unsethook);
1413                 free(value);
1414         }
1415         free(name);
1416         return (rv);
1417 }
1418
1419 static int
1420 zfs_nvstore_iterate(void *vdev, int (*cb)(void *, void *))
1421 {
1422         struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev;
1423         spa_t *spa;
1424         nvlist_t *nv;
1425         nvp_header_t *nvh;
1426         int rv;
1427
1428         if (dev->dd.d_dev->dv_type != DEVT_ZFS)
1429                 return (ENOTSUP);
1430
1431         if ((spa = spa_find_by_dev(dev)) == NULL)
1432                 return (ENXIO);
1433
1434         if (spa->spa_bootenv == NULL)
1435                 return (ENXIO);
1436
1437         if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST,
1438             NULL, &nv, NULL) != 0)
1439                 return (ENOENT);
1440
1441         rv = 0;
1442         nvh = NULL;
1443         while ((nvh = nvlist_next_nvpair(nv, nvh)) != NULL) {
1444                 rv = cb(vdev, nvh);
1445                 if (rv != 0)
1446                         break;
1447         }
1448         return (rv);
1449 }
1450
1451 nvs_callbacks_t nvstore_zfs_cb = {
1452         .nvs_getter = zfs_nvstore_getter,
1453         .nvs_setter = zfs_nvstore_setter,
1454         .nvs_setter_str = zfs_nvstore_setter_str,
1455         .nvs_unset = zfs_nvstore_unset,
1456         .nvs_print = zfs_nvstore_print,
1457         .nvs_iterate = zfs_nvstore_iterate
1458 };
1459
1460 int
1461 zfs_attach_nvstore(void *vdev)
1462 {
1463         struct zfs_devdesc *dev = vdev;
1464         spa_t *spa;
1465         uint64_t version;
1466         int rv;
1467
1468         if (dev->dd.d_dev->dv_type != DEVT_ZFS)
1469                 return (ENOTSUP);
1470
1471         if ((spa = spa_find_by_dev(dev)) == NULL)
1472                 return (ENXIO);
1473
1474         rv = nvlist_find(spa->spa_bootenv, BOOTENV_VERSION, DATA_TYPE_UINT64,
1475             NULL, &version, NULL);
1476
1477         if (rv != 0 || version != VB_NVLIST) {
1478                 return (ENXIO);
1479         }
1480
1481         dev = malloc(sizeof (*dev));
1482         if (dev == NULL)
1483                 return (ENOMEM);
1484         memcpy(dev, vdev, sizeof (*dev));
1485
1486         rv = nvstore_init(spa->spa_name, &nvstore_zfs_cb, dev);
1487         if (rv != 0)
1488                 free(dev);
1489         else
1490                 rv = zfs_nvstore_iterate(dev, zfs_nvstore_setenv);
1491         return (rv);
1492 }
1493
1494 int
1495 zfs_probe_dev(const char *devname, uint64_t *pool_guid, bool parts_too)
1496 {
1497         struct ptable *table;
1498         struct zfs_probe_args pa;
1499         uint64_t mediasz;
1500         int ret;
1501
1502         if (pool_guid)
1503                 *pool_guid = 0;
1504         pa.fd = open(devname, O_RDWR);
1505         if (pa.fd == -1)
1506                 return (ENXIO);
1507         /* Probe the whole disk */
1508         ret = zfs_probe(pa.fd, pool_guid);
1509         if (ret == 0)
1510                 return (0);
1511         if (!parts_too)
1512                 return (ENXIO);
1513
1514         /* Probe each partition */
1515         ret = ioctl(pa.fd, DIOCGMEDIASIZE, &mediasz);
1516         if (ret == 0)
1517                 ret = ioctl(pa.fd, DIOCGSECTORSIZE, &pa.secsz);
1518         if (ret == 0) {
1519                 pa.devname = devname;
1520                 pa.pool_guid = pool_guid;
1521                 table = ptable_open(&pa, mediasz / pa.secsz, pa.secsz,
1522                     zfs_diskread);
1523                 if (table != NULL) {
1524                         ptable_iterate(table, &pa, zfs_probe_partition);
1525                         ptable_close(table);
1526                 }
1527         }
1528         close(pa.fd);
1529         if (pool_guid && *pool_guid == 0)
1530                 ret = ENXIO;
1531         return (ret);
1532 }
1533
1534 /*
1535  * Print information about ZFS pools
1536  */
1537 static int
1538 zfs_dev_print(int verbose)
1539 {
1540         spa_t *spa;
1541         char line[80];
1542         int ret = 0;
1543
1544         if (STAILQ_EMPTY(&zfs_pools))
1545                 return (0);
1546
1547         printf("%s devices:", zfs_dev.dv_name);
1548         if ((ret = pager_output("\n")) != 0)
1549                 return (ret);
1550
1551         if (verbose) {
1552                 return (spa_all_status());
1553         }
1554         STAILQ_FOREACH(spa, &zfs_pools, spa_link) {
1555                 snprintf(line, sizeof(line), "    zfs:%s\n", spa->spa_name);
1556                 ret = pager_output(line);
1557                 if (ret != 0)
1558                         break;
1559         }
1560         return (ret);
1561 }
1562
1563 /*
1564  * Attempt to open the pool described by (dev) for use by (f).
1565  */
1566 static int
1567 zfs_dev_open(struct open_file *f, ...)
1568 {
1569         va_list         args;
1570         struct zfs_devdesc      *dev;
1571         struct zfsmount *mount;
1572         spa_t           *spa;
1573         int             rv;
1574
1575         va_start(args, f);
1576         dev = va_arg(args, struct zfs_devdesc *);
1577         va_end(args);
1578
1579         if ((spa = spa_find_by_dev(dev)) == NULL)
1580                 return (ENXIO);
1581
1582         STAILQ_FOREACH(mount, &zfsmount, next) {
1583                 if (spa->spa_guid == mount->spa->spa_guid)
1584                         break;
1585         }
1586
1587         rv = 0;
1588         /* This device is not set as currdev, mount us private copy. */
1589         if (mount == NULL)
1590                 rv = zfs_mount(devformat(&dev->dd), NULL, (void **)&mount);
1591
1592         if (rv == 0) {
1593                 dev->dd.d_opendata = mount;
1594         }
1595         return (rv);
1596 }
1597
1598 static int
1599 zfs_dev_close(struct open_file *f)
1600 {
1601         struct devdesc *dev;
1602         struct zfsmount *mnt, *mount;
1603
1604         dev = f->f_devdata;
1605         mnt = dev->d_opendata;
1606
1607         STAILQ_FOREACH(mount, &zfsmount, next) {
1608                 if (mnt->spa->spa_guid == mount->spa->spa_guid)
1609                         break;
1610         }
1611
1612         /* XXX */
1613         return (0);
1614 }
1615
1616 static int
1617 zfs_dev_strategy(void *devdata, int rw, daddr_t dblk, size_t size, char *buf, size_t *rsize)
1618 {
1619
1620         return (ENOSYS);
1621 }
1622
1623 struct devsw zfs_dev = {
1624         .dv_name = "zfs",
1625         .dv_type = DEVT_ZFS,
1626         .dv_init = zfs_dev_init,
1627         .dv_strategy = zfs_dev_strategy,
1628         .dv_open = zfs_dev_open,
1629         .dv_close = zfs_dev_close,
1630         .dv_ioctl = noioctl,
1631         .dv_print = zfs_dev_print,
1632         .dv_cleanup = nullsys,
1633         .dv_fmtdev = zfs_fmtdev,
1634         .dv_parsedev = zfs_parsedev,
1635 };
1636
1637 static int
1638 zfs_parsedev(struct devdesc **idev, const char *devspec, const char **path)
1639 {
1640         static char     rootname[ZFS_MAXNAMELEN];
1641         static char     poolname[ZFS_MAXNAMELEN];
1642         spa_t           *spa;
1643         const char      *end;
1644         const char      *np;
1645         const char      *sep;
1646         int             rv;
1647         struct zfs_devdesc *dev;
1648
1649         np = devspec + 3;                       /* Skip the leading 'zfs' */
1650         if (*np != ':')
1651                 return (EINVAL);
1652         np++;
1653         end = strrchr(np, ':');
1654         if (end == NULL)
1655                 return (EINVAL);
1656         sep = strchr(np, '/');
1657         if (sep == NULL || sep >= end)
1658                 sep = end;
1659         memcpy(poolname, np, sep - np);
1660         poolname[sep - np] = '\0';
1661         if (sep < end) {
1662                 sep++;
1663                 memcpy(rootname, sep, end - sep);
1664                 rootname[end - sep] = '\0';
1665         }
1666         else
1667                 rootname[0] = '\0';
1668
1669         spa = spa_find_by_name(poolname);
1670         if (!spa)
1671                 return (ENXIO);
1672         dev = malloc(sizeof(*dev));
1673         if (dev == NULL)
1674                 return (ENOMEM);
1675         dev->pool_guid = spa->spa_guid;
1676         rv = zfs_lookup_dataset(spa, rootname, &dev->root_guid);
1677         if (rv != 0) {
1678                 free(dev);
1679                 return (rv);
1680         }
1681         if (path != NULL)
1682                 *path = (*end == '\0') ? end : end + 1;
1683         dev->dd.d_dev = &zfs_dev;
1684         *idev = &dev->dd;
1685         return (0);
1686 }
1687
1688 char *
1689 zfs_fmtdev(struct devdesc *vdev)
1690 {
1691         static char             rootname[ZFS_MAXNAMELEN];
1692         static char             buf[2 * ZFS_MAXNAMELEN + 8];
1693         struct zfs_devdesc      *dev = (struct zfs_devdesc *)vdev;
1694         spa_t                   *spa;
1695
1696         buf[0] = '\0';
1697         if (vdev->d_dev->dv_type != DEVT_ZFS)
1698                 return (buf);
1699
1700         /* Do we have any pools? */
1701         spa = STAILQ_FIRST(&zfs_pools);
1702         if (spa == NULL)
1703                 return (buf);
1704
1705         if (dev->pool_guid == 0)
1706                 dev->pool_guid = spa->spa_guid;
1707         else
1708                 spa = spa_find_by_guid(dev->pool_guid);
1709
1710         if (spa == NULL) {
1711                 printf("ZFS: can't find pool by guid\n");
1712                 return (buf);
1713         }
1714         if (dev->root_guid == 0 && zfs_get_root(spa, &dev->root_guid)) {
1715                 printf("ZFS: can't find root filesystem\n");
1716                 return (buf);
1717         }
1718         if (zfs_rlookup(spa, dev->root_guid, rootname)) {
1719                 printf("ZFS: can't find filesystem by guid\n");
1720                 return (buf);
1721         }
1722
1723         if (rootname[0] == '\0')
1724                 snprintf(buf, sizeof(buf), "%s:%s:", dev->dd.d_dev->dv_name,
1725                     spa->spa_name);
1726         else
1727                 snprintf(buf, sizeof(buf), "%s:%s/%s:", dev->dd.d_dev->dv_name,
1728                     spa->spa_name, rootname);
1729         return (buf);
1730 }
1731
1732 static int
1733 split_devname(const char *name, char *poolname, size_t size,
1734     const char **dsnamep)
1735 {
1736         const char *dsname;
1737         size_t len;
1738
1739         ASSERT(name != NULL);
1740         ASSERT(poolname != NULL);
1741
1742         len = strlen(name);
1743         dsname = strchr(name, '/');
1744         if (dsname != NULL) {
1745                 len = dsname - name;
1746                 dsname++;
1747         } else
1748                 dsname = "";
1749
1750         if (len + 1 > size)
1751                 return (EINVAL);
1752
1753         strlcpy(poolname, name, len + 1);
1754
1755         if (dsnamep != NULL)
1756                 *dsnamep = dsname;
1757
1758         return (0);
1759 }
1760
1761 int
1762 zfs_list(const char *name)
1763 {
1764         static char     poolname[ZFS_MAXNAMELEN];
1765         uint64_t        objid;
1766         spa_t           *spa;
1767         const char      *dsname;
1768         int             rv;
1769
1770         if (split_devname(name, poolname, sizeof(poolname), &dsname) != 0)
1771                 return (EINVAL);
1772
1773         spa = spa_find_by_name(poolname);
1774         if (!spa)
1775                 return (ENXIO);
1776         rv = zfs_lookup_dataset(spa, dsname, &objid);
1777         if (rv != 0)
1778                 return (rv);
1779
1780         return (zfs_list_dataset(spa, objid));
1781 }
1782
1783 void
1784 init_zfs_boot_options(const char *currdev_in)
1785 {
1786         char poolname[ZFS_MAXNAMELEN];
1787         char *beroot, *currdev;
1788         spa_t *spa;
1789         int currdev_len;
1790         const char *dsname;
1791
1792         currdev = NULL;
1793         currdev_len = strlen(currdev_in);
1794         if (currdev_len == 0)
1795                 return;
1796         if (strncmp(currdev_in, "zfs:", 4) != 0)
1797                 return;
1798         currdev = strdup(currdev_in);
1799         if (currdev == NULL)
1800                 return;
1801         /* Remove the trailing : */
1802         currdev[currdev_len - 1] = '\0';
1803
1804         setenv("zfs_be_active", currdev, 1);
1805         setenv("zfs_be_currpage", "1", 1);
1806         /* Remove the last element (current bootenv) */
1807         beroot = strrchr(currdev, '/');
1808         if (beroot != NULL)
1809                 beroot[0] = '\0';
1810         beroot = strchr(currdev, ':') + 1;
1811         setenv("zfs_be_root", beroot, 1);
1812
1813         if (split_devname(beroot, poolname, sizeof(poolname), &dsname) != 0)
1814                 return;
1815
1816         spa = spa_find_by_name(poolname);
1817         if (spa == NULL)
1818                 return;
1819
1820         zfs_bootenv_initial("bootenvs", spa, beroot, dsname, 0);
1821         zfs_checkpoints_initial(spa, beroot, dsname);
1822
1823         free(currdev);
1824 }
1825
1826 static void
1827 zfs_checkpoints_initial(spa_t *spa, const char *name, const char *dsname)
1828 {
1829         char envname[32];
1830
1831         if (spa->spa_uberblock_checkpoint.ub_checkpoint_txg != 0) {
1832                 snprintf(envname, sizeof(envname), "zpool_checkpoint");
1833                 setenv(envname, name, 1);
1834
1835                 spa->spa_uberblock = &spa->spa_uberblock_checkpoint;
1836                 spa->spa_mos = &spa->spa_mos_checkpoint;
1837
1838                 zfs_bootenv_initial("bootenvs_check", spa, name, dsname, 1);
1839
1840                 spa->spa_uberblock = &spa->spa_uberblock_master;
1841                 spa->spa_mos = &spa->spa_mos_master;
1842         }
1843 }
1844
1845 static void
1846 zfs_bootenv_initial(const char *envprefix, spa_t *spa, const char *rootname,
1847    const char *dsname, int checkpoint)
1848 {
1849         char            envname[32], envval[256];
1850         uint64_t        objid;
1851         int             bootenvs_idx, rv;
1852
1853         SLIST_INIT(&zfs_be_head);
1854         zfs_env_count = 0;
1855
1856         rv = zfs_lookup_dataset(spa, dsname, &objid);
1857         if (rv != 0)
1858                 return;
1859
1860         rv = zfs_callback_dataset(spa, objid, zfs_belist_add);
1861         bootenvs_idx = 0;
1862         /* Populate the initial environment variables */
1863         SLIST_FOREACH_SAFE(zfs_be, &zfs_be_head, entries, zfs_be_tmp) {
1864                 /* Enumerate all bootenvs for general usage */
1865                 snprintf(envname, sizeof(envname), "%s[%d]",
1866                     envprefix, bootenvs_idx);
1867                 snprintf(envval, sizeof(envval), "zfs:%s%s/%s",
1868                     checkpoint ? "!" : "", rootname, zfs_be->name);
1869                 rv = setenv(envname, envval, 1);
1870                 if (rv != 0)
1871                         break;
1872                 bootenvs_idx++;
1873         }
1874         snprintf(envname, sizeof(envname), "%s_count", envprefix);
1875         snprintf(envval, sizeof(envval), "%d", bootenvs_idx);
1876         setenv(envname, envval, 1);
1877
1878         /* Clean up the SLIST of ZFS BEs */
1879         while (!SLIST_EMPTY(&zfs_be_head)) {
1880                 zfs_be = SLIST_FIRST(&zfs_be_head);
1881                 SLIST_REMOVE_HEAD(&zfs_be_head, entries);
1882                 free(zfs_be->name);
1883                 free(zfs_be);
1884         }
1885 }
1886
1887 int
1888 zfs_bootenv(const char *name)
1889 {
1890         char            poolname[ZFS_MAXNAMELEN], *root;
1891         const char      *dsname;
1892         char            becount[4];
1893         uint64_t        objid;
1894         spa_t           *spa;
1895         int             rv, pages, perpage, currpage;
1896
1897         if (name == NULL)
1898                 return (EINVAL);
1899         if ((root = getenv("zfs_be_root")) == NULL)
1900                 return (EINVAL);
1901
1902         if (strcmp(name, root) != 0) {
1903                 if (setenv("zfs_be_root", name, 1) != 0)
1904                         return (ENOMEM);
1905         }
1906
1907         SLIST_INIT(&zfs_be_head);
1908         zfs_env_count = 0;
1909
1910         if (split_devname(name, poolname, sizeof(poolname), &dsname) != 0)
1911                 return (EINVAL);
1912
1913         spa = spa_find_by_name(poolname);
1914         if (!spa)
1915                 return (ENXIO);
1916         rv = zfs_lookup_dataset(spa, dsname, &objid);
1917         if (rv != 0)
1918                 return (rv);
1919         rv = zfs_callback_dataset(spa, objid, zfs_belist_add);
1920
1921         /* Calculate and store the number of pages of BEs */
1922         perpage = (ZFS_BE_LAST - ZFS_BE_FIRST + 1);
1923         pages = (zfs_env_count / perpage) + ((zfs_env_count % perpage) > 0 ? 1 : 0);
1924         snprintf(becount, 4, "%d", pages);
1925         if (setenv("zfs_be_pages", becount, 1) != 0)
1926                 return (ENOMEM);
1927
1928         /* Roll over the page counter if it has exceeded the maximum */
1929         currpage = strtol(getenv("zfs_be_currpage"), NULL, 10);
1930         if (currpage > pages) {
1931                 if (setenv("zfs_be_currpage", "1", 1) != 0)
1932                         return (ENOMEM);
1933         }
1934
1935         /* Populate the menu environment variables */
1936         zfs_set_env();
1937
1938         /* Clean up the SLIST of ZFS BEs */
1939         while (!SLIST_EMPTY(&zfs_be_head)) {
1940                 zfs_be = SLIST_FIRST(&zfs_be_head);
1941                 SLIST_REMOVE_HEAD(&zfs_be_head, entries);
1942                 free(zfs_be->name);
1943                 free(zfs_be);
1944         }
1945
1946         return (rv);
1947 }
1948
1949 int
1950 zfs_belist_add(const char *name, uint64_t value __unused)
1951 {
1952
1953         /* Skip special datasets that start with a $ character */
1954         if (strncmp(name, "$", 1) == 0) {
1955                 return (0);
1956         }
1957         /* Add the boot environment to the head of the SLIST */
1958         zfs_be = malloc(sizeof(struct zfs_be_entry));
1959         if (zfs_be == NULL) {
1960                 return (ENOMEM);
1961         }
1962         zfs_be->name = strdup(name);
1963         if (zfs_be->name == NULL) {
1964                 free(zfs_be);
1965                 return (ENOMEM);
1966         }
1967         SLIST_INSERT_HEAD(&zfs_be_head, zfs_be, entries);
1968         zfs_env_count++;
1969
1970         return (0);
1971 }
1972
1973 int
1974 zfs_set_env(void)
1975 {
1976         char envname[32], envval[256];
1977         char *beroot, *pagenum;
1978         int rv, page, ctr;
1979
1980         beroot = getenv("zfs_be_root");
1981         if (beroot == NULL) {
1982                 return (1);
1983         }
1984
1985         pagenum = getenv("zfs_be_currpage");
1986         if (pagenum != NULL) {
1987                 page = strtol(pagenum, NULL, 10);
1988         } else {
1989                 page = 1;
1990         }
1991
1992         ctr = 1;
1993         rv = 0;
1994         zfs_env_index = ZFS_BE_FIRST;
1995         SLIST_FOREACH_SAFE(zfs_be, &zfs_be_head, entries, zfs_be_tmp) {
1996                 /* Skip to the requested page number */
1997                 if (ctr <= ((ZFS_BE_LAST - ZFS_BE_FIRST + 1) * (page - 1))) {
1998                         ctr++;
1999                         continue;
2000                 }
2001
2002                 snprintf(envname, sizeof(envname), "bootenvmenu_caption[%d]", zfs_env_index);
2003                 snprintf(envval, sizeof(envval), "%s", zfs_be->name);
2004                 rv = setenv(envname, envval, 1);
2005                 if (rv != 0) {
2006                         break;
2007                 }
2008
2009                 snprintf(envname, sizeof(envname), "bootenvansi_caption[%d]", zfs_env_index);
2010                 rv = setenv(envname, envval, 1);
2011                 if (rv != 0){
2012                         break;
2013                 }
2014
2015                 snprintf(envname, sizeof(envname), "bootenvmenu_command[%d]", zfs_env_index);
2016                 rv = setenv(envname, "set_bootenv", 1);
2017                 if (rv != 0){
2018                         break;
2019                 }
2020
2021                 snprintf(envname, sizeof(envname), "bootenv_root[%d]", zfs_env_index);
2022                 snprintf(envval, sizeof(envval), "zfs:%s/%s", beroot, zfs_be->name);
2023                 rv = setenv(envname, envval, 1);
2024                 if (rv != 0){
2025                         break;
2026                 }
2027
2028                 zfs_env_index++;
2029                 if (zfs_env_index > ZFS_BE_LAST) {
2030                         break;
2031                 }
2032
2033         }
2034
2035         for (; zfs_env_index <= ZFS_BE_LAST; zfs_env_index++) {
2036                 snprintf(envname, sizeof(envname), "bootenvmenu_caption[%d]", zfs_env_index);
2037                 (void)unsetenv(envname);
2038                 snprintf(envname, sizeof(envname), "bootenvansi_caption[%d]", zfs_env_index);
2039                 (void)unsetenv(envname);
2040                 snprintf(envname, sizeof(envname), "bootenvmenu_command[%d]", zfs_env_index);
2041                 (void)unsetenv(envname);
2042                 snprintf(envname, sizeof(envname), "bootenv_root[%d]", zfs_env_index);
2043                 (void)unsetenv(envname);
2044         }
2045
2046         return (rv);
2047 }