uboot/fs/zfs/zfs.c
<<
>>
Prefs
   1/*
   2 *
   3 * ZFS filesystem ported to u-boot by
   4 * Jorgen Lundman <lundman at lundman.net>
   5 *
   6 *      GRUB  --  GRand Unified Bootloader
   7 *      Copyright (C) 1999,2000,2001,2002,2003,2004
   8 *      Free Software Foundation, Inc.
   9 *      Copyright 2004  Sun Microsystems, Inc.
  10 *
  11 * SPDX-License-Identifier:     GPL-2.0+
  12 */
  13
  14#include <common.h>
  15#include <malloc.h>
  16#include <linux/stat.h>
  17#include <linux/time.h>
  18#include <linux/ctype.h>
  19#include <asm/byteorder.h>
  20#include "zfs_common.h"
  21#include "div64.h"
  22
  23struct blk_desc *zfs_dev_desc;
  24
  25/*
  26 * The zfs plug-in routines for GRUB are:
  27 *
  28 * zfs_mount() - locates a valid uberblock of the root pool and reads
  29 *              in its MOS at the memory address MOS.
  30 *
  31 * zfs_open() - locates a plain file object by following the MOS
  32 *              and places its dnode at the memory address DNODE.
  33 *
  34 * zfs_read() - read in the data blocks pointed by the DNODE.
  35 *
  36 */
  37
  38#include <zfs/zfs.h>
  39#include <zfs/zio.h>
  40#include <zfs/dnode.h>
  41#include <zfs/uberblock_impl.h>
  42#include <zfs/vdev_impl.h>
  43#include <zfs/zio_checksum.h>
  44#include <zfs/zap_impl.h>
  45#include <zfs/zap_leaf.h>
  46#include <zfs/zfs_znode.h>
  47#include <zfs/dmu.h>
  48#include <zfs/dmu_objset.h>
  49#include <zfs/sa_impl.h>
  50#include <zfs/dsl_dir.h>
  51#include <zfs/dsl_dataset.h>
  52
  53
  54#define ZPOOL_PROP_BOOTFS               "bootfs"
  55
  56
  57/*
  58 * For nvlist manipulation. (from nvpair.h)
  59 */
  60#define NV_ENCODE_NATIVE        0
  61#define NV_ENCODE_XDR           1
  62#define NV_BIG_ENDIAN                   0
  63#define NV_LITTLE_ENDIAN        1
  64#define DATA_TYPE_UINT64        8
  65#define DATA_TYPE_STRING        9
  66#define DATA_TYPE_NVLIST        19
  67#define DATA_TYPE_NVLIST_ARRAY  20
  68
  69
  70/*
  71 * Macros to get fields in a bp or DVA.
  72 */
  73#define P2PHASE(x, align)               ((x) & ((align) - 1))
  74#define DVA_OFFSET_TO_PHYS_SECTOR(offset)                                       \
  75        ((offset + VDEV_LABEL_START_SIZE) >> SPA_MINBLOCKSHIFT)
  76
  77/*
  78 * return x rounded down to an align boundary
  79 * eg, P2ALIGN(1200, 1024) == 1024 (1*align)
  80 * eg, P2ALIGN(1024, 1024) == 1024 (1*align)
  81 * eg, P2ALIGN(0x1234, 0x100) == 0x1200 (0x12*align)
  82 * eg, P2ALIGN(0x5600, 0x100) == 0x5600 (0x56*align)
  83 */
  84#define P2ALIGN(x, align)               ((x) & -(align))
  85
  86/*
  87 * FAT ZAP data structures
  88 */
  89#define ZFS_CRC64_POLY 0xC96C5795D7870F42ULL    /* ECMA-182, reflected form */
  90#define ZAP_HASH_IDX(hash, n)   (((n) == 0) ? 0 : ((hash) >> (64 - (n))))
  91#define CHAIN_END       0xffff  /* end of the chunk chain */
  92
  93/*
  94 * The amount of space within the chunk available for the array is:
  95 * chunk size - space for type (1) - space for next pointer (2)
  96 */
  97#define ZAP_LEAF_ARRAY_BYTES (ZAP_LEAF_CHUNKSIZE - 3)
  98
  99#define ZAP_LEAF_HASH_SHIFT(bs) (bs - 5)
 100#define ZAP_LEAF_HASH_NUMENTRIES(bs) (1 << ZAP_LEAF_HASH_SHIFT(bs))
 101#define LEAF_HASH(bs, h)                                                                                                \
 102        ((ZAP_LEAF_HASH_NUMENTRIES(bs)-1) &                                                                     \
 103         ((h) >> (64 - ZAP_LEAF_HASH_SHIFT(bs)-l->l_hdr.lh_prefix_len)))
 104
 105/*
 106 * The amount of space available for chunks is:
 107 * block size shift - hash entry size (2) * number of hash
 108 * entries - header space (2*chunksize)
 109 */
 110#define ZAP_LEAF_NUMCHUNKS(bs)                                          \
 111        (((1<<bs) - 2*ZAP_LEAF_HASH_NUMENTRIES(bs)) /   \
 112         ZAP_LEAF_CHUNKSIZE - 2)
 113
 114/*
 115 * The chunks start immediately after the hash table.  The end of the
 116 * hash table is at l_hash + HASH_NUMENTRIES, which we simply cast to a
 117 * chunk_t.
 118 */
 119#define ZAP_LEAF_CHUNK(l, bs, idx)                                                                              \
 120        ((zap_leaf_chunk_t *)(l->l_hash + ZAP_LEAF_HASH_NUMENTRIES(bs)))[idx]
 121#define ZAP_LEAF_ENTRY(l, bs, idx) (&ZAP_LEAF_CHUNK(l, bs, idx).l_entry)
 122
 123
 124/*
 125 * Decompression Entry - lzjb
 126 */
 127#ifndef NBBY
 128#define NBBY    8
 129#endif
 130
 131
 132
 133typedef int zfs_decomp_func_t(void *s_start, void *d_start,
 134                                                          uint32_t s_len, uint32_t d_len);
 135typedef struct decomp_entry {
 136        char *name;
 137        zfs_decomp_func_t *decomp_func;
 138} decomp_entry_t;
 139
 140typedef struct dnode_end {
 141        dnode_phys_t dn;
 142        zfs_endian_t endian;
 143} dnode_end_t;
 144
 145struct zfs_data {
 146        /* cache for a file block of the currently zfs_open()-ed file */
 147        char *file_buf;
 148        uint64_t file_start;
 149        uint64_t file_end;
 150
 151        /* XXX: ashift is per vdev, not per pool.  We currently only ever touch
 152         * a single vdev, but when/if raid-z or stripes are supported, this
 153         * may need revision.
 154         */
 155        uint64_t vdev_ashift;
 156        uint64_t label_txg;
 157        uint64_t pool_guid;
 158
 159        /* cache for a dnode block */
 160        dnode_phys_t *dnode_buf;
 161        dnode_phys_t *dnode_mdn;
 162        uint64_t dnode_start;
 163        uint64_t dnode_end;
 164        zfs_endian_t dnode_endian;
 165
 166        uberblock_t current_uberblock;
 167
 168        dnode_end_t mos;
 169        dnode_end_t mdn;
 170        dnode_end_t dnode;
 171
 172        uint64_t vdev_phys_sector;
 173
 174        int (*userhook)(const char *, const struct zfs_dirhook_info *);
 175        struct zfs_dirhook_info *dirinfo;
 176
 177};
 178
 179
 180
 181
 182static int
 183zlib_decompress(void *s, void *d,
 184                                uint32_t slen, uint32_t dlen)
 185{
 186        if (zlib_decompress(s, d, slen, dlen) < 0)
 187                return ZFS_ERR_BAD_FS;
 188        return ZFS_ERR_NONE;
 189}
 190
 191static decomp_entry_t decomp_table[ZIO_COMPRESS_FUNCTIONS] = {
 192        {"inherit", NULL},              /* ZIO_COMPRESS_INHERIT */
 193        {"on", lzjb_decompress},        /* ZIO_COMPRESS_ON */
 194        {"off", NULL},          /* ZIO_COMPRESS_OFF */
 195        {"lzjb", lzjb_decompress},      /* ZIO_COMPRESS_LZJB */
 196        {"empty", NULL},                /* ZIO_COMPRESS_EMPTY */
 197        {"gzip-1", zlib_decompress},  /* ZIO_COMPRESS_GZIP1 */
 198        {"gzip-2", zlib_decompress},  /* ZIO_COMPRESS_GZIP2 */
 199        {"gzip-3", zlib_decompress},  /* ZIO_COMPRESS_GZIP3 */
 200        {"gzip-4", zlib_decompress},  /* ZIO_COMPRESS_GZIP4 */
 201        {"gzip-5", zlib_decompress},  /* ZIO_COMPRESS_GZIP5 */
 202        {"gzip-6", zlib_decompress},  /* ZIO_COMPRESS_GZIP6 */
 203        {"gzip-7", zlib_decompress},  /* ZIO_COMPRESS_GZIP7 */
 204        {"gzip-8", zlib_decompress},  /* ZIO_COMPRESS_GZIP8 */
 205        {"gzip-9", zlib_decompress},  /* ZIO_COMPRESS_GZIP9 */
 206};
 207
 208
 209
 210static int zio_read_data(blkptr_t *bp, zfs_endian_t endian,
 211                                                 void *buf, struct zfs_data *data);
 212
 213static int
 214zio_read(blkptr_t *bp, zfs_endian_t endian, void **buf,
 215                 size_t *size, struct zfs_data *data);
 216
 217/*
 218 * Our own version of log2().  Same thing as highbit()-1.
 219 */
 220static int
 221zfs_log2(uint64_t num)
 222{
 223        int i = 0;
 224
 225        while (num > 1) {
 226                i++;
 227                num = num >> 1;
 228        }
 229
 230        return i;
 231}
 232
 233
 234/* Checksum Functions */
 235static void
 236zio_checksum_off(const void *buf __attribute__ ((unused)),
 237                                 uint64_t size __attribute__ ((unused)),
 238                                 zfs_endian_t endian __attribute__ ((unused)),
 239                                 zio_cksum_t *zcp)
 240{
 241        ZIO_SET_CHECKSUM(zcp, 0, 0, 0, 0);
 242}
 243
 244/* Checksum Table and Values */
 245static zio_checksum_info_t zio_checksum_table[ZIO_CHECKSUM_FUNCTIONS] = {
 246        {NULL, 0, 0, "inherit"},
 247        {NULL, 0, 0, "on"},
 248        {zio_checksum_off, 0, 0, "off"},
 249        {zio_checksum_SHA256, 1, 1, "label"},
 250        {zio_checksum_SHA256, 1, 1, "gang_header"},
 251        {NULL, 0, 0, "zilog"},
 252        {fletcher_2_endian, 0, 0, "fletcher2"},
 253        {fletcher_4_endian, 1, 0, "fletcher4"},
 254        {zio_checksum_SHA256, 1, 0, "SHA256"},
 255        {NULL, 0, 0, "zilog2"},
 256};
 257
 258/*
 259 * zio_checksum_verify: Provides support for checksum verification.
 260 *
 261 * Fletcher2, Fletcher4, and SHA256 are supported.
 262 *
 263 */
 264static int
 265zio_checksum_verify(zio_cksum_t zc, uint32_t checksum,
 266                                        zfs_endian_t endian, char *buf, int size)
 267{
 268        zio_eck_t *zec = (zio_eck_t *) (buf + size) - 1;
 269        zio_checksum_info_t *ci = &zio_checksum_table[checksum];
 270        zio_cksum_t actual_cksum, expected_cksum;
 271
 272        if (checksum >= ZIO_CHECKSUM_FUNCTIONS || ci->ci_func == NULL) {
 273                printf("zfs unknown checksum function %d\n", checksum);
 274                return ZFS_ERR_NOT_IMPLEMENTED_YET;
 275        }
 276
 277        if (ci->ci_eck) {
 278                expected_cksum = zec->zec_cksum;
 279                zec->zec_cksum = zc;
 280                ci->ci_func(buf, size, endian, &actual_cksum);
 281                zec->zec_cksum = expected_cksum;
 282                zc = expected_cksum;
 283        } else {
 284                ci->ci_func(buf, size, endian, &actual_cksum);
 285        }
 286
 287        if ((actual_cksum.zc_word[0] != zc.zc_word[0])
 288                || (actual_cksum.zc_word[1] != zc.zc_word[1])
 289                || (actual_cksum.zc_word[2] != zc.zc_word[2])
 290                || (actual_cksum.zc_word[3] != zc.zc_word[3])) {
 291                return ZFS_ERR_BAD_FS;
 292        }
 293
 294        return ZFS_ERR_NONE;
 295}
 296
 297/*
 298 * vdev_uberblock_compare takes two uberblock structures and returns an integer
 299 * indicating the more recent of the two.
 300 *      Return Value = 1 if ub2 is more recent
 301 *      Return Value = -1 if ub1 is more recent
 302 * The most recent uberblock is determined using its transaction number and
 303 * timestamp.  The uberblock with the highest transaction number is
 304 * considered "newer".  If the transaction numbers of the two blocks match, the
 305 * timestamps are compared to determine the "newer" of the two.
 306 */
 307static int
 308vdev_uberblock_compare(uberblock_t *ub1, uberblock_t *ub2)
 309{
 310        zfs_endian_t ub1_endian, ub2_endian;
 311        if (zfs_to_cpu64(ub1->ub_magic, LITTLE_ENDIAN) == UBERBLOCK_MAGIC)
 312                ub1_endian = LITTLE_ENDIAN;
 313        else
 314                ub1_endian = BIG_ENDIAN;
 315        if (zfs_to_cpu64(ub2->ub_magic, LITTLE_ENDIAN) == UBERBLOCK_MAGIC)
 316                ub2_endian = LITTLE_ENDIAN;
 317        else
 318                ub2_endian = BIG_ENDIAN;
 319
 320        if (zfs_to_cpu64(ub1->ub_txg, ub1_endian)
 321                < zfs_to_cpu64(ub2->ub_txg, ub2_endian))
 322                return -1;
 323        if (zfs_to_cpu64(ub1->ub_txg, ub1_endian)
 324                > zfs_to_cpu64(ub2->ub_txg, ub2_endian))
 325                return 1;
 326
 327        if (zfs_to_cpu64(ub1->ub_timestamp, ub1_endian)
 328                < zfs_to_cpu64(ub2->ub_timestamp, ub2_endian))
 329                return -1;
 330        if (zfs_to_cpu64(ub1->ub_timestamp, ub1_endian)
 331                > zfs_to_cpu64(ub2->ub_timestamp, ub2_endian))
 332                return 1;
 333
 334        return 0;
 335}
 336
 337/*
 338 * Three pieces of information are needed to verify an uberblock: the magic
 339 * number, the version number, and the checksum.
 340 *
 341 * Currently Implemented: version number, magic number, label txg
 342 * Need to Implement: checksum
 343 *
 344 */
 345static int
 346uberblock_verify(uberblock_t *uber, int offset, struct zfs_data *data)
 347{
 348        int err;
 349        zfs_endian_t endian = UNKNOWN_ENDIAN;
 350        zio_cksum_t zc;
 351
 352        if (uber->ub_txg < data->label_txg) {
 353                debug("ignoring partially written label: uber_txg < label_txg %llu %llu\n",
 354                          uber->ub_txg, data->label_txg);
 355                return ZFS_ERR_BAD_FS;
 356        }
 357
 358        if (zfs_to_cpu64(uber->ub_magic, LITTLE_ENDIAN) == UBERBLOCK_MAGIC
 359                && zfs_to_cpu64(uber->ub_version, LITTLE_ENDIAN) > 0
 360                && zfs_to_cpu64(uber->ub_version, LITTLE_ENDIAN) <= SPA_VERSION)
 361                endian = LITTLE_ENDIAN;
 362
 363        if (zfs_to_cpu64(uber->ub_magic, BIG_ENDIAN) == UBERBLOCK_MAGIC
 364                && zfs_to_cpu64(uber->ub_version, BIG_ENDIAN) > 0
 365                && zfs_to_cpu64(uber->ub_version, BIG_ENDIAN) <= SPA_VERSION)
 366                endian = BIG_ENDIAN;
 367
 368        if (endian == UNKNOWN_ENDIAN) {
 369                printf("invalid uberblock magic\n");
 370                return ZFS_ERR_BAD_FS;
 371        }
 372
 373        memset(&zc, 0, sizeof(zc));
 374        zc.zc_word[0] = cpu_to_zfs64(offset, endian);
 375        err = zio_checksum_verify(zc, ZIO_CHECKSUM_LABEL, endian,
 376                                                          (char *) uber, UBERBLOCK_SIZE(data->vdev_ashift));
 377
 378        if (!err) {
 379                /* Check that the data pointed by the rootbp is usable. */
 380                void *osp = NULL;
 381                size_t ospsize;
 382                err = zio_read(&uber->ub_rootbp, endian, &osp, &ospsize, data);
 383                free(osp);
 384
 385                if (!err && ospsize < OBJSET_PHYS_SIZE_V14) {
 386                        printf("uberblock rootbp points to invalid data\n");
 387                        return ZFS_ERR_BAD_FS;
 388                }
 389        }
 390
 391        return err;
 392}
 393
 394/*
 395 * Find the best uberblock.
 396 * Return:
 397 *        Success - Pointer to the best uberblock.
 398 *        Failure - NULL
 399 */
 400static uberblock_t *find_bestub(char *ub_array, struct zfs_data *data)
 401{
 402        const uint64_t sector = data->vdev_phys_sector;
 403        uberblock_t *ubbest = NULL;
 404        uberblock_t *ubnext;
 405        unsigned int i, offset, pickedub = 0;
 406        int err = ZFS_ERR_NONE;
 407
 408        const unsigned int UBCOUNT = UBERBLOCK_COUNT(data->vdev_ashift);
 409        const uint64_t UBBYTES = UBERBLOCK_SIZE(data->vdev_ashift);
 410
 411        for (i = 0; i < UBCOUNT; i++) {
 412                ubnext = (uberblock_t *) (i * UBBYTES + ub_array);
 413                offset = (sector << SPA_MINBLOCKSHIFT) + VDEV_PHYS_SIZE + (i * UBBYTES);
 414
 415                err = uberblock_verify(ubnext, offset, data);
 416                if (err)
 417                        continue;
 418
 419                if (ubbest == NULL || vdev_uberblock_compare(ubnext, ubbest) > 0) {
 420                        ubbest = ubnext;
 421                        pickedub = i;
 422                }
 423        }
 424
 425        if (ubbest)
 426                debug("zfs Found best uberblock at idx %d, txg %llu\n",
 427                          pickedub, (unsigned long long) ubbest->ub_txg);
 428
 429        return ubbest;
 430}
 431
 432static inline size_t
 433get_psize(blkptr_t *bp, zfs_endian_t endian)
 434{
 435        return (((zfs_to_cpu64((bp)->blk_prop, endian) >> 16) & 0xffff) + 1)
 436                        << SPA_MINBLOCKSHIFT;
 437}
 438
 439static uint64_t
 440dva_get_offset(dva_t *dva, zfs_endian_t endian)
 441{
 442        return zfs_to_cpu64((dva)->dva_word[1],
 443                                                         endian) << SPA_MINBLOCKSHIFT;
 444}
 445
 446/*
 447 * Read a block of data based on the gang block address dva,
 448 * and put its data in buf.
 449 *
 450 */
 451static int
 452zio_read_gang(blkptr_t *bp, zfs_endian_t endian, dva_t *dva, void *buf,
 453                          struct zfs_data *data)
 454{
 455        zio_gbh_phys_t *zio_gb;
 456        uint64_t offset, sector;
 457        unsigned i;
 458        int err;
 459        zio_cksum_t zc;
 460
 461        memset(&zc, 0, sizeof(zc));
 462
 463        zio_gb = malloc(SPA_GANGBLOCKSIZE);
 464        if (!zio_gb)
 465                return ZFS_ERR_OUT_OF_MEMORY;
 466
 467        offset = dva_get_offset(dva, endian);
 468        sector = DVA_OFFSET_TO_PHYS_SECTOR(offset);
 469
 470        /* read in the gang block header */
 471        err = zfs_devread(sector, 0, SPA_GANGBLOCKSIZE, (char *) zio_gb);
 472
 473        if (err) {
 474                free(zio_gb);
 475                return err;
 476        }
 477
 478        /* XXX */
 479        /* self checksuming the gang block header */
 480        ZIO_SET_CHECKSUM(&zc, DVA_GET_VDEV(dva),
 481                                         dva_get_offset(dva, endian), bp->blk_birth, 0);
 482        err = zio_checksum_verify(zc, ZIO_CHECKSUM_GANG_HEADER, endian,
 483                                                          (char *) zio_gb, SPA_GANGBLOCKSIZE);
 484        if (err) {
 485                free(zio_gb);
 486                return err;
 487        }
 488
 489        endian = (zfs_to_cpu64(bp->blk_prop, endian) >> 63) & 1;
 490
 491        for (i = 0; i < SPA_GBH_NBLKPTRS; i++) {
 492                if (zio_gb->zg_blkptr[i].blk_birth == 0)
 493                        continue;
 494
 495                err = zio_read_data(&zio_gb->zg_blkptr[i], endian, buf, data);
 496                if (err) {
 497                        free(zio_gb);
 498                        return err;
 499                }
 500                buf = (char *) buf + get_psize(&zio_gb->zg_blkptr[i], endian);
 501        }
 502        free(zio_gb);
 503        return ZFS_ERR_NONE;
 504}
 505
 506/*
 507 * Read in a block of raw data to buf.
 508 */
 509static int
 510zio_read_data(blkptr_t *bp, zfs_endian_t endian, void *buf,
 511                          struct zfs_data *data)
 512{
 513        int i, psize;
 514        int err = ZFS_ERR_NONE;
 515
 516        psize = get_psize(bp, endian);
 517
 518        /* pick a good dva from the block pointer */
 519        for (i = 0; i < SPA_DVAS_PER_BP; i++) {
 520                uint64_t offset, sector;
 521
 522                if (bp->blk_dva[i].dva_word[0] == 0 && bp->blk_dva[i].dva_word[1] == 0)
 523                        continue;
 524
 525                if ((zfs_to_cpu64(bp->blk_dva[i].dva_word[1], endian)>>63) & 1) {
 526                        err = zio_read_gang(bp, endian, &bp->blk_dva[i], buf, data);
 527                } else {
 528                        /* read in a data block */
 529                        offset = dva_get_offset(&bp->blk_dva[i], endian);
 530                        sector = DVA_OFFSET_TO_PHYS_SECTOR(offset);
 531
 532                        err = zfs_devread(sector, 0, psize, buf);
 533                }
 534
 535                if (!err) {
 536                        /*Check the underlying checksum before we rule this DVA as "good"*/
 537                        uint32_t checkalgo = (zfs_to_cpu64((bp)->blk_prop, endian) >> 40) & 0xff;
 538
 539                        err = zio_checksum_verify(bp->blk_cksum, checkalgo, endian, buf, psize);
 540                        if (!err)
 541                                return ZFS_ERR_NONE;
 542                }
 543
 544                /* If read failed or checksum bad, reset the error.      Hopefully we've got some more DVA's to try.*/
 545        }
 546
 547        if (!err) {
 548                printf("couldn't find a valid DVA\n");
 549                err = ZFS_ERR_BAD_FS;
 550        }
 551
 552        return err;
 553}
 554
 555/*
 556 * Read in a block of data, verify its checksum, decompress if needed,
 557 * and put the uncompressed data in buf.
 558 */
 559static int
 560zio_read(blkptr_t *bp, zfs_endian_t endian, void **buf,
 561                 size_t *size, struct zfs_data *data)
 562{
 563        size_t lsize, psize;
 564        unsigned int comp;
 565        char *compbuf = NULL;
 566        int err;
 567
 568        *buf = NULL;
 569
 570        comp = (zfs_to_cpu64((bp)->blk_prop, endian)>>32) & 0xff;
 571        lsize = (BP_IS_HOLE(bp) ? 0 :
 572                         (((zfs_to_cpu64((bp)->blk_prop, endian) & 0xffff) + 1)
 573                          << SPA_MINBLOCKSHIFT));
 574        psize = get_psize(bp, endian);
 575
 576        if (size)
 577                *size = lsize;
 578
 579        if (comp >= ZIO_COMPRESS_FUNCTIONS) {
 580                printf("compression algorithm %u not supported\n", (unsigned int) comp);
 581                return ZFS_ERR_NOT_IMPLEMENTED_YET;
 582        }
 583
 584        if (comp != ZIO_COMPRESS_OFF && decomp_table[comp].decomp_func == NULL) {
 585                printf("compression algorithm %s not supported\n", decomp_table[comp].name);
 586                return ZFS_ERR_NOT_IMPLEMENTED_YET;
 587        }
 588
 589        if (comp != ZIO_COMPRESS_OFF) {
 590                compbuf = malloc(psize);
 591                if (!compbuf)
 592                        return ZFS_ERR_OUT_OF_MEMORY;
 593        } else {
 594                compbuf = *buf = malloc(lsize);
 595        }
 596
 597        err = zio_read_data(bp, endian, compbuf, data);
 598        if (err) {
 599                free(compbuf);
 600                *buf = NULL;
 601                return err;
 602        }
 603
 604        if (comp != ZIO_COMPRESS_OFF) {
 605                *buf = malloc(lsize);
 606                if (!*buf) {
 607                        free(compbuf);
 608                        return ZFS_ERR_OUT_OF_MEMORY;
 609                }
 610
 611                err = decomp_table[comp].decomp_func(compbuf, *buf, psize, lsize);
 612                free(compbuf);
 613                if (err) {
 614                        free(*buf);
 615                        *buf = NULL;
 616                        return err;
 617                }
 618        }
 619
 620        return ZFS_ERR_NONE;
 621}
 622
 623/*
 624 * Get the block from a block id.
 625 * push the block onto the stack.
 626 *
 627 */
 628static int
 629dmu_read(dnode_end_t *dn, uint64_t blkid, void **buf,
 630                 zfs_endian_t *endian_out, struct zfs_data *data)
 631{
 632        int idx, level;
 633        blkptr_t *bp_array = dn->dn.dn_blkptr;
 634        int epbs = dn->dn.dn_indblkshift - SPA_BLKPTRSHIFT;
 635        blkptr_t *bp;
 636        void *tmpbuf = 0;
 637        zfs_endian_t endian;
 638        int err = ZFS_ERR_NONE;
 639
 640        bp = malloc(sizeof(blkptr_t));
 641        if (!bp)
 642                return ZFS_ERR_OUT_OF_MEMORY;
 643
 644        endian = dn->endian;
 645        for (level = dn->dn.dn_nlevels - 1; level >= 0; level--) {
 646                idx = (blkid >> (epbs * level)) & ((1 << epbs) - 1);
 647                *bp = bp_array[idx];
 648                if (bp_array != dn->dn.dn_blkptr) {
 649                        free(bp_array);
 650                        bp_array = 0;
 651                }
 652
 653                if (BP_IS_HOLE(bp)) {
 654                        size_t size = zfs_to_cpu16(dn->dn.dn_datablkszsec,
 655                                                                                        dn->endian)
 656                                << SPA_MINBLOCKSHIFT;
 657                        *buf = malloc(size);
 658                        if (*buf) {
 659                                err = ZFS_ERR_OUT_OF_MEMORY;
 660                                break;
 661                        }
 662                        memset(*buf, 0, size);
 663                        endian = (zfs_to_cpu64(bp->blk_prop, endian) >> 63) & 1;
 664                        break;
 665                }
 666                if (level == 0) {
 667                        err = zio_read(bp, endian, buf, 0, data);
 668                        endian = (zfs_to_cpu64(bp->blk_prop, endian) >> 63) & 1;
 669                        break;
 670                }
 671                err = zio_read(bp, endian, &tmpbuf, 0, data);
 672                endian = (zfs_to_cpu64(bp->blk_prop, endian) >> 63) & 1;
 673                if (err)
 674                        break;
 675                bp_array = tmpbuf;
 676        }
 677        if (bp_array != dn->dn.dn_blkptr)
 678                free(bp_array);
 679        if (endian_out)
 680                *endian_out = endian;
 681
 682        free(bp);
 683        return err;
 684}
 685
 686/*
 687 * mzap_lookup: Looks up property described by "name" and returns the value
 688 * in "value".
 689 */
 690static int
 691mzap_lookup(mzap_phys_t *zapobj, zfs_endian_t endian,
 692                        int objsize, char *name, uint64_t * value)
 693{
 694        int i, chunks;
 695        mzap_ent_phys_t *mzap_ent = zapobj->mz_chunk;
 696
 697        chunks = objsize / MZAP_ENT_LEN - 1;
 698        for (i = 0; i < chunks; i++) {
 699                if (strcmp(mzap_ent[i].mze_name, name) == 0) {
 700                        *value = zfs_to_cpu64(mzap_ent[i].mze_value, endian);
 701                        return ZFS_ERR_NONE;
 702                }
 703        }
 704
 705        printf("couldn't find '%s'\n", name);
 706        return ZFS_ERR_FILE_NOT_FOUND;
 707}
 708
 709static int
 710mzap_iterate(mzap_phys_t *zapobj, zfs_endian_t endian, int objsize,
 711                         int (*hook)(const char *name,
 712                                                 uint64_t val,
 713                                                 struct zfs_data *data),
 714                         struct zfs_data *data)
 715{
 716        int i, chunks;
 717        mzap_ent_phys_t *mzap_ent = zapobj->mz_chunk;
 718
 719        chunks = objsize / MZAP_ENT_LEN - 1;
 720        for (i = 0; i < chunks; i++) {
 721                if (hook(mzap_ent[i].mze_name,
 722                                 zfs_to_cpu64(mzap_ent[i].mze_value, endian),
 723                                 data))
 724                        return 1;
 725        }
 726
 727        return 0;
 728}
 729
 730static uint64_t
 731zap_hash(uint64_t salt, const char *name)
 732{
 733        static uint64_t table[256];
 734        const uint8_t *cp;
 735        uint8_t c;
 736        uint64_t crc = salt;
 737
 738        if (table[128] == 0) {
 739                uint64_t *ct = NULL;
 740                int i, j;
 741                for (i = 0; i < 256; i++) {
 742                        for (ct = table + i, *ct = i, j = 8; j > 0; j--)
 743                                *ct = (*ct >> 1) ^ (-(*ct & 1) & ZFS_CRC64_POLY);
 744                }
 745        }
 746
 747        for (cp = (const uint8_t *) name; (c = *cp) != '\0'; cp++)
 748                crc = (crc >> 8) ^ table[(crc ^ c) & 0xFF];
 749
 750        /*
 751         * Only use 28 bits, since we need 4 bits in the cookie for the
 752         * collision differentiator.  We MUST use the high bits, since
 753         * those are the onces that we first pay attention to when
 754         * chosing the bucket.
 755         */
 756        crc &= ~((1ULL << (64 - ZAP_HASHBITS)) - 1);
 757
 758        return crc;
 759}
 760
 761/*
 762 * Only to be used on 8-bit arrays.
 763 * array_len is actual len in bytes (not encoded le_value_length).
 764 * buf is null-terminated.
 765 */
 766/* XXX */
 767static int
 768zap_leaf_array_equal(zap_leaf_phys_t *l, zfs_endian_t endian,
 769                                         int blksft, int chunk, int array_len, const char *buf)
 770{
 771        int bseen = 0;
 772
 773        while (bseen < array_len) {
 774                struct zap_leaf_array *la = &ZAP_LEAF_CHUNK(l, blksft, chunk).l_array;
 775                int toread = min(array_len - bseen, ZAP_LEAF_ARRAY_BYTES);
 776
 777                if (chunk >= ZAP_LEAF_NUMCHUNKS(blksft))
 778                        return 0;
 779
 780                if (memcmp(la->la_array, buf + bseen, toread) != 0)
 781                        break;
 782                chunk = zfs_to_cpu16(la->la_next, endian);
 783                bseen += toread;
 784        }
 785        return (bseen == array_len);
 786}
 787
 788/* XXX */
 789static int
 790zap_leaf_array_get(zap_leaf_phys_t *l, zfs_endian_t endian, int blksft,
 791                                   int chunk, int array_len, char *buf)
 792{
 793        int bseen = 0;
 794
 795        while (bseen < array_len) {
 796                struct zap_leaf_array *la = &ZAP_LEAF_CHUNK(l, blksft, chunk).l_array;
 797                int toread = min(array_len - bseen, ZAP_LEAF_ARRAY_BYTES);
 798
 799                if (chunk >= ZAP_LEAF_NUMCHUNKS(blksft))
 800                        /* Don't use errno because this error is to be ignored.  */
 801                        return ZFS_ERR_BAD_FS;
 802
 803                memcpy(buf + bseen, la->la_array,  toread);
 804                chunk = zfs_to_cpu16(la->la_next, endian);
 805                bseen += toread;
 806        }
 807        return ZFS_ERR_NONE;
 808}
 809
 810
 811/*
 812 * Given a zap_leaf_phys_t, walk thru the zap leaf chunks to get the
 813 * value for the property "name".
 814 *
 815 */
 816/* XXX */
 817static int
 818zap_leaf_lookup(zap_leaf_phys_t *l, zfs_endian_t endian,
 819                                int blksft, uint64_t h,
 820                                const char *name, uint64_t *value)
 821{
 822        uint16_t chunk;
 823        struct zap_leaf_entry *le;
 824
 825        /* Verify if this is a valid leaf block */
 826        if (zfs_to_cpu64(l->l_hdr.lh_block_type, endian) != ZBT_LEAF) {
 827                printf("invalid leaf type\n");
 828                return ZFS_ERR_BAD_FS;
 829        }
 830        if (zfs_to_cpu32(l->l_hdr.lh_magic, endian) != ZAP_LEAF_MAGIC) {
 831                printf("invalid leaf magic\n");
 832                return ZFS_ERR_BAD_FS;
 833        }
 834
 835        for (chunk = zfs_to_cpu16(l->l_hash[LEAF_HASH(blksft, h)], endian);
 836                 chunk != CHAIN_END; chunk = le->le_next) {
 837
 838                if (chunk >= ZAP_LEAF_NUMCHUNKS(blksft)) {
 839                        printf("invalid chunk number\n");
 840                        return ZFS_ERR_BAD_FS;
 841                }
 842
 843                le = ZAP_LEAF_ENTRY(l, blksft, chunk);
 844
 845                /* Verify the chunk entry */
 846                if (le->le_type != ZAP_CHUNK_ENTRY) {
 847                        printf("invalid chunk entry\n");
 848                        return ZFS_ERR_BAD_FS;
 849                }
 850
 851                if (zfs_to_cpu64(le->le_hash, endian) != h)
 852                        continue;
 853
 854                if (zap_leaf_array_equal(l, endian, blksft,
 855                                                                 zfs_to_cpu16(le->le_name_chunk, endian),
 856                                                                 zfs_to_cpu16(le->le_name_length, endian),
 857                                                                 name)) {
 858                        struct zap_leaf_array *la;
 859
 860                        if (le->le_int_size != 8 || le->le_value_length != 1) {
 861                                printf("invalid leaf chunk entry\n");
 862                                return ZFS_ERR_BAD_FS;
 863                        }
 864                        /* get the uint64_t property value */
 865                        la = &ZAP_LEAF_CHUNK(l, blksft, le->le_value_chunk).l_array;
 866
 867                        *value = be64_to_cpu(la->la_array64);
 868
 869                        return ZFS_ERR_NONE;
 870                }
 871        }
 872
 873        printf("couldn't find '%s'\n", name);
 874        return ZFS_ERR_FILE_NOT_FOUND;
 875}
 876
 877
 878/* Verify if this is a fat zap header block */
 879static int
 880zap_verify(zap_phys_t *zap)
 881{
 882        if (zap->zap_magic != (uint64_t) ZAP_MAGIC) {
 883                printf("bad ZAP magic\n");
 884                return ZFS_ERR_BAD_FS;
 885        }
 886
 887        if (zap->zap_flags != 0) {
 888                printf("bad ZAP flags\n");
 889                return ZFS_ERR_BAD_FS;
 890        }
 891
 892        if (zap->zap_salt == 0) {
 893                printf("bad ZAP salt\n");
 894                return ZFS_ERR_BAD_FS;
 895        }
 896
 897        return ZFS_ERR_NONE;
 898}
 899
 900/*
 901 * Fat ZAP lookup
 902 *
 903 */
 904/* XXX */
 905static int
 906fzap_lookup(dnode_end_t *zap_dnode, zap_phys_t *zap,
 907                        char *name, uint64_t *value, struct zfs_data *data)
 908{
 909        void *l;
 910        uint64_t hash, idx, blkid;
 911        int blksft = zfs_log2(zfs_to_cpu16(zap_dnode->dn.dn_datablkszsec,
 912                                                                                        zap_dnode->endian) << DNODE_SHIFT);
 913        int err;
 914        zfs_endian_t leafendian;
 915
 916        err = zap_verify(zap);
 917        if (err)
 918                return err;
 919
 920        hash = zap_hash(zap->zap_salt, name);
 921
 922        /* get block id from index */
 923        if (zap->zap_ptrtbl.zt_numblks != 0) {
 924                printf("external pointer tables not supported\n");
 925                return ZFS_ERR_NOT_IMPLEMENTED_YET;
 926        }
 927        idx = ZAP_HASH_IDX(hash, zap->zap_ptrtbl.zt_shift);
 928        blkid = ((uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))];
 929
 930        /* Get the leaf block */
 931        if ((1U << blksft) < sizeof(zap_leaf_phys_t)) {
 932                printf("ZAP leaf is too small\n");
 933                return ZFS_ERR_BAD_FS;
 934        }
 935        err = dmu_read(zap_dnode, blkid, &l, &leafendian, data);
 936        if (err)
 937                return err;
 938
 939        err = zap_leaf_lookup(l, leafendian, blksft, hash, name, value);
 940        free(l);
 941        return err;
 942}
 943
 944/* XXX */
 945static int
 946fzap_iterate(dnode_end_t *zap_dnode, zap_phys_t *zap,
 947                         int (*hook)(const char *name,
 948                                                 uint64_t val,
 949                                                 struct zfs_data *data),
 950                         struct zfs_data *data)
 951{
 952        zap_leaf_phys_t *l;
 953        void *l_in;
 954        uint64_t idx, blkid;
 955        uint16_t chunk;
 956        int blksft = zfs_log2(zfs_to_cpu16(zap_dnode->dn.dn_datablkszsec,
 957                                                                                        zap_dnode->endian) << DNODE_SHIFT);
 958        int err;
 959        zfs_endian_t endian;
 960
 961        if (zap_verify(zap))
 962                return 0;
 963
 964        /* get block id from index */
 965        if (zap->zap_ptrtbl.zt_numblks != 0) {
 966                printf("external pointer tables not supported\n");
 967                return 0;
 968        }
 969        /* Get the leaf block */
 970        if ((1U << blksft) < sizeof(zap_leaf_phys_t)) {
 971                printf("ZAP leaf is too small\n");
 972                return 0;
 973        }
 974        for (idx = 0; idx < zap->zap_ptrtbl.zt_numblks; idx++) {
 975                blkid = ((uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))];
 976
 977                err = dmu_read(zap_dnode, blkid, &l_in, &endian, data);
 978                l = l_in;
 979                if (err)
 980                        continue;
 981
 982                /* Verify if this is a valid leaf block */
 983                if (zfs_to_cpu64(l->l_hdr.lh_block_type, endian) != ZBT_LEAF) {
 984                        free(l);
 985                        continue;
 986                }
 987                if (zfs_to_cpu32(l->l_hdr.lh_magic, endian) != ZAP_LEAF_MAGIC) {
 988                        free(l);
 989                        continue;
 990                }
 991
 992                for (chunk = 0; chunk < ZAP_LEAF_NUMCHUNKS(blksft); chunk++) {
 993                        char *buf;
 994                        struct zap_leaf_array *la;
 995                        struct zap_leaf_entry *le;
 996                        uint64_t val;
 997                        le = ZAP_LEAF_ENTRY(l, blksft, chunk);
 998
 999                        /* Verify the chunk entry */
1000                        if (le->le_type != ZAP_CHUNK_ENTRY)
1001                                continue;
1002
1003                        buf = malloc(zfs_to_cpu16(le->le_name_length, endian)
1004                                                 + 1);
1005                        if (zap_leaf_array_get(l, endian, blksft, le->le_name_chunk,
1006                                                                   le->le_name_length, buf)) {
1007                                free(buf);
1008                                continue;
1009                        }
1010                        buf[le->le_name_length] = 0;
1011
1012                        if (le->le_int_size != 8
1013                                || zfs_to_cpu16(le->le_value_length, endian) != 1)
1014                                continue;
1015
1016                        /* get the uint64_t property value */
1017                        la = &ZAP_LEAF_CHUNK(l, blksft, le->le_value_chunk).l_array;
1018                        val = be64_to_cpu(la->la_array64);
1019                        if (hook(buf, val, data))
1020                                return 1;
1021                        free(buf);
1022                }
1023        }
1024        return 0;
1025}
1026
1027
1028/*
1029 * Read in the data of a zap object and find the value for a matching
1030 * property name.
1031 *
1032 */
1033static int
1034zap_lookup(dnode_end_t *zap_dnode, char *name, uint64_t *val,
1035                   struct zfs_data *data)
1036{
1037        uint64_t block_type;
1038        int size;
1039        void *zapbuf;
1040        int err;
1041        zfs_endian_t endian;
1042
1043        /* Read in the first block of the zap object data. */
1044        size = zfs_to_cpu16(zap_dnode->dn.dn_datablkszsec,
1045                                                         zap_dnode->endian) << SPA_MINBLOCKSHIFT;
1046        err = dmu_read(zap_dnode, 0, &zapbuf, &endian, data);
1047        if (err)
1048                return err;
1049        block_type = zfs_to_cpu64(*((uint64_t *) zapbuf), endian);
1050
1051        if (block_type == ZBT_MICRO) {
1052                err = (mzap_lookup(zapbuf, endian, size, name, val));
1053                free(zapbuf);
1054                return err;
1055        } else if (block_type == ZBT_HEADER) {
1056                /* this is a fat zap */
1057                err = (fzap_lookup(zap_dnode, zapbuf, name, val, data));
1058                free(zapbuf);
1059                return err;
1060        }
1061
1062        printf("unknown ZAP type\n");
1063        free(zapbuf);
1064        return ZFS_ERR_BAD_FS;
1065}
1066
1067static int
1068zap_iterate(dnode_end_t *zap_dnode,
1069                        int (*hook)(const char *name, uint64_t val,
1070                                                struct zfs_data *data),
1071                        struct zfs_data *data)
1072{
1073        uint64_t block_type;
1074        int size;
1075        void *zapbuf;
1076        int err;
1077        int ret;
1078        zfs_endian_t endian;
1079
1080        /* Read in the first block of the zap object data. */
1081        size = zfs_to_cpu16(zap_dnode->dn.dn_datablkszsec, zap_dnode->endian) << SPA_MINBLOCKSHIFT;
1082        err = dmu_read(zap_dnode, 0, &zapbuf, &endian, data);
1083        if (err)
1084                return 0;
1085        block_type = zfs_to_cpu64(*((uint64_t *) zapbuf), endian);
1086
1087        if (block_type == ZBT_MICRO) {
1088                ret = mzap_iterate(zapbuf, endian, size, hook, data);
1089                free(zapbuf);
1090                return ret;
1091        } else if (block_type == ZBT_HEADER) {
1092                /* this is a fat zap */
1093                ret = fzap_iterate(zap_dnode, zapbuf, hook, data);
1094                free(zapbuf);
1095                return ret;
1096        }
1097        printf("unknown ZAP type\n");
1098        free(zapbuf);
1099        return 0;
1100}
1101
1102
1103/*
1104 * Get the dnode of an object number from the metadnode of an object set.
1105 *
1106 * Input
1107 *      mdn - metadnode to get the object dnode
1108 *      objnum - object number for the object dnode
1109 *      buf - data buffer that holds the returning dnode
1110 */
1111static int
1112dnode_get(dnode_end_t *mdn, uint64_t objnum, uint8_t type,
1113                  dnode_end_t *buf, struct zfs_data *data)
1114{
1115        uint64_t blkid, blksz;  /* the block id this object dnode is in */
1116        int epbs;                       /* shift of number of dnodes in a block */
1117        int idx;                        /* index within a block */
1118        void *dnbuf;
1119        int err;
1120        zfs_endian_t endian;
1121
1122        blksz = zfs_to_cpu16(mdn->dn.dn_datablkszsec,
1123                                                          mdn->endian) << SPA_MINBLOCKSHIFT;
1124
1125        epbs = zfs_log2(blksz) - DNODE_SHIFT;
1126        blkid = objnum >> epbs;
1127        idx = objnum & ((1 << epbs) - 1);
1128
1129        if (data->dnode_buf != NULL && memcmp(data->dnode_mdn, mdn,
1130                                                                                  sizeof(*mdn)) == 0
1131                && objnum >= data->dnode_start && objnum < data->dnode_end) {
1132                memmove(&(buf->dn), &(data->dnode_buf)[idx], DNODE_SIZE);
1133                buf->endian = data->dnode_endian;
1134                if (type && buf->dn.dn_type != type)  {
1135                        printf("incorrect dnode type: %02X != %02x\n", buf->dn.dn_type, type);
1136                        return ZFS_ERR_BAD_FS;
1137                }
1138                return ZFS_ERR_NONE;
1139        }
1140
1141        err = dmu_read(mdn, blkid, &dnbuf, &endian, data);
1142        if (err)
1143                return err;
1144
1145        free(data->dnode_buf);
1146        free(data->dnode_mdn);
1147        data->dnode_mdn = malloc(sizeof(*mdn));
1148        if (!data->dnode_mdn) {
1149                data->dnode_buf = 0;
1150        } else {
1151                memcpy(data->dnode_mdn, mdn, sizeof(*mdn));
1152                data->dnode_buf = dnbuf;
1153                data->dnode_start = blkid << epbs;
1154                data->dnode_end = (blkid + 1) << epbs;
1155                data->dnode_endian = endian;
1156        }
1157
1158        memmove(&(buf->dn), (dnode_phys_t *) dnbuf + idx, DNODE_SIZE);
1159        buf->endian = endian;
1160        if (type && buf->dn.dn_type != type) {
1161                printf("incorrect dnode type\n");
1162                return ZFS_ERR_BAD_FS;
1163        }
1164
1165        return ZFS_ERR_NONE;
1166}
1167
1168/*
1169 * Get the file dnode for a given file name where mdn is the meta dnode
1170 * for this ZFS object set. When found, place the file dnode in dn.
1171 * The 'path' argument will be mangled.
1172 *
1173 */
1174static int
1175dnode_get_path(dnode_end_t *mdn, const char *path_in, dnode_end_t *dn,
1176                           struct zfs_data *data)
1177{
1178        uint64_t objnum, version;
1179        char *cname, ch;
1180        int err = ZFS_ERR_NONE;
1181        char *path, *path_buf;
1182        struct dnode_chain {
1183                struct dnode_chain *next;
1184                dnode_end_t dn;
1185        };
1186        struct dnode_chain *dnode_path = 0, *dn_new, *root;
1187
1188        dn_new = malloc(sizeof(*dn_new));
1189        if (!dn_new)
1190                return ZFS_ERR_OUT_OF_MEMORY;
1191        dn_new->next = 0;
1192        dnode_path = root = dn_new;
1193
1194        err = dnode_get(mdn, MASTER_NODE_OBJ, DMU_OT_MASTER_NODE,
1195                                        &(dnode_path->dn), data);
1196        if (err) {
1197                free(dn_new);
1198                return err;
1199        }
1200
1201        err = zap_lookup(&(dnode_path->dn), ZPL_VERSION_STR, &version, data);
1202        if (err) {
1203                free(dn_new);
1204                return err;
1205        }
1206        if (version > ZPL_VERSION) {
1207                free(dn_new);
1208                printf("too new ZPL version\n");
1209                return ZFS_ERR_NOT_IMPLEMENTED_YET;
1210        }
1211
1212        err = zap_lookup(&(dnode_path->dn), ZFS_ROOT_OBJ, &objnum, data);
1213        if (err) {
1214                free(dn_new);
1215                return err;
1216        }
1217
1218        err = dnode_get(mdn, objnum, 0, &(dnode_path->dn), data);
1219        if (err) {
1220                free(dn_new);
1221                return err;
1222        }
1223
1224        path = path_buf = strdup(path_in);
1225        if (!path_buf) {
1226                free(dn_new);
1227                return ZFS_ERR_OUT_OF_MEMORY;
1228        }
1229
1230        while (1) {
1231                /* skip leading slashes */
1232                while (*path == '/')
1233                        path++;
1234                if (!*path)
1235                        break;
1236                /* get the next component name */
1237                cname = path;
1238                while (*path && *path != '/')
1239                        path++;
1240                /* Skip dot.  */
1241                if (cname + 1 == path && cname[0] == '.')
1242                        continue;
1243                /* Handle double dot.  */
1244                if (cname + 2 == path && cname[0] == '.' && cname[1] == '.')  {
1245                        if (dn_new->next) {
1246                                dn_new = dnode_path;
1247                                dnode_path = dn_new->next;
1248                                free(dn_new);
1249                        } else {
1250                                printf("can't resolve ..\n");
1251                                err = ZFS_ERR_FILE_NOT_FOUND;
1252                                break;
1253                        }
1254                        continue;
1255                }
1256
1257                ch = *path;
1258                *path = 0;              /* ensure null termination */
1259
1260                if (dnode_path->dn.dn.dn_type != DMU_OT_DIRECTORY_CONTENTS) {
1261                        free(path_buf);
1262                        printf("not a directory\n");
1263                        return ZFS_ERR_BAD_FILE_TYPE;
1264                }
1265                err = zap_lookup(&(dnode_path->dn), cname, &objnum, data);
1266                if (err)
1267                        break;
1268
1269                dn_new = malloc(sizeof(*dn_new));
1270                if (!dn_new) {
1271                        err = ZFS_ERR_OUT_OF_MEMORY;
1272                        break;
1273                }
1274                dn_new->next = dnode_path;
1275                dnode_path = dn_new;
1276
1277                objnum = ZFS_DIRENT_OBJ(objnum);
1278                err = dnode_get(mdn, objnum, 0, &(dnode_path->dn), data);
1279                if (err)
1280                        break;
1281
1282                *path = ch;
1283        }
1284
1285        if (!err)
1286                memcpy(dn, &(dnode_path->dn), sizeof(*dn));
1287
1288        while (dnode_path) {
1289                dn_new = dnode_path->next;
1290                free(dnode_path);
1291                dnode_path = dn_new;
1292        }
1293        free(path_buf);
1294        return err;
1295}
1296
1297
1298/*
1299 * Given a MOS metadnode, get the metadnode of a given filesystem name (fsname),
1300 * e.g. pool/rootfs, or a given object number (obj), e.g. the object number
1301 * of pool/rootfs.
1302 *
1303 * If no fsname and no obj are given, return the DSL_DIR metadnode.
1304 * If fsname is given, return its metadnode and its matching object number.
1305 * If only obj is given, return the metadnode for this object number.
1306 *
1307 */
1308static int
1309get_filesystem_dnode(dnode_end_t *mosmdn, char *fsname,
1310                                         dnode_end_t *mdn, struct zfs_data *data)
1311{
1312        uint64_t objnum;
1313        int err;
1314
1315        err = dnode_get(mosmdn, DMU_POOL_DIRECTORY_OBJECT,
1316                                        DMU_OT_OBJECT_DIRECTORY, mdn, data);
1317        if (err)
1318                return err;
1319
1320        err = zap_lookup(mdn, DMU_POOL_ROOT_DATASET, &objnum, data);
1321        if (err)
1322                return err;
1323
1324        err = dnode_get(mosmdn, objnum, DMU_OT_DSL_DIR, mdn, data);
1325        if (err)
1326                return err;
1327
1328        while (*fsname) {
1329                uint64_t childobj;
1330                char *cname, ch;
1331
1332                while (*fsname == '/')
1333                        fsname++;
1334
1335                if (!*fsname || *fsname == '@')
1336                        break;
1337
1338                cname = fsname;
1339                while (*fsname && !isspace(*fsname) && *fsname != '/')
1340                        fsname++;
1341                ch = *fsname;
1342                *fsname = 0;
1343
1344                childobj = zfs_to_cpu64((((dsl_dir_phys_t *) DN_BONUS(&mdn->dn)))->dd_child_dir_zapobj, mdn->endian);
1345                err = dnode_get(mosmdn, childobj,
1346                                                DMU_OT_DSL_DIR_CHILD_MAP, mdn, data);
1347                if (err)
1348                        return err;
1349
1350                err = zap_lookup(mdn, cname, &objnum, data);
1351                if (err)
1352                        return err;
1353
1354                err = dnode_get(mosmdn, objnum, DMU_OT_DSL_DIR, mdn, data);
1355                if (err)
1356                        return err;
1357
1358                *fsname = ch;
1359        }
1360        return ZFS_ERR_NONE;
1361}
1362
1363static int
1364make_mdn(dnode_end_t *mdn, struct zfs_data *data)
1365{
1366        void *osp;
1367        blkptr_t *bp;
1368        size_t ospsize;
1369        int err;
1370
1371        bp = &(((dsl_dataset_phys_t *) DN_BONUS(&mdn->dn))->ds_bp);
1372        err = zio_read(bp, mdn->endian, &osp, &ospsize, data);
1373        if (err)
1374                return err;
1375        if (ospsize < OBJSET_PHYS_SIZE_V14) {
1376                free(osp);
1377                printf("too small osp\n");
1378                return ZFS_ERR_BAD_FS;
1379        }
1380
1381        mdn->endian = (zfs_to_cpu64(bp->blk_prop, mdn->endian)>>63) & 1;
1382        memmove((char *) &(mdn->dn),
1383                        (char *) &((objset_phys_t *) osp)->os_meta_dnode, DNODE_SIZE);
1384        free(osp);
1385        return ZFS_ERR_NONE;
1386}
1387
1388static int
1389dnode_get_fullpath(const char *fullpath, dnode_end_t *mdn,
1390                                   uint64_t *mdnobj, dnode_end_t *dn, int *isfs,
1391                                   struct zfs_data *data)
1392{
1393        char *fsname, *snapname;
1394        const char *ptr_at, *filename;
1395        uint64_t headobj;
1396        int err;
1397
1398        ptr_at = strchr(fullpath, '@');
1399        if (!ptr_at) {
1400                *isfs = 1;
1401                filename = 0;
1402                snapname = 0;
1403                fsname = strdup(fullpath);
1404        } else {
1405                const char *ptr_slash = strchr(ptr_at, '/');
1406
1407                *isfs = 0;
1408                fsname = malloc(ptr_at - fullpath + 1);
1409                if (!fsname)
1410                        return ZFS_ERR_OUT_OF_MEMORY;
1411                memcpy(fsname, fullpath, ptr_at - fullpath);
1412                fsname[ptr_at - fullpath] = 0;
1413                if (ptr_at[1] && ptr_at[1] != '/') {
1414                        snapname = malloc(ptr_slash - ptr_at);
1415                        if (!snapname) {
1416                                free(fsname);
1417                                return ZFS_ERR_OUT_OF_MEMORY;
1418                        }
1419                        memcpy(snapname, ptr_at + 1, ptr_slash - ptr_at - 1);
1420                        snapname[ptr_slash - ptr_at - 1] = 0;
1421                } else {
1422                        snapname = 0;
1423                }
1424                if (ptr_slash)
1425                        filename = ptr_slash;
1426                else
1427                        filename = "/";
1428                printf("zfs fsname = '%s' snapname='%s' filename = '%s'\n",
1429                           fsname, snapname, filename);
1430        }
1431
1432
1433        err = get_filesystem_dnode(&(data->mos), fsname, dn, data);
1434
1435        if (err) {
1436                free(fsname);
1437                free(snapname);
1438                return err;
1439        }
1440
1441        headobj = zfs_to_cpu64(((dsl_dir_phys_t *) DN_BONUS(&dn->dn))->dd_head_dataset_obj, dn->endian);
1442
1443        err = dnode_get(&(data->mos), headobj, DMU_OT_DSL_DATASET, mdn, data);
1444        if (err) {
1445                free(fsname);
1446                free(snapname);
1447                return err;
1448        }
1449
1450        if (snapname) {
1451                uint64_t snapobj;
1452
1453                snapobj = zfs_to_cpu64(((dsl_dataset_phys_t *) DN_BONUS(&mdn->dn))->ds_snapnames_zapobj, mdn->endian);
1454
1455                err = dnode_get(&(data->mos), snapobj,
1456                                                DMU_OT_DSL_DS_SNAP_MAP, mdn, data);
1457                if (!err)
1458                        err = zap_lookup(mdn, snapname, &headobj, data);
1459                if (!err)
1460                        err = dnode_get(&(data->mos), headobj, DMU_OT_DSL_DATASET, mdn, data);
1461                if (err) {
1462                        free(fsname);
1463                        free(snapname);
1464                        return err;
1465                }
1466        }
1467
1468        if (mdnobj)
1469                *mdnobj = headobj;
1470
1471        make_mdn(mdn, data);
1472
1473        if (*isfs) {
1474                free(fsname);
1475                free(snapname);
1476                return ZFS_ERR_NONE;
1477        }
1478        err = dnode_get_path(mdn, filename, dn, data);
1479        free(fsname);
1480        free(snapname);
1481        return err;
1482}
1483
1484/*
1485 * For a given XDR packed nvlist, verify the first 4 bytes and move on.
1486 *
1487 * An XDR packed nvlist is encoded as (comments from nvs_xdr_create) :
1488 *
1489 *              encoding method/host endian             (4 bytes)
1490 *              nvl_version                                             (4 bytes)
1491 *              nvl_nvflag                                              (4 bytes)
1492 *      encoded nvpairs:
1493 *              encoded size of the nvpair              (4 bytes)
1494 *              decoded size of the nvpair              (4 bytes)
1495 *              name string size                                (4 bytes)
1496 *              name string data                                (sizeof(NV_ALIGN4(string))
1497 *              data type                                               (4 bytes)
1498 *              # of elements in the nvpair             (4 bytes)
1499 *              data
1500 *              2 zero's for the last nvpair
1501 *              (end of the entire list)        (8 bytes)
1502 *
1503 */
1504
1505static int
1506nvlist_find_value(char *nvlist, char *name, int valtype, char **val,
1507                                  size_t *size_out, size_t *nelm_out)
1508{
1509        int name_len, type, encode_size;
1510        char *nvpair, *nvp_name;
1511
1512        /* Verify if the 1st and 2nd byte in the nvlist are valid. */
1513        /* NOTE: independently of what endianness header announces all
1514           subsequent values are big-endian.  */
1515        if (nvlist[0] != NV_ENCODE_XDR || (nvlist[1] != NV_LITTLE_ENDIAN
1516                                                                           && nvlist[1] != NV_BIG_ENDIAN)) {
1517                printf("zfs incorrect nvlist header\n");
1518                return ZFS_ERR_BAD_FS;
1519        }
1520
1521        /* skip the header, nvl_version, and nvl_nvflag */
1522        nvlist = nvlist + 4 * 3;
1523        /*
1524         * Loop thru the nvpair list
1525         * The XDR representation of an integer is in big-endian byte order.
1526         */
1527        while ((encode_size = be32_to_cpu(*(uint32_t *) nvlist))) {
1528                int nelm;
1529
1530                nvpair = nvlist + 4 * 2;        /* skip the encode/decode size */
1531
1532                name_len = be32_to_cpu(*(uint32_t *) nvpair);
1533                nvpair += 4;
1534
1535                nvp_name = nvpair;
1536                nvpair = nvpair + ((name_len + 3) & ~3);        /* align */
1537
1538                type = be32_to_cpu(*(uint32_t *) nvpair);
1539                nvpair += 4;
1540
1541                nelm = be32_to_cpu(*(uint32_t *) nvpair);
1542                if (nelm < 1) {
1543                        printf("empty nvpair\n");
1544                        return ZFS_ERR_BAD_FS;
1545                }
1546
1547                nvpair += 4;
1548
1549                if ((strncmp(nvp_name, name, name_len) == 0) && type == valtype) {
1550                        *val = nvpair;
1551                        *size_out = encode_size;
1552                        if (nelm_out)
1553                                *nelm_out = nelm;
1554                        return 1;
1555                }
1556
1557                nvlist += encode_size;  /* goto the next nvpair */
1558        }
1559        return 0;
1560}
1561
1562int
1563zfs_nvlist_lookup_uint64(char *nvlist, char *name, uint64_t *out)
1564{
1565        char *nvpair;
1566        size_t size;
1567        int found;
1568
1569        found = nvlist_find_value(nvlist, name, DATA_TYPE_UINT64, &nvpair, &size, 0);
1570        if (!found)
1571                return 0;
1572        if (size < sizeof(uint64_t)) {
1573                printf("invalid uint64\n");
1574                return ZFS_ERR_BAD_FS;
1575        }
1576
1577        *out = be64_to_cpu(*(uint64_t *) nvpair);
1578        return 1;
1579}
1580
1581char *
1582zfs_nvlist_lookup_string(char *nvlist, char *name)
1583{
1584        char *nvpair;
1585        char *ret;
1586        size_t slen;
1587        size_t size;
1588        int found;
1589
1590        found = nvlist_find_value(nvlist, name, DATA_TYPE_STRING, &nvpair, &size, 0);
1591        if (!found)
1592                return 0;
1593        if (size < 4) {
1594                printf("invalid string\n");
1595                return 0;
1596        }
1597        slen = be32_to_cpu(*(uint32_t *) nvpair);
1598        if (slen > size - 4)
1599                slen = size - 4;
1600        ret = malloc(slen + 1);
1601        if (!ret)
1602                return 0;
1603        memcpy(ret, nvpair + 4, slen);
1604        ret[slen] = 0;
1605        return ret;
1606}
1607
1608char *
1609zfs_nvlist_lookup_nvlist(char *nvlist, char *name)
1610{
1611        char *nvpair;
1612        char *ret;
1613        size_t size;
1614        int found;
1615
1616        found = nvlist_find_value(nvlist, name, DATA_TYPE_NVLIST, &nvpair,
1617                                                          &size, 0);
1618        if (!found)
1619                return 0;
1620        ret = calloc(1, size + 3 * sizeof(uint32_t));
1621        if (!ret)
1622                return 0;
1623        memcpy(ret, nvlist, sizeof(uint32_t));
1624
1625        memcpy(ret + sizeof(uint32_t), nvpair, size);
1626        return ret;
1627}
1628
1629int
1630zfs_nvlist_lookup_nvlist_array_get_nelm(char *nvlist, char *name)
1631{
1632        char *nvpair;
1633        size_t nelm, size;
1634        int found;
1635
1636        found = nvlist_find_value(nvlist, name, DATA_TYPE_NVLIST, &nvpair,
1637                                                          &size, &nelm);
1638        if (!found)
1639                return -1;
1640        return nelm;
1641}
1642
1643char *
1644zfs_nvlist_lookup_nvlist_array(char *nvlist, char *name,
1645                                                                        size_t index)
1646{
1647        char *nvpair, *nvpairptr;
1648        int found;
1649        char *ret;
1650        size_t size;
1651        unsigned i;
1652        size_t nelm;
1653
1654        found = nvlist_find_value(nvlist, name, DATA_TYPE_NVLIST, &nvpair,
1655                                                          &size, &nelm);
1656        if (!found)
1657                return 0;
1658        if (index >= nelm) {
1659                printf("trying to lookup past nvlist array\n");
1660                return 0;
1661        }
1662
1663        nvpairptr = nvpair;
1664
1665        for (i = 0; i < index; i++) {
1666                uint32_t encode_size;
1667
1668                /* skip the header, nvl_version, and nvl_nvflag */
1669                nvpairptr = nvpairptr + 4 * 2;
1670
1671                while (nvpairptr < nvpair + size
1672                           && (encode_size = be32_to_cpu(*(uint32_t *) nvpairptr)))
1673                        nvlist += encode_size;  /* goto the next nvpair */
1674
1675                nvlist = nvlist + 4 * 2;        /* skip the ending 2 zeros - 8 bytes */
1676        }
1677
1678        if (nvpairptr >= nvpair + size
1679                || nvpairptr + be32_to_cpu(*(uint32_t *) (nvpairptr + 4 * 2))
1680                >= nvpair + size) {
1681                printf("incorrect nvlist array\n");
1682                return 0;
1683        }
1684
1685        ret = calloc(1, be32_to_cpu(*(uint32_t *) (nvpairptr + 4 * 2))
1686                                 + 3 * sizeof(uint32_t));
1687        if (!ret)
1688                return 0;
1689        memcpy(ret, nvlist, sizeof(uint32_t));
1690
1691        memcpy(ret + sizeof(uint32_t), nvpairptr, size);
1692        return ret;
1693}
1694
1695static int
1696int_zfs_fetch_nvlist(struct zfs_data *data, char **nvlist)
1697{
1698        int err;
1699
1700        *nvlist = malloc(VDEV_PHYS_SIZE);
1701        /* Read in the vdev name-value pair list (112K). */
1702        err = zfs_devread(data->vdev_phys_sector, 0, VDEV_PHYS_SIZE, *nvlist);
1703        if (err) {
1704                free(*nvlist);
1705                *nvlist = 0;
1706                return err;
1707        }
1708        return ZFS_ERR_NONE;
1709}
1710
1711/*
1712 * Check the disk label information and retrieve needed vdev name-value pairs.
1713 *
1714 */
1715static int
1716check_pool_label(struct zfs_data *data)
1717{
1718        uint64_t pool_state;
1719        char *nvlist;                   /* for the pool */
1720        char *vdevnvlist;               /* for the vdev */
1721        uint64_t diskguid;
1722        uint64_t version;
1723        int found;
1724        int err;
1725
1726        err = int_zfs_fetch_nvlist(data, &nvlist);
1727        if (err)
1728                return err;
1729
1730        found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_POOL_STATE,
1731                                                                                  &pool_state);
1732        if (!found) {
1733                free(nvlist);
1734                printf("zfs pool state not found\n");
1735                return ZFS_ERR_BAD_FS;
1736        }
1737
1738        if (pool_state == POOL_STATE_DESTROYED) {
1739                free(nvlist);
1740                printf("zpool is marked as destroyed\n");
1741                return ZFS_ERR_BAD_FS;
1742        }
1743
1744        data->label_txg = 0;
1745        found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_POOL_TXG,
1746                                                                                  &data->label_txg);
1747        if (!found) {
1748                free(nvlist);
1749                printf("zfs pool txg not found\n");
1750                return ZFS_ERR_BAD_FS;
1751        }
1752
1753        /* not an active device */
1754        if (data->label_txg == 0) {
1755                free(nvlist);
1756                printf("zpool is not active\n");
1757                return ZFS_ERR_BAD_FS;
1758        }
1759
1760        found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_VERSION,
1761                                                                                  &version);
1762        if (!found) {
1763                free(nvlist);
1764                printf("zpool config version not found\n");
1765                return ZFS_ERR_BAD_FS;
1766        }
1767
1768        if (version > SPA_VERSION) {
1769                free(nvlist);
1770                printf("SPA version too new %llu > %llu\n",
1771                           (unsigned long long) version,
1772                           (unsigned long long) SPA_VERSION);
1773                return ZFS_ERR_NOT_IMPLEMENTED_YET;
1774        }
1775
1776        vdevnvlist = zfs_nvlist_lookup_nvlist(nvlist, ZPOOL_CONFIG_VDEV_TREE);
1777        if (!vdevnvlist) {
1778                free(nvlist);
1779                printf("ZFS config vdev tree not found\n");
1780                return ZFS_ERR_BAD_FS;
1781        }
1782
1783        found = zfs_nvlist_lookup_uint64(vdevnvlist, ZPOOL_CONFIG_ASHIFT,
1784                                                                                  &data->vdev_ashift);
1785        free(vdevnvlist);
1786        if (!found) {
1787                free(nvlist);
1788                printf("ZPOOL config ashift not found\n");
1789                return ZFS_ERR_BAD_FS;
1790        }
1791
1792        found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_GUID, &diskguid);
1793        if (!found) {
1794                free(nvlist);
1795                printf("ZPOOL config guid not found\n");
1796                return ZFS_ERR_BAD_FS;
1797        }
1798
1799        found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_POOL_GUID, &data->pool_guid);
1800        if (!found) {
1801                free(nvlist);
1802                printf("ZPOOL config pool guid not found\n");
1803                return ZFS_ERR_BAD_FS;
1804        }
1805
1806        free(nvlist);
1807
1808        printf("ZFS Pool GUID: %llu (%016llx) Label: GUID: %llu (%016llx), txg: %llu, SPA v%llu, ashift: %llu\n",
1809                   (unsigned long long) data->pool_guid,
1810                   (unsigned long long) data->pool_guid,
1811                   (unsigned long long) diskguid,
1812                   (unsigned long long) diskguid,
1813                   (unsigned long long) data->label_txg,
1814                   (unsigned long long) version,
1815                   (unsigned long long) data->vdev_ashift);
1816
1817        return ZFS_ERR_NONE;
1818}
1819
1820/*
1821 * vdev_label_start returns the physical disk offset (in bytes) of
1822 * label "l".
1823 */
1824static uint64_t vdev_label_start(uint64_t psize, int l)
1825{
1826        return (l * sizeof(vdev_label_t) + (l < VDEV_LABELS / 2 ?
1827                                                                                0 : psize -
1828                                                                                VDEV_LABELS * sizeof(vdev_label_t)));
1829}
1830
1831void
1832zfs_unmount(struct zfs_data *data)
1833{
1834        free(data->dnode_buf);
1835        free(data->dnode_mdn);
1836        free(data->file_buf);
1837        free(data);
1838}
1839
1840/*
1841 * zfs_mount() locates a valid uberblock of the root pool and read in its MOS
1842 * to the memory address MOS.
1843 *
1844 */
1845struct zfs_data *
1846zfs_mount(device_t dev)
1847{
1848        struct zfs_data *data = 0;
1849        int label = 0, bestlabel = -1;
1850        char *ub_array;
1851        uberblock_t *ubbest;
1852        uberblock_t *ubcur = NULL;
1853        void *osp = 0;
1854        size_t ospsize;
1855        int err;
1856
1857        data = malloc(sizeof(*data));
1858        if (!data)
1859                return 0;
1860        memset(data, 0, sizeof(*data));
1861
1862        ub_array = malloc(VDEV_UBERBLOCK_RING);
1863        if (!ub_array) {
1864                zfs_unmount(data);
1865                return 0;
1866        }
1867
1868        ubbest = malloc(sizeof(*ubbest));
1869        if (!ubbest) {
1870                free(ub_array);
1871                zfs_unmount(data);
1872                return 0;
1873        }
1874        memset(ubbest, 0, sizeof(*ubbest));
1875
1876        /*
1877         * some eltorito stacks don't give us a size and
1878         * we end up setting the size to MAXUINT, further
1879         * some of these devices stop working once a single
1880         * read past the end has been issued. Checking
1881         * for a maximum part_length and skipping the backup
1882         * labels at the end of the slice/partition/device
1883         * avoids breaking down on such devices.
1884         */
1885        const int vdevnum =
1886                dev->part_length == 0 ?
1887                VDEV_LABELS / 2 : VDEV_LABELS;
1888
1889        /* Size in bytes of the device (disk or partition) aligned to label size*/
1890        uint64_t device_size =
1891                dev->part_length << SECTOR_BITS;
1892
1893        const uint64_t alignedbytes =
1894                P2ALIGN(device_size, (uint64_t) sizeof(vdev_label_t));
1895
1896        for (label = 0; label < vdevnum; label++) {
1897                uint64_t labelstartbytes = vdev_label_start(alignedbytes, label);
1898                uint64_t labelstart = labelstartbytes >> SECTOR_BITS;
1899
1900                debug("zfs reading label %d at sector %llu (byte %llu)\n",
1901                          label, (unsigned long long) labelstart,
1902                          (unsigned long long) labelstartbytes);
1903
1904                data->vdev_phys_sector = labelstart +
1905                        ((VDEV_SKIP_SIZE + VDEV_BOOT_HEADER_SIZE) >> SECTOR_BITS);
1906
1907                err = check_pool_label(data);
1908                if (err) {
1909                        printf("zfs error checking label %d\n", label);
1910                        continue;
1911                }
1912
1913                /* Read in the uberblock ring (128K). */
1914                err = zfs_devread(data->vdev_phys_sector  +
1915                                                  (VDEV_PHYS_SIZE >> SECTOR_BITS),
1916                                                  0, VDEV_UBERBLOCK_RING, ub_array);
1917                if (err) {
1918                        printf("zfs error reading uberblock ring for label %d\n", label);
1919                        continue;
1920                }
1921
1922                ubcur = find_bestub(ub_array, data);
1923                if (!ubcur) {
1924                        printf("zfs No good uberblocks found in label %d\n", label);
1925                        continue;
1926                }
1927
1928                if (vdev_uberblock_compare(ubcur, ubbest) > 0) {
1929                        /* Looks like the block is good, so use it.*/
1930                        memcpy(ubbest, ubcur, sizeof(*ubbest));
1931                        bestlabel = label;
1932                        debug("zfs Current best uberblock found in label %d\n", label);
1933                }
1934        }
1935        free(ub_array);
1936
1937        /* We zero'd the structure to begin with.  If we never assigned to it,
1938           magic will still be zero. */
1939        if (!ubbest->ub_magic) {
1940                printf("couldn't find a valid ZFS label\n");
1941                zfs_unmount(data);
1942                free(ubbest);
1943                return 0;
1944        }
1945
1946        debug("zfs ubbest %p in label %d\n", ubbest, bestlabel);
1947
1948        zfs_endian_t ub_endian =
1949                zfs_to_cpu64(ubbest->ub_magic, LITTLE_ENDIAN) == UBERBLOCK_MAGIC
1950                ? LITTLE_ENDIAN : BIG_ENDIAN;
1951
1952        debug("zfs endian set to %s\n", !ub_endian ? "big" : "little");
1953
1954        err = zio_read(&ubbest->ub_rootbp, ub_endian, &osp, &ospsize, data);
1955
1956        if (err) {
1957                printf("couldn't zio_read object directory\n");
1958                zfs_unmount(data);
1959                free(osp);
1960                free(ubbest);
1961                return 0;
1962        }
1963
1964        if (ospsize < OBJSET_PHYS_SIZE_V14) {
1965                printf("osp too small\n");
1966                zfs_unmount(data);
1967                free(osp);
1968                free(ubbest);
1969                return 0;
1970        }
1971
1972        /* Got the MOS. Save it at the memory addr MOS. */
1973        memmove(&(data->mos.dn), &((objset_phys_t *) osp)->os_meta_dnode, DNODE_SIZE);
1974        data->mos.endian =
1975                (zfs_to_cpu64(ubbest->ub_rootbp.blk_prop, ub_endian) >> 63) & 1;
1976        memmove(&(data->current_uberblock), ubbest, sizeof(uberblock_t));
1977
1978        free(osp);
1979        free(ubbest);
1980
1981        return data;
1982}
1983
1984int
1985zfs_fetch_nvlist(device_t dev, char **nvlist)
1986{
1987        struct zfs_data *zfs;
1988        int err;
1989
1990        zfs = zfs_mount(dev);
1991        if (!zfs)
1992                return ZFS_ERR_BAD_FS;
1993        err = int_zfs_fetch_nvlist(zfs, nvlist);
1994        zfs_unmount(zfs);
1995        return err;
1996}
1997
1998/*
1999 * zfs_open() locates a file in the rootpool by following the
2000 * MOS and places the dnode of the file in the memory address DNODE.
2001 */
2002int
2003zfs_open(struct zfs_file *file, const char *fsfilename)
2004{
2005        struct zfs_data *data;
2006        int err;
2007        int isfs;
2008
2009        data = zfs_mount(file->device);
2010        if (!data)
2011                return ZFS_ERR_BAD_FS;
2012
2013        err = dnode_get_fullpath(fsfilename, &(data->mdn), 0,
2014                                                         &(data->dnode), &isfs, data);
2015        if (err) {
2016                zfs_unmount(data);
2017                return err;
2018        }
2019
2020        if (isfs) {
2021                zfs_unmount(data);
2022                printf("Missing @ or / separator\n");
2023                return ZFS_ERR_FILE_NOT_FOUND;
2024        }
2025
2026        /* We found the dnode for this file. Verify if it is a plain file. */
2027        if (data->dnode.dn.dn_type != DMU_OT_PLAIN_FILE_CONTENTS) {
2028                zfs_unmount(data);
2029                printf("not a file\n");
2030                return ZFS_ERR_BAD_FILE_TYPE;
2031        }
2032
2033        /* get the file size and set the file position to 0 */
2034
2035        /*
2036         * For DMU_OT_SA we will need to locate the SIZE attribute
2037         * attribute, which could be either in the bonus buffer
2038         * or the "spill" block.
2039         */
2040        if (data->dnode.dn.dn_bonustype == DMU_OT_SA) {
2041                void *sahdrp;
2042                int hdrsize;
2043
2044                if (data->dnode.dn.dn_bonuslen != 0) {
2045                        sahdrp = (sa_hdr_phys_t *) DN_BONUS(&data->dnode.dn);
2046                } else if (data->dnode.dn.dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
2047                        blkptr_t *bp = &data->dnode.dn.dn_spill;
2048
2049                        err = zio_read(bp, data->dnode.endian, &sahdrp, NULL, data);
2050                        if (err)
2051                                return err;
2052                } else {
2053                        printf("filesystem is corrupt :(\n");
2054                        return ZFS_ERR_BAD_FS;
2055                }
2056
2057                hdrsize = SA_HDR_SIZE(((sa_hdr_phys_t *) sahdrp));
2058                file->size = *(uint64_t *) ((char *) sahdrp + hdrsize + SA_SIZE_OFFSET);
2059                if ((data->dnode.dn.dn_bonuslen == 0) &&
2060                        (data->dnode.dn.dn_flags & DNODE_FLAG_SPILL_BLKPTR))
2061                        free(sahdrp);
2062        } else {
2063                file->size = zfs_to_cpu64(((znode_phys_t *) DN_BONUS(&data->dnode.dn))->zp_size, data->dnode.endian);
2064        }
2065
2066        file->data = data;
2067        file->offset = 0;
2068
2069        return ZFS_ERR_NONE;
2070}
2071
2072uint64_t
2073zfs_read(zfs_file_t file, char *buf, uint64_t len)
2074{
2075        struct zfs_data *data = (struct zfs_data *) file->data;
2076        int blksz, movesize;
2077        uint64_t length;
2078        int64_t red;
2079        int err;
2080
2081        if (data->file_buf == NULL) {
2082                data->file_buf = malloc(SPA_MAXBLOCKSIZE);
2083                if (!data->file_buf)
2084                        return -1;
2085                data->file_start = data->file_end = 0;
2086        }
2087
2088        /*
2089         * If offset is in memory, move it into the buffer provided and return.
2090         */
2091        if (file->offset >= data->file_start
2092                && file->offset + len <= data->file_end) {
2093                memmove(buf, data->file_buf + file->offset - data->file_start,
2094                                len);
2095                return len;
2096        }
2097
2098        blksz = zfs_to_cpu16(data->dnode.dn.dn_datablkszsec,
2099                                                          data->dnode.endian) << SPA_MINBLOCKSHIFT;
2100
2101        /*
2102         * Entire Dnode is too big to fit into the space available.      We
2103         * will need to read it in chunks.      This could be optimized to
2104         * read in as large a chunk as there is space available, but for
2105         * now, this only reads in one data block at a time.
2106         */
2107        length = len;
2108        red = 0;
2109        while (length) {
2110                void *t;
2111                /*
2112                 * Find requested blkid and the offset within that block.
2113                 */
2114                uint64_t blkid = file->offset + red;
2115                blkid = do_div(blkid, blksz);
2116                free(data->file_buf);
2117                data->file_buf = 0;
2118
2119                err = dmu_read(&(data->dnode), blkid, &t,
2120                                           0, data);
2121                data->file_buf = t;
2122                if (err)
2123                        return -1;
2124
2125                data->file_start = blkid * blksz;
2126                data->file_end = data->file_start + blksz;
2127
2128                movesize = min(length, data->file_end - (int)file->offset - red);
2129
2130                memmove(buf, data->file_buf + file->offset + red
2131                                - data->file_start, movesize);
2132                buf += movesize;
2133                length -= movesize;
2134                red += movesize;
2135        }
2136
2137        return len;
2138}
2139
2140int
2141zfs_close(zfs_file_t file)
2142{
2143        zfs_unmount((struct zfs_data *) file->data);
2144        return ZFS_ERR_NONE;
2145}
2146
2147int
2148zfs_getmdnobj(device_t dev, const char *fsfilename,
2149                                   uint64_t *mdnobj)
2150{
2151        struct zfs_data *data;
2152        int err;
2153        int isfs;
2154
2155        data = zfs_mount(dev);
2156        if (!data)
2157                return ZFS_ERR_BAD_FS;
2158
2159        err = dnode_get_fullpath(fsfilename, &(data->mdn), mdnobj,
2160                                                         &(data->dnode), &isfs, data);
2161        zfs_unmount(data);
2162        return err;
2163}
2164
2165static void
2166fill_fs_info(struct zfs_dirhook_info *info,
2167                         dnode_end_t mdn, struct zfs_data *data)
2168{
2169        int err;
2170        dnode_end_t dn;
2171        uint64_t objnum;
2172        uint64_t headobj;
2173
2174        memset(info, 0, sizeof(*info));
2175
2176        info->dir = 1;
2177
2178        if (mdn.dn.dn_type == DMU_OT_DSL_DIR) {
2179                headobj = zfs_to_cpu64(((dsl_dir_phys_t *) DN_BONUS(&mdn.dn))->dd_head_dataset_obj, mdn.endian);
2180
2181                err = dnode_get(&(data->mos), headobj, DMU_OT_DSL_DATASET, &mdn, data);
2182                if (err) {
2183                        printf("zfs failed here 1\n");
2184                        return;
2185                }
2186        }
2187        make_mdn(&mdn, data);
2188        err = dnode_get(&mdn, MASTER_NODE_OBJ, DMU_OT_MASTER_NODE,
2189                                        &dn, data);
2190        if (err) {
2191                printf("zfs failed here 2\n");
2192                return;
2193        }
2194
2195        err = zap_lookup(&dn, ZFS_ROOT_OBJ, &objnum, data);
2196        if (err) {
2197                printf("zfs failed here 3\n");
2198                return;
2199        }
2200
2201        err = dnode_get(&mdn, objnum, 0, &dn, data);
2202        if (err) {
2203                printf("zfs failed here 4\n");
2204                return;
2205        }
2206
2207        info->mtimeset = 1;
2208        info->mtime = zfs_to_cpu64(((znode_phys_t *) DN_BONUS(&dn.dn))->zp_mtime[0], dn.endian);
2209
2210        return;
2211}
2212
2213static int iterate_zap(const char *name, uint64_t val, struct zfs_data *data)
2214{
2215        struct zfs_dirhook_info info;
2216        dnode_end_t dn;
2217
2218        memset(&info, 0, sizeof(info));
2219
2220        dnode_get(&(data->mdn), val, 0, &dn, data);
2221        info.mtimeset = 1;
2222        info.mtime = zfs_to_cpu64(((znode_phys_t *) DN_BONUS(&dn.dn))->zp_mtime[0], dn.endian);
2223        info.dir = (dn.dn.dn_type == DMU_OT_DIRECTORY_CONTENTS);
2224        debug("zfs type=%d, name=%s\n",
2225                  (int)dn.dn.dn_type, (char *)name);
2226        if (!data->userhook)
2227                return 0;
2228        return data->userhook(name, &info);
2229}
2230
2231static int iterate_zap_fs(const char *name, uint64_t val, struct zfs_data *data)
2232{
2233        struct zfs_dirhook_info info;
2234        dnode_end_t mdn;
2235        int err;
2236        err = dnode_get(&(data->mos), val, 0, &mdn, data);
2237        if (err)
2238                return 0;
2239        if (mdn.dn.dn_type != DMU_OT_DSL_DIR)
2240                return 0;
2241
2242        fill_fs_info(&info, mdn, data);
2243
2244        if (!data->userhook)
2245                return 0;
2246        return data->userhook(name, &info);
2247}
2248
2249static int iterate_zap_snap(const char *name, uint64_t val, struct zfs_data *data)
2250{
2251        struct zfs_dirhook_info info;
2252        char *name2;
2253        int ret = 0;
2254        dnode_end_t mdn;
2255        int err;
2256
2257        err = dnode_get(&(data->mos), val, 0, &mdn, data);
2258        if (err)
2259                return 0;
2260
2261        if (mdn.dn.dn_type != DMU_OT_DSL_DATASET)
2262                return 0;
2263
2264        fill_fs_info(&info, mdn, data);
2265
2266        name2 = malloc(strlen(name) + 2);
2267        name2[0] = '@';
2268        memcpy(name2 + 1, name, strlen(name) + 1);
2269        if (data->userhook)
2270                ret = data->userhook(name2, &info);
2271        free(name2);
2272        return ret;
2273}
2274
2275int
2276zfs_ls(device_t device, const char *path,
2277           int (*hook)(const char *, const struct zfs_dirhook_info *))
2278{
2279        struct zfs_data *data;
2280        int err;
2281        int isfs;
2282
2283        data = zfs_mount(device);
2284        if (!data)
2285                return ZFS_ERR_BAD_FS;
2286
2287        data->userhook = hook;
2288
2289        err = dnode_get_fullpath(path, &(data->mdn), 0, &(data->dnode), &isfs, data);
2290        if (err) {
2291                zfs_unmount(data);
2292                return err;
2293        }
2294        if (isfs) {
2295                uint64_t childobj, headobj;
2296                uint64_t snapobj;
2297                dnode_end_t dn;
2298                struct zfs_dirhook_info info;
2299
2300                fill_fs_info(&info, data->dnode, data);
2301                hook("@", &info);
2302
2303                childobj = zfs_to_cpu64(((dsl_dir_phys_t *) DN_BONUS(&data->dnode.dn))->dd_child_dir_zapobj, data->dnode.endian);
2304                headobj = zfs_to_cpu64(((dsl_dir_phys_t *) DN_BONUS(&data->dnode.dn))->dd_head_dataset_obj, data->dnode.endian);
2305                err = dnode_get(&(data->mos), childobj,
2306                                                DMU_OT_DSL_DIR_CHILD_MAP, &dn, data);
2307                if (err) {
2308                        zfs_unmount(data);
2309                        return err;
2310                }
2311
2312
2313                zap_iterate(&dn, iterate_zap_fs, data);
2314
2315                err = dnode_get(&(data->mos), headobj, DMU_OT_DSL_DATASET, &dn, data);
2316                if (err) {
2317                        zfs_unmount(data);
2318                        return err;
2319                }
2320
2321                snapobj = zfs_to_cpu64(((dsl_dataset_phys_t *) DN_BONUS(&dn.dn))->ds_snapnames_zapobj, dn.endian);
2322
2323                err = dnode_get(&(data->mos), snapobj,
2324                                                DMU_OT_DSL_DS_SNAP_MAP, &dn, data);
2325                if (err) {
2326                        zfs_unmount(data);
2327                        return err;
2328                }
2329
2330                zap_iterate(&dn, iterate_zap_snap, data);
2331        } else {
2332                if (data->dnode.dn.dn_type != DMU_OT_DIRECTORY_CONTENTS) {
2333                        zfs_unmount(data);
2334                        printf("not a directory\n");
2335                        return ZFS_ERR_BAD_FILE_TYPE;
2336                }
2337                zap_iterate(&(data->dnode), iterate_zap, data);
2338        }
2339        zfs_unmount(data);
2340        return ZFS_ERR_NONE;
2341}
2342