bookmark.xd

#!/usr/sbin/dtrace -Cs

#define	P2PHASE(x, align)		((x) & ((align) - 1))

#define	BF64_DECODE(x, low, len)	P2PHASE((x) >> (low), 1ULL << (len))

#define	BF64_GET(x, low, len)		BF64_DECODE(x, low, len)

#define	BF64_GET_SB(x, low, len, shift, bias)	\
    	((BF64_GET(x, low, len) + (bias)) << (shift))


#define	SPA_MINBLOCKSHIFT	9
#define	SPA_MAXBLOCKSHIFT	17
#define	SPA_MINBLOCKSIZE	(1ULL << SPA_MINBLOCKSHIFT)
#define	SPA_MAXBLOCKSIZE	(1ULL << SPA_MAXBLOCKSHIFT)

#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	*/

#define	SPA_BLKPTRSHIFT	7		/* blkptr_t is 128 bytes	*/
#define	SPA_DVAS_PER_BP	3		/* Number of DVAs in a bp	*/

#define	BPE_GET_ETYPE(bp)	\
 	BF64_GET((bp)->blk_prop, 40, 8)
#define	BPE_GET_LSIZE(bp)	\
    	BF64_GET_SB((bp)->blk_prop, 0, 25, 0, 1)
#define	BPE_GET_PSIZE(bp)	\
 	BF64_GET_SB((bp)->blk_prop, 25, 7, 0, 1)

#define	DVA_GET_ASIZE(dva)	\
	BF64_GET_SB((dva)->dva_word[0], 0, 24, SPA_MINBLOCKSHIFT, 0)

#define	DVA_GET_GRID(dva)	BF64_GET((dva)->dva_word[0], 24, 8)

#define	DVA_GET_VDEV(dva)	BF64_GET((dva)->dva_word[0], 32, 32)

#define	DVA_GET_OFFSET(dva)	\
	BF64_GET_SB((dva)->dva_word[1], 0, 63, SPA_MINBLOCKSHIFT, 0)

#define	DVA_GET_GANG(dva)	BF64_GET((dva)->dva_word[1], 63, 1)

#define	BP_GET_LSIZE(bp)	\
    	(BP_IS_EMBEDDED(bp) ?	\
	(BPE_GET_ETYPE(bp) == 0 ? BPE_GET_LSIZE(bp) : 0): \
	BF64_GET_SB((bp)->blk_prop, 0, 16, SPA_MINBLOCKSHIFT, 1))

#define	BP_GET_PSIZE(bp)	\
    	(BP_IS_EMBEDDED(bp) ? 0 : \
	BF64_GET_SB((bp)->blk_prop, 16, 16, SPA_MINBLOCKSHIFT, 1))

#define	BP_GET_COMPRESS(bp)		BF64_GET((bp)->blk_prop, 32, 7)

#define	BP_GET_CHECKSUM(bp)		\
    	(BP_IS_EMBEDDED(bp) ? 2 : \
	BF64_GET((bp)->blk_prop, 40, 8))

#define	BP_GET_TYPE(bp)			BF64_GET((bp)->blk_prop, 48, 8)

#define	BP_GET_LEVEL(bp)		BF64_GET((bp)->blk_prop, 56, 5)

#define	BP_GET_PROP_BIT_61(bp)		BF64_GET((bp)->blk_prop, 61, 1)

#define	BP_GET_DEDUP(bp)		BF64_GET((bp)->blk_prop, 62, 1)

#define	BP_GET_BYTEORDER(bp)		(0 - BF64_GET((bp)->blk_prop, 63, 1))

#define BP_IS_EMBEDDED(bp)		BF64_GET((bp)->blk_prop, 39, 1)

#define	BP_PHYSICAL_BIRTH(bp)		\
    	(BP_IS_EMBEDDED(bp) ? 0 : \
	(bp)->blk_phys_birth ? (bp)->blk_phys_birth : (bp)->blk_birth)

#define	BP_GET_ASIZE(bp)	\
    	(BP_IS_EMBEDDED(bp) ? 0 : \
	(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_IS_METADATA(BP_GET_TYPE(bp))) ? \
	BP_GET_PSIZE(bp) : BP_GET_LSIZE(bp))

#define	BP_GET_NDVAS(bp)	\
    	(BP_IS_EMBEDDED(bp) ? 0 : \
	!!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)	\
    	(BP_IS_EMBEDDED(bp) ? 0 : \
	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	BP_IDENTITY(bp)		(&(bp)->blk_dva[0])
#define	BP_IS_GANG(bp)		DVA_GET_GANG(BP_IDENTITY(bp))
#define	DVA_IS_EMPTY(dva)	((dva)->dva_word[0] == 0ULL &&	\
    				(dva)->dva_word[1] == 0ULL)
#define	BP_IS_HOLE(bp) \
    	(!BP_IS_EMBEDDED(bp) && DVA_IS_EMPTY(BP_IDENTITY(bp)))

#define	BP_IS_RAIDZ(bp)		(DVA_GET_ASIZE(&(bp)->blk_dva[0]) > \
				BP_GET_PSIZE(bp))

#ifdef _BIG_ENDIAN
#define	ZFS_HOST_BYTEORDER	(0ULL)
#else
#define	ZFS_HOST_BYTEORDER	(-1ULL)
#endif

#define	BP_SHOULD_BYTESWAP(bp)	(BP_GET_BYTEORDER(bp) != ZFS_HOST_BYTEORDER)

typedef enum zio_type {
	ZIO_TYPE_NULL = 0,
	ZIO_TYPE_READ,
	ZIO_TYPE_WRITE,
	ZIO_TYPE_FREE,
	ZIO_TYPE_CLAIM,
	ZIO_TYPE_IOCTL,
	ZIO_TYPES
} zio_type_t;

#define BP_GET_COMPRESS_NAME(bp) \
	(stringof(zfs`zio_compress_table[BP_GET_COMPRESS(bp)].ci_name))
#define BP_GET_CHECKSUM_NAME(bp) \
    	(stringof(zfs`zio_checksum_table[BP_GET_CHECKSUM(bp)].ci_name))

#define	DMU_OT_NEWTYPE 0x80
#define	DMU_OT_METADATA 0x40
#define	DMU_OT_BYTESWAP_MASK 0x3f

#define	DMU_OT_IS_METADATA(ot) (((ot) & DMU_OT_NEWTYPE) ? \
	((ot) & DMU_OT_METADATA) : \
	zfs`dmu_ot[(ot)].ot_metadata)

#define	DMU_OT_BYTESWAP(ot) (((ot) & DMU_OT_NEWTYPE) ? \
	((ot) & DMU_OT_BYTESWAP_MASK) : \
	zfs`dmu_ot[(ot)].ot_byteswap)

#define BP_GET_TYPE_NAME(bp) ((BP_GET_TYPE(bp) & DMU_OT_NEWTYPE) ? \
	stringof(zfs`dmu_ot_byteswap[DMU_OT_BYTESWAP(BP_GET_TYPE(bp))].ob_name) : \
	stringof(zfs`dmu_ot[BP_GET_TYPE(bp)].ot_name))

#define PRINTF_BP(bp) \
	if (BP_IS_HOLE(bp)) {						\
	    	printf("<hole> birth=%u\n", (bp)->blk_birth);		\
	} else if (BP_IS_EMBEDDED(bp)) {				\
		printf("EMBEDDED [L%u %s et=%u %s size=%xL/%xP birth=%uL\n", \
		    BP_GET_LEVEL(bp),					\
		    BP_GET_TYPE_NAME(bp),				\
		    BPE_GET_ETYPE(bp),					\
		    BP_GET_COMPRESS_NAME(bp),				\
		    BPE_GET_LSIZE(bp),					\
		    BPE_GET_PSIZE(bp),					\
		    (bp)->blk_birth);					\
	} else {							\
		printf("[L%u %s] %s %s %s %s %s ndvas=%u ",			\
		    BP_GET_LEVEL(bp),						\
		    BP_GET_TYPE_NAME(bp),					\
		    BP_GET_CHECKSUM_NAME(bp),					\
		    BP_GET_COMPRESS_NAME(bp),					\
		    BP_GET_BYTEORDER(bp) == 0 ? "BE" : "LE",			\
		    BP_IS_GANG(bp) ? "gang" : "contiguous",			\
		    BP_GET_DEDUP(bp) ? "dedup" : "unique",			\
		    BP_GET_NDVAS(bp));						\
		printf("size=%xL/%xP birth=%uL/%uP fill=%u ",			\
		    BP_GET_LSIZE(bp),						\
		    BP_GET_PSIZE(bp),						\
		    bp->blk_birth,						\
		    BP_PHYSICAL_BIRTH(bp),					\
		    bp->blk_fill);						\
		printf("cksum=%x:%x:%x:%x\n",					\
		    bp->blk_cksum.zc_word[0],					\
		    bp->blk_cksum.zc_word[1],					\
		    bp->blk_cksum.zc_word[2],					\
		    bp->blk_cksum.zc_word[3]);					\
	}

dsl_dataset_block_kill:entry
{
	trace(args[2]->tx_txg);
	PRINTF_BP(args[1])
}

dsl_deadlist_insert:entry
{
	PRINTF_BP(args[1]);
}

bplist_append:entry
{
	PRINTF_BP(args[1]);
}

dsl_bookmark_block_killed:entry
{
	PRINTF_BP(args[1]);
}

dsl_bookmark_sync_done:entry
{
	trace(0);
}

zap_update:entry
/callers["dsl_bookmark_sync_done"]/
{
	trace(stringof(args[2]));
}