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