From 4d3c95f5ea7c737a21cd6b9c59435ee693b3f127 Mon Sep 17 00:00:00 2001 From: Jorgen Lundman Date: Thu, 19 Jul 2012 20:48:25 +0000 Subject: [PATCH] zfs: Add ZFS filesystem support U-Boot port is based on sources forked from GRUB-0.97 by Sun in 2004, which can be found here: http://src.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/grub/grub-0.97/stage2/zfs-include/zfs.h Released by Sun for GRUB under the license: * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. GRUB official releases include ZFS in version: ftp://alpha.gnu.org/gnu/grub/grub-1.99~rc1.tar.gz And patched against GRUB Bazaar repository for ashift fixes (4KB HDDs) more conveniently found at github: https://github.com/pendor/grub-zfs/commit/e7b6ef3ac3b9685ac4c394c897b1d4221b7381f1 Signed-off-by: Jorgen Lundman --- Makefile | 2 +- common/Makefile | 1 + common/cmd_zfs.c | 236 ++++ doc/README.zfs | 29 + fs/Makefile | 1 + fs/zfs/Makefile | 47 + fs/zfs/dev.c | 137 ++ fs/zfs/zfs.c | 2395 ++++++++++++++++++++++++++++++++++ fs/zfs/zfs_fletcher.c | 87 ++ fs/zfs/zfs_lzjb.c | 97 ++ fs/zfs/zfs_sha256.c | 148 +++ include/config_cmd_all.h | 1 + include/zfs/dmu.h | 120 ++ include/zfs/dmu_objset.h | 43 + include/zfs/dnode.h | 81 ++ include/zfs/dsl_dataset.h | 53 + include/zfs/dsl_dir.h | 49 + include/zfs/sa_impl.h | 35 + include/zfs/spa.h | 292 +++++ include/zfs/uberblock_impl.h | 57 + include/zfs/vdev_impl.h | 70 + include/zfs/zap_impl.h | 111 ++ include/zfs/zap_leaf.h | 103 ++ include/zfs/zfs.h | 122 ++ include/zfs/zfs_acl.h | 55 + include/zfs/zfs_znode.h | 71 + include/zfs/zil.h | 57 + include/zfs/zio.h | 92 ++ include/zfs/zio_checksum.h | 50 + include/zfs_common.h | 109 ++ 30 files changed, 4750 insertions(+), 1 deletion(-) create mode 100644 common/cmd_zfs.c create mode 100644 doc/README.zfs create mode 100644 fs/zfs/Makefile create mode 100644 fs/zfs/dev.c create mode 100644 fs/zfs/zfs.c create mode 100644 fs/zfs/zfs_fletcher.c create mode 100644 fs/zfs/zfs_lzjb.c create mode 100644 fs/zfs/zfs_sha256.c create mode 100644 include/zfs/dmu.h create mode 100644 include/zfs/dmu_objset.h create mode 100644 include/zfs/dnode.h create mode 100644 include/zfs/dsl_dataset.h create mode 100644 include/zfs/dsl_dir.h create mode 100644 include/zfs/sa_impl.h create mode 100644 include/zfs/spa.h create mode 100644 include/zfs/uberblock_impl.h create mode 100644 include/zfs/vdev_impl.h create mode 100644 include/zfs/zap_impl.h create mode 100644 include/zfs/zap_leaf.h create mode 100644 include/zfs/zfs.h create mode 100644 include/zfs/zfs_acl.h create mode 100644 include/zfs/zfs_znode.h create mode 100644 include/zfs/zil.h create mode 100644 include/zfs/zio.h create mode 100644 include/zfs/zio_checksum.h create mode 100644 include/zfs_common.h diff --git a/Makefile b/Makefile index 20fa27220a..73c8e39abc 100644 --- a/Makefile +++ b/Makefile @@ -247,7 +247,7 @@ endif LIBS += arch/$(ARCH)/lib/lib$(ARCH).o LIBS += fs/cramfs/libcramfs.o fs/fat/libfat.o fs/fdos/libfdos.o fs/jffs2/libjffs2.o \ fs/reiserfs/libreiserfs.o fs/ext2/libext2fs.o fs/yaffs2/libyaffs2.o \ - fs/ubifs/libubifs.o + fs/ubifs/libubifs.o fs/zfs/libzfs.o LIBS += net/libnet.o LIBS += disk/libdisk.o LIBS += drivers/bios_emulator/libatibiosemu.o diff --git a/common/Makefile b/common/Makefile index 483eb4daa3..3d62775dc0 100644 --- a/common/Makefile +++ b/common/Makefile @@ -162,6 +162,7 @@ endif COBJS-$(CONFIG_CMD_XIMG) += cmd_ximg.o COBJS-$(CONFIG_YAFFS2) += cmd_yaffs2.o COBJS-$(CONFIG_CMD_SPL) += cmd_spl.o +COBJS-$(CONFIG_CMD_ZFS) += cmd_zfs.o # others ifdef CONFIG_DDR_SPD diff --git a/common/cmd_zfs.c b/common/cmd_zfs.c new file mode 100644 index 0000000000..a6ea2c07cd --- /dev/null +++ b/common/cmd_zfs.c @@ -0,0 +1,236 @@ +/* + * + * ZFS filesystem porting to Uboot by + * Jorgen Lundman + * + * zfsfs support + * made from existing GRUB Sources by Sun, GNU and others. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(CONFIG_CMD_USB) && defined(CONFIG_USB_STORAGE) +#include +#endif + +#if !defined(CONFIG_DOS_PARTITION) && !defined(CONFIG_EFI_PARTITION) +#error DOS or EFI partition support must be selected +#endif + +#define DOS_PART_MAGIC_OFFSET 0x1fe +#define DOS_FS_TYPE_OFFSET 0x36 +#define DOS_FS32_TYPE_OFFSET 0x52 + +static int do_zfs_load(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) +{ + char *filename = NULL; + char *ep; + int dev; + unsigned long part = 1; + ulong addr = 0; + ulong part_length; + disk_partition_t info; + char buf[12]; + unsigned long count; + const char *addr_str; + struct zfs_file zfile; + struct device_s vdev; + + if (argc < 3) + return CMD_RET_USAGE; + + count = 0; + addr = simple_strtoul(argv[3], NULL, 16); + filename = getenv("bootfile"); + switch (argc) { + case 3: + addr_str = getenv("loadaddr"); + if (addr_str != NULL) + addr = simple_strtoul(addr_str, NULL, 16); + else + addr = CONFIG_SYS_LOAD_ADDR; + + break; + case 4: + break; + case 5: + filename = argv[4]; + break; + case 6: + filename = argv[4]; + count = simple_strtoul(argv[5], NULL, 16); + break; + + default: + return cmd_usage(cmdtp); + } + + if (!filename) { + puts("** No boot file defined **\n"); + return 1; + } + + dev = (int)simple_strtoul(argv[2], &ep, 16); + zfs_dev_desc = get_dev(argv[1], dev); + if (zfs_dev_desc == NULL) { + printf("** Block device %s %d not supported\n", argv[1], dev); + return 1; + } + + if (*ep) { + if (*ep != ':') { + puts("** Invalid boot device, use `dev[:part]' **\n"); + return 1; + } + part = simple_strtoul(++ep, NULL, 16); + } + + if (part != 0) { + if (get_partition_info(zfs_dev_desc, part, &info)) { + printf("** Bad partition %lu **\n", part); + return 1; + } + + if (strncmp((char *)info.type, BOOT_PART_TYPE, + strlen(BOOT_PART_TYPE)) != 0) { + printf("** Invalid partition type \"%s\" (expect \"" BOOT_PART_TYPE "\")\n", + info.type); + return 1; + } + printf("Loading file \"%s\" " + "from %s device %d:%lu %s\n", + filename, argv[1], dev, part, info.name); + } else { + printf("Loading file \"%s\" from %s device %d\n", + filename, argv[1], dev); + } + + part_length = zfs_set_blk_dev(zfs_dev_desc, part); + if (part_length == 0) { + printf("**Bad partition - %s %d:%lu **\n", argv[1], dev, part); + return 1; + } + + vdev.part_length = part_length; + + memset(&zfile, 0, sizeof(zfile)); + zfile.device = &vdev; + if (zfs_open(&zfile, filename)) { + printf("** File not found %s\n", filename); + return 1; + } + + if ((count < zfile.size) && (count != 0)) + zfile.size = (uint64_t)count; + + if (zfs_read(&zfile, (char *)addr, zfile.size) != zfile.size) { + printf("** Unable to read \"%s\" from %s %d:%lu **\n", + filename, argv[1], dev, part); + zfs_close(&zfile); + return 1; + } + + zfs_close(&zfile); + + /* Loading ok, update default load address */ + load_addr = addr; + + printf("%llu bytes read\n", zfile.size); + sprintf(buf, "%llX", zfile.size); + setenv("filesize", buf); + + return 0; +} + + +int zfs_print(const char *entry, const struct zfs_dirhook_info *data) +{ + printf("%s %s\n", + data->dir ? " " : " ", + entry); + return 0; /* 0 continue, 1 stop */ +} + + + +static int do_zfs_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) +{ + const char *filename = "/"; + int dev; + unsigned long part = 1; + char *ep; + int part_length; + struct device_s vdev; + + if (argc < 3) + return cmd_usage(cmdtp); + + dev = (int)simple_strtoul(argv[2], &ep, 16); + zfs_dev_desc = get_dev(argv[1], dev); + + if (zfs_dev_desc == NULL) { + printf("\n** Block device %s %d not supported\n", argv[1], dev); + return 1; + } + + if (*ep) { + if (*ep != ':') { + puts("\n** Invalid boot device, use `dev[:part]' **\n"); + return 1; + } + part = simple_strtoul(++ep, NULL, 16); + } + + if (argc == 4) + filename = argv[3]; + + part_length = zfs_set_blk_dev(zfs_dev_desc, part); + if (part_length == 0) { + printf("** Bad partition - %s %d:%lu **\n", argv[1], dev, part); + return 1; + } + + vdev.part_length = part_length; + + zfs_ls(&vdev, filename, + zfs_print); + + return 0; +} + + +U_BOOT_CMD(zfsls, 4, 1, do_zfs_ls, + "list files in a directory (default /)", + " [directory]\n" + " - list files from 'dev' on 'interface' in a '/DATASET/@/$dir/'"); + +U_BOOT_CMD(zfsload, 6, 0, do_zfs_load, + "load binary file from a ZFS filesystem", + " [addr] [filename] [bytes]\n" + " - load binary file '/DATASET/@/$dir/$file' from 'dev' on 'interface'\n" + " to address 'addr' from ZFS filesystem"); diff --git a/doc/README.zfs b/doc/README.zfs new file mode 100644 index 0000000000..f5998f2f88 --- /dev/null +++ b/doc/README.zfs @@ -0,0 +1,29 @@ +This patch series adds support for ZFS listing and load to u-boot. + +To Enable zfs ls and load commands, modify the board specific config file with +#define CONFIG_CMD_ZFS + +Steps to test: + +1. After applying the patch, zfs specific commands can be seen + in the boot loader prompt using + UBOOT #help + + zfsload- load binary file from a ZFS file system + zfsls - list files in a directory (default /) + +2. To list the files in zfs pool, device or partition, execute + zfsls [POOL/@/dir/file] + For example: + UBOOT #zfsls mmc 0:5 /rpool/@/usr/bin/ + +3. To read and load a file from an ZFS formatted partition to RAM, execute + zfsload [addr] [filename] [bytes] + For example: + UBOOT #zfsload mmc 2:2 0x30007fc0 /rpool/@/boot/uImage + +References : + -- ZFS GRUB sources from Solaris GRUB-0.97 + -- GRUB Bazaar repository + +Jorgen Lundman 2012. diff --git a/fs/Makefile b/fs/Makefile index 22aad126bc..28da76e959 100644 --- a/fs/Makefile +++ b/fs/Makefile @@ -30,6 +30,7 @@ subdirs-$(CONFIG_CMD_JFFS2) += jffs2 subdirs-$(CONFIG_CMD_REISER) += reiserfs subdirs-$(CONFIG_YAFFS2) += yaffs2 subdirs-$(CONFIG_CMD_UBIFS) += ubifs +subdirs-$(CONFIG_CMD_ZFS) += zfs SUBDIRS := $(subdirs-y) diff --git a/fs/zfs/Makefile b/fs/zfs/Makefile new file mode 100644 index 0000000000..938fc5e533 --- /dev/null +++ b/fs/zfs/Makefile @@ -0,0 +1,47 @@ +# +# (C) Copyright 2012 +# Jorgen Lundman +# +# See file CREDITS for list of people who contributed to this +# project. +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License as +# published by the Free Software Foundation; either version 2 of +# the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, +# MA 02111-1307 USA +# + +include $(TOPDIR)/config.mk + +LIB = $(obj)libzfs.o + +AOBJS = +COBJS-$(CONFIG_CMD_ZFS) := dev.o zfs.o zfs_fletcher.o zfs_sha256.o zfs_lzjb.o + +SRCS := $(AOBJS:.o=.S) $(COBJS-y:.o=.c) +OBJS := $(addprefix $(obj),$(AOBJS) $(COBJS-y)) + + +all: $(LIB) $(AOBJS) + +$(LIB): $(obj).depend $(OBJS) + $(call cmd_link_o_target, $(OBJS)) + +######################################################################### + +# defines $(obj).depend target +include $(SRCTREE)/rules.mk + +sinclude $(obj).depend + +######################################################################### diff --git a/fs/zfs/dev.c b/fs/zfs/dev.c new file mode 100644 index 0000000000..d68372c808 --- /dev/null +++ b/fs/zfs/dev.c @@ -0,0 +1,137 @@ +/* + * + * based on code of fs/reiserfs/dev.c by + * + * (C) Copyright 2003 - 2004 + * Sysgo AG, , Pavel Bartusek + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + + +#include +#include +#include + +static block_dev_desc_t *zfs_block_dev_desc; +static disk_partition_t part_info; + +int zfs_set_blk_dev(block_dev_desc_t *rbdd, int part) +{ + zfs_block_dev_desc = rbdd; + + if (part == 0) { + /* disk doesn't use partition table */ + part_info.start = 0; + part_info.size = rbdd->lba; + part_info.blksz = rbdd->blksz; + } else { + if (get_partition_info(zfs_block_dev_desc, part, &part_info)) + return 0; + } + + return part_info.size; +} + +/* err */ +int zfs_devread(int sector, int byte_offset, int byte_len, char *buf) +{ + short sec_buffer[SECTOR_SIZE/sizeof(short)]; + char *sec_buf = (char *)sec_buffer; + unsigned block_len; + + /* + * Check partition boundaries + */ + if ((sector < 0) || + ((sector + ((byte_offset + byte_len - 1) >> SECTOR_BITS)) >= + part_info.size)) { + /* errnum = ERR_OUTSIDE_PART; */ + printf(" ** zfs_devread() read outside partition sector %d\n", sector); + return 1; + } + + /* + * Get the read to the beginning of a partition. + */ + sector += byte_offset >> SECTOR_BITS; + byte_offset &= SECTOR_SIZE - 1; + + debug(" <%d, %d, %d>\n", sector, byte_offset, byte_len); + + if (zfs_block_dev_desc == NULL) { + printf("** Invalid Block Device Descriptor (NULL)\n"); + return 1; + } + + if (byte_offset != 0) { + /* read first part which isn't aligned with start of sector */ + if (zfs_block_dev_desc->block_read(zfs_block_dev_desc->dev, + part_info.start + sector, 1, + (unsigned long *) sec_buf) != 1) { + printf(" ** zfs_devread() read error **\n"); + return 1; + } + memcpy(buf, sec_buf + byte_offset, + min(SECTOR_SIZE - byte_offset, byte_len)); + buf += min(SECTOR_SIZE - byte_offset, byte_len); + byte_len -= min(SECTOR_SIZE - byte_offset, byte_len); + sector++; + } + + if (byte_len == 0) + return 0; + + /* read sector aligned part */ + block_len = byte_len & ~(SECTOR_SIZE - 1); + + if (block_len == 0) { + u8 p[SECTOR_SIZE]; + + block_len = SECTOR_SIZE; + zfs_block_dev_desc->block_read(zfs_block_dev_desc->dev, + part_info.start + sector, + 1, (unsigned long *)p); + memcpy(buf, p, byte_len); + return 0; + } + + if (zfs_block_dev_desc->block_read(zfs_block_dev_desc->dev, + part_info.start + sector, + block_len / SECTOR_SIZE, + (unsigned long *) buf) != + block_len / SECTOR_SIZE) { + printf(" ** zfs_devread() read error - block\n"); + return 1; + } + + block_len = byte_len & ~(SECTOR_SIZE - 1); + buf += block_len; + byte_len -= block_len; + sector += block_len / SECTOR_SIZE; + + if (byte_len != 0) { + /* read rest of data which are not in whole sector */ + if (zfs_block_dev_desc-> + block_read(zfs_block_dev_desc->dev, + part_info.start + sector, 1, + (unsigned long *) sec_buf) != 1) { + printf(" ** zfs_devread() read error - last part\n"); + return 1; + } + memcpy(buf, sec_buf, byte_len); + } + return 0; +} diff --git a/fs/zfs/zfs.c b/fs/zfs/zfs.c new file mode 100644 index 0000000000..360f723c84 --- /dev/null +++ b/fs/zfs/zfs.c @@ -0,0 +1,2395 @@ +/* + * + * ZFS filesystem ported to u-boot by + * Jorgen Lundman + * + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 + * Free Software Foundation, Inc. + * Copyright 2004 Sun Microsystems, Inc. + * + * GRUB is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * GRUB is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GRUB. If not, see . + * + */ + +#include +#include +#include +#include +#include +#include +#include "zfs_common.h" + +block_dev_desc_t *zfs_dev_desc; + +/* + * The zfs plug-in routines for GRUB are: + * + * zfs_mount() - locates a valid uberblock of the root pool and reads + * in its MOS at the memory address MOS. + * + * zfs_open() - locates a plain file object by following the MOS + * and places its dnode at the memory address DNODE. + * + * zfs_read() - read in the data blocks pointed by the DNODE. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#define ZPOOL_PROP_BOOTFS "bootfs" + + +/* + * For nvlist manipulation. (from nvpair.h) + */ +#define NV_ENCODE_NATIVE 0 +#define NV_ENCODE_XDR 1 +#define NV_BIG_ENDIAN 0 +#define NV_LITTLE_ENDIAN 1 +#define DATA_TYPE_UINT64 8 +#define DATA_TYPE_STRING 9 +#define DATA_TYPE_NVLIST 19 +#define DATA_TYPE_NVLIST_ARRAY 20 + + +/* + * Macros to get fields in a bp or DVA. + */ +#define P2PHASE(x, align) ((x) & ((align) - 1)) +#define DVA_OFFSET_TO_PHYS_SECTOR(offset) \ + ((offset + VDEV_LABEL_START_SIZE) >> SPA_MINBLOCKSHIFT) + +/* + * return x rounded down to an align boundary + * eg, P2ALIGN(1200, 1024) == 1024 (1*align) + * eg, P2ALIGN(1024, 1024) == 1024 (1*align) + * eg, P2ALIGN(0x1234, 0x100) == 0x1200 (0x12*align) + * eg, P2ALIGN(0x5600, 0x100) == 0x5600 (0x56*align) + */ +#define P2ALIGN(x, align) ((x) & -(align)) + +/* + * FAT ZAP data structures + */ +#define ZFS_CRC64_POLY 0xC96C5795D7870F42ULL /* ECMA-182, reflected form */ +#define ZAP_HASH_IDX(hash, n) (((n) == 0) ? 0 : ((hash) >> (64 - (n)))) +#define CHAIN_END 0xffff /* end of the chunk chain */ + +/* + * The amount of space within the chunk available for the array is: + * chunk size - space for type (1) - space for next pointer (2) + */ +#define ZAP_LEAF_ARRAY_BYTES (ZAP_LEAF_CHUNKSIZE - 3) + +#define ZAP_LEAF_HASH_SHIFT(bs) (bs - 5) +#define ZAP_LEAF_HASH_NUMENTRIES(bs) (1 << ZAP_LEAF_HASH_SHIFT(bs)) +#define LEAF_HASH(bs, h) \ + ((ZAP_LEAF_HASH_NUMENTRIES(bs)-1) & \ + ((h) >> (64 - ZAP_LEAF_HASH_SHIFT(bs)-l->l_hdr.lh_prefix_len))) + +/* + * The amount of space available for chunks is: + * block size shift - hash entry size (2) * number of hash + * entries - header space (2*chunksize) + */ +#define ZAP_LEAF_NUMCHUNKS(bs) \ + (((1<l_hash + ZAP_LEAF_HASH_NUMENTRIES(bs)))[idx] +#define ZAP_LEAF_ENTRY(l, bs, idx) (&ZAP_LEAF_CHUNK(l, bs, idx).l_entry) + + +/* + * Decompression Entry - lzjb + */ +#ifndef NBBY +#define NBBY 8 +#endif + + + +typedef int zfs_decomp_func_t(void *s_start, void *d_start, + uint32_t s_len, uint32_t d_len); +typedef struct decomp_entry { + char *name; + zfs_decomp_func_t *decomp_func; +} decomp_entry_t; + +typedef struct dnode_end { + dnode_phys_t dn; + zfs_endian_t endian; +} dnode_end_t; + +struct zfs_data { + /* cache for a file block of the currently zfs_open()-ed file */ + char *file_buf; + uint64_t file_start; + uint64_t file_end; + + /* XXX: ashift is per vdev, not per pool. We currently only ever touch + * a single vdev, but when/if raid-z or stripes are supported, this + * may need revision. + */ + uint64_t vdev_ashift; + uint64_t label_txg; + uint64_t pool_guid; + + /* cache for a dnode block */ + dnode_phys_t *dnode_buf; + dnode_phys_t *dnode_mdn; + uint64_t dnode_start; + uint64_t dnode_end; + zfs_endian_t dnode_endian; + + uberblock_t current_uberblock; + + dnode_end_t mos; + dnode_end_t mdn; + dnode_end_t dnode; + + uint64_t vdev_phys_sector; + + int (*userhook)(const char *, const struct zfs_dirhook_info *); + struct zfs_dirhook_info *dirinfo; + +}; + + + + +static int +zlib_decompress(void *s, void *d, + uint32_t slen, uint32_t dlen) +{ + if (zlib_decompress(s, d, slen, dlen) < 0) + return ZFS_ERR_BAD_FS; + return ZFS_ERR_NONE; +} + +static decomp_entry_t decomp_table[ZIO_COMPRESS_FUNCTIONS] = { + {"inherit", NULL}, /* ZIO_COMPRESS_INHERIT */ + {"on", lzjb_decompress}, /* ZIO_COMPRESS_ON */ + {"off", NULL}, /* ZIO_COMPRESS_OFF */ + {"lzjb", lzjb_decompress}, /* ZIO_COMPRESS_LZJB */ + {"empty", NULL}, /* ZIO_COMPRESS_EMPTY */ + {"gzip-1", zlib_decompress}, /* ZIO_COMPRESS_GZIP1 */ + {"gzip-2", zlib_decompress}, /* ZIO_COMPRESS_GZIP2 */ + {"gzip-3", zlib_decompress}, /* ZIO_COMPRESS_GZIP3 */ + {"gzip-4", zlib_decompress}, /* ZIO_COMPRESS_GZIP4 */ + {"gzip-5", zlib_decompress}, /* ZIO_COMPRESS_GZIP5 */ + {"gzip-6", zlib_decompress}, /* ZIO_COMPRESS_GZIP6 */ + {"gzip-7", zlib_decompress}, /* ZIO_COMPRESS_GZIP7 */ + {"gzip-8", zlib_decompress}, /* ZIO_COMPRESS_GZIP8 */ + {"gzip-9", zlib_decompress}, /* ZIO_COMPRESS_GZIP9 */ +}; + + + +static int zio_read_data(blkptr_t *bp, zfs_endian_t endian, + void *buf, struct zfs_data *data); + +static int +zio_read(blkptr_t *bp, zfs_endian_t endian, void **buf, + size_t *size, struct zfs_data *data); + +/* + * Our own version of log2(). Same thing as highbit()-1. + */ +static int +zfs_log2(uint64_t num) +{ + int i = 0; + + while (num > 1) { + i++; + num = num >> 1; + } + + return i; +} + + +/* Checksum Functions */ +static void +zio_checksum_off(const void *buf __attribute__ ((unused)), + uint64_t size __attribute__ ((unused)), + zfs_endian_t endian __attribute__ ((unused)), + zio_cksum_t *zcp) +{ + ZIO_SET_CHECKSUM(zcp, 0, 0, 0, 0); +} + +/* Checksum Table and Values */ +static zio_checksum_info_t zio_checksum_table[ZIO_CHECKSUM_FUNCTIONS] = { + {NULL, 0, 0, "inherit"}, + {NULL, 0, 0, "on"}, + {zio_checksum_off, 0, 0, "off"}, + {zio_checksum_SHA256, 1, 1, "label"}, + {zio_checksum_SHA256, 1, 1, "gang_header"}, + {NULL, 0, 0, "zilog"}, + {fletcher_2_endian, 0, 0, "fletcher2"}, + {fletcher_4_endian, 1, 0, "fletcher4"}, + {zio_checksum_SHA256, 1, 0, "SHA256"}, + {NULL, 0, 0, "zilog2"}, +}; + +/* + * zio_checksum_verify: Provides support for checksum verification. + * + * Fletcher2, Fletcher4, and SHA256 are supported. + * + */ +static int +zio_checksum_verify(zio_cksum_t zc, uint32_t checksum, + zfs_endian_t endian, char *buf, int size) +{ + zio_eck_t *zec = (zio_eck_t *) (buf + size) - 1; + zio_checksum_info_t *ci = &zio_checksum_table[checksum]; + zio_cksum_t actual_cksum, expected_cksum; + + if (checksum >= ZIO_CHECKSUM_FUNCTIONS || ci->ci_func == NULL) { + printf("zfs unknown checksum function %d\n", checksum); + return ZFS_ERR_NOT_IMPLEMENTED_YET; + } + + if (ci->ci_eck) { + expected_cksum = zec->zec_cksum; + zec->zec_cksum = zc; + ci->ci_func(buf, size, endian, &actual_cksum); + zec->zec_cksum = expected_cksum; + zc = expected_cksum; + } else { + ci->ci_func(buf, size, endian, &actual_cksum); + } + + if ((actual_cksum.zc_word[0] != zc.zc_word[0]) + || (actual_cksum.zc_word[1] != zc.zc_word[1]) + || (actual_cksum.zc_word[2] != zc.zc_word[2]) + || (actual_cksum.zc_word[3] != zc.zc_word[3])) { + return ZFS_ERR_BAD_FS; + } + + return ZFS_ERR_NONE; +} + +/* + * vdev_uberblock_compare takes two uberblock structures and returns an integer + * indicating the more recent of the two. + * Return Value = 1 if ub2 is more recent + * Return Value = -1 if ub1 is more recent + * The most recent uberblock is determined using its transaction number and + * timestamp. The uberblock with the highest transaction number is + * considered "newer". If the transaction numbers of the two blocks match, the + * timestamps are compared to determine the "newer" of the two. + */ +static int +vdev_uberblock_compare(uberblock_t *ub1, uberblock_t *ub2) +{ + zfs_endian_t ub1_endian, ub2_endian; + if (zfs_to_cpu64(ub1->ub_magic, LITTLE_ENDIAN) == UBERBLOCK_MAGIC) + ub1_endian = LITTLE_ENDIAN; + else + ub1_endian = BIG_ENDIAN; + if (zfs_to_cpu64(ub2->ub_magic, LITTLE_ENDIAN) == UBERBLOCK_MAGIC) + ub2_endian = LITTLE_ENDIAN; + else + ub2_endian = BIG_ENDIAN; + + if (zfs_to_cpu64(ub1->ub_txg, ub1_endian) + < zfs_to_cpu64(ub2->ub_txg, ub2_endian)) + return -1; + if (zfs_to_cpu64(ub1->ub_txg, ub1_endian) + > zfs_to_cpu64(ub2->ub_txg, ub2_endian)) + return 1; + + if (zfs_to_cpu64(ub1->ub_timestamp, ub1_endian) + < zfs_to_cpu64(ub2->ub_timestamp, ub2_endian)) + return -1; + if (zfs_to_cpu64(ub1->ub_timestamp, ub1_endian) + > zfs_to_cpu64(ub2->ub_timestamp, ub2_endian)) + return 1; + + return 0; +} + +/* + * Three pieces of information are needed to verify an uberblock: the magic + * number, the version number, and the checksum. + * + * Currently Implemented: version number, magic number, label txg + * Need to Implement: checksum + * + */ +static int +uberblock_verify(uberblock_t *uber, int offset, struct zfs_data *data) +{ + int err; + zfs_endian_t endian = UNKNOWN_ENDIAN; + zio_cksum_t zc; + + if (uber->ub_txg < data->label_txg) { + debug("ignoring partially written label: uber_txg < label_txg %llu %llu\n", + uber->ub_txg, data->label_txg); + return ZFS_ERR_BAD_FS; + } + + if (zfs_to_cpu64(uber->ub_magic, LITTLE_ENDIAN) == UBERBLOCK_MAGIC + && zfs_to_cpu64(uber->ub_version, LITTLE_ENDIAN) > 0 + && zfs_to_cpu64(uber->ub_version, LITTLE_ENDIAN) <= SPA_VERSION) + endian = LITTLE_ENDIAN; + + if (zfs_to_cpu64(uber->ub_magic, BIG_ENDIAN) == UBERBLOCK_MAGIC + && zfs_to_cpu64(uber->ub_version, BIG_ENDIAN) > 0 + && zfs_to_cpu64(uber->ub_version, BIG_ENDIAN) <= SPA_VERSION) + endian = BIG_ENDIAN; + + if (endian == UNKNOWN_ENDIAN) { + printf("invalid uberblock magic\n"); + return ZFS_ERR_BAD_FS; + } + + memset(&zc, 0, sizeof(zc)); + zc.zc_word[0] = cpu_to_zfs64(offset, endian); + err = zio_checksum_verify(zc, ZIO_CHECKSUM_LABEL, endian, + (char *) uber, UBERBLOCK_SIZE(data->vdev_ashift)); + + if (!err) { + /* Check that the data pointed by the rootbp is usable. */ + void *osp = NULL; + size_t ospsize; + err = zio_read(&uber->ub_rootbp, endian, &osp, &ospsize, data); + free(osp); + + if (!err && ospsize < OBJSET_PHYS_SIZE_V14) { + printf("uberblock rootbp points to invalid data\n"); + return ZFS_ERR_BAD_FS; + } + } + + return err; +} + +/* + * Find the best uberblock. + * Return: + * Success - Pointer to the best uberblock. + * Failure - NULL + */ +static uberblock_t *find_bestub(char *ub_array, struct zfs_data *data) +{ + const uint64_t sector = data->vdev_phys_sector; + uberblock_t *ubbest = NULL; + uberblock_t *ubnext; + unsigned int i, offset, pickedub = 0; + int err = ZFS_ERR_NONE; + + const unsigned int UBCOUNT = UBERBLOCK_COUNT(data->vdev_ashift); + const uint64_t UBBYTES = UBERBLOCK_SIZE(data->vdev_ashift); + + for (i = 0; i < UBCOUNT; i++) { + ubnext = (uberblock_t *) (i * UBBYTES + ub_array); + offset = (sector << SPA_MINBLOCKSHIFT) + VDEV_PHYS_SIZE + (i * UBBYTES); + + err = uberblock_verify(ubnext, offset, data); + if (err) + continue; + + if (ubbest == NULL || vdev_uberblock_compare(ubnext, ubbest) > 0) { + ubbest = ubnext; + pickedub = i; + } + } + + if (ubbest) + debug("zfs Found best uberblock at idx %d, txg %llu\n", + pickedub, (unsigned long long) ubbest->ub_txg); + + return ubbest; +} + +static inline size_t +get_psize(blkptr_t *bp, zfs_endian_t endian) +{ + return (((zfs_to_cpu64((bp)->blk_prop, endian) >> 16) & 0xffff) + 1) + << SPA_MINBLOCKSHIFT; +} + +static uint64_t +dva_get_offset(dva_t *dva, zfs_endian_t endian) +{ + return zfs_to_cpu64((dva)->dva_word[1], + endian) << SPA_MINBLOCKSHIFT; +} + +/* + * Read a block of data based on the gang block address dva, + * and put its data in buf. + * + */ +static int +zio_read_gang(blkptr_t *bp, zfs_endian_t endian, dva_t *dva, void *buf, + struct zfs_data *data) +{ + zio_gbh_phys_t *zio_gb; + uint64_t offset, sector; + unsigned i; + int err; + zio_cksum_t zc; + + memset(&zc, 0, sizeof(zc)); + + zio_gb = malloc(SPA_GANGBLOCKSIZE); + if (!zio_gb) + return ZFS_ERR_OUT_OF_MEMORY; + + offset = dva_get_offset(dva, endian); + sector = DVA_OFFSET_TO_PHYS_SECTOR(offset); + + /* read in the gang block header */ + err = zfs_devread(sector, 0, SPA_GANGBLOCKSIZE, (char *) zio_gb); + + if (err) { + free(zio_gb); + return err; + } + + /* XXX */ + /* self checksuming the gang block header */ + ZIO_SET_CHECKSUM(&zc, DVA_GET_VDEV(dva), + dva_get_offset(dva, endian), bp->blk_birth, 0); + err = zio_checksum_verify(zc, ZIO_CHECKSUM_GANG_HEADER, endian, + (char *) zio_gb, SPA_GANGBLOCKSIZE); + if (err) { + free(zio_gb); + return err; + } + + endian = (zfs_to_cpu64(bp->blk_prop, endian) >> 63) & 1; + + for (i = 0; i < SPA_GBH_NBLKPTRS; i++) { + if (zio_gb->zg_blkptr[i].blk_birth == 0) + continue; + + err = zio_read_data(&zio_gb->zg_blkptr[i], endian, buf, data); + if (err) { + free(zio_gb); + return err; + } + buf = (char *) buf + get_psize(&zio_gb->zg_blkptr[i], endian); + } + free(zio_gb); + return ZFS_ERR_NONE; +} + +/* + * Read in a block of raw data to buf. + */ +static int +zio_read_data(blkptr_t *bp, zfs_endian_t endian, void *buf, + struct zfs_data *data) +{ + int i, psize; + int err = ZFS_ERR_NONE; + + psize = get_psize(bp, endian); + + /* pick a good dva from the block pointer */ + for (i = 0; i < SPA_DVAS_PER_BP; i++) { + uint64_t offset, sector; + + if (bp->blk_dva[i].dva_word[0] == 0 && bp->blk_dva[i].dva_word[1] == 0) + continue; + + if ((zfs_to_cpu64(bp->blk_dva[i].dva_word[1], endian)>>63) & 1) { + err = zio_read_gang(bp, endian, &bp->blk_dva[i], buf, data); + } else { + /* read in a data block */ + offset = dva_get_offset(&bp->blk_dva[i], endian); + sector = DVA_OFFSET_TO_PHYS_SECTOR(offset); + + err = zfs_devread(sector, 0, psize, buf); + } + + if (!err) { + /*Check the underlying checksum before we rule this DVA as "good"*/ + uint32_t checkalgo = (zfs_to_cpu64((bp)->blk_prop, endian) >> 40) & 0xff; + + err = zio_checksum_verify(bp->blk_cksum, checkalgo, endian, buf, psize); + if (!err) + return ZFS_ERR_NONE; + } + + /* If read failed or checksum bad, reset the error. Hopefully we've got some more DVA's to try.*/ + } + + if (!err) { + printf("couldn't find a valid DVA\n"); + err = ZFS_ERR_BAD_FS; + } + + return err; +} + +/* + * Read in a block of data, verify its checksum, decompress if needed, + * and put the uncompressed data in buf. + */ +static int +zio_read(blkptr_t *bp, zfs_endian_t endian, void **buf, + size_t *size, struct zfs_data *data) +{ + size_t lsize, psize; + unsigned int comp; + char *compbuf = NULL; + int err; + + *buf = NULL; + + comp = (zfs_to_cpu64((bp)->blk_prop, endian)>>32) & 0xff; + lsize = (BP_IS_HOLE(bp) ? 0 : + (((zfs_to_cpu64((bp)->blk_prop, endian) & 0xffff) + 1) + << SPA_MINBLOCKSHIFT)); + psize = get_psize(bp, endian); + + if (size) + *size = lsize; + + if (comp >= ZIO_COMPRESS_FUNCTIONS) { + printf("compression algorithm %u not supported\n", (unsigned int) comp); + return ZFS_ERR_NOT_IMPLEMENTED_YET; + } + + if (comp != ZIO_COMPRESS_OFF && decomp_table[comp].decomp_func == NULL) { + printf("compression algorithm %s not supported\n", decomp_table[comp].name); + return ZFS_ERR_NOT_IMPLEMENTED_YET; + } + + if (comp != ZIO_COMPRESS_OFF) { + compbuf = malloc(psize); + if (!compbuf) + return ZFS_ERR_OUT_OF_MEMORY; + } else { + compbuf = *buf = malloc(lsize); + } + + err = zio_read_data(bp, endian, compbuf, data); + if (err) { + free(compbuf); + *buf = NULL; + return err; + } + + if (comp != ZIO_COMPRESS_OFF) { + *buf = malloc(lsize); + if (!*buf) { + free(compbuf); + return ZFS_ERR_OUT_OF_MEMORY; + } + + err = decomp_table[comp].decomp_func(compbuf, *buf, psize, lsize); + free(compbuf); + if (err) { + free(*buf); + *buf = NULL; + return err; + } + } + + return ZFS_ERR_NONE; +} + +/* + * Get the block from a block id. + * push the block onto the stack. + * + */ +static int +dmu_read(dnode_end_t *dn, uint64_t blkid, void **buf, + zfs_endian_t *endian_out, struct zfs_data *data) +{ + int idx, level; + blkptr_t *bp_array = dn->dn.dn_blkptr; + int epbs = dn->dn.dn_indblkshift - SPA_BLKPTRSHIFT; + blkptr_t *bp; + void *tmpbuf = 0; + zfs_endian_t endian; + int err = ZFS_ERR_NONE; + + bp = malloc(sizeof(blkptr_t)); + if (!bp) + return ZFS_ERR_OUT_OF_MEMORY; + + endian = dn->endian; + for (level = dn->dn.dn_nlevels - 1; level >= 0; level--) { + idx = (blkid >> (epbs * level)) & ((1 << epbs) - 1); + *bp = bp_array[idx]; + if (bp_array != dn->dn.dn_blkptr) { + free(bp_array); + bp_array = 0; + } + + if (BP_IS_HOLE(bp)) { + size_t size = zfs_to_cpu16(dn->dn.dn_datablkszsec, + dn->endian) + << SPA_MINBLOCKSHIFT; + *buf = malloc(size); + if (*buf) { + err = ZFS_ERR_OUT_OF_MEMORY; + break; + } + memset(*buf, 0, size); + endian = (zfs_to_cpu64(bp->blk_prop, endian) >> 63) & 1; + break; + } + if (level == 0) { + err = zio_read(bp, endian, buf, 0, data); + endian = (zfs_to_cpu64(bp->blk_prop, endian) >> 63) & 1; + break; + } + err = zio_read(bp, endian, &tmpbuf, 0, data); + endian = (zfs_to_cpu64(bp->blk_prop, endian) >> 63) & 1; + if (err) + break; + bp_array = tmpbuf; + } + if (bp_array != dn->dn.dn_blkptr) + free(bp_array); + if (endian_out) + *endian_out = endian; + + free(bp); + return err; +} + +/* + * mzap_lookup: Looks up property described by "name" and returns the value + * in "value". + */ +static int +mzap_lookup(mzap_phys_t *zapobj, zfs_endian_t endian, + int objsize, char *name, uint64_t * value) +{ + int i, chunks; + mzap_ent_phys_t *mzap_ent = zapobj->mz_chunk; + + chunks = objsize / MZAP_ENT_LEN - 1; + for (i = 0; i < chunks; i++) { + if (strcmp(mzap_ent[i].mze_name, name) == 0) { + *value = zfs_to_cpu64(mzap_ent[i].mze_value, endian); + return ZFS_ERR_NONE; + } + } + + printf("couldn't find '%s'\n", name); + return ZFS_ERR_FILE_NOT_FOUND; +} + +static int +mzap_iterate(mzap_phys_t *zapobj, zfs_endian_t endian, int objsize, + int (*hook)(const char *name, + uint64_t val, + struct zfs_data *data), + struct zfs_data *data) +{ + int i, chunks; + mzap_ent_phys_t *mzap_ent = zapobj->mz_chunk; + + chunks = objsize / MZAP_ENT_LEN - 1; + for (i = 0; i < chunks; i++) { + if (hook(mzap_ent[i].mze_name, + zfs_to_cpu64(mzap_ent[i].mze_value, endian), + data)) + return 1; + } + + return 0; +} + +static uint64_t +zap_hash(uint64_t salt, const char *name) +{ + static uint64_t table[256]; + const uint8_t *cp; + uint8_t c; + uint64_t crc = salt; + + if (table[128] == 0) { + uint64_t *ct; + int i, j; + for (i = 0; i < 256; i++) { + for (ct = table + i, *ct = i, j = 8; j > 0; j--) + *ct = (*ct >> 1) ^ (-(*ct & 1) & ZFS_CRC64_POLY); + } + } + + for (cp = (const uint8_t *) name; (c = *cp) != '\0'; cp++) + crc = (crc >> 8) ^ table[(crc ^ c) & 0xFF]; + + /* + * Only use 28 bits, since we need 4 bits in the cookie for the + * collision differentiator. We MUST use the high bits, since + * those are the onces that we first pay attention to when + * chosing the bucket. + */ + crc &= ~((1ULL << (64 - ZAP_HASHBITS)) - 1); + + return crc; +} + +/* + * Only to be used on 8-bit arrays. + * array_len is actual len in bytes (not encoded le_value_length). + * buf is null-terminated. + */ +/* XXX */ +static int +zap_leaf_array_equal(zap_leaf_phys_t *l, zfs_endian_t endian, + int blksft, int chunk, int array_len, const char *buf) +{ + int bseen = 0; + + while (bseen < array_len) { + struct zap_leaf_array *la = &ZAP_LEAF_CHUNK(l, blksft, chunk).l_array; + int toread = MIN(array_len - bseen, ZAP_LEAF_ARRAY_BYTES); + + if (chunk >= ZAP_LEAF_NUMCHUNKS(blksft)) + return 0; + + if (memcmp(la->la_array, buf + bseen, toread) != 0) + break; + chunk = zfs_to_cpu16(la->la_next, endian); + bseen += toread; + } + return (bseen == array_len); +} + +/* XXX */ +static int +zap_leaf_array_get(zap_leaf_phys_t *l, zfs_endian_t endian, int blksft, + int chunk, int array_len, char *buf) +{ + int bseen = 0; + + while (bseen < array_len) { + struct zap_leaf_array *la = &ZAP_LEAF_CHUNK(l, blksft, chunk).l_array; + int toread = MIN(array_len - bseen, ZAP_LEAF_ARRAY_BYTES); + + if (chunk >= ZAP_LEAF_NUMCHUNKS(blksft)) + /* Don't use errno because this error is to be ignored. */ + return ZFS_ERR_BAD_FS; + + memcpy(buf + bseen, la->la_array, toread); + chunk = zfs_to_cpu16(la->la_next, endian); + bseen += toread; + } + return ZFS_ERR_NONE; +} + + +/* + * Given a zap_leaf_phys_t, walk thru the zap leaf chunks to get the + * value for the property "name". + * + */ +/* XXX */ +static int +zap_leaf_lookup(zap_leaf_phys_t *l, zfs_endian_t endian, + int blksft, uint64_t h, + const char *name, uint64_t *value) +{ + uint16_t chunk; + struct zap_leaf_entry *le; + + /* Verify if this is a valid leaf block */ + if (zfs_to_cpu64(l->l_hdr.lh_block_type, endian) != ZBT_LEAF) { + printf("invalid leaf type\n"); + return ZFS_ERR_BAD_FS; + } + if (zfs_to_cpu32(l->l_hdr.lh_magic, endian) != ZAP_LEAF_MAGIC) { + printf("invalid leaf magic\n"); + return ZFS_ERR_BAD_FS; + } + + for (chunk = zfs_to_cpu16(l->l_hash[LEAF_HASH(blksft, h)], endian); + chunk != CHAIN_END; chunk = le->le_next) { + + if (chunk >= ZAP_LEAF_NUMCHUNKS(blksft)) { + printf("invalid chunk number\n"); + return ZFS_ERR_BAD_FS; + } + + le = ZAP_LEAF_ENTRY(l, blksft, chunk); + + /* Verify the chunk entry */ + if (le->le_type != ZAP_CHUNK_ENTRY) { + printf("invalid chunk entry\n"); + return ZFS_ERR_BAD_FS; + } + + if (zfs_to_cpu64(le->le_hash, endian) != h) + continue; + + if (zap_leaf_array_equal(l, endian, blksft, + zfs_to_cpu16(le->le_name_chunk, endian), + zfs_to_cpu16(le->le_name_length, endian), + name)) { + struct zap_leaf_array *la; + + if (le->le_int_size != 8 || le->le_value_length != 1) { + printf("invalid leaf chunk entry\n"); + return ZFS_ERR_BAD_FS; + } + /* get the uint64_t property value */ + la = &ZAP_LEAF_CHUNK(l, blksft, le->le_value_chunk).l_array; + + *value = be64_to_cpu(la->la_array64); + + return ZFS_ERR_NONE; + } + } + + printf("couldn't find '%s'\n", name); + return ZFS_ERR_FILE_NOT_FOUND; +} + + +/* Verify if this is a fat zap header block */ +static int +zap_verify(zap_phys_t *zap) +{ + if (zap->zap_magic != (uint64_t) ZAP_MAGIC) { + printf("bad ZAP magic\n"); + return ZFS_ERR_BAD_FS; + } + + if (zap->zap_flags != 0) { + printf("bad ZAP flags\n"); + return ZFS_ERR_BAD_FS; + } + + if (zap->zap_salt == 0) { + printf("bad ZAP salt\n"); + return ZFS_ERR_BAD_FS; + } + + return ZFS_ERR_NONE; +} + +/* + * Fat ZAP lookup + * + */ +/* XXX */ +static int +fzap_lookup(dnode_end_t *zap_dnode, zap_phys_t *zap, + char *name, uint64_t *value, struct zfs_data *data) +{ + void *l; + uint64_t hash, idx, blkid; + int blksft = zfs_log2(zfs_to_cpu16(zap_dnode->dn.dn_datablkszsec, + zap_dnode->endian) << DNODE_SHIFT); + int err; + zfs_endian_t leafendian; + + err = zap_verify(zap); + if (err) + return err; + + hash = zap_hash(zap->zap_salt, name); + + /* get block id from index */ + if (zap->zap_ptrtbl.zt_numblks != 0) { + printf("external pointer tables not supported\n"); + return ZFS_ERR_NOT_IMPLEMENTED_YET; + } + idx = ZAP_HASH_IDX(hash, zap->zap_ptrtbl.zt_shift); + blkid = ((uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))]; + + /* Get the leaf block */ + if ((1U << blksft) < sizeof(zap_leaf_phys_t)) { + printf("ZAP leaf is too small\n"); + return ZFS_ERR_BAD_FS; + } + err = dmu_read(zap_dnode, blkid, &l, &leafendian, data); + if (err) + return err; + + err = zap_leaf_lookup(l, leafendian, blksft, hash, name, value); + free(l); + return err; +} + +/* XXX */ +static int +fzap_iterate(dnode_end_t *zap_dnode, zap_phys_t *zap, + int (*hook)(const char *name, + uint64_t val, + struct zfs_data *data), + struct zfs_data *data) +{ + zap_leaf_phys_t *l; + void *l_in; + uint64_t idx, blkid; + uint16_t chunk; + int blksft = zfs_log2(zfs_to_cpu16(zap_dnode->dn.dn_datablkszsec, + zap_dnode->endian) << DNODE_SHIFT); + int err; + zfs_endian_t endian; + + if (zap_verify(zap)) + return 0; + + /* get block id from index */ + if (zap->zap_ptrtbl.zt_numblks != 0) { + printf("external pointer tables not supported\n"); + return 0; + } + /* Get the leaf block */ + if ((1U << blksft) < sizeof(zap_leaf_phys_t)) { + printf("ZAP leaf is too small\n"); + return 0; + } + for (idx = 0; idx < zap->zap_ptrtbl.zt_numblks; idx++) { + blkid = ((uint64_t *) zap)[idx + (1 << (blksft - 3 - 1))]; + + err = dmu_read(zap_dnode, blkid, &l_in, &endian, data); + l = l_in; + if (err) + continue; + + /* Verify if this is a valid leaf block */ + if (zfs_to_cpu64(l->l_hdr.lh_block_type, endian) != ZBT_LEAF) { + free(l); + continue; + } + if (zfs_to_cpu32(l->l_hdr.lh_magic, endian) != ZAP_LEAF_MAGIC) { + free(l); + continue; + } + + for (chunk = 0; chunk < ZAP_LEAF_NUMCHUNKS(blksft); chunk++) { + char *buf; + struct zap_leaf_array *la; + struct zap_leaf_entry *le; + uint64_t val; + le = ZAP_LEAF_ENTRY(l, blksft, chunk); + + /* Verify the chunk entry */ + if (le->le_type != ZAP_CHUNK_ENTRY) + continue; + + buf = malloc(zfs_to_cpu16(le->le_name_length, endian) + + 1); + if (zap_leaf_array_get(l, endian, blksft, le->le_name_chunk, + le->le_name_length, buf)) { + free(buf); + continue; + } + buf[le->le_name_length] = 0; + + if (le->le_int_size != 8 + || zfs_to_cpu16(le->le_value_length, endian) != 1) + continue; + + /* get the uint64_t property value */ + la = &ZAP_LEAF_CHUNK(l, blksft, le->le_value_chunk).l_array; + val = be64_to_cpu(la->la_array64); + if (hook(buf, val, data)) + return 1; + free(buf); + } + } + return 0; +} + + +/* + * Read in the data of a zap object and find the value for a matching + * property name. + * + */ +static int +zap_lookup(dnode_end_t *zap_dnode, char *name, uint64_t *val, + struct zfs_data *data) +{ + uint64_t block_type; + int size; + void *zapbuf; + int err; + zfs_endian_t endian; + + /* Read in the first block of the zap object data. */ + size = zfs_to_cpu16(zap_dnode->dn.dn_datablkszsec, + zap_dnode->endian) << SPA_MINBLOCKSHIFT; + err = dmu_read(zap_dnode, 0, &zapbuf, &endian, data); + if (err) + return err; + block_type = zfs_to_cpu64(*((uint64_t *) zapbuf), endian); + + if (block_type == ZBT_MICRO) { + err = (mzap_lookup(zapbuf, endian, size, name, val)); + free(zapbuf); + return err; + } else if (block_type == ZBT_HEADER) { + /* this is a fat zap */ + err = (fzap_lookup(zap_dnode, zapbuf, name, val, data)); + free(zapbuf); + return err; + } + + printf("unknown ZAP type\n"); + return ZFS_ERR_BAD_FS; +} + +static int +zap_iterate(dnode_end_t *zap_dnode, + int (*hook)(const char *name, uint64_t val, + struct zfs_data *data), + struct zfs_data *data) +{ + uint64_t block_type; + int size; + void *zapbuf; + int err; + int ret; + zfs_endian_t endian; + + /* Read in the first block of the zap object data. */ + size = zfs_to_cpu16(zap_dnode->dn.dn_datablkszsec, zap_dnode->endian) << SPA_MINBLOCKSHIFT; + err = dmu_read(zap_dnode, 0, &zapbuf, &endian, data); + if (err) + return 0; + block_type = zfs_to_cpu64(*((uint64_t *) zapbuf), endian); + + if (block_type == ZBT_MICRO) { + ret = mzap_iterate(zapbuf, endian, size, hook, data); + free(zapbuf); + return ret; + } else if (block_type == ZBT_HEADER) { + /* this is a fat zap */ + ret = fzap_iterate(zap_dnode, zapbuf, hook, data); + free(zapbuf); + return ret; + } + printf("unknown ZAP type\n"); + return 0; +} + + +/* + * Get the dnode of an object number from the metadnode of an object set. + * + * Input + * mdn - metadnode to get the object dnode + * objnum - object number for the object dnode + * buf - data buffer that holds the returning dnode + */ +static int +dnode_get(dnode_end_t *mdn, uint64_t objnum, uint8_t type, + dnode_end_t *buf, struct zfs_data *data) +{ + uint64_t blkid, blksz; /* the block id this object dnode is in */ + int epbs; /* shift of number of dnodes in a block */ + int idx; /* index within a block */ + void *dnbuf; + int err; + zfs_endian_t endian; + + blksz = zfs_to_cpu16(mdn->dn.dn_datablkszsec, + mdn->endian) << SPA_MINBLOCKSHIFT; + + epbs = zfs_log2(blksz) - DNODE_SHIFT; + blkid = objnum >> epbs; + idx = objnum & ((1 << epbs) - 1); + + if (data->dnode_buf != NULL && memcmp(data->dnode_mdn, mdn, + sizeof(*mdn)) == 0 + && objnum >= data->dnode_start && objnum < data->dnode_end) { + memmove(&(buf->dn), &(data->dnode_buf)[idx], DNODE_SIZE); + buf->endian = data->dnode_endian; + if (type && buf->dn.dn_type != type) { + printf("incorrect dnode type: %02X != %02x\n", buf->dn.dn_type, type); + return ZFS_ERR_BAD_FS; + } + return ZFS_ERR_NONE; + } + + err = dmu_read(mdn, blkid, &dnbuf, &endian, data); + if (err) + return err; + + free(data->dnode_buf); + free(data->dnode_mdn); + data->dnode_mdn = malloc(sizeof(*mdn)); + if (!data->dnode_mdn) { + data->dnode_buf = 0; + } else { + memcpy(data->dnode_mdn, mdn, sizeof(*mdn)); + data->dnode_buf = dnbuf; + data->dnode_start = blkid << epbs; + data->dnode_end = (blkid + 1) << epbs; + data->dnode_endian = endian; + } + + memmove(&(buf->dn), (dnode_phys_t *) dnbuf + idx, DNODE_SIZE); + buf->endian = endian; + if (type && buf->dn.dn_type != type) { + printf("incorrect dnode type\n"); + return ZFS_ERR_BAD_FS; + } + + return ZFS_ERR_NONE; +} + +/* + * Get the file dnode for a given file name where mdn is the meta dnode + * for this ZFS object set. When found, place the file dnode in dn. + * The 'path' argument will be mangled. + * + */ +static int +dnode_get_path(dnode_end_t *mdn, const char *path_in, dnode_end_t *dn, + struct zfs_data *data) +{ + uint64_t objnum, version; + char *cname, ch; + int err = ZFS_ERR_NONE; + char *path, *path_buf; + struct dnode_chain { + struct dnode_chain *next; + dnode_end_t dn; + }; + struct dnode_chain *dnode_path = 0, *dn_new, *root; + + dn_new = malloc(sizeof(*dn_new)); + if (!dn_new) + return ZFS_ERR_OUT_OF_MEMORY; + dn_new->next = 0; + dnode_path = root = dn_new; + + err = dnode_get(mdn, MASTER_NODE_OBJ, DMU_OT_MASTER_NODE, + &(dnode_path->dn), data); + if (err) { + free(dn_new); + return err; + } + + err = zap_lookup(&(dnode_path->dn), ZPL_VERSION_STR, &version, data); + if (err) { + free(dn_new); + return err; + } + if (version > ZPL_VERSION) { + free(dn_new); + printf("too new ZPL version\n"); + return ZFS_ERR_NOT_IMPLEMENTED_YET; + } + + err = zap_lookup(&(dnode_path->dn), ZFS_ROOT_OBJ, &objnum, data); + if (err) { + free(dn_new); + return err; + } + + err = dnode_get(mdn, objnum, 0, &(dnode_path->dn), data); + if (err) { + free(dn_new); + return err; + } + + path = path_buf = strdup(path_in); + if (!path_buf) { + free(dn_new); + return ZFS_ERR_OUT_OF_MEMORY; + } + + while (1) { + /* skip leading slashes */ + while (*path == '/') + path++; + if (!*path) + break; + /* get the next component name */ + cname = path; + while (*path && *path != '/') + path++; + /* Skip dot. */ + if (cname + 1 == path && cname[0] == '.') + continue; + /* Handle double dot. */ + if (cname + 2 == path && cname[0] == '.' && cname[1] == '.') { + if (dn_new->next) { + dn_new = dnode_path; + dnode_path = dn_new->next; + free(dn_new); + } else { + printf("can't resolve ..\n"); + err = ZFS_ERR_FILE_NOT_FOUND; + break; + } + continue; + } + + ch = *path; + *path = 0; /* ensure null termination */ + + if (dnode_path->dn.dn.dn_type != DMU_OT_DIRECTORY_CONTENTS) { + free(path_buf); + printf("not a directory\n"); + return ZFS_ERR_BAD_FILE_TYPE; + } + err = zap_lookup(&(dnode_path->dn), cname, &objnum, data); + if (err) + break; + + dn_new = malloc(sizeof(*dn_new)); + if (!dn_new) { + err = ZFS_ERR_OUT_OF_MEMORY; + break; + } + dn_new->next = dnode_path; + dnode_path = dn_new; + + objnum = ZFS_DIRENT_OBJ(objnum); + err = dnode_get(mdn, objnum, 0, &(dnode_path->dn), data); + if (err) + break; + + *path = ch; + } + + if (!err) + memcpy(dn, &(dnode_path->dn), sizeof(*dn)); + + while (dnode_path) { + dn_new = dnode_path->next; + free(dnode_path); + dnode_path = dn_new; + } + free(path_buf); + return err; +} + + +/* + * Given a MOS metadnode, get the metadnode of a given filesystem name (fsname), + * e.g. pool/rootfs, or a given object number (obj), e.g. the object number + * of pool/rootfs. + * + * If no fsname and no obj are given, return the DSL_DIR metadnode. + * If fsname is given, return its metadnode and its matching object number. + * If only obj is given, return the metadnode for this object number. + * + */ +static int +get_filesystem_dnode(dnode_end_t *mosmdn, char *fsname, + dnode_end_t *mdn, struct zfs_data *data) +{ + uint64_t objnum; + int err; + + err = dnode_get(mosmdn, DMU_POOL_DIRECTORY_OBJECT, + DMU_OT_OBJECT_DIRECTORY, mdn, data); + if (err) + return err; + + err = zap_lookup(mdn, DMU_POOL_ROOT_DATASET, &objnum, data); + if (err) + return err; + + err = dnode_get(mosmdn, objnum, DMU_OT_DSL_DIR, mdn, data); + if (err) + return err; + + while (*fsname) { + uint64_t childobj; + char *cname, ch; + + while (*fsname == '/') + fsname++; + + if (!*fsname || *fsname == '@') + break; + + cname = fsname; + while (*fsname && !isspace(*fsname) && *fsname != '/') + fsname++; + ch = *fsname; + *fsname = 0; + + childobj = zfs_to_cpu64((((dsl_dir_phys_t *) DN_BONUS(&mdn->dn)))->dd_child_dir_zapobj, mdn->endian); + err = dnode_get(mosmdn, childobj, + DMU_OT_DSL_DIR_CHILD_MAP, mdn, data); + if (err) + return err; + + err = zap_lookup(mdn, cname, &objnum, data); + if (err) + return err; + + err = dnode_get(mosmdn, objnum, DMU_OT_DSL_DIR, mdn, data); + if (err) + return err; + + *fsname = ch; + } + return ZFS_ERR_NONE; +} + +static int +make_mdn(dnode_end_t *mdn, struct zfs_data *data) +{ + void *osp; + blkptr_t *bp; + size_t ospsize; + int err; + + bp = &(((dsl_dataset_phys_t *) DN_BONUS(&mdn->dn))->ds_bp); + err = zio_read(bp, mdn->endian, &osp, &ospsize, data); + if (err) + return err; + if (ospsize < OBJSET_PHYS_SIZE_V14) { + free(osp); + printf("too small osp\n"); + return ZFS_ERR_BAD_FS; + } + + mdn->endian = (zfs_to_cpu64(bp->blk_prop, mdn->endian)>>63) & 1; + memmove((char *) &(mdn->dn), + (char *) &((objset_phys_t *) osp)->os_meta_dnode, DNODE_SIZE); + free(osp); + return ZFS_ERR_NONE; +} + +static int +dnode_get_fullpath(const char *fullpath, dnode_end_t *mdn, + uint64_t *mdnobj, dnode_end_t *dn, int *isfs, + struct zfs_data *data) +{ + char *fsname, *snapname; + const char *ptr_at, *filename; + uint64_t headobj; + int err; + + ptr_at = strchr(fullpath, '@'); + if (!ptr_at) { + *isfs = 1; + filename = 0; + snapname = 0; + fsname = strdup(fullpath); + } else { + const char *ptr_slash = strchr(ptr_at, '/'); + + *isfs = 0; + fsname = malloc(ptr_at - fullpath + 1); + if (!fsname) + return ZFS_ERR_OUT_OF_MEMORY; + memcpy(fsname, fullpath, ptr_at - fullpath); + fsname[ptr_at - fullpath] = 0; + if (ptr_at[1] && ptr_at[1] != '/') { + snapname = malloc(ptr_slash - ptr_at); + if (!snapname) { + free(fsname); + return ZFS_ERR_OUT_OF_MEMORY; + } + memcpy(snapname, ptr_at + 1, ptr_slash - ptr_at - 1); + snapname[ptr_slash - ptr_at - 1] = 0; + } else { + snapname = 0; + } + if (ptr_slash) + filename = ptr_slash; + else + filename = "/"; + printf("zfs fsname = '%s' snapname='%s' filename = '%s'\n", + fsname, snapname, filename); + } + + + err = get_filesystem_dnode(&(data->mos), fsname, dn, data); + + if (err) { + free(fsname); + free(snapname); + return err; + } + + headobj = zfs_to_cpu64(((dsl_dir_phys_t *) DN_BONUS(&dn->dn))->dd_head_dataset_obj, dn->endian); + + err = dnode_get(&(data->mos), headobj, DMU_OT_DSL_DATASET, mdn, data); + if (err) { + free(fsname); + free(snapname); + return err; + } + + if (snapname) { + uint64_t snapobj; + + snapobj = zfs_to_cpu64(((dsl_dataset_phys_t *) DN_BONUS(&mdn->dn))->ds_snapnames_zapobj, mdn->endian); + + err = dnode_get(&(data->mos), snapobj, + DMU_OT_DSL_DS_SNAP_MAP, mdn, data); + if (!err) + err = zap_lookup(mdn, snapname, &headobj, data); + if (!err) + err = dnode_get(&(data->mos), headobj, DMU_OT_DSL_DATASET, mdn, data); + if (err) { + free(fsname); + free(snapname); + return err; + } + } + + if (mdnobj) + *mdnobj = headobj; + + make_mdn(mdn, data); + + if (*isfs) { + free(fsname); + free(snapname); + return ZFS_ERR_NONE; + } + err = dnode_get_path(mdn, filename, dn, data); + free(fsname); + free(snapname); + return err; +} + +/* + * For a given XDR packed nvlist, verify the first 4 bytes and move on. + * + * An XDR packed nvlist is encoded as (comments from nvs_xdr_create) : + * + * encoding method/host endian (4 bytes) + * nvl_version (4 bytes) + * nvl_nvflag (4 bytes) + * encoded nvpairs: + * encoded size of the nvpair (4 bytes) + * decoded size of the nvpair (4 bytes) + * name string size (4 bytes) + * name string data (sizeof(NV_ALIGN4(string)) + * data type (4 bytes) + * # of elements in the nvpair (4 bytes) + * data + * 2 zero's for the last nvpair + * (end of the entire list) (8 bytes) + * + */ + +static int +nvlist_find_value(char *nvlist, char *name, int valtype, char **val, + size_t *size_out, size_t *nelm_out) +{ + int name_len, type, encode_size; + char *nvpair, *nvp_name; + + /* Verify if the 1st and 2nd byte in the nvlist are valid. */ + /* NOTE: independently of what endianness header announces all + subsequent values are big-endian. */ + if (nvlist[0] != NV_ENCODE_XDR || (nvlist[1] != NV_LITTLE_ENDIAN + && nvlist[1] != NV_BIG_ENDIAN)) { + printf("zfs incorrect nvlist header\n"); + return ZFS_ERR_BAD_FS; + } + + /* skip the header, nvl_version, and nvl_nvflag */ + nvlist = nvlist + 4 * 3; + /* + * Loop thru the nvpair list + * The XDR representation of an integer is in big-endian byte order. + */ + while ((encode_size = be32_to_cpu(*(uint32_t *) nvlist))) { + int nelm; + + nvpair = nvlist + 4 * 2; /* skip the encode/decode size */ + + name_len = be32_to_cpu(*(uint32_t *) nvpair); + nvpair += 4; + + nvp_name = nvpair; + nvpair = nvpair + ((name_len + 3) & ~3); /* align */ + + type = be32_to_cpu(*(uint32_t *) nvpair); + nvpair += 4; + + nelm = be32_to_cpu(*(uint32_t *) nvpair); + if (nelm < 1) { + printf("empty nvpair\n"); + return ZFS_ERR_BAD_FS; + } + + nvpair += 4; + + if ((strncmp(nvp_name, name, name_len) == 0) && type == valtype) { + *val = nvpair; + *size_out = encode_size; + if (nelm_out) + *nelm_out = nelm; + return 1; + } + + nvlist += encode_size; /* goto the next nvpair */ + } + return 0; +} + +int +zfs_nvlist_lookup_uint64(char *nvlist, char *name, uint64_t *out) +{ + char *nvpair; + size_t size; + int found; + + found = nvlist_find_value(nvlist, name, DATA_TYPE_UINT64, &nvpair, &size, 0); + if (!found) + return 0; + if (size < sizeof(uint64_t)) { + printf("invalid uint64\n"); + return ZFS_ERR_BAD_FS; + } + + *out = be64_to_cpu(*(uint64_t *) nvpair); + return 1; +} + +char * +zfs_nvlist_lookup_string(char *nvlist, char *name) +{ + char *nvpair; + char *ret; + size_t slen; + size_t size; + int found; + + found = nvlist_find_value(nvlist, name, DATA_TYPE_STRING, &nvpair, &size, 0); + if (!found) + return 0; + if (size < 4) { + printf("invalid string\n"); + return 0; + } + slen = be32_to_cpu(*(uint32_t *) nvpair); + if (slen > size - 4) + slen = size - 4; + ret = malloc(slen + 1); + if (!ret) + return 0; + memcpy(ret, nvpair + 4, slen); + ret[slen] = 0; + return ret; +} + +char * +zfs_nvlist_lookup_nvlist(char *nvlist, char *name) +{ + char *nvpair; + char *ret; + size_t size; + int found; + + found = nvlist_find_value(nvlist, name, DATA_TYPE_NVLIST, &nvpair, + &size, 0); + if (!found) + return 0; + ret = calloc(1, size + 3 * sizeof(uint32_t)); + if (!ret) + return 0; + memcpy(ret, nvlist, sizeof(uint32_t)); + + memcpy(ret + sizeof(uint32_t), nvpair, size); + return ret; +} + +int +zfs_nvlist_lookup_nvlist_array_get_nelm(char *nvlist, char *name) +{ + char *nvpair; + size_t nelm, size; + int found; + + found = nvlist_find_value(nvlist, name, DATA_TYPE_NVLIST, &nvpair, + &size, &nelm); + if (!found) + return -1; + return nelm; +} + +char * +zfs_nvlist_lookup_nvlist_array(char *nvlist, char *name, + size_t index) +{ + char *nvpair, *nvpairptr; + int found; + char *ret; + size_t size; + unsigned i; + size_t nelm; + + found = nvlist_find_value(nvlist, name, DATA_TYPE_NVLIST, &nvpair, + &size, &nelm); + if (!found) + return 0; + if (index >= nelm) { + printf("trying to lookup past nvlist array\n"); + return 0; + } + + nvpairptr = nvpair; + + for (i = 0; i < index; i++) { + uint32_t encode_size; + + /* skip the header, nvl_version, and nvl_nvflag */ + nvpairptr = nvpairptr + 4 * 2; + + while (nvpairptr < nvpair + size + && (encode_size = be32_to_cpu(*(uint32_t *) nvpairptr))) + nvlist += encode_size; /* goto the next nvpair */ + + nvlist = nvlist + 4 * 2; /* skip the ending 2 zeros - 8 bytes */ + } + + if (nvpairptr >= nvpair + size + || nvpairptr + be32_to_cpu(*(uint32_t *) (nvpairptr + 4 * 2)) + >= nvpair + size) { + printf("incorrect nvlist array\n"); + return 0; + } + + ret = calloc(1, be32_to_cpu(*(uint32_t *) (nvpairptr + 4 * 2)) + + 3 * sizeof(uint32_t)); + if (!ret) + return 0; + memcpy(ret, nvlist, sizeof(uint32_t)); + + memcpy(ret + sizeof(uint32_t), nvpairptr, size); + return ret; +} + +static int +int_zfs_fetch_nvlist(struct zfs_data *data, char **nvlist) +{ + int err; + + *nvlist = malloc(VDEV_PHYS_SIZE); + /* Read in the vdev name-value pair list (112K). */ + err = zfs_devread(data->vdev_phys_sector, 0, VDEV_PHYS_SIZE, *nvlist); + if (err) { + free(*nvlist); + *nvlist = 0; + return err; + } + return ZFS_ERR_NONE; +} + +/* + * Check the disk label information and retrieve needed vdev name-value pairs. + * + */ +static int +check_pool_label(struct zfs_data *data) +{ + uint64_t pool_state; + char *nvlist; /* for the pool */ + char *vdevnvlist; /* for the vdev */ + uint64_t diskguid; + uint64_t version; + int found; + int err; + + err = int_zfs_fetch_nvlist(data, &nvlist); + if (err) + return err; + + found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_POOL_STATE, + &pool_state); + if (!found) { + free(nvlist); + printf("zfs pool state not found\n"); + return ZFS_ERR_BAD_FS; + } + + if (pool_state == POOL_STATE_DESTROYED) { + free(nvlist); + printf("zpool is marked as destroyed\n"); + return ZFS_ERR_BAD_FS; + } + + data->label_txg = 0; + found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_POOL_TXG, + &data->label_txg); + if (!found) { + free(nvlist); + printf("zfs pool txg not found\n"); + return ZFS_ERR_BAD_FS; + } + + /* not an active device */ + if (data->label_txg == 0) { + free(nvlist); + printf("zpool is not active\n"); + return ZFS_ERR_BAD_FS; + } + + found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_VERSION, + &version); + if (!found) { + free(nvlist); + printf("zpool config version not found\n"); + return ZFS_ERR_BAD_FS; + } + + if (version > SPA_VERSION) { + free(nvlist); + printf("SPA version too new %llu > %llu\n", + (unsigned long long) version, + (unsigned long long) SPA_VERSION); + return ZFS_ERR_NOT_IMPLEMENTED_YET; + } + + vdevnvlist = zfs_nvlist_lookup_nvlist(nvlist, ZPOOL_CONFIG_VDEV_TREE); + if (!vdevnvlist) { + free(nvlist); + printf("ZFS config vdev tree not found\n"); + return ZFS_ERR_BAD_FS; + } + + found = zfs_nvlist_lookup_uint64(vdevnvlist, ZPOOL_CONFIG_ASHIFT, + &data->vdev_ashift); + free(vdevnvlist); + if (!found) { + free(nvlist); + printf("ZPOOL config ashift not found\n"); + return ZFS_ERR_BAD_FS; + } + + found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_GUID, &diskguid); + if (!found) { + free(nvlist); + printf("ZPOOL config guid not found\n"); + return ZFS_ERR_BAD_FS; + } + + found = zfs_nvlist_lookup_uint64(nvlist, ZPOOL_CONFIG_POOL_GUID, &data->pool_guid); + if (!found) { + free(nvlist); + printf("ZPOOL config pool guid not found\n"); + return ZFS_ERR_BAD_FS; + } + + free(nvlist); + + printf("ZFS Pool GUID: %llu (%016llx) Label: GUID: %llu (%016llx), txg: %llu, SPA v%llu, ashift: %llu\n", + (unsigned long long) data->pool_guid, + (unsigned long long) data->pool_guid, + (unsigned long long) diskguid, + (unsigned long long) diskguid, + (unsigned long long) data->label_txg, + (unsigned long long) version, + (unsigned long long) data->vdev_ashift); + + return ZFS_ERR_NONE; +} + +/* + * vdev_label_start returns the physical disk offset (in bytes) of + * label "l". + */ +static uint64_t vdev_label_start(uint64_t psize, int l) +{ + return (l * sizeof(vdev_label_t) + (l < VDEV_LABELS / 2 ? + 0 : psize - + VDEV_LABELS * sizeof(vdev_label_t))); +} + +void +zfs_unmount(struct zfs_data *data) +{ + free(data->dnode_buf); + free(data->dnode_mdn); + free(data->file_buf); + free(data); +} + +/* + * zfs_mount() locates a valid uberblock of the root pool and read in its MOS + * to the memory address MOS. + * + */ +struct zfs_data * +zfs_mount(device_t dev) +{ + struct zfs_data *data = 0; + int label = 0, bestlabel = -1; + char *ub_array; + uberblock_t *ubbest; + uberblock_t *ubcur = NULL; + void *osp = 0; + size_t ospsize; + int err; + + data = malloc(sizeof(*data)); + if (!data) + return 0; + memset(data, 0, sizeof(*data)); + + ub_array = malloc(VDEV_UBERBLOCK_RING); + if (!ub_array) { + zfs_unmount(data); + return 0; + } + + ubbest = malloc(sizeof(*ubbest)); + if (!ubbest) { + zfs_unmount(data); + return 0; + } + memset(ubbest, 0, sizeof(*ubbest)); + + /* + * some eltorito stacks don't give us a size and + * we end up setting the size to MAXUINT, further + * some of these devices stop working once a single + * read past the end has been issued. Checking + * for a maximum part_length and skipping the backup + * labels at the end of the slice/partition/device + * avoids breaking down on such devices. + */ + const int vdevnum = + dev->part_length == 0 ? + VDEV_LABELS / 2 : VDEV_LABELS; + + /* Size in bytes of the device (disk or partition) aligned to label size*/ + uint64_t device_size = + dev->part_length << SECTOR_BITS; + + const uint64_t alignedbytes = + P2ALIGN(device_size, (uint64_t) sizeof(vdev_label_t)); + + for (label = 0; label < vdevnum; label++) { + uint64_t labelstartbytes = vdev_label_start(alignedbytes, label); + uint64_t labelstart = labelstartbytes >> SECTOR_BITS; + + debug("zfs reading label %d at sector %llu (byte %llu)\n", + label, (unsigned long long) labelstart, + (unsigned long long) labelstartbytes); + + data->vdev_phys_sector = labelstart + + ((VDEV_SKIP_SIZE + VDEV_BOOT_HEADER_SIZE) >> SECTOR_BITS); + + err = check_pool_label(data); + if (err) { + printf("zfs error checking label %d\n", label); + continue; + } + + /* Read in the uberblock ring (128K). */ + err = zfs_devread(data->vdev_phys_sector + + (VDEV_PHYS_SIZE >> SECTOR_BITS), + 0, VDEV_UBERBLOCK_RING, ub_array); + if (err) { + printf("zfs error reading uberblock ring for label %d\n", label); + continue; + } + + ubcur = find_bestub(ub_array, data); + if (!ubcur) { + printf("zfs No good uberblocks found in label %d\n", label); + continue; + } + + if (vdev_uberblock_compare(ubcur, ubbest) > 0) { + /* Looks like the block is good, so use it.*/ + memcpy(ubbest, ubcur, sizeof(*ubbest)); + bestlabel = label; + debug("zfs Current best uberblock found in label %d\n", label); + } + } + free(ub_array); + + /* We zero'd the structure to begin with. If we never assigned to it, + magic will still be zero. */ + if (!ubbest->ub_magic) { + printf("couldn't find a valid ZFS label\n"); + zfs_unmount(data); + free(ubbest); + return 0; + } + + debug("zfs ubbest %p in label %d\n", ubbest, bestlabel); + + zfs_endian_t ub_endian = + zfs_to_cpu64(ubbest->ub_magic, LITTLE_ENDIAN) == UBERBLOCK_MAGIC + ? LITTLE_ENDIAN : BIG_ENDIAN; + + debug("zfs endian set to %s\n", !ub_endian ? "big" : "little"); + + err = zio_read(&ubbest->ub_rootbp, ub_endian, &osp, &ospsize, data); + + if (err) { + printf("couldn't zio_read object directory\n"); + zfs_unmount(data); + free(ubbest); + return 0; + } + + if (ospsize < OBJSET_PHYS_SIZE_V14) { + printf("osp too small\n"); + zfs_unmount(data); + free(osp); + free(ubbest); + return 0; + } + + /* Got the MOS. Save it at the memory addr MOS. */ + memmove(&(data->mos.dn), &((objset_phys_t *) osp)->os_meta_dnode, DNODE_SIZE); + data->mos.endian = + (zfs_to_cpu64(ubbest->ub_rootbp.blk_prop, ub_endian) >> 63) & 1; + memmove(&(data->current_uberblock), ubbest, sizeof(uberblock_t)); + + free(osp); + free(ubbest); + + return data; +} + +int +zfs_fetch_nvlist(device_t dev, char **nvlist) +{ + struct zfs_data *zfs; + int err; + + zfs = zfs_mount(dev); + if (!zfs) + return ZFS_ERR_BAD_FS; + err = int_zfs_fetch_nvlist(zfs, nvlist); + zfs_unmount(zfs); + return err; +} + +static int +zfs_label(device_t device, char **label) +{ + char *nvlist; + int err; + struct zfs_data *data; + + data = zfs_mount(device); + if (!data) + return ZFS_ERR_BAD_FS; + + err = int_zfs_fetch_nvlist(data, &nvlist); + if (err) { + zfs_unmount(data); + return err; + } + + *label = zfs_nvlist_lookup_string(nvlist, ZPOOL_CONFIG_POOL_NAME); + free(nvlist); + zfs_unmount(data); + return ZFS_ERR_NONE; +} + +static int +zfs_uuid(device_t device, char **uuid) +{ + struct zfs_data *data; + + data = zfs_mount(device); + if (!data) + return ZFS_ERR_BAD_FS; + + *uuid = malloc(17); /* %016llx + nil */ + if (!*uuid) + return ZFS_ERR_OUT_OF_MEMORY; + + /* *uuid = xasprintf ("%016llx", (long long unsigned) data->pool_guid);*/ + snprintf(*uuid, 17, "%016llx", (long long unsigned) data->pool_guid); + zfs_unmount(data); + + return ZFS_ERR_NONE; +} + +/* + * zfs_open() locates a file in the rootpool by following the + * MOS and places the dnode of the file in the memory address DNODE. + */ +int +zfs_open(struct zfs_file *file, const char *fsfilename) +{ + struct zfs_data *data; + int err; + int isfs; + + data = zfs_mount(file->device); + if (!data) + return ZFS_ERR_BAD_FS; + + err = dnode_get_fullpath(fsfilename, &(data->mdn), 0, + &(data->dnode), &isfs, data); + if (err) { + zfs_unmount(data); + return err; + } + + if (isfs) { + zfs_unmount(data); + printf("Missing @ or / separator\n"); + return ZFS_ERR_FILE_NOT_FOUND; + } + + /* We found the dnode for this file. Verify if it is a plain file. */ + if (data->dnode.dn.dn_type != DMU_OT_PLAIN_FILE_CONTENTS) { + zfs_unmount(data); + printf("not a file\n"); + return ZFS_ERR_BAD_FILE_TYPE; + } + + /* get the file size and set the file position to 0 */ + + /* + * For DMU_OT_SA we will need to locate the SIZE attribute + * attribute, which could be either in the bonus buffer + * or the "spill" block. + */ + if (data->dnode.dn.dn_bonustype == DMU_OT_SA) { + void *sahdrp; + int hdrsize; + + if (data->dnode.dn.dn_bonuslen != 0) { + sahdrp = (sa_hdr_phys_t *) DN_BONUS(&data->dnode.dn); + } else if (data->dnode.dn.dn_flags & DNODE_FLAG_SPILL_BLKPTR) { + blkptr_t *bp = &data->dnode.dn.dn_spill; + + err = zio_read(bp, data->dnode.endian, &sahdrp, NULL, data); + if (err) + return err; + } else { + printf("filesystem is corrupt :(\n"); + return ZFS_ERR_BAD_FS; + } + + hdrsize = SA_HDR_SIZE(((sa_hdr_phys_t *) sahdrp)); + file->size = *(uint64_t *) ((char *) sahdrp + hdrsize + SA_SIZE_OFFSET); + } else { + file->size = zfs_to_cpu64(((znode_phys_t *) DN_BONUS(&data->dnode.dn))->zp_size, data->dnode.endian); + } + + file->data = data; + file->offset = 0; + + return ZFS_ERR_NONE; +} + +uint64_t +zfs_read(zfs_file_t file, char *buf, uint64_t len) +{ + struct zfs_data *data = (struct zfs_data *) file->data; + int blksz, movesize; + uint64_t length; + int64_t red; + int err; + + if (data->file_buf == NULL) { + data->file_buf = malloc(SPA_MAXBLOCKSIZE); + if (!data->file_buf) + return -1; + data->file_start = data->file_end = 0; + } + + /* + * If offset is in memory, move it into the buffer provided and return. + */ + if (file->offset >= data->file_start + && file->offset + len <= data->file_end) { + memmove(buf, data->file_buf + file->offset - data->file_start, + len); + return len; + } + + blksz = zfs_to_cpu16(data->dnode.dn.dn_datablkszsec, + data->dnode.endian) << SPA_MINBLOCKSHIFT; + + /* + * Entire Dnode is too big to fit into the space available. We + * will need to read it in chunks. This could be optimized to + * read in as large a chunk as there is space available, but for + * now, this only reads in one data block at a time. + */ + length = len; + red = 0; + while (length) { + void *t; + /* + * Find requested blkid and the offset within that block. + */ + uint64_t blkid = (file->offset + red) / blksz; + free(data->file_buf); + data->file_buf = 0; + + err = dmu_read(&(data->dnode), blkid, &t, + 0, data); + data->file_buf = t; + if (err) + return -1; + + data->file_start = blkid * blksz; + data->file_end = data->file_start + blksz; + + movesize = MIN(length, data->file_end - (int) file->offset - red); + + memmove(buf, data->file_buf + file->offset + red + - data->file_start, movesize); + buf += movesize; + length -= movesize; + red += movesize; + } + + return len; +} + +int +zfs_close(zfs_file_t file) +{ + zfs_unmount((struct zfs_data *) file->data); + return ZFS_ERR_NONE; +} + +int +zfs_getmdnobj(device_t dev, const char *fsfilename, + uint64_t *mdnobj) +{ + struct zfs_data *data; + int err; + int isfs; + + data = zfs_mount(dev); + if (!data) + return ZFS_ERR_BAD_FS; + + err = dnode_get_fullpath(fsfilename, &(data->mdn), mdnobj, + &(data->dnode), &isfs, data); + zfs_unmount(data); + return err; +} + +static void +fill_fs_info(struct zfs_dirhook_info *info, + dnode_end_t mdn, struct zfs_data *data) +{ + int err; + dnode_end_t dn; + uint64_t objnum; + uint64_t headobj; + + memset(info, 0, sizeof(*info)); + + info->dir = 1; + + if (mdn.dn.dn_type == DMU_OT_DSL_DIR) { + headobj = zfs_to_cpu64(((dsl_dir_phys_t *) DN_BONUS(&mdn.dn))->dd_head_dataset_obj, mdn.endian); + + err = dnode_get(&(data->mos), headobj, DMU_OT_DSL_DATASET, &mdn, data); + if (err) { + printf("zfs failed here 1\n"); + return; + } + } + make_mdn(&mdn, data); + err = dnode_get(&mdn, MASTER_NODE_OBJ, DMU_OT_MASTER_NODE, + &dn, data); + if (err) { + printf("zfs failed here 2\n"); + return; + } + + err = zap_lookup(&dn, ZFS_ROOT_OBJ, &objnum, data); + if (err) { + printf("zfs failed here 3\n"); + return; + } + + err = dnode_get(&mdn, objnum, 0, &dn, data); + if (err) { + printf("zfs failed here 4\n"); + return; + } + + info->mtimeset = 1; + info->mtime = zfs_to_cpu64(((znode_phys_t *) DN_BONUS(&dn.dn))->zp_mtime[0], dn.endian); + + return; +} + +static int iterate_zap(const char *name, uint64_t val, struct zfs_data *data) +{ + struct zfs_dirhook_info info; + dnode_end_t dn; + + memset(&info, 0, sizeof(info)); + + dnode_get(&(data->mdn), val, 0, &dn, data); + info.mtimeset = 1; + info.mtime = zfs_to_cpu64(((znode_phys_t *) DN_BONUS(&dn.dn))->zp_mtime[0], dn.endian); + info.dir = (dn.dn.dn_type == DMU_OT_DIRECTORY_CONTENTS); + debug("zfs type=%d, name=%s\n", + (int)dn.dn.dn_type, (char *)name); + if (!data->userhook) + return 0; + return data->userhook(name, &info); +} + +static int iterate_zap_fs(const char *name, uint64_t val, struct zfs_data *data) +{ + struct zfs_dirhook_info info; + dnode_end_t mdn; + int err; + err = dnode_get(&(data->mos), val, 0, &mdn, data); + if (err) + return 0; + if (mdn.dn.dn_type != DMU_OT_DSL_DIR) + return 0; + + fill_fs_info(&info, mdn, data); + + if (!data->userhook) + return 0; + return data->userhook(name, &info); +} + +static int iterate_zap_snap(const char *name, uint64_t val, struct zfs_data *data) +{ + struct zfs_dirhook_info info; + char *name2; + int ret = 0; + dnode_end_t mdn; + int err; + + err = dnode_get(&(data->mos), val, 0, &mdn, data); + if (err) + return 0; + + if (mdn.dn.dn_type != DMU_OT_DSL_DATASET) + return 0; + + fill_fs_info(&info, mdn, data); + + name2 = malloc(strlen(name) + 2); + name2[0] = '@'; + memcpy(name2 + 1, name, strlen(name) + 1); + if (data->userhook) + ret = data->userhook(name2, &info); + free(name2); + return ret; +} + +int +zfs_ls(device_t device, const char *path, + int (*hook)(const char *, const struct zfs_dirhook_info *)) +{ + struct zfs_data *data; + int err; + int isfs; +#if 0 + char *label = NULL; + + zfs_label(device, &label); + if (label) + printf("ZPOOL label '%s'\n", + label); +#endif + + data = zfs_mount(device); + if (!data) + return ZFS_ERR_BAD_FS; + + data->userhook = hook; + + err = dnode_get_fullpath(path, &(data->mdn), 0, &(data->dnode), &isfs, data); + if (err) { + zfs_unmount(data); + return err; + } + if (isfs) { + uint64_t childobj, headobj; + uint64_t snapobj; + dnode_end_t dn; + struct zfs_dirhook_info info; + + fill_fs_info(&info, data->dnode, data); + hook("@", &info); + + childobj = zfs_to_cpu64(((dsl_dir_phys_t *) DN_BONUS(&data->dnode.dn))->dd_child_dir_zapobj, data->dnode.endian); + headobj = zfs_to_cpu64(((dsl_dir_phys_t *) DN_BONUS(&data->dnode.dn))->dd_head_dataset_obj, data->dnode.endian); + err = dnode_get(&(data->mos), childobj, + DMU_OT_DSL_DIR_CHILD_MAP, &dn, data); + if (err) { + zfs_unmount(data); + return err; + } + + + zap_iterate(&dn, iterate_zap_fs, data); + + err = dnode_get(&(data->mos), headobj, DMU_OT_DSL_DATASET, &dn, data); + if (err) { + zfs_unmount(data); + return err; + } + + snapobj = zfs_to_cpu64(((dsl_dataset_phys_t *) DN_BONUS(&dn.dn))->ds_snapnames_zapobj, dn.endian); + + err = dnode_get(&(data->mos), snapobj, + DMU_OT_DSL_DS_SNAP_MAP, &dn, data); + if (err) { + zfs_unmount(data); + return err; + } + + zap_iterate(&dn, iterate_zap_snap, data); + } else { + if (data->dnode.dn.dn_type != DMU_OT_DIRECTORY_CONTENTS) { + zfs_unmount(data); + printf("not a directory\n"); + return ZFS_ERR_BAD_FILE_TYPE; + } + zap_iterate(&(data->dnode), iterate_zap, data); + } + zfs_unmount(data); + return ZFS_ERR_NONE; +} diff --git a/fs/zfs/zfs_fletcher.c b/fs/zfs/zfs_fletcher.c new file mode 100644 index 0000000000..08f708ca96 --- /dev/null +++ b/fs/zfs/zfs_fletcher.c @@ -0,0 +1,87 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright 2007 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include +#include +#include +#include +#include +#include +#include "zfs_common.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +void +fletcher_2_endian(const void *buf, uint64_t size, + zfs_endian_t endian, + zio_cksum_t *zcp) +{ + const uint64_t *ip = buf; + const uint64_t *ipend = ip + (size / sizeof(uint64_t)); + uint64_t a0, b0, a1, b1; + + for (a0 = b0 = a1 = b1 = 0; ip < ipend; ip += 2) { + a0 += zfs_to_cpu64(ip[0], endian); + a1 += zfs_to_cpu64(ip[1], endian); + b0 += a0; + b1 += a1; + } + + zcp->zc_word[0] = cpu_to_zfs64(a0, endian); + zcp->zc_word[1] = cpu_to_zfs64(a1, endian); + zcp->zc_word[2] = cpu_to_zfs64(b0, endian); + zcp->zc_word[3] = cpu_to_zfs64(b1, endian); +} + +void +fletcher_4_endian(const void *buf, uint64_t size, zfs_endian_t endian, + zio_cksum_t *zcp) +{ + const uint32_t *ip = buf; + const uint32_t *ipend = ip + (size / sizeof(uint32_t)); + uint64_t a, b, c, d; + + for (a = b = c = d = 0; ip < ipend; ip++) { + a += zfs_to_cpu32(ip[0], endian); + b += a; + c += b; + d += c; + } + + zcp->zc_word[0] = cpu_to_zfs64(a, endian); + zcp->zc_word[1] = cpu_to_zfs64(b, endian); + zcp->zc_word[2] = cpu_to_zfs64(c, endian); + zcp->zc_word[3] = cpu_to_zfs64(d, endian); +} diff --git a/fs/zfs/zfs_lzjb.c b/fs/zfs/zfs_lzjb.c new file mode 100644 index 0000000000..b22d7e1ddb --- /dev/null +++ b/fs/zfs/zfs_lzjb.c @@ -0,0 +1,97 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright 2007 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include +#include +#include +#include +#include +#include +#include "zfs_common.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define MATCH_BITS 6 +#define MATCH_MIN 3 +#define OFFSET_MASK ((1 << (16 - MATCH_BITS)) - 1) + +/* + * Decompression Entry - lzjb + */ +#ifndef NBBY +#define NBBY 8 +#endif + +int +lzjb_decompress(void *s_start, void *d_start, uint32_t s_len, + uint32_t d_len) +{ + uint8_t *src = s_start; + uint8_t *dst = d_start; + uint8_t *d_end = (uint8_t *) d_start + d_len; + uint8_t *s_end = (uint8_t *) s_start + s_len; + uint8_t *cpy, copymap = 0; + int copymask = 1 << (NBBY - 1); + + while (dst < d_end && src < s_end) { + if ((copymask <<= 1) == (1 << NBBY)) { + copymask = 1; + copymap = *src++; + } + if (src >= s_end) { + printf("lzjb decompression failed\n"); + return ZFS_ERR_BAD_FS; + } + if (copymap & copymask) { + int mlen = (src[0] >> (NBBY - MATCH_BITS)) + MATCH_MIN; + int offset = ((src[0] << NBBY) | src[1]) & OFFSET_MASK; + src += 2; + cpy = dst - offset; + if (src > s_end || cpy < (uint8_t *) d_start) { + printf("lzjb decompression failed\n"); + return ZFS_ERR_BAD_FS; + } + while (--mlen >= 0 && dst < d_end) + *dst++ = *cpy++; + } else { + *dst++ = *src++; + } + } + if (dst < d_end) { + printf("lzjb decompression failed\n"); + return ZFS_ERR_BAD_FS; + } + return ZFS_ERR_NONE; +} diff --git a/fs/zfs/zfs_sha256.c b/fs/zfs/zfs_sha256.c new file mode 100644 index 0000000000..f1a4d9769c --- /dev/null +++ b/fs/zfs/zfs_sha256.c @@ -0,0 +1,148 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright 2007 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#include +#include +#include +#include +#include +#include +#include "zfs_common.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* + * SHA-256 checksum, as specified in FIPS 180-2, available at: + * http://csrc.nist.gov/cryptval + * + * This is a very compact implementation of SHA-256. + * It is designed to be simple and portable, not to be fast. + */ + +/* + * The literal definitions according to FIPS180-2 would be: + * + * Ch(x, y, z) (((x) & (y)) ^ ((~(x)) & (z))) + * Maj(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z))) + * + * We use logical equivalents which require one less op. + */ +#define Ch(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) +#define Maj(x, y, z) (((x) & (y)) ^ ((z) & ((x) ^ (y)))) +#define Rot32(x, s) (((x) >> s) | ((x) << (32 - s))) +#define SIGMA0(x) (Rot32(x, 2) ^ Rot32(x, 13) ^ Rot32(x, 22)) +#define SIGMA1(x) (Rot32(x, 6) ^ Rot32(x, 11) ^ Rot32(x, 25)) +#define sigma0(x) (Rot32(x, 7) ^ Rot32(x, 18) ^ ((x) >> 3)) +#define sigma1(x) (Rot32(x, 17) ^ Rot32(x, 19) ^ ((x) >> 10)) + +static const uint32_t SHA256_K[64] = { + 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, + 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, + 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, + 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, + 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, + 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, + 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, + 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, + 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, + 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, + 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, + 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, + 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, + 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, + 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, + 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 +}; + +static void +SHA256Transform(uint32_t *H, const uint8_t *cp) +{ + uint32_t a, b, c, d, e, f, g, h, t, T1, T2, W[64]; + + for (t = 0; t < 16; t++, cp += 4) + W[t] = (cp[0] << 24) | (cp[1] << 16) | (cp[2] << 8) | cp[3]; + + for (t = 16; t < 64; t++) + W[t] = sigma1(W[t - 2]) + W[t - 7] + + sigma0(W[t - 15]) + W[t - 16]; + + a = H[0]; b = H[1]; c = H[2]; d = H[3]; + e = H[4]; f = H[5]; g = H[6]; h = H[7]; + + for (t = 0; t < 64; t++) { + T1 = h + SIGMA1(e) + Ch(e, f, g) + SHA256_K[t] + W[t]; + T2 = SIGMA0(a) + Maj(a, b, c); + h = g; g = f; f = e; e = d + T1; + d = c; c = b; b = a; a = T1 + T2; + } + + H[0] += a; H[1] += b; H[2] += c; H[3] += d; + H[4] += e; H[5] += f; H[6] += g; H[7] += h; +} + +void +zio_checksum_SHA256(const void *buf, uint64_t size, + zfs_endian_t endian, zio_cksum_t *zcp) +{ + uint32_t H[8] = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, + 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 }; + uint8_t pad[128]; + unsigned padsize = size & 63; + unsigned i; + + for (i = 0; i < size - padsize; i += 64) + SHA256Transform(H, (uint8_t *)buf + i); + + for (i = 0; i < padsize; i++) + pad[i] = ((uint8_t *)buf)[i]; + + for (pad[padsize++] = 0x80; (padsize & 63) != 56; padsize++) + pad[padsize] = 0; + + for (i = 0; i < 8; i++) + pad[padsize++] = (size << 3) >> (56 - 8 * i); + + for (i = 0; i < padsize; i += 64) + SHA256Transform(H, pad + i); + + zcp->zc_word[0] = cpu_to_zfs64((uint64_t)H[0] << 32 | H[1], + endian); + zcp->zc_word[1] = cpu_to_zfs64((uint64_t)H[2] << 32 | H[3], + endian); + zcp->zc_word[2] = cpu_to_zfs64((uint64_t)H[4] << 32 | H[5], + endian); + zcp->zc_word[3] = cpu_to_zfs64((uint64_t)H[6] << 32 | H[7], + endian); +} diff --git a/include/config_cmd_all.h b/include/config_cmd_all.h index 73c0558202..f434cd0891 100644 --- a/include/config_cmd_all.h +++ b/include/config_cmd_all.h @@ -87,5 +87,6 @@ #define CONFIG_CMD_UNZIP /* unzip from memory to memory */ #define CONFIG_CMD_USB /* USB Support */ #define CONFIG_CMD_XIMG /* Load part of Multi Image */ +#define CONFIG_CMD_ZFS /* ZFS Support */ #endif /* _CONFIG_CMD_ALL_H */ diff --git a/include/zfs/dmu.h b/include/zfs/dmu.h new file mode 100644 index 0000000000..7faa7088b5 --- /dev/null +++ b/include/zfs/dmu.h @@ -0,0 +1,120 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright 2010 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _SYS_DMU_H +#define _SYS_DMU_H + +/* + * This file describes the interface that the DMU provides for its + * consumers. + * + * The DMU also interacts with the SPA. That interface is described in + * dmu_spa.h. + */ +typedef enum dmu_object_type { + DMU_OT_NONE, + /* general: */ + DMU_OT_OBJECT_DIRECTORY, /* ZAP */ + DMU_OT_OBJECT_ARRAY, /* UINT64 */ + DMU_OT_PACKED_NVLIST, /* UINT8 (XDR by nvlist_pack/unpack) */ + DMU_OT_PACKED_NVLIST_SIZE, /* UINT64 */ + DMU_OT_BPLIST, /* UINT64 */ + DMU_OT_BPLIST_HDR, /* UINT64 */ + /* spa: */ + DMU_OT_SPACE_MAP_HEADER, /* UINT64 */ + DMU_OT_SPACE_MAP, /* UINT64 */ + /* zil: */ + DMU_OT_INTENT_LOG, /* UINT64 */ + /* dmu: */ + DMU_OT_DNODE, /* DNODE */ + DMU_OT_OBJSET, /* OBJSET */ + /* dsl: */ + DMU_OT_DSL_DIR, /* UINT64 */ + DMU_OT_DSL_DIR_CHILD_MAP, /* ZAP */ + DMU_OT_DSL_DS_SNAP_MAP, /* ZAP */ + DMU_OT_DSL_PROPS, /* ZAP */ + DMU_OT_DSL_DATASET, /* UINT64 */ + /* zpl: */ + DMU_OT_ZNODE, /* ZNODE */ + DMU_OT_OLDACL, /* OLD ACL */ + DMU_OT_PLAIN_FILE_CONTENTS, /* UINT8 */ + DMU_OT_DIRECTORY_CONTENTS, /* ZAP */ + DMU_OT_MASTER_NODE, /* ZAP */ + DMU_OT_UNLINKED_SET, /* ZAP */ + /* zvol: */ + DMU_OT_ZVOL, /* UINT8 */ + DMU_OT_ZVOL_PROP, /* ZAP */ + /* other; for testing only! */ + DMU_OT_PLAIN_OTHER, /* UINT8 */ + DMU_OT_UINT64_OTHER, /* UINT64 */ + DMU_OT_ZAP_OTHER, /* ZAP */ + /* new object types: */ + DMU_OT_ERROR_LOG, /* ZAP */ + DMU_OT_SPA_HISTORY, /* UINT8 */ + DMU_OT_SPA_HISTORY_OFFSETS, /* spa_his_phys_t */ + DMU_OT_POOL_PROPS, /* ZAP */ + DMU_OT_DSL_PERMS, /* ZAP */ + DMU_OT_ACL, /* ACL */ + DMU_OT_SYSACL, /* SYSACL */ + DMU_OT_FUID, /* FUID table (Packed NVLIST UINT8) */ + DMU_OT_FUID_SIZE, /* FUID table size UINT64 */ + DMU_OT_NEXT_CLONES, /* ZAP */ + DMU_OT_SCRUB_QUEUE, /* ZAP */ + DMU_OT_USERGROUP_USED, /* ZAP */ + DMU_OT_USERGROUP_QUOTA, /* ZAP */ + DMU_OT_USERREFS, /* ZAP */ + DMU_OT_DDT_ZAP, /* ZAP */ + DMU_OT_DDT_STATS, /* ZAP */ + DMU_OT_SA, /* System attr */ + DMU_OT_SA_MASTER_NODE, /* ZAP */ + DMU_OT_SA_ATTR_REGISTRATION, /* ZAP */ + DMU_OT_SA_ATTR_LAYOUTS, /* ZAP */ + DMU_OT_NUMTYPES +} dmu_object_type_t; + +typedef enum dmu_objset_type { + DMU_OST_NONE, + DMU_OST_META, + DMU_OST_ZFS, + DMU_OST_ZVOL, + DMU_OST_OTHER, /* For testing only! */ + DMU_OST_ANY, /* Be careful! */ + DMU_OST_NUMTYPES +} dmu_objset_type_t; + +/* + * The names of zap entries in the DIRECTORY_OBJECT of the MOS. + */ +#define DMU_POOL_DIRECTORY_OBJECT 1 +#define DMU_POOL_CONFIG "config" +#define DMU_POOL_ROOT_DATASET "root_dataset" +#define DMU_POOL_SYNC_BPLIST "sync_bplist" +#define DMU_POOL_ERRLOG_SCRUB "errlog_scrub" +#define DMU_POOL_ERRLOG_LAST "errlog_last" +#define DMU_POOL_SPARES "spares" +#define DMU_POOL_DEFLATE "deflate" +#define DMU_POOL_HISTORY "history" +#define DMU_POOL_PROPS "pool_props" +#define DMU_POOL_L2CACHE "l2cache" + +#endif /* _SYS_DMU_H */ diff --git a/include/zfs/dmu_objset.h b/include/zfs/dmu_objset.h new file mode 100644 index 0000000000..dbd67ad00a --- /dev/null +++ b/include/zfs/dmu_objset.h @@ -0,0 +1,43 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _SYS_DMU_OBJSET_H +#define _SYS_DMU_OBJSET_H + +#include + +#define OBJSET_PHYS_SIZE 2048 +#define OBJSET_PHYS_SIZE_V14 1024 + +typedef struct objset_phys { + dnode_phys_t os_meta_dnode; + zil_header_t os_zil_header; + uint64_t os_type; + uint64_t os_flags; + char os_pad[OBJSET_PHYS_SIZE - sizeof(dnode_phys_t)*3 - + sizeof(zil_header_t) - sizeof(uint64_t)*2]; + dnode_phys_t os_userused_dnode; + dnode_phys_t os_groupused_dnode; +} objset_phys_t; + +#endif /* _SYS_DMU_OBJSET_H */ diff --git a/include/zfs/dnode.h b/include/zfs/dnode.h new file mode 100644 index 0000000000..09b45626b8 --- /dev/null +++ b/include/zfs/dnode.h @@ -0,0 +1,81 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright 2010 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _SYS_DNODE_H +#define _SYS_DNODE_H + +#include + +/* + * Fixed constants. + */ +#define DNODE_SHIFT 9 /* 512 bytes */ +#define DN_MIN_INDBLKSHIFT 10 /* 1k */ +#define DN_MAX_INDBLKSHIFT 14 /* 16k */ +#define DNODE_BLOCK_SHIFT 14 /* 16k */ +#define DNODE_CORE_SIZE 64 /* 64 bytes for dnode sans blkptrs */ +#define DN_MAX_OBJECT_SHIFT 48 /* 256 trillion (zfs_fid_t limit) */ +#define DN_MAX_OFFSET_SHIFT 64 /* 2^64 bytes in a dnode */ + +/* + * Derived constants. + */ +#define DNODE_SIZE (1 << DNODE_SHIFT) +#define DN_MAX_NBLKPTR ((DNODE_SIZE - DNODE_CORE_SIZE) >> SPA_BLKPTRSHIFT) +#define DN_MAX_BONUSLEN (DNODE_SIZE - DNODE_CORE_SIZE - (1 << SPA_BLKPTRSHIFT)) +#define DN_MAX_OBJECT (1ULL << DN_MAX_OBJECT_SHIFT) + +#define DNODES_PER_BLOCK_SHIFT (DNODE_BLOCK_SHIFT - DNODE_SHIFT) +#define DNODES_PER_BLOCK (1ULL << DNODES_PER_BLOCK_SHIFT) +#define DNODES_PER_LEVEL_SHIFT (DN_MAX_INDBLKSHIFT - SPA_BLKPTRSHIFT) + +#define DNODE_FLAG_SPILL_BLKPTR (1<<2) + +#define DN_BONUS(dnp) ((void *)((dnp)->dn_bonus + \ + (((dnp)->dn_nblkptr - 1) * sizeof(blkptr_t)))) + +typedef struct dnode_phys { + uint8_t dn_type; /* dmu_object_type_t */ + uint8_t dn_indblkshift; /* ln2(indirect block size) */ + uint8_t dn_nlevels; /* 1=dn_blkptr->data blocks */ + uint8_t dn_nblkptr; /* length of dn_blkptr */ + uint8_t dn_bonustype; /* type of data in bonus buffer */ + uint8_t dn_checksum; /* ZIO_CHECKSUM type */ + uint8_t dn_compress; /* ZIO_COMPRESS type */ + uint8_t dn_flags; /* DNODE_FLAG_* */ + uint16_t dn_datablkszsec; /* data block size in 512b sectors */ + uint16_t dn_bonuslen; /* length of dn_bonus */ + uint8_t dn_pad2[4]; + + /* accounting is protected by dn_dirty_mtx */ + uint64_t dn_maxblkid; /* largest allocated block ID */ + uint64_t dn_used; /* bytes (or sectors) of disk space */ + + uint64_t dn_pad3[4]; + + blkptr_t dn_blkptr[1]; + uint8_t dn_bonus[DN_MAX_BONUSLEN - sizeof(blkptr_t)]; + blkptr_t dn_spill; +} dnode_phys_t; + +#endif /* _SYS_DNODE_H */ diff --git a/include/zfs/dsl_dataset.h b/include/zfs/dsl_dataset.h new file mode 100644 index 0000000000..ab0ee22a36 --- /dev/null +++ b/include/zfs/dsl_dataset.h @@ -0,0 +1,53 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright 2007 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _SYS_DSL_DATASET_H +#define _SYS_DSL_DATASET_H + +typedef struct dsl_dataset_phys { + uint64_t ds_dir_obj; + uint64_t ds_prev_snap_obj; + uint64_t ds_prev_snap_txg; + uint64_t ds_next_snap_obj; + uint64_t ds_snapnames_zapobj; /* zap obj of snaps; ==0 for snaps */ + uint64_t ds_num_children; /* clone/snap children; ==0 for head */ + uint64_t ds_creation_time; /* seconds since 1970 */ + uint64_t ds_creation_txg; + uint64_t ds_deadlist_obj; + uint64_t ds_used_bytes; + uint64_t ds_compressed_bytes; + uint64_t ds_uncompressed_bytes; + uint64_t ds_unique_bytes; /* only relevant to snapshots */ + /* + * The ds_fsid_guid is a 56-bit ID that can change to avoid + * collisions. The ds_guid is a 64-bit ID that will never + * change, so there is a small probability that it will collide. + */ + uint64_t ds_fsid_guid; + uint64_t ds_guid; + uint64_t ds_flags; + blkptr_t ds_bp; + uint64_t ds_pad[8]; /* pad out to 320 bytes for good measure */ +} dsl_dataset_phys_t; + +#endif /* _SYS_DSL_DATASET_H */ diff --git a/include/zfs/dsl_dir.h b/include/zfs/dsl_dir.h new file mode 100644 index 0000000000..54d6663366 --- /dev/null +++ b/include/zfs/dsl_dir.h @@ -0,0 +1,49 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright 2007 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _SYS_DSL_DIR_H +#define _SYS_DSL_DIR_H + +typedef struct dsl_dir_phys { + uint64_t dd_creation_time; /* not actually used */ + uint64_t dd_head_dataset_obj; + uint64_t dd_parent_obj; + uint64_t dd_clone_parent_obj; + uint64_t dd_child_dir_zapobj; + /* + * how much space our children are accounting for; for leaf + * datasets, == physical space used by fs + snaps + */ + uint64_t dd_used_bytes; + uint64_t dd_compressed_bytes; + uint64_t dd_uncompressed_bytes; + /* Administrative quota setting */ + uint64_t dd_quota; + /* Administrative reservation setting */ + uint64_t dd_reserved; + uint64_t dd_props_zapobj; + uint64_t dd_deleg_zapobj; /* dataset permissions */ + uint64_t dd_pad[20]; /* pad out to 256 bytes for good measure */ +} dsl_dir_phys_t; + +#endif /* _SYS_DSL_DIR_H */ diff --git a/include/zfs/sa_impl.h b/include/zfs/sa_impl.h new file mode 100644 index 0000000000..4d935586c5 --- /dev/null +++ b/include/zfs/sa_impl.h @@ -0,0 +1,35 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright 2010 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ +#ifndef _SYS_SA_IMPL_H +#define _SYS_SA_IMPL_H + +typedef struct sa_hdr_phys { + uint32_t sa_magic; + uint16_t sa_layout_info; + uint16_t sa_lengths[1]; +} sa_hdr_phys_t; + +#define SA_HDR_SIZE(hdr) BF32_GET_SB(hdr->sa_layout_info, 10, 16, 3, 0) +#define SA_SIZE_OFFSET 0x8 + +#endif /* _SYS_SA_IMPL_H */ diff --git a/include/zfs/spa.h b/include/zfs/spa.h new file mode 100644 index 0000000000..360cf897d6 --- /dev/null +++ b/include/zfs/spa.h @@ -0,0 +1,292 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved. + */ + +#ifndef ZFS_SPA_HEADER +#define ZFS_SPA_HEADER 1 + + +/* + * General-purpose 32-bit and 64-bit bitfield encodings. + */ +#define BF32_DECODE(x, low, len) P2PHASE((x) >> (low), 1U << (len)) +#define BF64_DECODE(x, low, len) P2PHASE((x) >> (low), 1ULL << (len)) +#define BF32_ENCODE(x, low, len) (P2PHASE((x), 1U << (len)) << (low)) +#define BF64_ENCODE(x, low, len) (P2PHASE((x), 1ULL << (len)) << (low)) + +#define BF32_GET(x, low, len) BF32_DECODE(x, low, len) +#define BF64_GET(x, low, len) BF64_DECODE(x, low, len) + +#define BF32_SET(x, low, len, val) \ + ((x) ^= BF32_ENCODE((x >> low) ^ (val), low, len)) +#define BF64_SET(x, low, len, val) \ + ((x) ^= BF64_ENCODE((x >> low) ^ (val), low, len)) + +#define BF32_GET_SB(x, low, len, shift, bias) \ + ((BF32_GET(x, low, len) + (bias)) << (shift)) +#define BF64_GET_SB(x, low, len, shift, bias) \ + ((BF64_GET(x, low, len) + (bias)) << (shift)) + +#define BF32_SET_SB(x, low, len, shift, bias, val) \ + BF32_SET(x, low, len, ((val) >> (shift)) - (bias)) +#define BF64_SET_SB(x, low, len, shift, bias, val) \ + BF64_SET(x, low, len, ((val) >> (shift)) - (bias)) + +/* + * We currently support nine block sizes, from 512 bytes to 128K. + * We could go higher, but the benefits are near-zero and the cost + * of COWing a giant block to modify one byte would become excessive. + */ +#define SPA_MINBLOCKSHIFT 9 +#define SPA_MAXBLOCKSHIFT 17 +#define SPA_MINBLOCKSIZE (1ULL << SPA_MINBLOCKSHIFT) +#define SPA_MAXBLOCKSIZE (1ULL << SPA_MAXBLOCKSHIFT) + +#define SPA_BLOCKSIZES (SPA_MAXBLOCKSHIFT - SPA_MINBLOCKSHIFT + 1) + +/* + * Size of block to hold the configuration data (a packed nvlist) + */ +#define SPA_CONFIG_BLOCKSIZE (1 << 14) + +/* + * The DVA size encodings for LSIZE and PSIZE support blocks up to 32MB. + * The ASIZE encoding should be at least 64 times larger (6 more bits) + * to support up to 4-way RAID-Z mirror mode with worst-case gang block + * overhead, three DVAs per bp, plus one more bit in case we do anything + * else that expands the ASIZE. + */ +#define SPA_LSIZEBITS 16 /* LSIZE up to 32M (2^16 * 512) */ +#define SPA_PSIZEBITS 16 /* PSIZE up to 32M (2^16 * 512) */ +#define SPA_ASIZEBITS 24 /* ASIZE up to 64 times larger */ + +/* + * All SPA data is represented by 128-bit data virtual addresses (DVAs). + * The members of the dva_t should be considered opaque outside the SPA. + */ +typedef struct dva { + uint64_t dva_word[2]; +} dva_t; + +/* + * Each block has a 256-bit checksum -- strong enough for cryptographic hashes. + */ +typedef struct zio_cksum { + uint64_t zc_word[4]; +} zio_cksum_t; + +/* + * Each block is described by its DVAs, time of birth, checksum, etc. + * The word-by-word, bit-by-bit layout of the blkptr is as follows: + * + * 64 56 48 40 32 24 16 8 0 + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * 0 | vdev1 | GRID | ASIZE | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * 1 |G| offset1 | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * 2 | vdev2 | GRID | ASIZE | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * 3 |G| offset2 | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * 4 | vdev3 | GRID | ASIZE | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * 5 |G| offset3 | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * 6 |BDX|lvl| type | cksum | comp | PSIZE | LSIZE | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * 7 | padding | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * 8 | padding | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * 9 | physical birth txg | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * a | logical birth txg | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * b | fill count | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * c | checksum[0] | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * d | checksum[1] | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * e | checksum[2] | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * f | checksum[3] | + * +-------+-------+-------+-------+-------+-------+-------+-------+ + * + * Legend: + * + * vdev virtual device ID + * offset offset into virtual device + * LSIZE logical size + * PSIZE physical size (after compression) + * ASIZE allocated size (including RAID-Z parity and gang block headers) + * GRID RAID-Z layout information (reserved for future use) + * cksum checksum function + * comp compression function + * G gang block indicator + * B byteorder (endianness) + * D dedup + * X unused + * lvl level of indirection + * type DMU object type + * phys birth txg of block allocation; zero if same as logical birth txg + * log. birth transaction group in which the block was logically born + * fill count number of non-zero blocks under this bp + * checksum[4] 256-bit checksum of the data this bp describes + */ +#define SPA_BLKPTRSHIFT 7 /* blkptr_t is 128 bytes */ +#define SPA_DVAS_PER_BP 3 /* Number of DVAs in a bp */ + +typedef struct blkptr { + dva_t blk_dva[SPA_DVAS_PER_BP]; /* Data Virtual Addresses */ + uint64_t blk_prop; /* size, compression, type, etc */ + uint64_t blk_pad[2]; /* Extra space for the future */ + uint64_t blk_phys_birth; /* txg when block was allocated */ + uint64_t blk_birth; /* transaction group at birth */ + uint64_t blk_fill; /* fill count */ + zio_cksum_t blk_cksum; /* 256-bit checksum */ +} blkptr_t; + +/* + * Macros to get and set fields in a bp or DVA. + */ +#define DVA_GET_ASIZE(dva) \ + BF64_GET_SB((dva)->dva_word[0], 0, 24, SPA_MINBLOCKSHIFT, 0) +#define DVA_SET_ASIZE(dva, x) \ + BF64_SET_SB((dva)->dva_word[0], 0, 24, SPA_MINBLOCKSHIFT, 0, x) + +#define DVA_GET_GRID(dva) BF64_GET((dva)->dva_word[0], 24, 8) +#define DVA_SET_GRID(dva, x) BF64_SET((dva)->dva_word[0], 24, 8, x) + +#define DVA_GET_VDEV(dva) BF64_GET((dva)->dva_word[0], 32, 32) +#define DVA_SET_VDEV(dva, x) BF64_SET((dva)->dva_word[0], 32, 32, x) + +#define DVA_GET_GANG(dva) BF64_GET((dva)->dva_word[1], 63, 1) +#define DVA_SET_GANG(dva, x) BF64_SET((dva)->dva_word[1], 63, 1, x) + +#define BP_GET_LSIZE(bp) \ + BF64_GET_SB((bp)->blk_prop, 0, 16, SPA_MINBLOCKSHIFT, 1) +#define BP_SET_LSIZE(bp, x) \ + BF64_SET_SB((bp)->blk_prop, 0, 16, SPA_MINBLOCKSHIFT, 1, x) + +#define BP_GET_COMPRESS(bp) BF64_GET((bp)->blk_prop, 32, 8) +#define BP_SET_COMPRESS(bp, x) BF64_SET((bp)->blk_prop, 32, 8, x) + +#define BP_GET_CHECKSUM(bp) BF64_GET((bp)->blk_prop, 40, 8) +#define BP_SET_CHECKSUM(bp, x) BF64_SET((bp)->blk_prop, 40, 8, x) + +#define BP_GET_TYPE(bp) BF64_GET((bp)->blk_prop, 48, 8) +#define BP_SET_TYPE(bp, x) BF64_SET((bp)->blk_prop, 48, 8, x) + +#define BP_GET_LEVEL(bp) BF64_GET((bp)->blk_prop, 56, 5) +#define BP_SET_LEVEL(bp, x) BF64_SET((bp)->blk_prop, 56, 5, x) + +#define BP_GET_PROP_BIT_61(bp) BF64_GET((bp)->blk_prop, 61, 1) +#define BP_SET_PROP_BIT_61(bp, x) BF64_SET((bp)->blk_prop, 61, 1, x) + +#define BP_GET_DEDUP(bp) BF64_GET((bp)->blk_prop, 62, 1) +#define BP_SET_DEDUP(bp, x) BF64_SET((bp)->blk_prop, 62, 1, x) + +#define BP_GET_BYTEORDER(bp) (0 - BF64_GET((bp)->blk_prop, 63, 1)) +#define BP_SET_BYTEORDER(bp, x) BF64_SET((bp)->blk_prop, 63, 1, x) + +#define BP_PHYSICAL_BIRTH(bp) \ + ((bp)->blk_phys_birth ? (bp)->blk_phys_birth : (bp)->blk_birth) + +#define BP_SET_BIRTH(bp, logical, physical) \ + { \ + (bp)->blk_birth = (logical); \ + (bp)->blk_phys_birth = ((logical) == (physical) ? 0 : (physical)); \ + } + +#define BP_GET_ASIZE(bp) \ + (DVA_GET_ASIZE(&(bp)->blk_dva[0]) + DVA_GET_ASIZE(&(bp)->blk_dva[1]) + \ + DVA_GET_ASIZE(&(bp)->blk_dva[2])) + +#define BP_GET_UCSIZE(bp) \ + ((BP_GET_LEVEL(bp) > 0 || dmu_ot[BP_GET_TYPE(bp)].ot_metadata) ? \ + BP_GET_PSIZE(bp) : BP_GET_LSIZE(bp)); + +#define BP_GET_NDVAS(bp) \ + (!!DVA_GET_ASIZE(&(bp)->blk_dva[0]) + \ + !!DVA_GET_ASIZE(&(bp)->blk_dva[1]) + \ + !!DVA_GET_ASIZE(&(bp)->blk_dva[2])) + +#define BP_COUNT_GANG(bp) \ + (DVA_GET_GANG(&(bp)->blk_dva[0]) + \ + DVA_GET_GANG(&(bp)->blk_dva[1]) + \ + DVA_GET_GANG(&(bp)->blk_dva[2])) + +#define DVA_EQUAL(dva1, dva2) \ + ((dva1)->dva_word[1] == (dva2)->dva_word[1] && \ + (dva1)->dva_word[0] == (dva2)->dva_word[0]) + +#define BP_EQUAL(bp1, bp2) \ + (BP_PHYSICAL_BIRTH(bp1) == BP_PHYSICAL_BIRTH(bp2) && \ + DVA_EQUAL(&(bp1)->blk_dva[0], &(bp2)->blk_dva[0]) && \ + DVA_EQUAL(&(bp1)->blk_dva[1], &(bp2)->blk_dva[1]) && \ + DVA_EQUAL(&(bp1)->blk_dva[2], &(bp2)->blk_dva[2])) + +#define ZIO_CHECKSUM_EQUAL(zc1, zc2) \ + (0 == (((zc1).zc_word[0] - (zc2).zc_word[0]) | \ + ((zc1).zc_word[1] - (zc2).zc_word[1]) | \ + ((zc1).zc_word[2] - (zc2).zc_word[2]) | \ + ((zc1).zc_word[3] - (zc2).zc_word[3]))) + +#define DVA_IS_VALID(dva) (DVA_GET_ASIZE(dva) != 0) + +#define ZIO_SET_CHECKSUM(zcp, w0, w1, w2, w3) \ + { \ + (zcp)->zc_word[0] = w0; \ + (zcp)->zc_word[1] = w1; \ + (zcp)->zc_word[2] = w2; \ + (zcp)->zc_word[3] = w3; \ + } + +#define BP_IDENTITY(bp) (&(bp)->blk_dva[0]) +#define BP_IS_GANG(bp) DVA_GET_GANG(BP_IDENTITY(bp)) +#define BP_IS_HOLE(bp) ((bp)->blk_birth == 0) + +/* BP_IS_RAIDZ(bp) assumes no block compression */ +#define BP_IS_RAIDZ(bp) (DVA_GET_ASIZE(&(bp)->blk_dva[0]) > \ + BP_GET_PSIZE(bp)) + +#define BP_ZERO(bp) \ + { \ + (bp)->blk_dva[0].dva_word[0] = 0; \ + (bp)->blk_dva[0].dva_word[1] = 0; \ + (bp)->blk_dva[1].dva_word[0] = 0; \ + (bp)->blk_dva[1].dva_word[1] = 0; \ + (bp)->blk_dva[2].dva_word[0] = 0; \ + (bp)->blk_dva[2].dva_word[1] = 0; \ + (bp)->blk_prop = 0; \ + (bp)->blk_pad[0] = 0; \ + (bp)->blk_pad[1] = 0; \ + (bp)->blk_phys_birth = 0; \ + (bp)->blk_birth = 0; \ + (bp)->blk_fill = 0; \ + ZIO_SET_CHECKSUM(&(bp)->blk_cksum, 0, 0, 0, 0); \ + } + +#define BP_SPRINTF_LEN 320 + +#endif /* ! ZFS_SPA_HEADER */ diff --git a/include/zfs/uberblock_impl.h b/include/zfs/uberblock_impl.h new file mode 100644 index 0000000000..806da9585c --- /dev/null +++ b/include/zfs/uberblock_impl.h @@ -0,0 +1,57 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright 2007 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _SYS_UBERBLOCK_IMPL_H +#define _SYS_UBERBLOCK_IMPL_H + +#define UBMAX(a, b) ((a) > (b) ? (a) : (b)) + +/* + * The uberblock version is incremented whenever an incompatible on-disk + * format change is made to the SPA, DMU, or ZAP. + * + * Note: the first two fields should never be moved. When a storage pool + * is opened, the uberblock must be read off the disk before the version + * can be checked. If the ub_version field is moved, we may not detect + * version mismatch. If the ub_magic field is moved, applications that + * expect the magic number in the first word won't work. + */ +#define UBERBLOCK_MAGIC 0x00bab10c /* oo-ba-bloc! */ +#define UBERBLOCK_SHIFT 10 /* up to 1K */ + +typedef struct uberblock { + uint64_t ub_magic; /* UBERBLOCK_MAGIC */ + uint64_t ub_version; /* ZFS_VERSION */ + uint64_t ub_txg; /* txg of last sync */ + uint64_t ub_guid_sum; /* sum of all vdev guids */ + uint64_t ub_timestamp; /* UTC time of last sync */ + blkptr_t ub_rootbp; /* MOS objset_phys_t */ +} uberblock_t; + +#define VDEV_UBERBLOCK_SHIFT(as) UBMAX(as, UBERBLOCK_SHIFT) +#define UBERBLOCK_SIZE(as) (1ULL << VDEV_UBERBLOCK_SHIFT(as)) + +/* Number of uberblocks that can fit in the ring at a given ashift */ +#define UBERBLOCK_COUNT(as) (VDEV_UBERBLOCK_RING >> VDEV_UBERBLOCK_SHIFT(as)) + +#endif /* _SYS_UBERBLOCK_IMPL_H */ diff --git a/include/zfs/vdev_impl.h b/include/zfs/vdev_impl.h new file mode 100644 index 0000000000..3aa646ea8c --- /dev/null +++ b/include/zfs/vdev_impl.h @@ -0,0 +1,70 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright 2010 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _SYS_VDEV_IMPL_H +#define _SYS_VDEV_IMPL_H + +#define VDEV_SKIP_SIZE (8 << 10) +#define VDEV_BOOT_HEADER_SIZE (8 << 10) +#define VDEV_PHYS_SIZE (112 << 10) +#define VDEV_UBERBLOCK_RING (128 << 10) + +/* ZFS boot block */ +#define VDEV_BOOT_MAGIC 0x2f5b007b10cULL +#define VDEV_BOOT_VERSION 1 /* version number */ + +typedef struct vdev_boot_header { + uint64_t vb_magic; /* VDEV_BOOT_MAGIC */ + uint64_t vb_version; /* VDEV_BOOT_VERSION */ + uint64_t vb_offset; /* start offset (bytes) */ + uint64_t vb_size; /* size (bytes) */ + char vb_pad[VDEV_BOOT_HEADER_SIZE - 4 * sizeof(uint64_t)]; +} vdev_boot_header_t; + +typedef struct vdev_phys { + char vp_nvlist[VDEV_PHYS_SIZE - sizeof(zio_eck_t)]; + zio_eck_t vp_zbt; +} vdev_phys_t; + +typedef struct vdev_label { + char vl_pad[VDEV_SKIP_SIZE]; /* 8K */ + vdev_boot_header_t vl_boot_header; /* 8K */ + vdev_phys_t vl_vdev_phys; /* 112K */ + char vl_uberblock[VDEV_UBERBLOCK_RING]; /* 128K */ +} vdev_label_t; /* 256K total */ + +/* + * Size and offset of embedded boot loader region on each label. + * The total size of the first two labels plus the boot area is 4MB. + */ +#define VDEV_BOOT_OFFSET (2 * sizeof(vdev_label_t)) +#define VDEV_BOOT_SIZE (7ULL << 19) /* 3.5M */ + +/* + * Size of label regions at the start and end of each leaf device. + */ +#define VDEV_LABEL_START_SIZE (2 * sizeof(vdev_label_t) + VDEV_BOOT_SIZE) +#define VDEV_LABEL_END_SIZE (2 * sizeof(vdev_label_t)) +#define VDEV_LABELS 4 + +#endif /* _SYS_VDEV_IMPL_H */ diff --git a/include/zfs/zap_impl.h b/include/zfs/zap_impl.h new file mode 100644 index 0000000000..5d24ab06fe --- /dev/null +++ b/include/zfs/zap_impl.h @@ -0,0 +1,111 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved. + */ + +#ifndef _SYS_ZAP_IMPL_H +#define _SYS_ZAP_IMPL_H + +#define ZAP_MAGIC 0x2F52AB2ABULL + +#define ZAP_HASHBITS 28 +#define MZAP_ENT_LEN 64 +#define MZAP_NAME_LEN (MZAP_ENT_LEN - 8 - 4 - 2) +#define MZAP_MAX_BLKSHIFT SPA_MAXBLOCKSHIFT +#define MZAP_MAX_BLKSZ (1 << MZAP_MAX_BLKSHIFT) + +typedef struct mzap_ent_phys { + uint64_t mze_value; + uint32_t mze_cd; + uint16_t mze_pad; /* in case we want to chain them someday */ + char mze_name[MZAP_NAME_LEN]; +} mzap_ent_phys_t; + +typedef struct mzap_phys { + uint64_t mz_block_type; /* ZBT_MICRO */ + uint64_t mz_salt; + uint64_t mz_pad[6]; + mzap_ent_phys_t mz_chunk[1]; + /* actually variable size depending on block size */ +} mzap_phys_t; + +/* + * The (fat) zap is stored in one object. It is an array of + * 1<= 6] [zap_leaf_t] [ptrtbl] ... + * + */ + +#define ZBT_LEAF ((1ULL << 63) + 0) +#define ZBT_HEADER ((1ULL << 63) + 1) +#define ZBT_MICRO ((1ULL << 63) + 3) +/* any other values are ptrtbl blocks */ + +/* + * the embedded pointer table takes up half a block: + * block size / entry size (2^3) / 2 + */ +#define ZAP_EMBEDDED_PTRTBL_SHIFT(zap) (FZAP_BLOCK_SHIFT(zap) - 3 - 1) + +/* + * The embedded pointer table starts half-way through the block. Since + * the pointer table itself is half the block, it starts at (64-bit) + * word number (1<zap_f.zap_phys) \ + [(idx) + (1< + +#define MASTER_NODE_OBJ 1 +#define ZFS_ROOT_OBJ "ROOT" +#define ZPL_VERSION_STR "VERSION" +#define ZFS_SA_ATTRS "SA_ATTRS" + +#define ZPL_VERSION 5ULL + +#define ZFS_DIRENT_OBJ(de) BF64_GET(de, 0, 48) + +/* + * This is the persistent portion of the znode. It is stored + * in the "bonus buffer" of the file. Short symbolic links + * are also stored in the bonus buffer. + */ +typedef struct znode_phys { + uint64_t zp_atime[2]; /* 0 - last file access time */ + uint64_t zp_mtime[2]; /* 16 - last file modification time */ + uint64_t zp_ctime[2]; /* 32 - last file change time */ + uint64_t zp_crtime[2]; /* 48 - creation time */ + uint64_t zp_gen; /* 64 - generation (txg of creation) */ + uint64_t zp_mode; /* 72 - file mode bits */ + uint64_t zp_size; /* 80 - size of file */ + uint64_t zp_parent; /* 88 - directory parent (`..') */ + uint64_t zp_links; /* 96 - number of links to file */ + uint64_t zp_xattr; /* 104 - DMU object for xattrs */ + uint64_t zp_rdev; /* 112 - dev_t for VBLK & VCHR files */ + uint64_t zp_flags; /* 120 - persistent flags */ + uint64_t zp_uid; /* 128 - file owner */ + uint64_t zp_gid; /* 136 - owning group */ + uint64_t zp_pad[4]; /* 144 - future */ + zfs_znode_acl_t zp_acl; /* 176 - 263 ACL */ + /* + * Data may pad out any remaining bytes in the znode buffer, eg: + * + * |<---------------------- dnode_phys (512) ------------------------>| + * |<-- dnode (192) --->|<----------- "bonus" buffer (320) ---------->| + * |<---- znode (264) ---->|<---- data (56) ---->| + * + * At present, we only use this space to store symbolic links. + */ +} znode_phys_t; + +#endif /* _SYS_FS_ZFS_ZNODE_H */ diff --git a/include/zfs/zil.h b/include/zfs/zil.h new file mode 100644 index 0000000000..036573aa7f --- /dev/null +++ b/include/zfs/zil.h @@ -0,0 +1,57 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _SYS_ZIL_H +#define _SYS_ZIL_H + +/* + * Intent log format: + * + * Each objset has its own intent log. The log header (zil_header_t) + * for objset N's intent log is kept in the Nth object of the SPA's + * intent_log objset. The log header points to a chain of log blocks, + * each of which contains log records (i.e., transactions) followed by + * a log block trailer (zil_trailer_t). The format of a log record + * depends on the record (or transaction) type, but all records begin + * with a common structure that defines the type, length, and txg. + */ + +/* + * Intent log header - this on disk structure holds fields to manage + * the log. All fields are 64 bit to easily handle cross architectures. + */ +typedef struct zil_header { + uint64_t zh_claim_txg; /* txg in which log blocks were claimed */ + uint64_t zh_replay_seq; /* highest replayed sequence number */ + blkptr_t zh_log; /* log chain */ + uint64_t zh_claim_seq; /* highest claimed sequence number */ + uint64_t zh_flags; /* header flags */ + uint64_t zh_pad[4]; +} zil_header_t; + +/* + * zh_flags bit settings + */ +#define ZIL_REPLAY_NEEDED 0x1 /* replay needed - internal only */ + +#endif /* _SYS_ZIL_H */ diff --git a/include/zfs/zio.h b/include/zfs/zio.h new file mode 100644 index 0000000000..4adb14cb04 --- /dev/null +++ b/include/zfs/zio.h @@ -0,0 +1,92 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. + */ + +#ifndef _ZIO_H +#define _ZIO_H + +#include + +#define ZEC_MAGIC 0x210da7ab10c7a11ULL /* zio data bloc tail */ + +typedef struct zio_eck { + uint64_t zec_magic; /* for validation, endianness */ + zio_cksum_t zec_cksum; /* 256-bit checksum */ +} zio_eck_t; + +/* + * Gang block headers are self-checksumming and contain an array + * of block pointers. + */ +#define SPA_GANGBLOCKSIZE SPA_MINBLOCKSIZE +#define SPA_GBH_NBLKPTRS ((SPA_GANGBLOCKSIZE - \ + sizeof(zio_eck_t)) / sizeof(blkptr_t)) +#define SPA_GBH_FILLER ((SPA_GANGBLOCKSIZE - \ + sizeof(zio_eck_t) - \ + (SPA_GBH_NBLKPTRS * sizeof(blkptr_t))) /\ + sizeof(uint64_t)) + +#define ZIO_GET_IOSIZE(zio) \ + (BP_IS_GANG((zio)->io_bp) ? \ + SPA_GANGBLOCKSIZE : BP_GET_PSIZE((zio)->io_bp)) + +typedef struct zio_gbh { + blkptr_t zg_blkptr[SPA_GBH_NBLKPTRS]; + uint64_t zg_filler[SPA_GBH_FILLER]; + zio_eck_t zg_tail; +} zio_gbh_phys_t; + +enum zio_checksum { + ZIO_CHECKSUM_INHERIT = 0, + ZIO_CHECKSUM_ON, + ZIO_CHECKSUM_OFF, + ZIO_CHECKSUM_LABEL, + ZIO_CHECKSUM_GANG_HEADER, + ZIO_CHECKSUM_ZILOG, + ZIO_CHECKSUM_FLETCHER_2, + ZIO_CHECKSUM_FLETCHER_4, + ZIO_CHECKSUM_SHA256, + ZIO_CHECKSUM_ZILOG2, + ZIO_CHECKSUM_FUNCTIONS +}; + +#define ZIO_CHECKSUM_ON_VALUE ZIO_CHECKSUM_FLETCHER_2 +#define ZIO_CHECKSUM_DEFAULT ZIO_CHECKSUM_ON + +enum zio_compress { + ZIO_COMPRESS_INHERIT = 0, + ZIO_COMPRESS_ON, + ZIO_COMPRESS_OFF, + ZIO_COMPRESS_LZJB, + ZIO_COMPRESS_EMPTY, + ZIO_COMPRESS_GZIP1, + ZIO_COMPRESS_GZIP2, + ZIO_COMPRESS_GZIP3, + ZIO_COMPRESS_GZIP4, + ZIO_COMPRESS_GZIP5, + ZIO_COMPRESS_GZIP6, + ZIO_COMPRESS_GZIP7, + ZIO_COMPRESS_GZIP8, + ZIO_COMPRESS_GZIP9, + ZIO_COMPRESS_FUNCTIONS +}; + +#endif /* _ZIO_H */ diff --git a/include/zfs/zio_checksum.h b/include/zfs/zio_checksum.h new file mode 100644 index 0000000000..0d5fce6653 --- /dev/null +++ b/include/zfs/zio_checksum.h @@ -0,0 +1,50 @@ +/* + * GRUB -- GRand Unified Bootloader + * Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +/* + * Copyright 2010 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _SYS_ZIO_CHECKSUM_H +#define _SYS_ZIO_CHECKSUM_H + +/* + * Signature for checksum functions. + */ +typedef void zio_checksum_t(const void *data, uint64_t size, + zfs_endian_t endian, zio_cksum_t *zcp); + +/* + * Information about each checksum function. + */ +typedef struct zio_checksum_info { + zio_checksum_t *ci_func; /* checksum function for each byteorder */ + int ci_correctable; /* number of correctable bits */ + int ci_eck; /* uses zio embedded checksum? */ + char *ci_name; /* descriptive name */ +} zio_checksum_info_t; + +extern void zio_checksum_SHA256(const void *, uint64_t, + zfs_endian_t endian, zio_cksum_t *); +extern void fletcher_2_endian(const void *, uint64_t, zfs_endian_t endian, + zio_cksum_t *); +extern void fletcher_4_endian(const void *, uint64_t, zfs_endian_t endian, + zio_cksum_t *); + +#endif /* _SYS_ZIO_CHECKSUM_H */ diff --git a/include/zfs_common.h b/include/zfs_common.h new file mode 100644 index 0000000000..04e73d0cd2 --- /dev/null +++ b/include/zfs_common.h @@ -0,0 +1,109 @@ +/* + * ZFS filesystem port for Uboot by + * Jorgen Lundman + * + * zfsfs support + * made from existing GRUB Sources by Sun, GNU and others. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef __ZFS_COMMON__ +#define __ZFS_COMMON__ + +#define SECTOR_SIZE 0x200 +#define SECTOR_BITS 9 + + +typedef enum zfs_endian { + UNKNOWN_ENDIAN = -2, + LITTLE_ENDIAN = -1, + BIG_ENDIAN = 0 +} zfs_endian_t; + + +/* Endian macros. */ +#define zfs_to_cpu16(x, a) (((a) == BIG_ENDIAN) ? be16_to_cpu(x) \ + : le16_to_cpu(x)) +#define cpu_to_zfs16(x, a) (((a) == BIG_ENDIAN) ? cpu_to_be16(x) \ + : cpu_to_le16(x)) + +#define zfs_to_cpu32(x, a) (((a) == BIG_ENDIAN) ? be32_to_cpu(x) \ + : le32_to_cpu(x)) +#define cpu_to_zfs32(x, a) (((a) == BIG_ENDIAN) ? cpu_to_be32(x) \ + : cpu_to_le32(x)) + +#define zfs_to_cpu64(x, a) (((a) == BIG_ENDIAN) ? be64_to_cpu(x) \ + : le64_to_cpu(x)) +#define cpu_to_zfs64(x, a) (((a) == BIG_ENDIAN) ? cpu_to_be64(x) \ + : cpu_to_le64(x)) + + +enum zfs_errors { + ZFS_ERR_NONE = 0, + ZFS_ERR_NOT_IMPLEMENTED_YET = -1, + ZFS_ERR_BAD_FS = -2, + ZFS_ERR_OUT_OF_MEMORY = -3, + ZFS_ERR_FILE_NOT_FOUND = -4, + ZFS_ERR_BAD_FILE_TYPE = -5, + ZFS_ERR_OUT_OF_RANGE = -6, +}; + +struct zfs_filesystem { + + /* Block Device Descriptor */ + block_dev_desc_t *dev_desc; +}; + + +extern block_dev_desc_t *zfs_dev_desc; + +struct device_s { + uint64_t part_length; +}; +typedef struct device_s *device_t; + +struct zfs_file { + device_t device; + uint64_t size; + void *data; + uint64_t offset; +}; + +typedef struct zfs_file *zfs_file_t; + +struct zfs_dirhook_info { + int dir; + int mtimeset; + time_t mtime; + time_t mtime2; +}; + + + + +struct zfs_filesystem *zfsget_fs(void); +int init_fs(block_dev_desc_t *dev_desc); +void deinit_fs(block_dev_desc_t *dev_desc); +int zfs_open(zfs_file_t, const char *filename); +uint64_t zfs_read(zfs_file_t, char *buf, uint64_t len); +struct zfs_data *zfs_mount(device_t); +int zfs_close(zfs_file_t); +int zfs_ls(device_t dev, const char *path, + int (*hook) (const char *, const struct zfs_dirhook_info *)); +int zfs_devread(int sector, int byte_offset, int byte_len, char *buf); +int zfs_set_blk_dev(block_dev_desc_t *rbdd, int part); +void zfs_unmount(struct zfs_data *data); +int lzjb_decompress(void *, void *, uint32_t, uint32_t); +#endif -- 2.39.5