/*

 *  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.

 */

/*

 * 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.

 *

 * ZFS_SCRATCH is used as a working area.

 *

 * (memory addr)   MOS      DNODE	ZFS_SCRATCH

 *		    |         |          |

 *	    +-------V---------V----------V---------------+

 *   memory |       | dnode   | dnode    |  scratch      |

 *	    |       | 512B    | 512B     |  area         |

 *	    +--------------------------------------------+

 */

#ifdef	FSYS_ZFS

#include "shared.h"

#include "filesys.h"

#include "fsys_zfs.h"

/* cache for a file block of the currently zfs_open()-ed file */

static void *file_buf = NULL;

static uint64_t file_start = 0;

static uint64_t file_end = 0;

/* cache for a dnode block */

static dnode_phys_t *dnode_buf = NULL;

static dnode_phys_t *dnode_mdn = NULL;

static uint64_t dnode_start = 0;

static uint64_t dnode_end = 0;

static uint64_t pool_guid = 0;

static uberblock_t current_uberblock;

static char *stackbase;

decomp_entry_t decomp_table[ZIO_COMPRESS_FUNCTIONS] =

{

	{"inherit", 0},			/* ZIO_COMPRESS_INHERIT */

	{"on", lzjb_decompress}, 	/* ZIO_COMPRESS_ON */

	{"off", 0},			/* ZIO_COMPRESS_OFF */

	{"lzjb", lzjb_decompress},	/* ZIO_COMPRESS_LZJB */

	{"empty", 0}			/* ZIO_COMPRESS_EMPTY */

};

static int zio_read_data(blkptr_t *bp, void *buf, char *stack);

/*

 * Our own version of bcmp().

 */

static int

zfs_bcmp(const void *s1, const void *s2, size_t n)

{

	const uchar_t *ps1 = s1;

	const uchar_t *ps2 = s2;

	if (s1 != s2 && n != 0) {

		do {

			if (*ps1++ != *ps2++)

				return (1);

		} while (--n != 0);

	}

	return (0);

}

/*

 * 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, uint64_t size, zio_cksum_t *zcp)

{

	ZIO_SET_CHECKSUM(zcp, 0, 0, 0, 0);

}

/* Checksum Table and Values */

zio_checksum_info_t zio_checksum_table[ZIO_CHECKSUM_FUNCTIONS] = {

};

/*

 * zio_checksum_verify: Provides support for checksum verification.

 *

 * Fletcher2, Fletcher4, and SHA256 are supported.

 *

 * Return:

 * 	-1 = Failure

 *	 0 = Success

 */

static int

zio_checksum_verify(blkptr_t *bp, char *data, int size)

{

	zio_cksum_t zc = bp->blk_cksum;

	uint32_t checksum = BP_GET_CHECKSUM(bp);

	int byteswap = BP_SHOULD_BYTESWAP(bp);

	zio_eck_t *zec = (zio_eck_t *)(data + size) - 1;

	zio_checksum_info_t *ci = &zio_checksum_table[checksum];

	zio_cksum_t actual_cksum, expected_cksum;

	/* byteswap is not supported */

	if (byteswap)

		return (-1);

	if (checksum >= ZIO_CHECKSUM_FUNCTIONS || ci->ci_func[0] == NULL)

		return (-1);

	if (ci->ci_eck) {

		expected_cksum = zec->zec_cksum;

		zec->zec_cksum = zc;

		ci->ci_func[0](data, size, &actual_cksum);

		zec->zec_cksum = expected_cksum;

		zc = expected_cksum;

	} else {

		ci->ci_func[byteswap](data, size, &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 (-1);

	return (0);

}

/*

 * 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)));

}

/*

 * 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)

{

	if (ub1->ub_txg < ub2->ub_txg)

		return (-1);

	if (ub1->ub_txg > ub2->ub_txg)

		return (1);

	if (ub1->ub_timestamp < ub2->ub_timestamp)

		return (-1);

	if (ub1->ub_timestamp > ub2->ub_timestamp)

		return (1);

	return (0);

}

/*

 * Three pieces of information are needed to verify an uberblock: the magic

 * number, the version number, and the checksum.

 *

 * Return:

 *     0 - Success

 *    -1 - Failure

 */

static int

uberblock_verify(uberblock_t *uber, uint64_t ub_size, uint64_t offset)

{

	blkptr_t bp;

	BP_ZERO(&bp);

	BP_SET_CHECKSUM(&bp, ZIO_CHECKSUM_LABEL);

	BP_SET_BYTEORDER(&bp, ZFS_HOST_BYTEORDER);

	ZIO_SET_CHECKSUM(&bp.blk_cksum, offset, 0, 0, 0);

	if (zio_checksum_verify(&bp, (char *)uber, ub_size) != 0)

		return (-1);

	if (uber->ub_magic == UBERBLOCK_MAGIC &&

		return (0);

	return (-1);

}

/*

 * Find the best uberblock.

 * Return:

 *    Success - Pointer to the best uberblock.

 *    Failure - NULL

 */

static uberblock_t *

find_bestub(char *ub_array, uint64_t ashift, uint64_t sector)

{

	uberblock_t *ubbest = NULL;

	uberblock_t *ubnext;

	uint64_t offset, ub_size;

	int i;

	ub_size = VDEV_UBERBLOCK_SIZE(ashift);

	for (i = 0; i < VDEV_UBERBLOCK_COUNT(ashift); i++) {

		ubnext = (uberblock_t *)ub_array;

		ub_array += ub_size;

		offset = (sector << SPA_MINBLOCKSHIFT) +

		    VDEV_UBERBLOCK_OFFSET(ashift, i);

		if (uberblock_verify(ubnext, ub_size, offset) != 0)

			continue;

		if (ubbest == NULL ||

		    vdev_uberblock_compare(ubnext, ubbest) > 0)

			ubbest = ubnext;

	}

	return (ubbest);

}

/*

 * Read a block of data based on the gang block address dva,

 * and put its data in buf.

 *

 * Return:

 *	0 - success

 *	1 - failure

 */

static int

zio_read_gang(blkptr_t *bp, dva_t *dva, void *buf, char *stack)

{

	zio_gbh_phys_t *zio_gb;

	uint64_t offset, sector;

	blkptr_t tmpbp;

	int i;

	zio_gb = (zio_gbh_phys_t *)stack;

	stack += SPA_GANGBLOCKSIZE;

	offset = DVA_GET_OFFSET(dva);

	/* read in the gang block header */

	if (devread(sector, 0, SPA_GANGBLOCKSIZE, (char *)zio_gb) == 0) {

		grub_printf("failed to read in a gang block header\n");

		return (1);

	}

	/* self checksuming the gang block header */

	BP_ZERO(&tmpbp);

	BP_SET_CHECKSUM(&tmpbp, ZIO_CHECKSUM_GANG_HEADER);

	BP_SET_BYTEORDER(&tmpbp, ZFS_HOST_BYTEORDER);

	ZIO_SET_CHECKSUM(&tmpbp.blk_cksum, DVA_GET_VDEV(dva),

	    DVA_GET_OFFSET(dva), bp->blk_birth, 0);

	if (zio_checksum_verify(&tmpbp, (char *)zio_gb, SPA_GANGBLOCKSIZE)) {

		grub_printf("failed to checksum a gang block header\n");

		return (1);

	}

	for (i = 0; i < SPA_GBH_NBLKPTRS; i++) {

		if (zio_gb->zg_blkptr[i].blk_birth == 0)

			continue;

		if (zio_read_data(&zio_gb->zg_blkptr[i], buf, stack))

			return (1);

		buf += BP_GET_PSIZE(&zio_gb->zg_blkptr[i]);

	}

	return (0);

}

/*

 * Read in a block of raw data to buf.

 *

 * Return:

 *	0 - success

 *	1 - failure

 */

static int

zio_read_data(blkptr_t *bp, void *buf, char *stack)

{

	int i, psize;

	psize = BP_GET_PSIZE(bp);

	/* 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 (DVA_GET_GANG(&bp->blk_dva[i])) {

			if (zio_read_gang(bp, &bp->blk_dva[i], buf, stack) == 0)

				return (0);

		} else {

			/* read in a data block */

			offset = DVA_GET_OFFSET(&bp->blk_dva[i]);

				return (0);

		}

	}

	return (1);

}

/*

 * Read in a block of data, verify its checksum, decompress if needed,

 * and put the uncompressed data in buf.

 *

 * Return:

 *	0 - success

 *	errnum - failure

 */

static int

zio_read(blkptr_t *bp, void *buf, char *stack)

{

	int lsize, psize, comp;

	char *retbuf;

	comp = BP_GET_COMPRESS(bp);

	lsize = BP_GET_LSIZE(bp);

	psize = BP_GET_PSIZE(bp);

	if ((unsigned int)comp >= ZIO_COMPRESS_FUNCTIONS ||

	    (comp != ZIO_COMPRESS_OFF &&

	    decomp_table[comp].decomp_func == NULL)) {

		grub_printf("compression algorithm not supported\n");

		return (ERR_FSYS_CORRUPT);

	}

	if ((char *)buf < stack && ((char *)buf) + lsize > stack) {

		grub_printf("not enough memory allocated\n");

		return (ERR_WONT_FIT);

	}

	retbuf = buf;

	if (comp != ZIO_COMPRESS_OFF) {

		buf = stack;

		stack += psize;

	}

		grub_printf("zio_read_data failed\n");

		return (ERR_FSYS_CORRUPT);

	}

	if (zio_checksum_verify(bp, buf, psize) != 0) {

		grub_printf("checksum verification failed\n");

		return (ERR_FSYS_CORRUPT);

	}

	if (comp != ZIO_COMPRESS_OFF)

		decomp_table[comp].decomp_func(buf, retbuf, psize, lsize);

	return (0);

}

/*

 * Get the block from a block id.

 * push the block onto the stack.

 *

 * Return:

 * 	0 - success

 * 	errnum - failure

 */

static int

dmu_read(dnode_phys_t *dn, uint64_t blkid, void *buf, char *stack)

{

	int idx, level;

	blkptr_t *bp_array = dn->dn_blkptr;

	int epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;

	blkptr_t *bp, *tmpbuf;

	bp = (blkptr_t *)stack;

	stack += sizeof (blkptr_t);

	tmpbuf = (blkptr_t *)stack;

	stack += 1<<dn->dn_indblkshift;

	for (level = dn->dn_nlevels - 1; level >= 0; level--) {

		idx = (blkid >> (epbs * level)) & ((1<<epbs)-1);

		*bp = bp_array[idx];

		if (level == 0)

			tmpbuf = buf;

		if (BP_IS_HOLE(bp)) {

			grub_memset(buf, 0,

			    dn->dn_datablkszsec << SPA_MINBLOCKSHIFT);

			break;

		} else if (errnum = zio_read(bp, tmpbuf, stack)) {

			return (errnum);

		}

		bp_array = tmpbuf;

	}

	return (0);

}

/*

 * mzap_lookup: Looks up property described by "name" and returns the value

 * in "value".

 *

 * Return:

 *	0 - success

 *	errnum - failure

 */

static int

	uint64_t *value)

{

	int i, chunks;

	mzap_ent_phys_t *mzap_ent = zapobj->mz_chunk;

	for (i = 0; i < chunks; i++) {

		if (grub_strcmp(mzap_ent[i].mze_name, name) == 0) {

			*value = mzap_ent[i].mze_value;

			return (0);

		}

	}

	return (ERR_FSYS_CORRUPT);

}

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);

		}

	}

	if (crc == 0 || table[128] != ZFS_CRC64_POLY) {

		errnum = ERR_FSYS_CORRUPT;

		return (0);

	}