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 /* 377 * if path is NULL, create mount structure, but do not add it to list. 378 */ 379 static int 380 zfs_mount(const char *dev, const char *path, void **data) 381 { 382 struct zfs_devdesc *zfsdev = NULL; 383 spa_t *spa; 384 struct zfsmount *mnt = NULL; 385 int rv; 386 387 errno = 0; 388 rv = zfs_parsedev((struct devdesc **)&zfsdev, dev, NULL); 389 if (rv != 0) { 390 return (rv); 391 } 392 393 spa = spa_find_by_dev(zfsdev); 394 if (spa == NULL) { 395 rv = ENXIO; 396 goto err; 397 } 398 399 mnt = calloc(1, sizeof(*mnt)); 400 if (mnt == NULL) { 401 rv = ENOMEM; 402 goto err; 403 } 404 405 if (mnt->path != NULL) { 406 mnt->path = strdup(path); 407 if (mnt->path == NULL) { 408 rv = ENOMEM; 409 goto err; 410 } 411 } 412 413 rv = zfs_mount_impl(spa, zfsdev->root_guid, mnt); 414 415 if (rv == 0 && mnt->objset.os_type != DMU_OST_ZFS) { 416 printf("Unexpected object set type %ju\n", 417 (uintmax_t)mnt->objset.os_type); 418 rv = EIO; 419 } 420 err: 421 if (rv != 0) { 422 if (mnt != NULL) 423 free(mnt->path); 424 free(mnt); 425 free(zfsdev); 426 return (rv); 427 } 428 429 *data = mnt; 430 if (path != NULL) 431 STAILQ_INSERT_TAIL(&zfsmount, mnt, next); 432 433 free(zfsdev); 434 435 return (rv); 436 } 437 438 static int 439 zfs_unmount(const char *dev, void *data) 440 { 441 struct zfsmount *mnt = data; 442 443 STAILQ_REMOVE(&zfsmount, mnt, zfsmount, next); 444 free(mnt->path); 445 free(mnt); 446 return (0); 447 } 448 449 static int 450 vdev_read(vdev_t *vdev, void *priv, off_t offset, void *buf, size_t bytes) 451 { 452 int fd, ret; 453 size_t res, head, tail, total_size, full_sec_size; 454 unsigned secsz, do_tail_read; 455 off_t start_sec; 456 char *outbuf, *bouncebuf; 457 458 fd = (uintptr_t) priv; 459 outbuf = (char *) buf; 460 bouncebuf = NULL; 461 462 ret = ioctl(fd, DIOCGSECTORSIZE, &secsz); 463 if (ret != 0) 464 return (ret); 465 466 /* 467 * Handling reads of arbitrary offset and size - multi-sector case 468 * and single-sector case. 469 * 470 * Multi-sector Case 471 * (do_tail_read = true if tail > 0) 472 * 473 * |<----------------------total_size--------------------->| 474 * | | 475 * |<--head-->|<--------------bytes------------>|<--tail-->| 476 * | | | | 477 * | | |<~full_sec_size~>| | | 478 * +------------------+ +------------------+ 479 * | |0101010| . . . |0101011| | 480 * +------------------+ +------------------+ 481 * start_sec start_sec + n 482 * 483 * 484 * Single-sector Case 485 * (do_tail_read = false) 486 * 487 * |<------total_size = secsz----->| 488 * | | 489 * |<-head->|<---bytes--->|<-tail->| 490 * +-------------------------------+ 491 * | |0101010101010| | 492 * +-------------------------------+ 493 * start_sec 494 */ 495 start_sec = offset / secsz; 496 head = offset % secsz; 497 total_size = roundup2(head + bytes, secsz); 498 tail = total_size - (head + bytes); 499 do_tail_read = ((tail > 0) && (head + bytes > secsz)); 500 full_sec_size = total_size; 501 if (head > 0) 502 full_sec_size -= secsz; 503 if (do_tail_read) 504 full_sec_size -= secsz; 505 506 /* Return of partial sector data requires a bounce buffer. */ 507 if ((head > 0) || do_tail_read || bytes < secsz) { 508 bouncebuf = malloc(secsz); 509 if (bouncebuf == NULL) { 510 printf("vdev_read: out of memory\n"); 511 return (ENOMEM); 512 } 513 } 514 515 if (lseek(fd, start_sec * secsz, SEEK_SET) == -1) { 516 ret = errno; 517 goto error; 518 } 519 520 /* Partial data return from first sector */ 521 if (head > 0) { 522 res = read(fd, bouncebuf, secsz); 523 if (res != secsz) { 524 ret = EIO; 525 goto error; 526 } 527 memcpy(outbuf, bouncebuf + head, min(secsz - head, bytes)); 528 outbuf += min(secsz - head, bytes); 529 } 530 531 /* 532 * Full data return from read sectors. 533 * Note, there is still corner case where we read 534 * from sector boundary, but less than sector size, e.g. reading 512B 535 * from 4k sector. 536 */ 537 if (full_sec_size > 0) { 538 if (bytes < full_sec_size) { 539 res = read(fd, bouncebuf, secsz); 540 if (res != secsz) { 541 ret = EIO; 542 goto error; 543 } 544 memcpy(outbuf, bouncebuf, bytes); 545 } else { 546 res = read(fd, outbuf, full_sec_size); 547 if (res != full_sec_size) { 548 ret = EIO; 549 goto error; 550 } 551 outbuf += full_sec_size; 552 } 553 } 554 555 /* Partial data return from last sector */ 556 if (do_tail_read) { 557 res = read(fd, bouncebuf, secsz); 558 if (res != secsz) { 559 ret = EIO; 560 goto error; 561 } 562 memcpy(outbuf, bouncebuf, secsz - tail); 563 } 564 565 ret = 0; 566 error: 567 free(bouncebuf); 568 return (ret); 569 } 570 571 static int 572 vdev_write(vdev_t *vdev, off_t offset, void *buf, size_t bytes) 573 { 574 int fd, ret; 575 size_t head, tail, total_size, full_sec_size; 576 unsigned secsz, do_tail_write; 577 off_t start_sec; 578 ssize_t res; 579 char *outbuf, *bouncebuf; 580 581 fd = (uintptr_t)vdev->v_priv; 582 outbuf = (char *)buf; 583 bouncebuf = NULL; 584 585 ret = ioctl(fd, DIOCGSECTORSIZE, &secsz); 586 if (ret != 0) 587 return (ret); 588 589 start_sec = offset / secsz; 590 head = offset % secsz; 591 total_size = roundup2(head + bytes, secsz); 592 tail = total_size - (head + bytes); 593 do_tail_write = ((tail > 0) && (head + bytes > secsz)); 594 full_sec_size = total_size; 595 if (head > 0) 596 full_sec_size -= secsz; 597 if (do_tail_write) 598 full_sec_size -= secsz; 599 600 /* Partial sector write requires a bounce buffer. */ 601 if ((head > 0) || do_tail_write || bytes < secsz) { 602 bouncebuf = malloc(secsz); 603 if (bouncebuf == NULL) { 604 printf("vdev_write: out of memory\n"); 605 return (ENOMEM); 606 } 607 } 608 609 if (lseek(fd, start_sec * secsz, SEEK_SET) == -1) { 610 ret = errno; 611 goto error; 612 } 613 614 /* Partial data for first sector */ 615 if (head > 0) { 616 res = read(fd, bouncebuf, secsz); 617 if ((unsigned)res != secsz) { 618 ret = EIO; 619 goto error; 620 } 621 memcpy(bouncebuf + head, outbuf, min(secsz - head, bytes)); 622 (void) lseek(fd, -secsz, SEEK_CUR); 623 res = write(fd, bouncebuf, secsz); 624 if ((unsigned)res != secsz) { 625 ret = EIO; 626 goto error; 627 } 628 outbuf += min(secsz - head, bytes); 629 } 630 631 /* 632 * Full data write to sectors. 633 * Note, there is still corner case where we write 634 * to sector boundary, but less than sector size, e.g. write 512B 635 * to 4k sector. 636 */ 637 if (full_sec_size > 0) { 638 if (bytes < full_sec_size) { 639 res = read(fd, bouncebuf, secsz); 640 if ((unsigned)res != secsz) { 641 ret = EIO; 642 goto error; 643 } 644 memcpy(bouncebuf, outbuf, bytes); 645 (void) lseek(fd, -secsz, SEEK_CUR); 646 res = write(fd, bouncebuf, secsz); 647 if ((unsigned)res != secsz) { 648 ret = EIO; 649 goto error; 650 } 651 } else { 652 res = write(fd, outbuf, full_sec_size); 653 if ((unsigned)res != full_sec_size) { 654 ret = EIO; 655 goto error; 656 } 657 outbuf += full_sec_size; 658 } 659 } 660 661 /* Partial data write to last sector */ 662 if (do_tail_write) { 663 res = read(fd, bouncebuf, secsz); 664 if ((unsigned)res != secsz) { 665 ret = EIO; 666 goto error; 667 } 668 memcpy(bouncebuf, outbuf, secsz - tail); 669 (void) lseek(fd, -secsz, SEEK_CUR); 670 res = write(fd, bouncebuf, secsz); 671 if ((unsigned)res != secsz) { 672 ret = EIO; 673 goto error; 674 } 675 } 676 677 ret = 0; 678 error: 679 free(bouncebuf); 680 return (ret); 681 } 682 683 static int 684 zfs_dev_init(void) 685 { 686 spa_t *spa; 687 spa_t *next; 688 spa_t *prev; 689 690 zfs_init(); 691 if (archsw.arch_zfs_probe == NULL) 692 return (ENXIO); 693 archsw.arch_zfs_probe(); 694 695 prev = NULL; 696 spa = STAILQ_FIRST(&zfs_pools); 697 while (spa != NULL) { 698 next = STAILQ_NEXT(spa, spa_link); 699 if (zfs_spa_init(spa)) { 700 if (prev == NULL) 701 STAILQ_REMOVE_HEAD(&zfs_pools, spa_link); 702 else 703 STAILQ_REMOVE_AFTER(&zfs_pools, prev, spa_link); 704 } else 705 prev = spa; 706 spa = next; 707 } 708 return (0); 709 } 710 711 struct zfs_probe_args { 712 int fd; 713 const char *devname; 714 uint64_t *pool_guid; 715 u_int secsz; 716 }; 717 718 static int 719 zfs_diskread(void *arg, void *buf, size_t blocks, uint64_t offset) 720 { 721 struct zfs_probe_args *ppa; 722 723 ppa = (struct zfs_probe_args *)arg; 724 return (vdev_read(NULL, (void *)(uintptr_t)ppa->fd, 725 offset * ppa->secsz, buf, blocks * ppa->secsz)); 726 } 727 728 static int 729 zfs_probe(int fd, uint64_t *pool_guid) 730 { 731 spa_t *spa; 732 int ret; 733 734 spa = NULL; 735 ret = vdev_probe(vdev_read, vdev_write, (void *)(uintptr_t)fd, &spa); 736 if (ret == 0 && pool_guid != NULL) 737 if (*pool_guid == 0) 738 *pool_guid = spa->spa_guid; 739 return (ret); 740 } 741 742 static int 743 zfs_probe_partition(void *arg, const char *partname, 744 const struct ptable_entry *part) 745 { 746 struct zfs_probe_args *ppa, pa; 747 struct ptable *table; 748 char devname[32]; 749 int ret; 750 751 /* Probe only freebsd-zfs and freebsd partitions */ 752 if (part->type != PART_FREEBSD && 753 part->type != PART_FREEBSD_ZFS) 754 return (0); 755 756 ppa = (struct zfs_probe_args *)arg; 757 strncpy(devname, ppa->devname, strlen(ppa->devname) - 1); 758 devname[strlen(ppa->devname) - 1] = '\0'; 759 snprintf(devname, sizeof(devname), "%s%s:", devname, partname); 760 pa.fd = open(devname, O_RDWR); 761 if (pa.fd == -1) 762 return (0); 763 ret = zfs_probe(pa.fd, ppa->pool_guid); 764 if (ret == 0) 765 return (0); 766 /* Do we have BSD label here? */ 767 if (part->type == PART_FREEBSD) { 768 pa.devname = devname; 769 pa.pool_guid = ppa->pool_guid; 770 pa.secsz = ppa->secsz; 771 table = ptable_open(&pa, part->end - part->start + 1, 772 ppa->secsz, zfs_diskread); 773 if (table != NULL) { 774 ptable_iterate(table, &pa, zfs_probe_partition); 775 ptable_close(table); 776 } 777 } 778 close(pa.fd); 779 return (0); 780 } 781 782 /* 783 * Return bootenv nvlist from pool label. 784 */ 785 int 786 zfs_get_bootenv(void *vdev, nvlist_t **benvp) 787 { 788 struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev; 789 nvlist_t *benv = NULL; 790 vdev_t *vd; 791 spa_t *spa; 792 793 if (dev->dd.d_dev->dv_type != DEVT_ZFS) 794 return (ENOTSUP); 795 796 if ((spa = spa_find_by_dev(dev)) == NULL) 797 return (ENXIO); 798 799 if (spa->spa_bootenv == NULL) { 800 STAILQ_FOREACH(vd, &spa->spa_root_vdev->v_children, 801 v_childlink) { 802 benv = vdev_read_bootenv(vd); 803 804 if (benv != NULL) 805 break; 806 } 807 spa->spa_bootenv = benv; 808 } else { 809 benv = spa->spa_bootenv; 810 } 811 812 if (benv == NULL) 813 return (ENOENT); 814 815 *benvp = benv; 816 return (0); 817 } 818 819 /* 820 * Store nvlist to pool label bootenv area. Also updates cached pointer in spa. 821 */ 822 int 823 zfs_set_bootenv(void *vdev, nvlist_t *benv) 824 { 825 struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev; 826 spa_t *spa; 827 vdev_t *vd; 828 829 if (dev->dd.d_dev->dv_type != DEVT_ZFS) 830 return (ENOTSUP); 831 832 if ((spa = spa_find_by_dev(dev)) == NULL) 833 return (ENXIO); 834 835 STAILQ_FOREACH(vd, &spa->spa_root_vdev->v_children, v_childlink) { 836 vdev_write_bootenv(vd, benv); 837 } 838 839 spa->spa_bootenv = benv; 840 return (0); 841 } 842 843 /* 844 * Get bootonce value by key. The bootonce <key, value> pair is removed 845 * from the bootenv nvlist and the remaining nvlist is committed back to disk. 846 */ 847 int 848 zfs_get_bootonce(void *vdev, const char *key, char *buf, size_t size) 849 { 850 nvlist_t *benv; 851 char *result = NULL; 852 int result_size, rv; 853 854 if ((rv = zfs_get_bootenv(vdev, &benv)) != 0) 855 return (rv); 856 857 if ((rv = nvlist_find(benv, key, DATA_TYPE_STRING, NULL, 858 &result, &result_size)) == 0) { 859 if (result_size == 0) { 860 /* ignore empty string */ 861 rv = ENOENT; 862 } else { 863 size = MIN((size_t)result_size + 1, size); 864 strlcpy(buf, result, size); 865 } 866 (void) nvlist_remove(benv, key, DATA_TYPE_STRING); 867 (void) zfs_set_bootenv(vdev, benv); 868 } 869 870 return (rv); 871 } 872 873 /* 874 * nvstore backend. 875 */ 876 877 static int zfs_nvstore_setter(void *, int, const char *, 878 const void *, size_t); 879 static int zfs_nvstore_setter_str(void *, const char *, const char *, 880 const char *); 881 static int zfs_nvstore_unset_impl(void *, const char *, bool); 882 static int zfs_nvstore_setenv(void *, void *); 883 884 /* 885 * nvstore is only present for current rootfs pool. 886 */ 887 static int 888 zfs_nvstore_sethook(struct env_var *ev, int flags __unused, const void *value) 889 { 890 struct zfs_devdesc *dev; 891 int rv; 892 893 archsw.arch_getdev((void **)&dev, NULL, NULL); 894 if (dev == NULL) 895 return (ENXIO); 896 897 rv = zfs_nvstore_setter_str(dev, NULL, ev->ev_name, value); 898 899 free(dev); 900 return (rv); 901 } 902 903 /* 904 * nvstore is only present for current rootfs pool. 905 */ 906 static int 907 zfs_nvstore_unsethook(struct env_var *ev) 908 { 909 struct zfs_devdesc *dev; 910 int rv; 911 912 archsw.arch_getdev((void **)&dev, NULL, NULL); 913 if (dev == NULL) 914 return (ENXIO); 915 916 rv = zfs_nvstore_unset_impl(dev, ev->ev_name, false); 917 918 free(dev); 919 return (rv); 920 } 921 922 static int 923 zfs_nvstore_getter(void *vdev, const char *name, void **data) 924 { 925 struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev; 926 spa_t *spa; 927 nvlist_t *nv; 928 char *str, **ptr; 929 int size; 930 int rv; 931 932 if (dev->dd.d_dev->dv_type != DEVT_ZFS) 933 return (ENOTSUP); 934 935 if ((spa = spa_find_by_dev(dev)) == NULL) 936 return (ENXIO); 937 938 if (spa->spa_bootenv == NULL) 939 return (ENXIO); 940 941 if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST, 942 NULL, &nv, NULL) != 0) 943 return (ENOENT); 944 945 rv = nvlist_find(nv, name, DATA_TYPE_STRING, NULL, &str, &size); 946 if (rv == 0) { 947 ptr = (char **)data; 948 asprintf(ptr, "%.*s", size, str); 949 if (*data == NULL) 950 rv = ENOMEM; 951 } 952 nvlist_destroy(nv); 953 return (rv); 954 } 955 956 static int 957 zfs_nvstore_setter(void *vdev, int type, const char *name, 958 const void *data, size_t size) 959 { 960 struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev; 961 spa_t *spa; 962 nvlist_t *nv; 963 int rv; 964 bool env_set = true; 965 966 if (dev->dd.d_dev->dv_type != DEVT_ZFS) 967 return (ENOTSUP); 968 969 if ((spa = spa_find_by_dev(dev)) == NULL) 970 return (ENXIO); 971 972 if (spa->spa_bootenv == NULL) 973 return (ENXIO); 974 975 if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST, 976 NULL, &nv, NULL) != 0) { 977 nv = nvlist_create(NV_UNIQUE_NAME); 978 if (nv == NULL) 979 return (ENOMEM); 980 } 981 982 rv = 0; 983 switch (type) { 984 case DATA_TYPE_INT8: 985 if (size != sizeof (int8_t)) { 986 rv = EINVAL; 987 break; 988 } 989 rv = nvlist_add_int8(nv, name, *(int8_t *)data); 990 break; 991 992 case DATA_TYPE_INT16: 993 if (size != sizeof (int16_t)) { 994 rv = EINVAL; 995 break; 996 } 997 rv = nvlist_add_int16(nv, name, *(int16_t *)data); 998 break; 999 1000 case DATA_TYPE_INT32: 1001 if (size != sizeof (int32_t)) { 1002 rv = EINVAL; 1003 break; 1004 } 1005 rv = nvlist_add_int32(nv, name, *(int32_t *)data); 1006 break; 1007 1008 case DATA_TYPE_INT64: 1009 if (size != sizeof (int64_t)) { 1010 rv = EINVAL; 1011 break; 1012 } 1013 rv = nvlist_add_int64(nv, name, *(int64_t *)data); 1014 break; 1015 1016 case DATA_TYPE_BYTE: 1017 if (size != sizeof (uint8_t)) { 1018 rv = EINVAL; 1019 break; 1020 } 1021 rv = nvlist_add_byte(nv, name, *(int8_t *)data); 1022 break; 1023 1024 case DATA_TYPE_UINT8: 1025 if (size != sizeof (uint8_t)) { 1026 rv = EINVAL; 1027 break; 1028 } 1029 rv = nvlist_add_uint8(nv, name, *(int8_t *)data); 1030 break; 1031 1032 case DATA_TYPE_UINT16: 1033 if (size != sizeof (uint16_t)) { 1034 rv = EINVAL; 1035 break; 1036 } 1037 rv = nvlist_add_uint16(nv, name, *(uint16_t *)data); 1038 break; 1039 1040 case DATA_TYPE_UINT32: 1041 if (size != sizeof (uint32_t)) { 1042 rv = EINVAL; 1043 break; 1044 } 1045 rv = nvlist_add_uint32(nv, name, *(uint32_t *)data); 1046 break; 1047 1048 case DATA_TYPE_UINT64: 1049 if (size != sizeof (uint64_t)) { 1050 rv = EINVAL; 1051 break; 1052 } 1053 rv = nvlist_add_uint64(nv, name, *(uint64_t *)data); 1054 break; 1055 1056 case DATA_TYPE_STRING: 1057 rv = nvlist_add_string(nv, name, data); 1058 break; 1059 1060 case DATA_TYPE_BOOLEAN_VALUE: 1061 if (size != sizeof (boolean_t)) { 1062 rv = EINVAL; 1063 break; 1064 } 1065 rv = nvlist_add_boolean_value(nv, name, *(boolean_t *)data); 1066 break; 1067 1068 default: 1069 rv = EINVAL; 1070 break; 1071 } 1072 1073 if (rv == 0) { 1074 rv = nvlist_add_nvlist(spa->spa_bootenv, OS_NVSTORE, nv); 1075 if (rv == 0) { 1076 rv = zfs_set_bootenv(vdev, spa->spa_bootenv); 1077 } 1078 if (rv == 0) { 1079 if (env_set) { 1080 rv = zfs_nvstore_setenv(vdev, 1081 nvpair_find(nv, name)); 1082 } else { 1083 env_discard(env_getenv(name)); 1084 rv = 0; 1085 } 1086 } 1087 } 1088 1089 nvlist_destroy(nv); 1090 return (rv); 1091 } 1092 1093 static int 1094 get_int64(const char *data, int64_t *ip) 1095 { 1096 char *end; 1097 int64_t val; 1098 1099 errno = 0; 1100 val = strtoll(data, &end, 0); 1101 if (errno != 0 || *data == '\0' || *end != '\0') 1102 return (EINVAL); 1103 1104 *ip = val; 1105 return (0); 1106 } 1107 1108 static int 1109 get_uint64(const char *data, uint64_t *ip) 1110 { 1111 char *end; 1112 uint64_t val; 1113 1114 errno = 0; 1115 val = strtoull(data, &end, 0); 1116 if (errno != 0 || *data == '\0' || *end != '\0') 1117 return (EINVAL); 1118 1119 *ip = val; 1120 return (0); 1121 } 1122 1123 /* 1124 * Translate textual data to data type. If type is not set, and we are 1125 * creating new pair, use DATA_TYPE_STRING. 1126 */ 1127 static int 1128 zfs_nvstore_setter_str(void *vdev, const char *type, const char *name, 1129 const char *data) 1130 { 1131 struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev; 1132 spa_t *spa; 1133 nvlist_t *nv; 1134 int rv; 1135 data_type_t dt; 1136 int64_t val; 1137 uint64_t uval; 1138 1139 if (dev->dd.d_dev->dv_type != DEVT_ZFS) 1140 return (ENOTSUP); 1141 1142 if ((spa = spa_find_by_dev(dev)) == NULL) 1143 return (ENXIO); 1144 1145 if (spa->spa_bootenv == NULL) 1146 return (ENXIO); 1147 1148 if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST, 1149 NULL, &nv, NULL) != 0) { 1150 nv = NULL; 1151 } 1152 1153 if (type == NULL) { 1154 nvp_header_t *nvh; 1155 1156 /* 1157 * if there is no existing pair, default to string. 1158 * Otherwise, use type from existing pair. 1159 */ 1160 nvh = nvpair_find(nv, name); 1161 if (nvh == NULL) { 1162 dt = DATA_TYPE_STRING; 1163 } else { 1164 nv_string_t *nvp_name; 1165 nv_pair_data_t *nvp_data; 1166 1167 nvp_name = (nv_string_t *)(nvh + 1); 1168 nvp_data = (nv_pair_data_t *)(&nvp_name->nv_data[0] + 1169 NV_ALIGN4(nvp_name->nv_size)); 1170 dt = nvp_data->nv_type; 1171 } 1172 } else { 1173 dt = nvpair_type_from_name(type); 1174 } 1175 nvlist_destroy(nv); 1176 1177 rv = 0; 1178 switch (dt) { 1179 case DATA_TYPE_INT8: 1180 rv = get_int64(data, &val); 1181 if (rv == 0) { 1182 int8_t v = val; 1183 1184 rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v)); 1185 } 1186 break; 1187 case DATA_TYPE_INT16: 1188 rv = get_int64(data, &val); 1189 if (rv == 0) { 1190 int16_t v = val; 1191 1192 rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v)); 1193 } 1194 break; 1195 case DATA_TYPE_INT32: 1196 rv = get_int64(data, &val); 1197 if (rv == 0) { 1198 int32_t v = val; 1199 1200 rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v)); 1201 } 1202 break; 1203 case DATA_TYPE_INT64: 1204 rv = get_int64(data, &val); 1205 if (rv == 0) { 1206 rv = zfs_nvstore_setter(vdev, dt, name, &val, 1207 sizeof (val)); 1208 } 1209 break; 1210 1211 case DATA_TYPE_BYTE: 1212 rv = get_uint64(data, &uval); 1213 if (rv == 0) { 1214 uint8_t v = uval; 1215 1216 rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v)); 1217 } 1218 break; 1219 1220 case DATA_TYPE_UINT8: 1221 rv = get_uint64(data, &uval); 1222 if (rv == 0) { 1223 uint8_t v = uval; 1224 1225 rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v)); 1226 } 1227 break; 1228 1229 case DATA_TYPE_UINT16: 1230 rv = get_uint64(data, &uval); 1231 if (rv == 0) { 1232 uint16_t v = uval; 1233 1234 rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v)); 1235 } 1236 break; 1237 1238 case DATA_TYPE_UINT32: 1239 rv = get_uint64(data, &uval); 1240 if (rv == 0) { 1241 uint32_t v = uval; 1242 1243 rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v)); 1244 } 1245 break; 1246 1247 case DATA_TYPE_UINT64: 1248 rv = get_uint64(data, &uval); 1249 if (rv == 0) { 1250 rv = zfs_nvstore_setter(vdev, dt, name, &uval, 1251 sizeof (uval)); 1252 } 1253 break; 1254 1255 case DATA_TYPE_STRING: 1256 rv = zfs_nvstore_setter(vdev, dt, name, data, strlen(data) + 1); 1257 break; 1258 1259 case DATA_TYPE_BOOLEAN_VALUE: 1260 rv = get_int64(data, &val); 1261 if (rv == 0) { 1262 boolean_t v = val; 1263 1264 rv = zfs_nvstore_setter(vdev, dt, name, &v, sizeof (v)); 1265 } 1266 1267 default: 1268 rv = EINVAL; 1269 } 1270 return (rv); 1271 } 1272 1273 static int 1274 zfs_nvstore_unset_impl(void *vdev, const char *name, bool unset_env) 1275 { 1276 struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev; 1277 spa_t *spa; 1278 nvlist_t *nv; 1279 int rv; 1280 1281 if (dev->dd.d_dev->dv_type != DEVT_ZFS) 1282 return (ENOTSUP); 1283 1284 if ((spa = spa_find_by_dev(dev)) == NULL) 1285 return (ENXIO); 1286 1287 if (spa->spa_bootenv == NULL) 1288 return (ENXIO); 1289 1290 if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST, 1291 NULL, &nv, NULL) != 0) 1292 return (ENOENT); 1293 1294 rv = nvlist_remove(nv, name, DATA_TYPE_UNKNOWN); 1295 if (rv == 0) { 1296 if (nvlist_next_nvpair(nv, NULL) == NULL) { 1297 rv = nvlist_remove(spa->spa_bootenv, OS_NVSTORE, 1298 DATA_TYPE_NVLIST); 1299 } else { 1300 rv = nvlist_add_nvlist(spa->spa_bootenv, 1301 OS_NVSTORE, nv); 1302 } 1303 if (rv == 0) 1304 rv = zfs_set_bootenv(vdev, spa->spa_bootenv); 1305 } 1306 1307 if (unset_env) 1308 env_discard(env_getenv(name)); 1309 return (rv); 1310 } 1311 1312 static int 1313 zfs_nvstore_unset(void *vdev, const char *name) 1314 { 1315 return (zfs_nvstore_unset_impl(vdev, name, true)); 1316 } 1317 1318 static int 1319 zfs_nvstore_print(void *vdev __unused, void *ptr) 1320 { 1321 1322 nvpair_print(ptr, 0); 1323 return (0); 1324 } 1325 1326 /* 1327 * Create environment variable from nvpair. 1328 * set hook will update nvstore with new value, unset hook will remove 1329 * variable from nvstore. 1330 */ 1331 static int 1332 zfs_nvstore_setenv(void *vdev __unused, void *ptr) 1333 { 1334 nvp_header_t *nvh = ptr; 1335 nv_string_t *nvp_name, *nvp_value; 1336 nv_pair_data_t *nvp_data; 1337 char *name, *value; 1338 int rv = 0; 1339 1340 if (nvh == NULL) 1341 return (ENOENT); 1342 1343 nvp_name = (nv_string_t *)(nvh + 1); 1344 nvp_data = (nv_pair_data_t *)(&nvp_name->nv_data[0] + 1345 NV_ALIGN4(nvp_name->nv_size)); 1346 1347 if ((name = nvstring_get(nvp_name)) == NULL) 1348 return (ENOMEM); 1349 1350 value = NULL; 1351 switch (nvp_data->nv_type) { 1352 case DATA_TYPE_BYTE: 1353 case DATA_TYPE_UINT8: 1354 (void) asprintf(&value, "%uc", 1355 *(unsigned *)&nvp_data->nv_data[0]); 1356 if (value == NULL) 1357 rv = ENOMEM; 1358 break; 1359 1360 case DATA_TYPE_INT8: 1361 (void) asprintf(&value, "%c", *(int *)&nvp_data->nv_data[0]); 1362 if (value == NULL) 1363 rv = ENOMEM; 1364 break; 1365 1366 case DATA_TYPE_INT16: 1367 (void) asprintf(&value, "%hd", *(short *)&nvp_data->nv_data[0]); 1368 if (value == NULL) 1369 rv = ENOMEM; 1370 break; 1371 1372 case DATA_TYPE_UINT16: 1373 (void) asprintf(&value, "%hu", 1374 *(unsigned short *)&nvp_data->nv_data[0]); 1375 if (value == NULL) 1376 rv = ENOMEM; 1377 break; 1378 1379 case DATA_TYPE_BOOLEAN_VALUE: 1380 case DATA_TYPE_INT32: 1381 (void) asprintf(&value, "%d", *(int *)&nvp_data->nv_data[0]); 1382 if (value == NULL) 1383 rv = ENOMEM; 1384 break; 1385 1386 case DATA_TYPE_UINT32: 1387 (void) asprintf(&value, "%u", 1388 *(unsigned *)&nvp_data->nv_data[0]); 1389 if (value == NULL) 1390 rv = ENOMEM; 1391 break; 1392 1393 case DATA_TYPE_INT64: 1394 (void) asprintf(&value, "%jd", 1395 (intmax_t)*(int64_t *)&nvp_data->nv_data[0]); 1396 if (value == NULL) 1397 rv = ENOMEM; 1398 break; 1399 1400 case DATA_TYPE_UINT64: 1401 (void) asprintf(&value, "%ju", 1402 (uintmax_t)*(uint64_t *)&nvp_data->nv_data[0]); 1403 if (value == NULL) 1404 rv = ENOMEM; 1405 break; 1406 1407 case DATA_TYPE_STRING: 1408 nvp_value = (nv_string_t *)&nvp_data->nv_data[0]; 1409 if ((value = nvstring_get(nvp_value)) == NULL) { 1410 rv = ENOMEM; 1411 break; 1412 } 1413 break; 1414 1415 default: 1416 rv = EINVAL; 1417 break; 1418 } 1419 1420 if (value != NULL) { 1421 rv = env_setenv(name, EV_VOLATILE | EV_NOHOOK, value, 1422 zfs_nvstore_sethook, zfs_nvstore_unsethook); 1423 free(value); 1424 } 1425 free(name); 1426 return (rv); 1427 } 1428 1429 static int 1430 zfs_nvstore_iterate(void *vdev, int (*cb)(void *, void *)) 1431 { 1432 struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev; 1433 spa_t *spa; 1434 nvlist_t *nv; 1435 nvp_header_t *nvh; 1436 int rv; 1437 1438 if (dev->dd.d_dev->dv_type != DEVT_ZFS) 1439 return (ENOTSUP); 1440 1441 if ((spa = spa_find_by_dev(dev)) == NULL) 1442 return (ENXIO); 1443 1444 if (spa->spa_bootenv == NULL) 1445 return (ENXIO); 1446 1447 if (nvlist_find(spa->spa_bootenv, OS_NVSTORE, DATA_TYPE_NVLIST, 1448 NULL, &nv, NULL) != 0) 1449 return (ENOENT); 1450 1451 rv = 0; 1452 nvh = NULL; 1453 while ((nvh = nvlist_next_nvpair(nv, nvh)) != NULL) { 1454 rv = cb(vdev, nvh); 1455 if (rv != 0) 1456 break; 1457 } 1458 return (rv); 1459 } 1460 1461 nvs_callbacks_t nvstore_zfs_cb = { 1462 .nvs_getter = zfs_nvstore_getter, 1463 .nvs_setter = zfs_nvstore_setter, 1464 .nvs_setter_str = zfs_nvstore_setter_str, 1465 .nvs_unset = zfs_nvstore_unset, 1466 .nvs_print = zfs_nvstore_print, 1467 .nvs_iterate = zfs_nvstore_iterate 1468 }; 1469 1470 int 1471 zfs_attach_nvstore(void *vdev) 1472 { 1473 struct zfs_devdesc *dev = vdev; 1474 spa_t *spa; 1475 uint64_t version; 1476 int rv; 1477 1478 if (dev->dd.d_dev->dv_type != DEVT_ZFS) 1479 return (ENOTSUP); 1480 1481 if ((spa = spa_find_by_dev(dev)) == NULL) 1482 return (ENXIO); 1483 1484 rv = nvlist_find(spa->spa_bootenv, BOOTENV_VERSION, DATA_TYPE_UINT64, 1485 NULL, &version, NULL); 1486 1487 if (rv != 0 || version != VB_NVLIST) { 1488 return (ENXIO); 1489 } 1490 1491 dev = malloc(sizeof (*dev)); 1492 if (dev == NULL) 1493 return (ENOMEM); 1494 memcpy(dev, vdev, sizeof (*dev)); 1495 1496 rv = nvstore_init(spa->spa_name, &nvstore_zfs_cb, dev); 1497 if (rv != 0) 1498 free(dev); 1499 else 1500 rv = zfs_nvstore_iterate(dev, zfs_nvstore_setenv); 1501 return (rv); 1502 } 1503 1504 int 1505 zfs_probe_dev(const char *devname, uint64_t *pool_guid, bool parts_too) 1506 { 1507 struct ptable *table; 1508 struct zfs_probe_args pa; 1509 uint64_t mediasz; 1510 int ret; 1511 1512 if (pool_guid) 1513 *pool_guid = 0; 1514 pa.fd = open(devname, O_RDWR); 1515 if (pa.fd == -1) 1516 return (ENXIO); 1517 /* Probe the whole disk */ 1518 ret = zfs_probe(pa.fd, pool_guid); 1519 if (ret == 0) 1520 return (0); 1521 if (!parts_too) 1522 return (ENXIO); 1523 1524 /* Probe each partition */ 1525 ret = ioctl(pa.fd, DIOCGMEDIASIZE, &mediasz); 1526 if (ret == 0) 1527 ret = ioctl(pa.fd, DIOCGSECTORSIZE, &pa.secsz); 1528 if (ret == 0) { 1529 pa.devname = devname; 1530 pa.pool_guid = pool_guid; 1531 table = ptable_open(&pa, mediasz / pa.secsz, pa.secsz, 1532 zfs_diskread); 1533 if (table != NULL) { 1534 ptable_iterate(table, &pa, zfs_probe_partition); 1535 ptable_close(table); 1536 } 1537 } 1538 close(pa.fd); 1539 if (pool_guid && *pool_guid == 0) 1540 ret = ENXIO; 1541 return (ret); 1542 } 1543 1544 /* 1545 * Print information about ZFS pools 1546 */ 1547 static int 1548 zfs_dev_print(int verbose) 1549 { 1550 spa_t *spa; 1551 char line[80]; 1552 int ret = 0; 1553 1554 if (STAILQ_EMPTY(&zfs_pools)) 1555 return (0); 1556 1557 printf("%s devices:", zfs_dev.dv_name); 1558 if ((ret = pager_output("\n")) != 0) 1559 return (ret); 1560 1561 if (verbose) { 1562 return (spa_all_status()); 1563 } 1564 STAILQ_FOREACH(spa, &zfs_pools, spa_link) { 1565 snprintf(line, sizeof(line), " zfs:%s\n", spa->spa_name); 1566 ret = pager_output(line); 1567 if (ret != 0) 1568 break; 1569 } 1570 return (ret); 1571 } 1572 1573 /* 1574 * Attempt to open the pool described by (dev) for use by (f). 1575 */ 1576 static int 1577 zfs_dev_open(struct open_file *f, ...) 1578 { 1579 va_list args; 1580 struct zfs_devdesc *dev; 1581 struct zfsmount *mount; 1582 spa_t *spa; 1583 int rv; 1584 1585 va_start(args, f); 1586 dev = va_arg(args, struct zfs_devdesc *); 1587 va_end(args); 1588 1589 if ((spa = spa_find_by_dev(dev)) == NULL) 1590 return (ENXIO); 1591 1592 STAILQ_FOREACH(mount, &zfsmount, next) { 1593 if (spa->spa_guid == mount->spa->spa_guid) 1594 break; 1595 } 1596 1597 rv = 0; 1598 /* This device is not set as currdev, mount us private copy. */ 1599 if (mount == NULL) 1600 rv = zfs_mount(devformat(&dev->dd), NULL, (void **)&mount); 1601 1602 if (rv == 0) { 1603 dev->dd.d_opendata = mount; 1604 } 1605 return (rv); 1606 } 1607 1608 static int 1609 zfs_dev_close(struct open_file *f) 1610 { 1611 struct devdesc *dev; 1612 struct zfsmount *mnt, *mount; 1613 1614 dev = f->f_devdata; 1615 mnt = dev->d_opendata; 1616 1617 STAILQ_FOREACH(mount, &zfsmount, next) { 1618 if (mnt->spa->spa_guid == mount->spa->spa_guid) 1619 break; 1620 } 1621 1622 /* XXX */ 1623 return (0); 1624 } 1625 1626 static int 1627 zfs_dev_strategy(void *devdata, int rw, daddr_t dblk, size_t size, char *buf, size_t *rsize) 1628 { 1629 1630 return (ENOSYS); 1631 } 1632 1633 struct devsw zfs_dev = { 1634 .dv_name = "zfs", 1635 .dv_type = DEVT_ZFS, 1636 .dv_init = zfs_dev_init, 1637 .dv_strategy = zfs_dev_strategy, 1638 .dv_open = zfs_dev_open, 1639 .dv_close = zfs_dev_close, 1640 .dv_ioctl = noioctl, 1641 .dv_print = zfs_dev_print, 1642 .dv_cleanup = nullsys, 1643 .dv_fmtdev = zfs_fmtdev, 1644 .dv_parsedev = zfs_parsedev, 1645 }; 1646 1647 static int 1648 zfs_parsedev(struct devdesc **idev, const char *devspec, const char **path) 1649 { 1650 static char rootname[ZFS_MAXNAMELEN]; 1651 static char poolname[ZFS_MAXNAMELEN]; 1652 spa_t *spa; 1653 const char *end; 1654 const char *np; 1655 const char *sep; 1656 int rv; 1657 struct zfs_devdesc *dev; 1658 1659 np = devspec + 3; /* Skip the leading 'zfs' */ 1660 if (*np != ':') 1661 return (EINVAL); 1662 np++; 1663 end = strrchr(np, ':'); 1664 if (end == NULL) 1665 return (EINVAL); 1666 sep = strchr(np, '/'); 1667 if (sep == NULL || sep >= end) 1668 sep = end; 1669 memcpy(poolname, np, sep - np); 1670 poolname[sep - np] = '\0'; 1671 if (sep < end) { 1672 sep++; 1673 memcpy(rootname, sep, end - sep); 1674 rootname[end - sep] = '\0'; 1675 } 1676 else 1677 rootname[0] = '\0'; 1678 1679 spa = spa_find_by_name(poolname); 1680 if (!spa) 1681 return (ENXIO); 1682 dev = malloc(sizeof(*dev)); 1683 if (dev == NULL) 1684 return (ENOMEM); 1685 dev->pool_guid = spa->spa_guid; 1686 rv = zfs_lookup_dataset(spa, rootname, &dev->root_guid); 1687 if (rv != 0) { 1688 free(dev); 1689 return (rv); 1690 } 1691 if (path != NULL) 1692 *path = (*end == '\0') ? end : end + 1; 1693 dev->dd.d_dev = &zfs_dev; 1694 *idev = &dev->dd; 1695 return (0); 1696 } 1697 1698 char * 1699 zfs_fmtdev(struct devdesc *vdev) 1700 { 1701 static char rootname[ZFS_MAXNAMELEN]; 1702 static char buf[2 * ZFS_MAXNAMELEN + 8]; 1703 struct zfs_devdesc *dev = (struct zfs_devdesc *)vdev; 1704 spa_t *spa; 1705 1706 buf[0] = '\0'; 1707 if (vdev->d_dev->dv_type != DEVT_ZFS) 1708 return (buf); 1709 1710 /* Do we have any pools? */ 1711 spa = STAILQ_FIRST(&zfs_pools); 1712 if (spa == NULL) 1713 return (buf); 1714 1715 if (dev->pool_guid == 0) 1716 dev->pool_guid = spa->spa_guid; 1717 else 1718 spa = spa_find_by_guid(dev->pool_guid); 1719 1720 if (spa == NULL) { 1721 printf("ZFS: can't find pool by guid\n"); 1722 return (buf); 1723 } 1724 if (dev->root_guid == 0 && zfs_get_root(spa, &dev->root_guid)) { 1725 printf("ZFS: can't find root filesystem\n"); 1726 return (buf); 1727 } 1728 if (zfs_rlookup(spa, dev->root_guid, rootname)) { 1729 printf("ZFS: can't find filesystem by guid\n"); 1730 return (buf); 1731 } 1732 1733 if (rootname[0] == '\0') 1734 snprintf(buf, sizeof(buf), "%s:%s:", dev->dd.d_dev->dv_name, 1735 spa->spa_name); 1736 else 1737 snprintf(buf, sizeof(buf), "%s:%s/%s:", dev->dd.d_dev->dv_name, 1738 spa->spa_name, rootname); 1739 return (buf); 1740 } 1741 1742 static int 1743 split_devname(const char *name, char *poolname, size_t size, 1744 const char **dsnamep) 1745 { 1746 const char *dsname; 1747 size_t len; 1748 1749 ASSERT(name != NULL); 1750 ASSERT(poolname != NULL); 1751 1752 len = strlen(name); 1753 dsname = strchr(name, '/'); 1754 if (dsname != NULL) { 1755 len = dsname - name; 1756 dsname++; 1757 } else 1758 dsname = ""; 1759 1760 if (len + 1 > size) 1761 return (EINVAL); 1762 1763 strlcpy(poolname, name, len + 1); 1764 1765 if (dsnamep != NULL) 1766 *dsnamep = dsname; 1767 1768 return (0); 1769 } 1770 1771 int 1772 zfs_list(const char *name) 1773 { 1774 static char poolname[ZFS_MAXNAMELEN]; 1775 uint64_t objid; 1776 spa_t *spa; 1777 const char *dsname; 1778 int rv; 1779 1780 if (split_devname(name, poolname, sizeof(poolname), &dsname) != 0) 1781 return (EINVAL); 1782 1783 spa = spa_find_by_name(poolname); 1784 if (!spa) 1785 return (ENXIO); 1786 rv = zfs_lookup_dataset(spa, dsname, &objid); 1787 if (rv != 0) 1788 return (rv); 1789 1790 return (zfs_list_dataset(spa, objid)); 1791 } 1792 1793 void 1794 init_zfs_boot_options(const char *currdev_in) 1795 { 1796 char poolname[ZFS_MAXNAMELEN]; 1797 char *beroot, *currdev; 1798 spa_t *spa; 1799 int currdev_len; 1800 const char *dsname; 1801 1802 currdev = NULL; 1803 currdev_len = strlen(currdev_in); 1804 if (currdev_len == 0) 1805 return; 1806 if (strncmp(currdev_in, "zfs:", 4) != 0) 1807 return; 1808 currdev = strdup(currdev_in); 1809 if (currdev == NULL) 1810 return; 1811 /* Remove the trailing : */ 1812 currdev[currdev_len - 1] = '\0'; 1813 1814 setenv("zfs_be_active", currdev, 1); 1815 setenv("zfs_be_currpage", "1", 1); 1816 /* Remove the last element (current bootenv) */ 1817 beroot = strrchr(currdev, '/'); 1818 if (beroot != NULL) 1819 beroot[0] = '\0'; 1820 beroot = strchr(currdev, ':') + 1; 1821 setenv("zfs_be_root", beroot, 1); 1822 1823 if (split_devname(beroot, poolname, sizeof(poolname), &dsname) != 0) 1824 return; 1825 1826 spa = spa_find_by_name(poolname); 1827 if (spa == NULL) 1828 return; 1829 1830 zfs_bootenv_initial("bootenvs", spa, beroot, dsname, 0); 1831 zfs_checkpoints_initial(spa, beroot, dsname); 1832 1833 free(currdev); 1834 } 1835 1836 static void 1837 zfs_checkpoints_initial(spa_t *spa, const char *name, const char *dsname) 1838 { 1839 char envname[32]; 1840 1841 if (spa->spa_uberblock_checkpoint.ub_checkpoint_txg != 0) { 1842 snprintf(envname, sizeof(envname), "zpool_checkpoint"); 1843 setenv(envname, name, 1); 1844 1845 spa->spa_uberblock = &spa->spa_uberblock_checkpoint; 1846 spa->spa_mos = &spa->spa_mos_checkpoint; 1847 1848 zfs_bootenv_initial("bootenvs_check", spa, name, dsname, 1); 1849 1850 spa->spa_uberblock = &spa->spa_uberblock_master; 1851 spa->spa_mos = &spa->spa_mos_master; 1852 } 1853 } 1854 1855 static void 1856 zfs_bootenv_initial(const char *envprefix, spa_t *spa, const char *rootname, 1857 const char *dsname, int checkpoint) 1858 { 1859 char envname[32], envval[256]; 1860 uint64_t objid; 1861 int bootenvs_idx, rv; 1862 1863 SLIST_INIT(&zfs_be_head); 1864 zfs_env_count = 0; 1865 1866 rv = zfs_lookup_dataset(spa, dsname, &objid); 1867 if (rv != 0) 1868 return; 1869 1870 rv = zfs_callback_dataset(spa, objid, zfs_belist_add); 1871 bootenvs_idx = 0; 1872 /* Populate the initial environment variables */ 1873 SLIST_FOREACH_SAFE(zfs_be, &zfs_be_head, entries, zfs_be_tmp) { 1874 /* Enumerate all bootenvs for general usage */ 1875 snprintf(envname, sizeof(envname), "%s[%d]", 1876 envprefix, bootenvs_idx); 1877 snprintf(envval, sizeof(envval), "zfs:%s%s/%s", 1878 checkpoint ? "!" : "", rootname, zfs_be->name); 1879 rv = setenv(envname, envval, 1); 1880 if (rv != 0) 1881 break; 1882 bootenvs_idx++; 1883 } 1884 snprintf(envname, sizeof(envname), "%s_count", envprefix); 1885 snprintf(envval, sizeof(envval), "%d", bootenvs_idx); 1886 setenv(envname, envval, 1); 1887 1888 /* Clean up the SLIST of ZFS BEs */ 1889 while (!SLIST_EMPTY(&zfs_be_head)) { 1890 zfs_be = SLIST_FIRST(&zfs_be_head); 1891 SLIST_REMOVE_HEAD(&zfs_be_head, entries); 1892 free(zfs_be->name); 1893 free(zfs_be); 1894 } 1895 } 1896 1897 int 1898 zfs_bootenv(const char *name) 1899 { 1900 char poolname[ZFS_MAXNAMELEN], *root; 1901 const char *dsname; 1902 char becount[4]; 1903 uint64_t objid; 1904 spa_t *spa; 1905 int rv, pages, perpage, currpage; 1906 1907 if (name == NULL) 1908 return (EINVAL); 1909 if ((root = getenv("zfs_be_root")) == NULL) 1910 return (EINVAL); 1911 1912 if (strcmp(name, root) != 0) { 1913 if (setenv("zfs_be_root", name, 1) != 0) 1914 return (ENOMEM); 1915 } 1916 1917 SLIST_INIT(&zfs_be_head); 1918 zfs_env_count = 0; 1919 1920 if (split_devname(name, poolname, sizeof(poolname), &dsname) != 0) 1921 return (EINVAL); 1922 1923 spa = spa_find_by_name(poolname); 1924 if (!spa) 1925 return (ENXIO); 1926 rv = zfs_lookup_dataset(spa, dsname, &objid); 1927 if (rv != 0) 1928 return (rv); 1929 rv = zfs_callback_dataset(spa, objid, zfs_belist_add); 1930 1931 /* Calculate and store the number of pages of BEs */ 1932 perpage = (ZFS_BE_LAST - ZFS_BE_FIRST + 1); 1933 pages = (zfs_env_count / perpage) + ((zfs_env_count % perpage) > 0 ? 1 : 0); 1934 snprintf(becount, 4, "%d", pages); 1935 if (setenv("zfs_be_pages", becount, 1) != 0) 1936 return (ENOMEM); 1937 1938 /* Roll over the page counter if it has exceeded the maximum */ 1939 currpage = strtol(getenv("zfs_be_currpage"), NULL, 10); 1940 if (currpage > pages) { 1941 if (setenv("zfs_be_currpage", "1", 1) != 0) 1942 return (ENOMEM); 1943 } 1944 1945 /* Populate the menu environment variables */ 1946 zfs_set_env(); 1947 1948 /* Clean up the SLIST of ZFS BEs */ 1949 while (!SLIST_EMPTY(&zfs_be_head)) { 1950 zfs_be = SLIST_FIRST(&zfs_be_head); 1951 SLIST_REMOVE_HEAD(&zfs_be_head, entries); 1952 free(zfs_be->name); 1953 free(zfs_be); 1954 } 1955 1956 return (rv); 1957 } 1958 1959 int 1960 zfs_belist_add(const char *name, uint64_t value __unused) 1961 { 1962 1963 /* Skip special datasets that start with a $ character */ 1964 if (strncmp(name, "$", 1) == 0) { 1965 return (0); 1966 } 1967 /* Add the boot environment to the head of the SLIST */ 1968 zfs_be = malloc(sizeof(struct zfs_be_entry)); 1969 if (zfs_be == NULL) { 1970 return (ENOMEM); 1971 } 1972 zfs_be->name = strdup(name); 1973 if (zfs_be->name == NULL) { 1974 free(zfs_be); 1975 return (ENOMEM); 1976 } 1977 SLIST_INSERT_HEAD(&zfs_be_head, zfs_be, entries); 1978 zfs_env_count++; 1979 1980 return (0); 1981 } 1982 1983 int 1984 zfs_set_env(void) 1985 { 1986 char envname[32], envval[256]; 1987 char *beroot, *pagenum; 1988 int rv, page, ctr; 1989 1990 beroot = getenv("zfs_be_root"); 1991 if (beroot == NULL) { 1992 return (1); 1993 } 1994 1995 pagenum = getenv("zfs_be_currpage"); 1996 if (pagenum != NULL) { 1997 page = strtol(pagenum, NULL, 10); 1998 } else { 1999 page = 1; 2000 } 2001 2002 ctr = 1; 2003 rv = 0; 2004 zfs_env_index = ZFS_BE_FIRST; 2005 SLIST_FOREACH_SAFE(zfs_be, &zfs_be_head, entries, zfs_be_tmp) { 2006 /* Skip to the requested page number */ 2007 if (ctr <= ((ZFS_BE_LAST - ZFS_BE_FIRST + 1) * (page - 1))) { 2008 ctr++; 2009 continue; 2010 } 2011 2012 snprintf(envname, sizeof(envname), "bootenvmenu_caption[%d]", zfs_env_index); 2013 snprintf(envval, sizeof(envval), "%s", zfs_be->name); 2014 rv = setenv(envname, envval, 1); 2015 if (rv != 0) { 2016 break; 2017 } 2018 2019 snprintf(envname, sizeof(envname), "bootenvansi_caption[%d]", zfs_env_index); 2020 rv = setenv(envname, envval, 1); 2021 if (rv != 0){ 2022 break; 2023 } 2024 2025 snprintf(envname, sizeof(envname), "bootenvmenu_command[%d]", zfs_env_index); 2026 rv = setenv(envname, "set_bootenv", 1); 2027 if (rv != 0){ 2028 break; 2029 } 2030 2031 snprintf(envname, sizeof(envname), "bootenv_root[%d]", zfs_env_index); 2032 snprintf(envval, sizeof(envval), "zfs:%s/%s", beroot, zfs_be->name); 2033 rv = setenv(envname, envval, 1); 2034 if (rv != 0){ 2035 break; 2036 } 2037 2038 zfs_env_index++; 2039 if (zfs_env_index > ZFS_BE_LAST) { 2040 break; 2041 } 2042 2043 } 2044 2045 for (; zfs_env_index <= ZFS_BE_LAST; zfs_env_index++) { 2046 snprintf(envname, sizeof(envname), "bootenvmenu_caption[%d]", zfs_env_index); 2047 (void)unsetenv(envname); 2048 snprintf(envname, sizeof(envname), "bootenvansi_caption[%d]", zfs_env_index); 2049 (void)unsetenv(envname); 2050 snprintf(envname, sizeof(envname), "bootenvmenu_command[%d]", zfs_env_index); 2051 (void)unsetenv(envname); 2052 snprintf(envname, sizeof(envname), "bootenv_root[%d]", zfs_env_index); 2053 (void)unsetenv(envname); 2054 } 2055 2056 return (rv); 2057 } 2058