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