1 /* 2 * GRUB -- GRand Unified Bootloader 3 * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. 4 * Copyright 2021 RackTop Systems, Inc. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 */ 20 21 /* 22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* 27 * Copyright (c) 2012, 2015 by Delphix. All rights reserved. 28 * Copyright (c) 2013 by Saso Kiselkov. All rights reserved. 29 * Copyright (c) 2014 Integros [integros.com] 30 */ 31 32 /* 33 * The zfs plug-in routines for GRUB are: 34 * 35 * zfs_mount() - locates a valid uberblock of the root pool and reads 36 * in its MOS at the memory address MOS. 37 * 38 * zfs_open() - locates a plain file object by following the MOS 39 * and places its dnode at the memory address DNODE. 40 * 41 * zfs_read() - read in the data blocks pointed by the DNODE. 42 * 43 * ZFS_SCRATCH is used as a working area. 44 * 45 * (memory addr) MOS DNODE ZFS_SCRATCH 46 * | | | 47 * +-------V---------V----------V---------------+ 48 * memory | | dnode | dnode | scratch | 49 * | | 512B | 512B | area | 50 * +--------------------------------------------+ 51 */ 52 53 #ifdef FSYS_ZFS 54 55 #include "shared.h" 56 #include "filesys.h" 57 #include "fsys_zfs.h" 58 59 /* cache for a file block of the currently zfs_open()-ed file */ 60 static void *file_buf = NULL; 61 static uint64_t file_start = 0; 62 static uint64_t file_end = 0; 63 64 /* cache for a dnode block */ 65 static dnode_phys_t *dnode_buf = NULL; 66 static dnode_phys_t *dnode_mdn = NULL; 67 static uint64_t dnode_start = 0; 68 static uint64_t dnode_end = 0; 69 70 static uint64_t pool_guid = 0; 71 static uberblock_t current_uberblock; 72 static char *stackbase; 73 74 decomp_entry_t decomp_table[ZIO_COMPRESS_FUNCTIONS] = 75 { 76 {"inherit", 0}, /* ZIO_COMPRESS_INHERIT */ 77 {"on", lzjb_decompress}, /* ZIO_COMPRESS_ON */ 78 {"off", 0}, /* ZIO_COMPRESS_OFF */ 79 {"lzjb", lzjb_decompress}, /* ZIO_COMPRESS_LZJB */ 80 {"empty", 0}, /* ZIO_COMPRESS_EMPTY */ 81 {"gzip-1", 0}, /* ZIO_COMPRESS_GZIP_1 */ 82 {"gzip-2", 0}, /* ZIO_COMPRESS_GZIP_2 */ 83 {"gzip-3", 0}, /* ZIO_COMPRESS_GZIP_3 */ 84 {"gzip-4", 0}, /* ZIO_COMPRESS_GZIP_4 */ 85 {"gzip-5", 0}, /* ZIO_COMPRESS_GZIP_5 */ 86 {"gzip-6", 0}, /* ZIO_COMPRESS_GZIP_6 */ 87 {"gzip-7", 0}, /* ZIO_COMPRESS_GZIP_7 */ 88 {"gzip-8", 0}, /* ZIO_COMPRESS_GZIP_8 */ 89 {"gzip-9", 0}, /* ZIO_COMPRESS_GZIP_9 */ 90 {"zle", 0}, /* ZIO_COMPRESS_ZLE */ 91 {"lz4", lz4_decompress} /* ZIO_COMPRESS_LZ4 */ 92 }; 93 94 static int zio_read_data(blkptr_t *bp, void *buf, char *stack); 95 96 /* 97 * Our own version of bcmp(). 98 */ 99 static int 100 zfs_bcmp(const void *s1, const void *s2, size_t n) 101 { 102 const uchar_t *ps1 = s1; 103 const uchar_t *ps2 = s2; 104 105 if (s1 != s2 && n != 0) { 106 do { 107 if (*ps1++ != *ps2++) 108 return (1); 109 } while (--n != 0); 110 } 111 112 return (0); 113 } 114 115 /* 116 * Our own version of log2(). Same thing as highbit()-1. 117 */ 118 static int 119 zfs_log2(uint64_t num) 120 { 121 int i = 0; 122 123 while (num > 1) { 124 i++; 125 num = num >> 1; 126 } 127 128 return (i); 129 } 130 131 /* Checksum Functions */ 132 static void 133 zio_checksum_off(const void *buf, uint64_t size, zio_cksum_t *zcp) 134 { 135 ZIO_SET_CHECKSUM(zcp, 0, 0, 0, 0); 136 } 137 138 /* Checksum Table and Values */ 139 zio_checksum_info_t zio_checksum_table[ZIO_CHECKSUM_FUNCTIONS] = { 140 {{NULL, NULL}, 0, 0, "inherit"}, 141 {{NULL, NULL}, 0, 0, "on"}, 142 {{zio_checksum_off, zio_checksum_off}, 0, 0, "off"}, 143 {{zio_checksum_SHA256, zio_checksum_SHA256}, 1, 1, "label"}, 144 {{zio_checksum_SHA256, zio_checksum_SHA256}, 1, 1, "gang_header"}, 145 {{NULL, NULL}, 0, 0, "zilog"}, 146 {{fletcher_2_native, fletcher_2_byteswap}, 0, 0, "fletcher2"}, 147 {{fletcher_4_native, fletcher_4_byteswap}, 1, 0, "fletcher4"}, 148 {{zio_checksum_SHA256, zio_checksum_SHA256}, 1, 0, "SHA256"}, 149 {{NULL, NULL}, 0, 0, "zilog2"}, 150 {{zio_checksum_off, zio_checksum_off}, 0, 0, "noparity"}, 151 {{zio_checksum_SHA512, NULL}, 0, 0, "SHA512"} 152 }; 153 154 /* 155 * zio_checksum_verify: Provides support for checksum verification. 156 * 157 * Fletcher2, Fletcher4, SHA-256 and SHA-512/256 are supported. 158 * 159 * Return: 160 * -1 = Failure 161 * 0 = Success 162 */ 163 static int 164 zio_checksum_verify(blkptr_t *bp, char *data, int size) 165 { 166 zio_cksum_t zc = bp->blk_cksum; 167 uint32_t checksum = BP_GET_CHECKSUM(bp); 168 int byteswap = BP_SHOULD_BYTESWAP(bp); 169 zio_eck_t *zec = (zio_eck_t *)(data + size) - 1; 170 zio_checksum_info_t *ci = &zio_checksum_table[checksum]; 171 zio_cksum_t actual_cksum, expected_cksum; 172 173 if (byteswap) { 174 grub_printf("byteswap not supported\n"); 175 return (-1); 176 } 177 178 if (checksum >= ZIO_CHECKSUM_FUNCTIONS || ci->ci_func[0] == NULL) { 179 grub_printf("checksum algorithm %u not supported\n", checksum); 180 return (-1); 181 } 182 183 if (ci->ci_eck) { 184 expected_cksum = zec->zec_cksum; 185 zec->zec_cksum = zc; 186 ci->ci_func[0](data, size, &actual_cksum); 187 zec->zec_cksum = expected_cksum; 188 zc = expected_cksum; 189 } else { 190 ci->ci_func[byteswap](data, size, &actual_cksum); 191 } 192 193 if ((actual_cksum.zc_word[0] - zc.zc_word[0]) | 194 (actual_cksum.zc_word[1] - zc.zc_word[1]) | 195 (actual_cksum.zc_word[2] - zc.zc_word[2]) | 196 (actual_cksum.zc_word[3] - zc.zc_word[3])) 197 return (-1); 198 199 return (0); 200 } 201 202 /* 203 * vdev_label_start returns the physical disk offset (in bytes) of 204 * label "l". 205 */ 206 static uint64_t 207 vdev_label_start(uint64_t psize, int l) 208 { 209 return (l * sizeof (vdev_label_t) + (l < VDEV_LABELS / 2 ? 210 0 : psize - VDEV_LABELS * sizeof (vdev_label_t))); 211 } 212 213 /* 214 * vdev_uberblock_compare takes two uberblock structures and returns an integer 215 * indicating the more recent of the two. 216 * Return Value = 1 if ub2 is more recent 217 * Return Value = -1 if ub1 is more recent 218 * The most recent uberblock is determined using its transaction number and 219 * timestamp. The uberblock with the highest transaction number is 220 * considered "newer". If the transaction numbers of the two blocks match, the 221 * timestamps are compared to determine the "newer" of the two. 222 */ 223 static int 224 vdev_uberblock_compare(uberblock_t *ub1, uberblock_t *ub2) 225 { 226 if (ub1->ub_txg < ub2->ub_txg) 227 return (-1); 228 if (ub1->ub_txg > ub2->ub_txg) 229 return (1); 230 231 if (ub1->ub_timestamp < ub2->ub_timestamp) 232 return (-1); 233 if (ub1->ub_timestamp > ub2->ub_timestamp) 234 return (1); 235 236 return (0); 237 } 238 239 /* 240 * Three pieces of information are needed to verify an uberblock: the magic 241 * number, the version number, and the checksum. 242 * 243 * Return: 244 * 0 - Success 245 * -1 - Failure 246 */ 247 static int 248 uberblock_verify(uberblock_t *uber, uint64_t ub_size, uint64_t offset) 249 { 250 blkptr_t bp; 251 252 BP_ZERO(&bp); 253 BP_SET_CHECKSUM(&bp, ZIO_CHECKSUM_LABEL); 254 BP_SET_BYTEORDER(&bp, ZFS_HOST_BYTEORDER); 255 ZIO_SET_CHECKSUM(&bp.blk_cksum, offset, 0, 0, 0); 256 257 if (zio_checksum_verify(&bp, (char *)uber, ub_size) != 0) 258 return (-1); 259 260 if (uber->ub_magic == UBERBLOCK_MAGIC && 261 SPA_VERSION_IS_SUPPORTED(uber->ub_version)) 262 return (0); 263 264 return (-1); 265 } 266 267 /* 268 * Find the best uberblock. 269 * Return: 270 * Success - Pointer to the best uberblock. 271 * Failure - NULL 272 */ 273 static uberblock_t * 274 find_bestub(char *ub_array, uint64_t ashift, uint64_t sector) 275 { 276 uberblock_t *ubbest = NULL; 277 uberblock_t *ubnext; 278 uint64_t offset, ub_size; 279 int i; 280 281 ub_size = VDEV_UBERBLOCK_SIZE(ashift); 282 283 for (i = 0; i < VDEV_UBERBLOCK_COUNT(ashift); i++) { 284 ubnext = (uberblock_t *)ub_array; 285 ub_array += ub_size; 286 offset = (sector << SPA_MINBLOCKSHIFT) + 287 VDEV_UBERBLOCK_OFFSET(ashift, i); 288 289 if (uberblock_verify(ubnext, ub_size, offset) != 0) 290 continue; 291 292 if (ubbest == NULL || 293 vdev_uberblock_compare(ubnext, ubbest) > 0) 294 ubbest = ubnext; 295 } 296 297 return (ubbest); 298 } 299 300 /* 301 * Read a block of data based on the gang block address dva, 302 * and put its data in buf. 303 * 304 * Return: 305 * 0 - success 306 * 1 - failure 307 */ 308 static int 309 zio_read_gang(blkptr_t *bp, dva_t *dva, void *buf, char *stack) 310 { 311 zio_gbh_phys_t *zio_gb; 312 uint64_t offset, sector; 313 blkptr_t tmpbp; 314 int i; 315 316 zio_gb = (zio_gbh_phys_t *)stack; 317 stack += SPA_GANGBLOCKSIZE; 318 offset = DVA_GET_OFFSET(dva); 319 sector = DVA_OFFSET_TO_PHYS_SECTOR(offset); 320 321 /* read in the gang block header */ 322 if (devread(sector, 0, SPA_GANGBLOCKSIZE, (char *)zio_gb) == 0) { 323 grub_printf("failed to read in a gang block header\n"); 324 return (1); 325 } 326 327 /* self checksuming the gang block header */ 328 BP_ZERO(&tmpbp); 329 BP_SET_CHECKSUM(&tmpbp, ZIO_CHECKSUM_GANG_HEADER); 330 BP_SET_BYTEORDER(&tmpbp, ZFS_HOST_BYTEORDER); 331 ZIO_SET_CHECKSUM(&tmpbp.blk_cksum, DVA_GET_VDEV(dva), 332 DVA_GET_OFFSET(dva), bp->blk_birth, 0); 333 if (zio_checksum_verify(&tmpbp, (char *)zio_gb, SPA_GANGBLOCKSIZE)) { 334 grub_printf("failed to checksum a gang block header\n"); 335 return (1); 336 } 337 338 for (i = 0; i < SPA_GBH_NBLKPTRS; i++) { 339 if (BP_IS_HOLE(&zio_gb->zg_blkptr[i])) 340 continue; 341 342 if (zio_read_data(&zio_gb->zg_blkptr[i], buf, stack)) 343 return (1); 344 buf += BP_GET_PSIZE(&zio_gb->zg_blkptr[i]); 345 } 346 347 return (0); 348 } 349 350 /* 351 * Read in a block of raw data to buf. 352 * 353 * Return: 354 * 0 - success 355 * 1 - failure 356 */ 357 static int 358 zio_read_data(blkptr_t *bp, void *buf, char *stack) 359 { 360 int i, psize; 361 362 psize = BP_GET_PSIZE(bp); 363 364 /* pick a good dva from the block pointer */ 365 for (i = 0; i < SPA_DVAS_PER_BP; i++) { 366 uint64_t offset, sector; 367 368 if (bp->blk_dva[i].dva_word[0] == 0 && 369 bp->blk_dva[i].dva_word[1] == 0) 370 continue; 371 372 if (DVA_GET_GANG(&bp->blk_dva[i])) { 373 if (zio_read_gang(bp, &bp->blk_dva[i], buf, stack) != 0) 374 continue; 375 } else { 376 /* read in a data block */ 377 offset = DVA_GET_OFFSET(&bp->blk_dva[i]); 378 sector = DVA_OFFSET_TO_PHYS_SECTOR(offset); 379 if (devread(sector, 0, psize, buf) == 0) 380 continue; 381 } 382 383 /* verify that the checksum matches */ 384 if (zio_checksum_verify(bp, buf, psize) == 0) { 385 return (0); 386 } 387 } 388 389 grub_printf("could not read block due to EIO or ECKSUM\n"); 390 return (1); 391 } 392 393 /* 394 * buf must be at least BPE_GET_PSIZE(bp) bytes long (which will never be 395 * more than BPE_PAYLOAD_SIZE bytes). 396 */ 397 static void 398 decode_embedded_bp_compressed(const blkptr_t *bp, void *buf) 399 { 400 int psize, i; 401 uint8_t *buf8 = buf; 402 uint64_t w = 0; 403 const uint64_t *bp64 = (const uint64_t *)bp; 404 405 psize = BPE_GET_PSIZE(bp); 406 407 /* 408 * Decode the words of the block pointer into the byte array. 409 * Low bits of first word are the first byte (little endian). 410 */ 411 for (i = 0; i < psize; i++) { 412 if (i % sizeof (w) == 0) { 413 /* beginning of a word */ 414 w = *bp64; 415 bp64++; 416 if (!BPE_IS_PAYLOADWORD(bp, bp64)) 417 bp64++; 418 } 419 buf8[i] = BF64_GET(w, (i % sizeof (w)) * NBBY, NBBY); 420 } 421 } 422 423 /* 424 * Fill in the buffer with the (decompressed) payload of the embedded 425 * blkptr_t. Takes into account compression and byteorder (the payload is 426 * treated as a stream of bytes). 427 * Return 0 on success, or ENOSPC if it won't fit in the buffer. 428 */ 429 static int 430 decode_embedded_bp(const blkptr_t *bp, void *buf) 431 { 432 int comp; 433 int lsize, psize; 434 uint8_t *dst = buf; 435 uint64_t w = 0; 436 437 lsize = BPE_GET_LSIZE(bp); 438 psize = BPE_GET_PSIZE(bp); 439 comp = BP_GET_COMPRESS(bp); 440 441 if (comp != ZIO_COMPRESS_OFF) { 442 uint8_t dstbuf[BPE_PAYLOAD_SIZE]; 443 444 if ((unsigned int)comp >= ZIO_COMPRESS_FUNCTIONS || 445 decomp_table[comp].decomp_func == NULL) { 446 grub_printf("compression algorithm not supported\n"); 447 return (ERR_FSYS_CORRUPT); 448 } 449 450 decode_embedded_bp_compressed(bp, dstbuf); 451 decomp_table[comp].decomp_func(dstbuf, buf, psize, lsize); 452 } else { 453 decode_embedded_bp_compressed(bp, buf); 454 } 455 456 return (0); 457 } 458 459 /* 460 * Read in a block of data, verify its checksum, decompress if needed, 461 * and put the uncompressed data in buf. 462 * 463 * Return: 464 * 0 - success 465 * errnum - failure 466 */ 467 static int 468 zio_read(blkptr_t *bp, void *buf, char *stack) 469 { 470 int lsize, psize, comp; 471 char *retbuf; 472 473 if (BP_IS_EMBEDDED(bp)) { 474 if (BPE_GET_ETYPE(bp) != BP_EMBEDDED_TYPE_DATA) { 475 grub_printf("unsupported embedded BP (type=%u)\n", 476 (int)BPE_GET_ETYPE(bp)); 477 return (ERR_FSYS_CORRUPT); 478 } 479 return (decode_embedded_bp(bp, buf)); 480 } 481 482 comp = BP_GET_COMPRESS(bp); 483 lsize = BP_GET_LSIZE(bp); 484 psize = BP_GET_PSIZE(bp); 485 486 if ((unsigned int)comp >= ZIO_COMPRESS_FUNCTIONS || 487 (comp != ZIO_COMPRESS_OFF && 488 decomp_table[comp].decomp_func == NULL)) { 489 grub_printf("compression algorithm not supported\n"); 490 return (ERR_FSYS_CORRUPT); 491 } 492 493 if ((char *)buf < stack && ((char *)buf) + lsize > stack) { 494 grub_printf("not enough memory to fit %u bytes on stack\n", 495 lsize); 496 return (ERR_WONT_FIT); 497 } 498 499 retbuf = buf; 500 if (comp != ZIO_COMPRESS_OFF) { 501 buf = stack; 502 stack += psize; 503 } 504 505 if (zio_read_data(bp, buf, stack) != 0) { 506 grub_printf("zio_read_data failed\n"); 507 return (ERR_FSYS_CORRUPT); 508 } 509 510 if (comp != ZIO_COMPRESS_OFF) { 511 if (decomp_table[comp].decomp_func(buf, retbuf, psize, 512 lsize) != 0) { 513 grub_printf("zio_read decompression failed\n"); 514 return (ERR_FSYS_CORRUPT); 515 } 516 } 517 518 return (0); 519 } 520 521 /* 522 * Get the block from a block id. 523 * push the block onto the stack. 524 * 525 * Return: 526 * 0 - success 527 * errnum - failure 528 */ 529 static int 530 dmu_read(dnode_phys_t *dn, uint64_t blkid, void *buf, char *stack) 531 { 532 int idx, level; 533 blkptr_t *bp_array = dn->dn_blkptr; 534 int epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT; 535 blkptr_t *bp, *tmpbuf; 536 537 bp = (blkptr_t *)stack; 538 stack += sizeof (blkptr_t); 539 540 tmpbuf = (blkptr_t *)stack; 541 stack += 1<<dn->dn_indblkshift; 542 543 for (level = dn->dn_nlevels - 1; level >= 0; level--) { 544 idx = (blkid >> (epbs * level)) & ((1<<epbs)-1); 545 *bp = bp_array[idx]; 546 if (level == 0) 547 tmpbuf = buf; 548 if (BP_IS_HOLE(bp)) { 549 grub_memset(buf, 0, 550 dn->dn_datablkszsec << SPA_MINBLOCKSHIFT); 551 break; 552 } else if (errnum = zio_read(bp, tmpbuf, stack)) { 553 return (errnum); 554 } 555 556 bp_array = tmpbuf; 557 } 558 559 return (0); 560 } 561 562 /* 563 * mzap_lookup: Looks up property described by "name" and returns the value 564 * in "value". 565 * 566 * Return: 567 * 0 - success 568 * errnum - failure 569 */ 570 static int 571 mzap_lookup(mzap_phys_t *zapobj, int objsize, const char *name, 572 uint64_t *value) 573 { 574 int i, chunks; 575 mzap_ent_phys_t *mzap_ent = zapobj->mz_chunk; 576 577 chunks = objsize / MZAP_ENT_LEN - 1; 578 for (i = 0; i < chunks; i++) { 579 if (grub_strcmp(mzap_ent[i].mze_name, name) == 0) { 580 *value = mzap_ent[i].mze_value; 581 return (0); 582 } 583 } 584 585 return (ERR_FSYS_CORRUPT); 586 } 587 588 static uint64_t 589 zap_hash(uint64_t salt, const char *name) 590 { 591 static uint64_t table[256]; 592 const uint8_t *cp; 593 uint8_t c; 594 uint64_t crc = salt; 595 596 if (table[128] == 0) { 597 uint64_t *ct; 598 int i, j; 599 for (i = 0; i < 256; i++) { 600 for (ct = table + i, *ct = i, j = 8; j > 0; j--) 601 *ct = (*ct >> 1) ^ (-(*ct & 1) & 602 ZFS_CRC64_POLY); 603 } 604 } 605 606 if (crc == 0 || table[128] != ZFS_CRC64_POLY) { 607 errnum = ERR_FSYS_CORRUPT; 608 return (0); 609 } 610 611 for (cp = (const uint8_t *)name; (c = *cp) != '\0'; cp++) 612 crc = (crc >> 8) ^ table[(crc ^ c) & 0xFF]; 613 614 /* 615 * Only use 28 bits, since we need 4 bits in the cookie for the 616 * collision differentiator. We MUST use the high bits, since 617 * those are the ones that we first pay attention to when 618 * choosing the bucket. 619 */ 620 crc &= ~((1ULL << (64 - 28)) - 1); 621 622 return (crc); 623 } 624 625 /* 626 * Only to be used on 8-bit arrays. 627 * array_len is actual len in bytes (not encoded le_value_length). 628 * buf is null-terminated. 629 */ 630 static int 631 zap_leaf_array_equal(zap_leaf_phys_t *l, int blksft, int chunk, 632 int array_len, const char *buf) 633 { 634 int bseen = 0; 635 636 while (bseen < array_len) { 637 struct zap_leaf_array *la = 638 &ZAP_LEAF_CHUNK(l, blksft, chunk).l_array; 639 int toread = MIN(array_len - bseen, ZAP_LEAF_ARRAY_BYTES); 640 641 if (chunk >= ZAP_LEAF_NUMCHUNKS(blksft)) 642 return (0); 643 644 if (zfs_bcmp(la->la_array, buf + bseen, toread) != 0) 645 break; 646 chunk = la->la_next; 647 bseen += toread; 648 } 649 return (bseen == array_len); 650 } 651 652 /* 653 * Given a zap_leaf_phys_t, walk thru the zap leaf chunks to get the 654 * value for the property "name". 655 * 656 * Return: 657 * 0 - success 658 * errnum - failure 659 */ 660 static int 661 zap_leaf_lookup(zap_leaf_phys_t *l, int blksft, uint64_t h, 662 const char *name, uint64_t *value) 663 { 664 uint16_t chunk; 665 struct zap_leaf_entry *le; 666 667 /* Verify if this is a valid leaf block */ 668 if (l->l_hdr.lh_block_type != ZBT_LEAF) 669 return (ERR_FSYS_CORRUPT); 670 if (l->l_hdr.lh_magic != ZAP_LEAF_MAGIC) 671 return (ERR_FSYS_CORRUPT); 672 673 for (chunk = l->l_hash[LEAF_HASH(blksft, h)]; 674 chunk != CHAIN_END; chunk = le->le_next) { 675 676 if (chunk >= ZAP_LEAF_NUMCHUNKS(blksft)) 677 return (ERR_FSYS_CORRUPT); 678 679 le = ZAP_LEAF_ENTRY(l, blksft, chunk); 680 681 /* Verify the chunk entry */ 682 if (le->le_type != ZAP_CHUNK_ENTRY) 683 return (ERR_FSYS_CORRUPT); 684 685 if (le->le_hash != h) 686 continue; 687 688 if (zap_leaf_array_equal(l, blksft, le->le_name_chunk, 689 le->le_name_length, name)) { 690 691 struct zap_leaf_array *la; 692 uint8_t *ip; 693 694 if (le->le_int_size != 8 || le->le_value_length != 1) 695 return (ERR_FSYS_CORRUPT); 696 697 /* get the uint64_t property value */ 698 la = &ZAP_LEAF_CHUNK(l, blksft, 699 le->le_value_chunk).l_array; 700 ip = la->la_array; 701 702 *value = (uint64_t)ip[0] << 56 | (uint64_t)ip[1] << 48 | 703 (uint64_t)ip[2] << 40 | (uint64_t)ip[3] << 32 | 704 (uint64_t)ip[4] << 24 | (uint64_t)ip[5] << 16 | 705 (uint64_t)ip[6] << 8 | (uint64_t)ip[7]; 706 707 return (0); 708 } 709 } 710 711 return (ERR_FSYS_CORRUPT); 712 } 713 714 /* 715 * Fat ZAP lookup 716 * 717 * Return: 718 * 0 - success 719 * errnum - failure 720 */ 721 static int 722 fzap_lookup(dnode_phys_t *zap_dnode, zap_phys_t *zap, 723 const char *name, uint64_t *value, char *stack) 724 { 725 zap_leaf_phys_t *l; 726 uint64_t hash, idx, blkid; 727 int blksft = zfs_log2(zap_dnode->dn_datablkszsec << DNODE_SHIFT); 728 729 /* Verify if this is a fat zap header block */ 730 if (zap->zap_magic != (uint64_t)ZAP_MAGIC || 731 zap->zap_flags != 0) 732 return (ERR_FSYS_CORRUPT); 733 734 hash = zap_hash(zap->zap_salt, name); 735 if (errnum) 736 return (errnum); 737 738 /* get block id from index */ 739 if (zap->zap_ptrtbl.zt_numblks != 0) { 740 /* external pointer tables not supported */ 741 return (ERR_FSYS_CORRUPT); 742 } 743 idx = ZAP_HASH_IDX(hash, zap->zap_ptrtbl.zt_shift); 744 blkid = ((uint64_t *)zap)[idx + (1<<(blksft-3-1))]; 745 746 /* Get the leaf block */ 747 l = (zap_leaf_phys_t *)stack; 748 stack += 1<<blksft; 749 if ((1<<blksft) < sizeof (zap_leaf_phys_t)) 750 return (ERR_FSYS_CORRUPT); 751 if (errnum = dmu_read(zap_dnode, blkid, l, stack)) 752 return (errnum); 753 754 return (zap_leaf_lookup(l, blksft, hash, name, value)); 755 } 756 757 /* 758 * Read in the data of a zap object and find the value for a matching 759 * property name. 760 * 761 * Return: 762 * 0 - success 763 * errnum - failure 764 */ 765 static int 766 zap_lookup(dnode_phys_t *zap_dnode, const char *name, uint64_t *val, 767 char *stack) 768 { 769 uint64_t block_type; 770 int size; 771 void *zapbuf; 772 773 /* Read in the first block of the zap object data. */ 774 zapbuf = stack; 775 size = zap_dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT; 776 stack += size; 777 778 if ((errnum = dmu_read(zap_dnode, 0, zapbuf, stack)) != 0) 779 return (errnum); 780 781 block_type = *((uint64_t *)zapbuf); 782 783 if (block_type == ZBT_MICRO) { 784 return (mzap_lookup(zapbuf, size, name, val)); 785 } else if (block_type == ZBT_HEADER) { 786 /* this is a fat zap */ 787 return (fzap_lookup(zap_dnode, zapbuf, name, 788 val, stack)); 789 } 790 791 return (ERR_FSYS_CORRUPT); 792 } 793 794 typedef struct zap_attribute { 795 int za_integer_length; 796 uint64_t za_num_integers; 797 uint64_t za_first_integer; 798 char *za_name; 799 } zap_attribute_t; 800 801 typedef int (zap_cb_t)(zap_attribute_t *za, void *arg, char *stack); 802 803 static int 804 zap_iterate(dnode_phys_t *zap_dnode, zap_cb_t *cb, void *arg, char *stack) 805 { 806 uint32_t size = zap_dnode->dn_datablkszsec << SPA_MINBLOCKSHIFT; 807 zap_attribute_t za; 808 int i; 809 mzap_phys_t *mzp = (mzap_phys_t *)stack; 810 stack += size; 811 812 if ((errnum = dmu_read(zap_dnode, 0, mzp, stack)) != 0) 813 return (errnum); 814 815 /* 816 * Iteration over fatzap objects has not yet been implemented. 817 * If we encounter a pool in which there are more features for 818 * read than can fit inside a microzap (i.e., more than 2048 819 * features for read), we can add support for fatzap iteration. 820 * For now, fail. 821 */ 822 if (mzp->mz_block_type != ZBT_MICRO) { 823 grub_printf("feature information stored in fatzap, pool " 824 "version not supported\n"); 825 return (1); 826 } 827 828 za.za_integer_length = 8; 829 za.za_num_integers = 1; 830 for (i = 0; i < size / MZAP_ENT_LEN - 1; i++) { 831 mzap_ent_phys_t *mzep = &mzp->mz_chunk[i]; 832 int err; 833 834 za.za_first_integer = mzep->mze_value; 835 za.za_name = mzep->mze_name; 836 err = cb(&za, arg, stack); 837 if (err != 0) 838 return (err); 839 } 840 841 return (0); 842 } 843 844 /* 845 * Get the dnode of an object number from the metadnode of an object set. 846 * 847 * Input 848 * mdn - metadnode to get the object dnode 849 * objnum - object number for the object dnode 850 * type - if nonzero, object must be of this type 851 * buf - data buffer that holds the returning dnode 852 * stack - scratch area 853 * 854 * Return: 855 * 0 - success 856 * errnum - failure 857 */ 858 static int 859 dnode_get(dnode_phys_t *mdn, uint64_t objnum, uint8_t type, dnode_phys_t *buf, 860 char *stack) 861 { 862 uint64_t blkid, blksz; /* the block id this object dnode is in */ 863 int epbs; /* shift of number of dnodes in a block */ 864 int idx; /* index within a block */ 865 dnode_phys_t *dnbuf; 866 867 blksz = mdn->dn_datablkszsec << SPA_MINBLOCKSHIFT; 868 epbs = zfs_log2(blksz) - DNODE_SHIFT; 869 blkid = objnum >> epbs; 870 idx = objnum & ((1<<epbs)-1); 871 872 if (dnode_buf != NULL && dnode_mdn == mdn && 873 objnum >= dnode_start && objnum < dnode_end) { 874 grub_memmove(buf, &dnode_buf[idx], DNODE_SIZE); 875 VERIFY_DN_TYPE(buf, type); 876 return (0); 877 } 878 879 if (dnode_buf && blksz == 1<<DNODE_BLOCK_SHIFT) { 880 dnbuf = dnode_buf; 881 dnode_mdn = mdn; 882 dnode_start = blkid << epbs; 883 dnode_end = (blkid + 1) << epbs; 884 } else { 885 dnbuf = (dnode_phys_t *)stack; 886 stack += blksz; 887 } 888 889 if (errnum = dmu_read(mdn, blkid, (char *)dnbuf, stack)) 890 return (errnum); 891 892 grub_memmove(buf, &dnbuf[idx], DNODE_SIZE); 893 VERIFY_DN_TYPE(buf, type); 894 895 return (0); 896 } 897 898 /* 899 * Check if this is a special file that resides at the top 900 * dataset of the pool. Currently this is the GRUB menu, 901 * boot signature and boot signature backup. 902 * str starts with '/'. 903 */ 904 static int 905 is_top_dataset_file(char *str) 906 { 907 char *tptr; 908 909 if ((tptr = grub_strstr(str, "menu.lst")) && 910 (tptr[8] == '\0' || tptr[8] == ' ') && 911 *(tptr-1) == '/') 912 return (1); 913 914 if (grub_strncmp(str, BOOTSIGN_DIR"/", 915 grub_strlen(BOOTSIGN_DIR) + 1) == 0) 916 return (1); 917 918 if (grub_strcmp(str, BOOTSIGN_BACKUP) == 0) 919 return (1); 920 921 return (0); 922 } 923 924 static int 925 check_feature(zap_attribute_t *za, void *arg, char *stack) 926 { 927 const char **names = arg; 928 int i; 929 930 if (za->za_first_integer == 0) 931 return (0); 932 933 for (i = 0; names[i] != NULL; i++) { 934 if (grub_strcmp(za->za_name, names[i]) == 0) { 935 return (0); 936 } 937 } 938 grub_printf("missing feature for read '%s'\n", za->za_name); 939 return (ERR_NEWER_VERSION); 940 } 941 942 /* 943 * Get the file dnode for a given file name where mdn is the meta dnode 944 * for this ZFS object set. When found, place the file dnode in dn. 945 * The 'path' argument will be mangled. 946 * 947 * Return: 948 * 0 - success 949 * errnum - failure 950 */ 951 static int 952 dnode_get_path(dnode_phys_t *mdn, char *path, dnode_phys_t *dn, 953 char *stack) 954 { 955 uint64_t objnum, version; 956 char *cname, ch; 957 958 if (errnum = dnode_get(mdn, MASTER_NODE_OBJ, DMU_OT_MASTER_NODE, 959 dn, stack)) 960 return (errnum); 961 962 if (errnum = zap_lookup(dn, ZPL_VERSION_STR, &version, stack)) 963 return (errnum); 964 if (version > ZPL_VERSION) 965 return (-1); 966 967 if (errnum = zap_lookup(dn, ZFS_ROOT_OBJ, &objnum, stack)) 968 return (errnum); 969 970 if (errnum = dnode_get(mdn, objnum, DMU_OT_DIRECTORY_CONTENTS, 971 dn, stack)) 972 return (errnum); 973 974 /* skip leading slashes */ 975 while (*path == '/') 976 path++; 977 978 while (*path && !grub_isspace(*path)) { 979 980 /* get the next component name */ 981 cname = path; 982 while (*path && !grub_isspace(*path) && *path != '/') 983 path++; 984 ch = *path; 985 *path = 0; /* ensure null termination */ 986 987 if (errnum = zap_lookup(dn, cname, &objnum, stack)) 988 return (errnum); 989 990 objnum = ZFS_DIRENT_OBJ(objnum); 991 if (errnum = dnode_get(mdn, objnum, 0, dn, stack)) 992 return (errnum); 993 994 *path = ch; 995 while (*path == '/') 996 path++; 997 } 998 999 /* We found the dnode for this file. Verify if it is a plain file. */ 1000 VERIFY_DN_TYPE(dn, DMU_OT_PLAIN_FILE_CONTENTS); 1001 1002 return (0); 1003 } 1004 1005 /* 1006 * Get the default 'bootfs' property value from the rootpool. 1007 * 1008 * Return: 1009 * 0 - success 1010 * errnum -failure 1011 */ 1012 static int 1013 get_default_bootfsobj(dnode_phys_t *mosmdn, uint64_t *obj, char *stack) 1014 { 1015 uint64_t objnum = 0; 1016 dnode_phys_t *dn = (dnode_phys_t *)stack; 1017 stack += DNODE_SIZE; 1018 1019 if (errnum = dnode_get(mosmdn, DMU_POOL_DIRECTORY_OBJECT, 1020 DMU_OT_OBJECT_DIRECTORY, dn, stack)) 1021 return (errnum); 1022 1023 /* 1024 * find the object number for 'pool_props', and get the dnode 1025 * of the 'pool_props'. 1026 */ 1027 if (zap_lookup(dn, DMU_POOL_PROPS, &objnum, stack)) 1028 return (ERR_FILESYSTEM_NOT_FOUND); 1029 1030 if (errnum = dnode_get(mosmdn, objnum, DMU_OT_POOL_PROPS, dn, stack)) 1031 return (errnum); 1032 1033 if (zap_lookup(dn, ZPOOL_PROP_BOOTFS, &objnum, stack)) 1034 return (ERR_FILESYSTEM_NOT_FOUND); 1035 1036 if (!objnum) 1037 return (ERR_FILESYSTEM_NOT_FOUND); 1038 1039 *obj = objnum; 1040 return (0); 1041 } 1042 1043 /* 1044 * List of pool features that the grub implementation of ZFS supports for 1045 * read. Note that features that are only required for write do not need 1046 * to be listed here since grub opens pools in read-only mode. 1047 * 1048 * When this list is updated the version number in usr/src/grub/capability 1049 * must be incremented to ensure the new grub gets installed. 1050 */ 1051 static const char *spa_feature_names[] = { 1052 "org.illumos:lz4_compress", 1053 "com.delphix:hole_birth", 1054 "com.delphix:extensible_dataset", 1055 "com.delphix:embedded_data", 1056 "org.open-zfs:large_blocks", 1057 "org.illumos:sha512", 1058 NULL 1059 }; 1060 1061 /* 1062 * Checks whether the MOS features that are active are supported by this 1063 * (GRUB's) implementation of ZFS. 1064 * 1065 * Return: 1066 * 0: Success. 1067 * errnum: Failure. 1068 */ 1069 static int 1070 check_mos_features(dnode_phys_t *mosmdn, char *stack) 1071 { 1072 uint64_t objnum; 1073 dnode_phys_t *dn; 1074 uint8_t error = 0; 1075 1076 dn = (dnode_phys_t *)stack; 1077 stack += DNODE_SIZE; 1078 1079 if ((errnum = dnode_get(mosmdn, DMU_POOL_DIRECTORY_OBJECT, 1080 DMU_OT_OBJECT_DIRECTORY, dn, stack)) != 0) 1081 return (errnum); 1082 1083 /* 1084 * Find the object number for 'features_for_read' and retrieve its 1085 * corresponding dnode. Note that we don't check features_for_write 1086 * because GRUB is not opening the pool for write. 1087 */ 1088 if ((errnum = zap_lookup(dn, DMU_POOL_FEATURES_FOR_READ, &objnum, 1089 stack)) != 0) 1090 return (errnum); 1091 1092 if ((errnum = dnode_get(mosmdn, objnum, DMU_OTN_ZAP_METADATA, 1093 dn, stack)) != 0) 1094 return (errnum); 1095 1096 return (zap_iterate(dn, check_feature, spa_feature_names, stack)); 1097 } 1098 1099 /* 1100 * Given a MOS metadnode, get the metadnode of a given filesystem name (fsname), 1101 * e.g. pool/rootfs, or a given object number (obj), e.g. the object number 1102 * of pool/rootfs. 1103 * 1104 * If no fsname and no obj are given, return the DSL_DIR metadnode. 1105 * If fsname is given, return its metadnode and its matching object number. 1106 * If only obj is given, return the metadnode for this object number. 1107 * 1108 * Return: 1109 * 0 - success 1110 * errnum - failure 1111 */ 1112 static int 1113 get_objset_mdn(dnode_phys_t *mosmdn, char *fsname, uint64_t *obj, 1114 dnode_phys_t *mdn, char *stack) 1115 { 1116 uint64_t objnum, headobj; 1117 char *cname, ch; 1118 blkptr_t *bp; 1119 objset_phys_t *osp; 1120 int issnapshot = 0; 1121 char *snapname; 1122 1123 if (fsname == NULL && obj) { 1124 headobj = *obj; 1125 goto skip; 1126 } 1127 1128 if (errnum = dnode_get(mosmdn, DMU_POOL_DIRECTORY_OBJECT, 1129 DMU_OT_OBJECT_DIRECTORY, mdn, stack)) 1130 return (errnum); 1131 1132 if (errnum = zap_lookup(mdn, DMU_POOL_ROOT_DATASET, &objnum, 1133 stack)) 1134 return (errnum); 1135 1136 if (errnum = dnode_get(mosmdn, objnum, 0, mdn, stack)) 1137 return (errnum); 1138 1139 if (fsname == NULL) { 1140 headobj = 1141 ((dsl_dir_phys_t *)DN_BONUS(mdn))->dd_head_dataset_obj; 1142 goto skip; 1143 } 1144 1145 /* take out the pool name */ 1146 while (*fsname && !grub_isspace(*fsname) && *fsname != '/') 1147 fsname++; 1148 1149 while (*fsname && !grub_isspace(*fsname)) { 1150 uint64_t childobj; 1151 1152 while (*fsname == '/') 1153 fsname++; 1154 1155 cname = fsname; 1156 while (*fsname && !grub_isspace(*fsname) && *fsname != '/') 1157 fsname++; 1158 ch = *fsname; 1159 *fsname = 0; 1160 1161 snapname = cname; 1162 while (*snapname && !grub_isspace(*snapname) && *snapname != 1163 '@') 1164 snapname++; 1165 if (*snapname == '@') { 1166 issnapshot = 1; 1167 *snapname = 0; 1168 } 1169 childobj = 1170 ((dsl_dir_phys_t *)DN_BONUS(mdn))->dd_child_dir_zapobj; 1171 if (errnum = dnode_get(mosmdn, childobj, 1172 DMU_OT_DSL_DIR_CHILD_MAP, mdn, stack)) 1173 return (errnum); 1174 1175 if (zap_lookup(mdn, cname, &objnum, stack)) 1176 return (ERR_FILESYSTEM_NOT_FOUND); 1177 1178 if (errnum = dnode_get(mosmdn, objnum, 0, 1179 mdn, stack)) 1180 return (errnum); 1181 1182 *fsname = ch; 1183 if (issnapshot) 1184 *snapname = '@'; 1185 } 1186 headobj = ((dsl_dir_phys_t *)DN_BONUS(mdn))->dd_head_dataset_obj; 1187 if (obj) 1188 *obj = headobj; 1189 1190 skip: 1191 if (errnum = dnode_get(mosmdn, headobj, 0, mdn, stack)) 1192 return (errnum); 1193 if (issnapshot) { 1194 uint64_t snapobj; 1195 1196 snapobj = ((dsl_dataset_phys_t *)DN_BONUS(mdn))-> 1197 ds_snapnames_zapobj; 1198 1199 if (errnum = dnode_get(mosmdn, snapobj, 1200 DMU_OT_DSL_DS_SNAP_MAP, mdn, stack)) 1201 return (errnum); 1202 if (zap_lookup(mdn, snapname + 1, &headobj, stack)) 1203 return (ERR_FILESYSTEM_NOT_FOUND); 1204 if (errnum = dnode_get(mosmdn, headobj, 0, mdn, stack)) 1205 return (errnum); 1206 if (obj) 1207 *obj = headobj; 1208 } 1209 1210 bp = &((dsl_dataset_phys_t *)DN_BONUS(mdn))->ds_bp; 1211 osp = (objset_phys_t *)stack; 1212 stack += sizeof (objset_phys_t); 1213 if (errnum = zio_read(bp, osp, stack)) 1214 return (errnum); 1215 1216 grub_memmove((char *)mdn, (char *)&osp->os_meta_dnode, DNODE_SIZE); 1217 1218 return (0); 1219 } 1220 1221 /* 1222 * For a given XDR packed nvlist, verify the first 4 bytes and move on. 1223 * 1224 * An XDR packed nvlist is encoded as (comments from nvs_xdr_create) : 1225 * 1226 * encoding method/host endian (4 bytes) 1227 * nvl_version (4 bytes) 1228 * nvl_nvflag (4 bytes) 1229 * encoded nvpairs: 1230 * encoded size of the nvpair (4 bytes) 1231 * decoded size of the nvpair (4 bytes) 1232 * name string size (4 bytes) 1233 * name string data (sizeof(NV_ALIGN4(string)) 1234 * data type (4 bytes) 1235 * # of elements in the nvpair (4 bytes) 1236 * data 1237 * 2 zero's for the last nvpair 1238 * (end of the entire list) (8 bytes) 1239 * 1240 * Return: 1241 * 0 - success 1242 * 1 - failure 1243 */ 1244 static int 1245 nvlist_unpack(char *nvlist, char **out) 1246 { 1247 /* Verify if the 1st and 2nd byte in the nvlist are valid. */ 1248 if (nvlist[0] != NV_ENCODE_XDR || nvlist[1] != HOST_ENDIAN) 1249 return (1); 1250 1251 *out = nvlist + 4; 1252 return (0); 1253 } 1254 1255 static char * 1256 nvlist_array(char *nvlist, int index) 1257 { 1258 int i, encode_size; 1259 1260 for (i = 0; i < index; i++) { 1261 /* skip the header, nvl_version, and nvl_nvflag */ 1262 nvlist = nvlist + 4 * 2; 1263 1264 while (encode_size = BSWAP_32(*(uint32_t *)nvlist)) 1265 nvlist += encode_size; /* goto the next nvpair */ 1266 1267 nvlist = nvlist + 4 * 2; /* skip the ending 2 zeros - 8 bytes */ 1268 } 1269 1270 return (nvlist); 1271 } 1272 1273 /* 1274 * The nvlist_next_nvpair() function returns a handle to the next nvpair in the 1275 * list following nvpair. If nvpair is NULL, the first pair is returned. If 1276 * nvpair is the last pair in the nvlist, NULL is returned. 1277 */ 1278 static char * 1279 nvlist_next_nvpair(char *nvl, char *nvpair) 1280 { 1281 char *cur, *prev; 1282 int encode_size; 1283 1284 if (nvl == NULL) 1285 return (NULL); 1286 1287 if (nvpair == NULL) { 1288 /* skip over nvl_version and nvl_nvflag */ 1289 nvpair = nvl + 4 * 2; 1290 } else { 1291 /* skip to the next nvpair */ 1292 encode_size = BSWAP_32(*(uint32_t *)nvpair); 1293 nvpair += encode_size; 1294 } 1295 1296 /* 8 bytes of 0 marks the end of the list */ 1297 if (*(uint64_t *)nvpair == 0) 1298 return (NULL); 1299 1300 return (nvpair); 1301 } 1302 1303 /* 1304 * This function returns 0 on success and 1 on failure. On success, a string 1305 * containing the name of nvpair is saved in buf. 1306 */ 1307 static int 1308 nvpair_name(char *nvp, char *buf, int buflen) 1309 { 1310 int len; 1311 1312 /* skip over encode/decode size */ 1313 nvp += 4 * 2; 1314 1315 len = BSWAP_32(*(uint32_t *)nvp); 1316 if (buflen < len + 1) 1317 return (1); 1318 1319 grub_memmove(buf, nvp + 4, len); 1320 buf[len] = '\0'; 1321 1322 return (0); 1323 } 1324 1325 /* 1326 * This function retrieves the value of the nvpair in the form of enumerated 1327 * type data_type_t. This is used to determine the appropriate type to pass to 1328 * nvpair_value(). 1329 */ 1330 static int 1331 nvpair_type(char *nvp) 1332 { 1333 int name_len, type; 1334 1335 /* skip over encode/decode size */ 1336 nvp += 4 * 2; 1337 1338 /* skip over name_len */ 1339 name_len = BSWAP_32(*(uint32_t *)nvp); 1340 nvp += 4; 1341 1342 /* skip over name */ 1343 nvp = nvp + ((name_len + 3) & ~3); /* align */ 1344 1345 type = BSWAP_32(*(uint32_t *)nvp); 1346 1347 return (type); 1348 } 1349 1350 static int 1351 nvpair_value(char *nvp, void *val, int valtype, int *nelmp) 1352 { 1353 int name_len, type, slen; 1354 char *strval = val; 1355 uint64_t *intval = val; 1356 1357 /* skip over encode/decode size */ 1358 nvp += 4 * 2; 1359 1360 /* skip over name_len */ 1361 name_len = BSWAP_32(*(uint32_t *)nvp); 1362 nvp += 4; 1363 1364 /* skip over name */ 1365 nvp = nvp + ((name_len + 3) & ~3); /* align */ 1366 1367 /* skip over type */ 1368 type = BSWAP_32(*(uint32_t *)nvp); 1369 nvp += 4; 1370 1371 if (type == valtype) { 1372 int nelm; 1373 1374 nelm = BSWAP_32(*(uint32_t *)nvp); 1375 if (valtype != DATA_TYPE_BOOLEAN && nelm < 1) 1376 return (1); 1377 nvp += 4; 1378 1379 switch (valtype) { 1380 case DATA_TYPE_BOOLEAN: 1381 return (0); 1382 1383 case DATA_TYPE_STRING: 1384 slen = BSWAP_32(*(uint32_t *)nvp); 1385 nvp += 4; 1386 grub_memmove(strval, nvp, slen); 1387 strval[slen] = '\0'; 1388 return (0); 1389 1390 case DATA_TYPE_UINT64: 1391 *intval = BSWAP_64(*(uint64_t *)nvp); 1392 return (0); 1393 1394 case DATA_TYPE_NVLIST: 1395 *(void **)val = (void *)nvp; 1396 return (0); 1397 1398 case DATA_TYPE_NVLIST_ARRAY: 1399 *(void **)val = (void *)nvp; 1400 if (nelmp) 1401 *nelmp = nelm; 1402 return (0); 1403 } 1404 } 1405 1406 return (1); 1407 } 1408 1409 static int 1410 nvlist_lookup_value(char *nvlist, char *name, void *val, int valtype, 1411 int *nelmp) 1412 { 1413 char *nvpair; 1414 1415 for (nvpair = nvlist_next_nvpair(nvlist, NULL); 1416 nvpair != NULL; 1417 nvpair = nvlist_next_nvpair(nvlist, nvpair)) { 1418 int name_len = BSWAP_32(*(uint32_t *)(nvpair + 4 * 2)); 1419 char *nvp_name = nvpair + 4 * 3; 1420 1421 if ((grub_strncmp(nvp_name, name, name_len) == 0) && 1422 nvpair_type(nvpair) == valtype) { 1423 return (nvpair_value(nvpair, val, valtype, nelmp)); 1424 } 1425 } 1426 return (1); 1427 } 1428 1429 /* 1430 * Check if this vdev is online and is in a good state. 1431 */ 1432 static int 1433 vdev_validate(char *nv) 1434 { 1435 uint64_t ival; 1436 1437 if (nvlist_lookup_value(nv, ZPOOL_CONFIG_OFFLINE, &ival, 1438 DATA_TYPE_UINT64, NULL) == 0 || 1439 nvlist_lookup_value(nv, ZPOOL_CONFIG_FAULTED, &ival, 1440 DATA_TYPE_UINT64, NULL) == 0 || 1441 nvlist_lookup_value(nv, ZPOOL_CONFIG_REMOVED, &ival, 1442 DATA_TYPE_UINT64, NULL) == 0) 1443 return (ERR_DEV_VALUES); 1444 1445 return (0); 1446 } 1447 1448 /* 1449 * Get a valid vdev pathname/devid from the boot device. 1450 * The caller should already allocate MAXPATHLEN memory for bootpath and devid. 1451 */ 1452 static int 1453 vdev_get_bootpath(char *nv, uint64_t inguid, char *devid, char *bootpath, 1454 int is_spare) 1455 { 1456 char type[16]; 1457 1458 if (nvlist_lookup_value(nv, ZPOOL_CONFIG_TYPE, &type, DATA_TYPE_STRING, 1459 NULL)) 1460 return (ERR_FSYS_CORRUPT); 1461 1462 if (grub_strcmp(type, VDEV_TYPE_DISK) == 0) { 1463 uint64_t guid; 1464 1465 if (vdev_validate(nv) != 0) 1466 return (ERR_NO_BOOTPATH); 1467 1468 if (nvlist_lookup_value(nv, ZPOOL_CONFIG_GUID, 1469 &guid, DATA_TYPE_UINT64, NULL) != 0) 1470 return (ERR_NO_BOOTPATH); 1471 1472 if (guid != inguid) 1473 return (ERR_NO_BOOTPATH); 1474 1475 /* for a spare vdev, pick the disk labeled with "is_spare" */ 1476 if (is_spare) { 1477 uint64_t spare = 0; 1478 (void) nvlist_lookup_value(nv, ZPOOL_CONFIG_IS_SPARE, 1479 &spare, DATA_TYPE_UINT64, NULL); 1480 if (!spare) 1481 return (ERR_NO_BOOTPATH); 1482 } 1483 1484 if (nvlist_lookup_value(nv, ZPOOL_CONFIG_PHYS_PATH, 1485 bootpath, DATA_TYPE_STRING, NULL) != 0) 1486 bootpath[0] = '\0'; 1487 1488 if (nvlist_lookup_value(nv, ZPOOL_CONFIG_DEVID, 1489 devid, DATA_TYPE_STRING, NULL) != 0) 1490 devid[0] = '\0'; 1491 1492 if (grub_strlen(bootpath) >= MAXPATHLEN || 1493 grub_strlen(devid) >= MAXPATHLEN) 1494 return (ERR_WONT_FIT); 1495 1496 return (0); 1497 1498 } else if (grub_strcmp(type, VDEV_TYPE_MIRROR) == 0 || 1499 grub_strcmp(type, VDEV_TYPE_REPLACING) == 0 || 1500 (is_spare = (grub_strcmp(type, VDEV_TYPE_SPARE) == 0))) { 1501 int nelm, i; 1502 char *child; 1503 1504 if (nvlist_lookup_value(nv, ZPOOL_CONFIG_CHILDREN, &child, 1505 DATA_TYPE_NVLIST_ARRAY, &nelm)) 1506 return (ERR_FSYS_CORRUPT); 1507 1508 for (i = 0; i < nelm; i++) { 1509 char *child_i; 1510 1511 child_i = nvlist_array(child, i); 1512 if (vdev_get_bootpath(child_i, inguid, devid, 1513 bootpath, is_spare) == 0) 1514 return (0); 1515 } 1516 } 1517 1518 return (ERR_NO_BOOTPATH); 1519 } 1520 1521 /* 1522 * Check the disk label information and retrieve needed vdev name-value pairs. 1523 * 1524 * Return: 1525 * 0 - success 1526 * ERR_* - failure 1527 */ 1528 static int 1529 check_pool_label(uint64_t sector, char *stack, char *outdevid, char *outpath, 1530 uint64_t *outguid, uint64_t *outdiskguid, uint64_t *outashift, 1531 uint64_t *outversion) 1532 { 1533 vdev_phys_t *vdev; 1534 uint64_t pool_state, txg = 0; 1535 char *nvlist, *nv, *features; 1536 1537 sector += (VDEV_SKIP_SIZE >> SPA_MINBLOCKSHIFT); 1538 1539 /* Read in the vdev name-value pair list (112K). */ 1540 if (devread(sector, 0, VDEV_PHYS_SIZE, stack) == 0) 1541 return (ERR_READ); 1542 1543 vdev = (vdev_phys_t *)stack; 1544 stack += sizeof (vdev_phys_t); 1545 1546 if (nvlist_unpack(vdev->vp_nvlist, &nvlist)) 1547 return (ERR_FSYS_CORRUPT); 1548 1549 if (nvlist_lookup_value(nvlist, ZPOOL_CONFIG_POOL_STATE, &pool_state, 1550 DATA_TYPE_UINT64, NULL)) 1551 return (ERR_FSYS_CORRUPT); 1552 1553 if (pool_state == POOL_STATE_DESTROYED) 1554 return (ERR_FILESYSTEM_NOT_FOUND); 1555 1556 if (nvlist_lookup_value(nvlist, ZPOOL_CONFIG_POOL_NAME, 1557 current_rootpool, DATA_TYPE_STRING, NULL)) 1558 return (ERR_FSYS_CORRUPT); 1559 1560 if (nvlist_lookup_value(nvlist, ZPOOL_CONFIG_POOL_TXG, &txg, 1561 DATA_TYPE_UINT64, NULL)) 1562 return (ERR_FSYS_CORRUPT); 1563 1564 /* not an active device */ 1565 if (txg == 0) 1566 return (ERR_NO_BOOTPATH); 1567 1568 if (nvlist_lookup_value(nvlist, ZPOOL_CONFIG_VERSION, outversion, 1569 DATA_TYPE_UINT64, NULL)) 1570 return (ERR_FSYS_CORRUPT); 1571 if (!SPA_VERSION_IS_SUPPORTED(*outversion)) 1572 return (ERR_NEWER_VERSION); 1573 if (nvlist_lookup_value(nvlist, ZPOOL_CONFIG_VDEV_TREE, &nv, 1574 DATA_TYPE_NVLIST, NULL)) 1575 return (ERR_FSYS_CORRUPT); 1576 if (nvlist_lookup_value(nvlist, ZPOOL_CONFIG_GUID, outdiskguid, 1577 DATA_TYPE_UINT64, NULL)) 1578 return (ERR_FSYS_CORRUPT); 1579 if (nvlist_lookup_value(nv, ZPOOL_CONFIG_ASHIFT, outashift, 1580 DATA_TYPE_UINT64, NULL) != 0) 1581 return (ERR_FSYS_CORRUPT); 1582 if (vdev_get_bootpath(nv, *outdiskguid, outdevid, outpath, 0)) 1583 return (ERR_NO_BOOTPATH); 1584 if (nvlist_lookup_value(nvlist, ZPOOL_CONFIG_POOL_GUID, outguid, 1585 DATA_TYPE_UINT64, NULL)) 1586 return (ERR_FSYS_CORRUPT); 1587 1588 if (nvlist_lookup_value(nvlist, ZPOOL_CONFIG_FEATURES_FOR_READ, 1589 &features, DATA_TYPE_NVLIST, NULL) == 0) { 1590 char *nvp; 1591 char *name = stack; 1592 stack += MAXNAMELEN; 1593 1594 for (nvp = nvlist_next_nvpair(features, NULL); 1595 nvp != NULL; 1596 nvp = nvlist_next_nvpair(features, nvp)) { 1597 zap_attribute_t za; 1598 1599 if (nvpair_name(nvp, name, MAXNAMELEN) != 0) 1600 return (ERR_FSYS_CORRUPT); 1601 1602 za.za_integer_length = 8; 1603 za.za_num_integers = 1; 1604 za.za_first_integer = 1; 1605 za.za_name = name; 1606 if (check_feature(&za, spa_feature_names, stack) != 0) 1607 return (ERR_NEWER_VERSION); 1608 } 1609 } 1610 1611 return (0); 1612 } 1613 1614 /* 1615 * zfs_mount() locates a valid uberblock of the root pool and read in its MOS 1616 * to the memory address MOS. 1617 * 1618 * Return: 1619 * 1 - success 1620 * 0 - failure 1621 */ 1622 int 1623 zfs_mount(void) 1624 { 1625 char *stack, *ub_array; 1626 int label = 0; 1627 uberblock_t *ubbest; 1628 objset_phys_t *osp; 1629 char tmp_bootpath[MAXNAMELEN]; 1630 char tmp_devid[MAXNAMELEN]; 1631 uint64_t tmp_guid, tmp_vdev, ashift, version; 1632 uint64_t adjpl = (uint64_t)part_length << SPA_MINBLOCKSHIFT; 1633 int err = errnum; /* preserve previous errnum state */ 1634 1635 /* if it's our first time here, zero the best uberblock out */ 1636 if (best_drive == 0 && best_part == 0 && find_best_root) { 1637 grub_memset(¤t_uberblock, 0, sizeof (uberblock_t)); 1638 pool_guid = 0; 1639 } 1640 1641 stackbase = ZFS_SCRATCH; 1642 stack = stackbase; 1643 ub_array = stack; 1644 stack += VDEV_UBERBLOCK_RING; 1645 1646 osp = (objset_phys_t *)stack; 1647 stack += sizeof (objset_phys_t); 1648 adjpl = P2ALIGN(adjpl, (uint64_t)sizeof (vdev_label_t)); 1649 1650 for (label = 0; label < VDEV_LABELS; label++) { 1651 1652 /* 1653 * some eltorito stacks don't give us a size and 1654 * we end up setting the size to MAXUINT, further 1655 * some of these devices stop working once a single 1656 * read past the end has been issued. Checking 1657 * for a maximum part_length and skipping the backup 1658 * labels at the end of the slice/partition/device 1659 * avoids breaking down on such devices. 1660 */ 1661 if (part_length == MAXUINT && label == 2) 1662 break; 1663 1664 uint64_t sector = vdev_label_start(adjpl, 1665 label) >> SPA_MINBLOCKSHIFT; 1666 1667 /* Read in the uberblock ring (128K). */ 1668 if (devread(sector + 1669 ((VDEV_SKIP_SIZE + VDEV_PHYS_SIZE) >> SPA_MINBLOCKSHIFT), 1670 0, VDEV_UBERBLOCK_RING, ub_array) == 0) 1671 continue; 1672 1673 if (check_pool_label(sector, stack, tmp_devid, tmp_bootpath, 1674 &tmp_guid, &tmp_vdev, &ashift, &version)) 1675 continue; 1676 1677 if (pool_guid == 0) 1678 pool_guid = tmp_guid; 1679 1680 if ((ubbest = find_bestub(ub_array, ashift, sector)) == NULL || 1681 zio_read(&ubbest->ub_rootbp, osp, stack) != 0) 1682 continue; 1683 1684 VERIFY_OS_TYPE(osp, DMU_OST_META); 1685 1686 if (version >= SPA_VERSION_FEATURES && 1687 check_mos_features(&osp->os_meta_dnode, stack) != 0) 1688 continue; 1689 1690 if (find_best_root && ((pool_guid != tmp_guid) || 1691 vdev_uberblock_compare(ubbest, &(current_uberblock)) <= 0)) 1692 continue; 1693 1694 /* Got the MOS. Save it at the memory addr MOS. */ 1695 grub_memmove(MOS, &osp->os_meta_dnode, DNODE_SIZE); 1696 grub_memmove(¤t_uberblock, ubbest, sizeof (uberblock_t)); 1697 grub_memmove(current_bootpath, tmp_bootpath, MAXNAMELEN); 1698 grub_memmove(current_devid, tmp_devid, grub_strlen(tmp_devid)); 1699 current_bootguid = tmp_guid; 1700 current_bootvdev = tmp_vdev; 1701 is_zfs_mount = 1; 1702 return (1); 1703 } 1704 1705 /* 1706 * While some fs impls. (tftp) rely on setting and keeping 1707 * global errnums set, others won't reset it and will break 1708 * when issuing rawreads. The goal here is to simply not 1709 * have zfs mount attempts impact the previous state. 1710 */ 1711 errnum = err; 1712 return (0); 1713 } 1714 1715 /* 1716 * zfs_open() locates a file in the rootpool by following the 1717 * MOS and places the dnode of the file in the memory address DNODE. 1718 * 1719 * Return: 1720 * 1 - success 1721 * 0 - failure 1722 */ 1723 int 1724 zfs_open(char *filename) 1725 { 1726 char *stack; 1727 dnode_phys_t *mdn; 1728 1729 file_buf = NULL; 1730 stackbase = ZFS_SCRATCH; 1731 stack = stackbase; 1732 1733 mdn = (dnode_phys_t *)stack; 1734 stack += sizeof (dnode_phys_t); 1735 1736 dnode_mdn = NULL; 1737 dnode_buf = (dnode_phys_t *)stack; 1738 stack += 1<<DNODE_BLOCK_SHIFT; 1739 1740 /* 1741 * menu.lst is placed at the root pool filesystem level, 1742 * do not goto 'current_bootfs'. 1743 */ 1744 if (is_top_dataset_file(filename)) { 1745 if (errnum = get_objset_mdn(MOS, NULL, NULL, mdn, stack)) 1746 return (0); 1747 1748 current_bootfs_obj = 0; 1749 } else { 1750 if (current_bootfs[0] == '\0') { 1751 /* Get the default root filesystem object number */ 1752 if (errnum = get_default_bootfsobj(MOS, 1753 ¤t_bootfs_obj, stack)) 1754 return (0); 1755 1756 if (errnum = get_objset_mdn(MOS, NULL, 1757 ¤t_bootfs_obj, mdn, stack)) 1758 return (0); 1759 } else { 1760 if (errnum = get_objset_mdn(MOS, current_bootfs, 1761 ¤t_bootfs_obj, mdn, stack)) { 1762 grub_memset(current_bootfs, 0, MAXNAMELEN); 1763 return (0); 1764 } 1765 } 1766 } 1767 1768 if (dnode_get_path(mdn, filename, DNODE, stack)) { 1769 errnum = ERR_FILE_NOT_FOUND; 1770 return (0); 1771 } 1772 1773 /* get the file size and set the file position to 0 */ 1774 1775 /* 1776 * For DMU_OT_SA we will need to locate the SIZE attribute 1777 * attribute, which could be either in the bonus buffer 1778 * or the "spill" block. 1779 */ 1780 if (DNODE->dn_bonustype == DMU_OT_SA) { 1781 sa_hdr_phys_t *sahdrp; 1782 int hdrsize; 1783 1784 if (DNODE->dn_bonuslen != 0) { 1785 sahdrp = (sa_hdr_phys_t *)DN_BONUS(DNODE); 1786 } else { 1787 if (DNODE->dn_flags & DNODE_FLAG_SPILL_BLKPTR) { 1788 blkptr_t *bp = &DNODE->dn_spill; 1789 void *buf; 1790 1791 buf = (void *)stack; 1792 stack += BP_GET_LSIZE(bp); 1793 1794 /* reset errnum to rawread() failure */ 1795 errnum = 0; 1796 if (zio_read(bp, buf, stack) != 0) { 1797 return (0); 1798 } 1799 sahdrp = buf; 1800 } else { 1801 errnum = ERR_FSYS_CORRUPT; 1802 return (0); 1803 } 1804 } 1805 hdrsize = SA_HDR_SIZE(sahdrp); 1806 filemax = *(uint64_t *)((char *)sahdrp + hdrsize + 1807 SA_SIZE_OFFSET); 1808 } else { 1809 filemax = ((znode_phys_t *)DN_BONUS(DNODE))->zp_size; 1810 } 1811 filepos = 0; 1812 1813 dnode_buf = NULL; 1814 return (1); 1815 } 1816 1817 /* 1818 * zfs_read reads in the data blocks pointed by the DNODE. 1819 * 1820 * Return: 1821 * len - the length successfully read in to the buffer 1822 * 0 - failure 1823 */ 1824 int 1825 zfs_read(char *buf, int len) 1826 { 1827 char *stack; 1828 int blksz, length, movesize; 1829 1830 if (file_buf == NULL) { 1831 file_buf = stackbase; 1832 stackbase += SPA_MAXBLOCKSIZE; 1833 file_start = file_end = 0; 1834 } 1835 stack = stackbase; 1836 1837 /* 1838 * If offset is in memory, move it into the buffer provided and return. 1839 */ 1840 if (filepos >= file_start && filepos+len <= file_end) { 1841 grub_memmove(buf, file_buf + filepos - file_start, len); 1842 filepos += len; 1843 return (len); 1844 } 1845 1846 blksz = DNODE->dn_datablkszsec << SPA_MINBLOCKSHIFT; 1847 1848 /* 1849 * Note: for GRUB, SPA_MAXBLOCKSIZE is 128KB. There is not enough 1850 * memory to allocate the new max blocksize (16MB), so while 1851 * GRUB understands the large_blocks on-disk feature, it can't 1852 * actually read large blocks. 1853 */ 1854 if (blksz > SPA_MAXBLOCKSIZE) { 1855 grub_printf("blocks larger than 128K are not supported\n"); 1856 return (0); 1857 } 1858 1859 /* 1860 * Entire Dnode is too big to fit into the space available. We 1861 * will need to read it in chunks. This could be optimized to 1862 * read in as large a chunk as there is space available, but for 1863 * now, this only reads in one data block at a time. 1864 */ 1865 length = len; 1866 while (length) { 1867 /* 1868 * Find requested blkid and the offset within that block. 1869 */ 1870 uint64_t blkid = filepos / blksz; 1871 1872 if (errnum = dmu_read(DNODE, blkid, file_buf, stack)) 1873 return (0); 1874 1875 file_start = blkid * blksz; 1876 file_end = file_start + blksz; 1877 1878 movesize = MIN(length, file_end - filepos); 1879 1880 grub_memmove(buf, file_buf + filepos - file_start, 1881 movesize); 1882 buf += movesize; 1883 length -= movesize; 1884 filepos += movesize; 1885 } 1886 1887 return (len); 1888 } 1889 1890 /* 1891 * No-Op 1892 */ 1893 int 1894 zfs_embed(unsigned long long *start_sector, int needed_sectors) 1895 { 1896 return (1); 1897 } 1898 1899 #endif /* FSYS_ZFS */ 1900