xref: /illumos-gate/usr/src/boot/sys/cddl/boot/zfs/zfsimpl.h (revision 08487eea68a2fa501b5042131c6db068089f82e1)
1*08487eeaSToomas Soome /*
2199767f8SToomas Soome  * Copyright (c) 2002 McAfee, Inc.
3199767f8SToomas Soome  * All rights reserved.
4199767f8SToomas Soome  *
5199767f8SToomas Soome  * This software was developed for the FreeBSD Project by Marshall
6199767f8SToomas Soome  * Kirk McKusick and McAfee Research,, the Security Research Division of
7199767f8SToomas Soome  * McAfee, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as
8199767f8SToomas Soome  * part of the DARPA CHATS research program
9199767f8SToomas Soome  *
10199767f8SToomas Soome  * Redistribution and use in source and binary forms, with or without
11199767f8SToomas Soome  * modification, are permitted provided that the following conditions
12199767f8SToomas Soome  * are met:
13199767f8SToomas Soome  * 1. Redistributions of source code must retain the above copyright
14199767f8SToomas Soome  *    notice, this list of conditions and the following disclaimer.
15199767f8SToomas Soome  * 2. Redistributions in binary form must reproduce the above copyright
16199767f8SToomas Soome  *    notice, this list of conditions and the following disclaimer in the
17199767f8SToomas Soome  *    documentation and/or other materials provided with the distribution.
18199767f8SToomas Soome  *
19199767f8SToomas Soome  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20199767f8SToomas Soome  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21199767f8SToomas Soome  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22199767f8SToomas Soome  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23199767f8SToomas Soome  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24199767f8SToomas Soome  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25199767f8SToomas Soome  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26199767f8SToomas Soome  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27199767f8SToomas Soome  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28199767f8SToomas Soome  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29199767f8SToomas Soome  * SUCH DAMAGE.
30199767f8SToomas Soome  */
31199767f8SToomas Soome /*
32199767f8SToomas Soome  * CDDL HEADER START
33199767f8SToomas Soome  *
34199767f8SToomas Soome  * The contents of this file are subject to the terms of the
35199767f8SToomas Soome  * Common Development and Distribution License (the "License").
36199767f8SToomas Soome  * You may not use this file except in compliance with the License.
37199767f8SToomas Soome  *
38199767f8SToomas Soome  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
39199767f8SToomas Soome  * or http://www.opensolaris.org/os/licensing.
40199767f8SToomas Soome  * See the License for the specific language governing permissions
41199767f8SToomas Soome  * and limitations under the License.
42199767f8SToomas Soome  *
43199767f8SToomas Soome  * When distributing Covered Code, include this CDDL HEADER in each
44199767f8SToomas Soome  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
45199767f8SToomas Soome  * If applicable, add the following below this CDDL HEADER, with the
46199767f8SToomas Soome  * fields enclosed by brackets "[]" replaced with your own identifying
47199767f8SToomas Soome  * information: Portions Copyright [yyyy] [name of copyright owner]
48199767f8SToomas Soome  *
49199767f8SToomas Soome  * CDDL HEADER END
50199767f8SToomas Soome  */
51199767f8SToomas Soome /*
52199767f8SToomas Soome  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
53199767f8SToomas Soome  * Use is subject to license terms.
54199767f8SToomas Soome  */
55199767f8SToomas Soome /*
56199767f8SToomas Soome  * Copyright 2013 by Saso Kiselkov. All rights reserved.
57199767f8SToomas Soome  */
58199767f8SToomas Soome /*
59199767f8SToomas Soome  * Copyright (c) 2013 by Delphix. All rights reserved.
60199767f8SToomas Soome  */
61199767f8SToomas Soome 
62*08487eeaSToomas Soome #ifndef _ZFSIMPL_H
63*08487eeaSToomas Soome #define	_ZFSIMPL_H
64*08487eeaSToomas Soome 
65199767f8SToomas Soome #define	MAXNAMELEN	256
66199767f8SToomas Soome 
67199767f8SToomas Soome #define _NOTE(s)
68199767f8SToomas Soome 
69199767f8SToomas Soome /* CRC64 table */
70199767f8SToomas Soome #define	ZFS_CRC64_POLY	0xC96C5795D7870F42ULL	/* ECMA-182, reflected form */
71199767f8SToomas Soome 
72199767f8SToomas Soome /*
73199767f8SToomas Soome  * Macros for various sorts of alignment and rounding when the alignment
74199767f8SToomas Soome  * is known to be a power of 2.
75199767f8SToomas Soome  */
76199767f8SToomas Soome #define	P2ALIGN(x, align)		((x) & -(align))
77199767f8SToomas Soome #define	P2PHASE(x, align)		((x) & ((align) - 1))
78199767f8SToomas Soome #define	P2NPHASE(x, align)		(-(x) & ((align) - 1))
79199767f8SToomas Soome #define	P2ROUNDUP(x, align)		(-(-(x) & -(align)))
80199767f8SToomas Soome #define	P2END(x, align)			(-(~(x) & -(align)))
81199767f8SToomas Soome #define	P2PHASEUP(x, align, phase)	((phase) - (((phase) - (x)) & -(align)))
82*08487eeaSToomas Soome #define	P2BOUNDARY(off, len, align)	\
83*08487eeaSToomas Soome 	(((off) ^ ((off) + (len) - 1)) > (align) - 1)
84199767f8SToomas Soome 
85199767f8SToomas Soome /*
86199767f8SToomas Soome  * General-purpose 32-bit and 64-bit bitfield encodings.
87199767f8SToomas Soome  */
88199767f8SToomas Soome #define	BF32_DECODE(x, low, len)	P2PHASE((x) >> (low), 1U << (len))
89199767f8SToomas Soome #define	BF64_DECODE(x, low, len)	P2PHASE((x) >> (low), 1ULL << (len))
90199767f8SToomas Soome #define	BF32_ENCODE(x, low, len)	(P2PHASE((x), 1U << (len)) << (low))
91199767f8SToomas Soome #define	BF64_ENCODE(x, low, len)	(P2PHASE((x), 1ULL << (len)) << (low))
92199767f8SToomas Soome 
93199767f8SToomas Soome #define	BF32_GET(x, low, len)		BF32_DECODE(x, low, len)
94199767f8SToomas Soome #define	BF64_GET(x, low, len)		BF64_DECODE(x, low, len)
95199767f8SToomas Soome 
96199767f8SToomas Soome #define	BF32_SET(x, low, len, val)	\
97199767f8SToomas Soome 	((x) ^= BF32_ENCODE((x >> low) ^ (val), low, len))
98199767f8SToomas Soome #define	BF64_SET(x, low, len, val)	\
99199767f8SToomas Soome 	((x) ^= BF64_ENCODE((x >> low) ^ (val), low, len))
100199767f8SToomas Soome 
101199767f8SToomas Soome #define	BF32_GET_SB(x, low, len, shift, bias)	\
102199767f8SToomas Soome 	((BF32_GET(x, low, len) + (bias)) << (shift))
103199767f8SToomas Soome #define	BF64_GET_SB(x, low, len, shift, bias)	\
104199767f8SToomas Soome 	((BF64_GET(x, low, len) + (bias)) << (shift))
105199767f8SToomas Soome 
106199767f8SToomas Soome #define	BF32_SET_SB(x, low, len, shift, bias, val)	\
107199767f8SToomas Soome 	BF32_SET(x, low, len, ((val) >> (shift)) - (bias))
108199767f8SToomas Soome #define	BF64_SET_SB(x, low, len, shift, bias, val)	\
109199767f8SToomas Soome 	BF64_SET(x, low, len, ((val) >> (shift)) - (bias))
110199767f8SToomas Soome 
111199767f8SToomas Soome /*
112199767f8SToomas Soome  * Macros to reverse byte order
113199767f8SToomas Soome  */
114199767f8SToomas Soome #define	BSWAP_8(x)	((x) & 0xff)
115199767f8SToomas Soome #define	BSWAP_16(x)	((BSWAP_8(x) << 8) | BSWAP_8((x) >> 8))
116199767f8SToomas Soome #define	BSWAP_32(x)	((BSWAP_16(x) << 16) | BSWAP_16((x) >> 16))
117199767f8SToomas Soome #define	BSWAP_64(x)	((BSWAP_32(x) << 32) | BSWAP_32((x) >> 32))
118199767f8SToomas Soome 
119199767f8SToomas Soome #define	SPA_MINBLOCKSHIFT	9
120199767f8SToomas Soome #define	SPA_OLDMAXBLOCKSHIFT	17
121199767f8SToomas Soome #define	SPA_MAXBLOCKSHIFT	24
122199767f8SToomas Soome #define	SPA_MINBLOCKSIZE	(1ULL << SPA_MINBLOCKSHIFT)
123199767f8SToomas Soome #define	SPA_OLDMAXBLOCKSIZE	(1ULL << SPA_OLDMAXBLOCKSHIFT)
124199767f8SToomas Soome #define	SPA_MAXBLOCKSIZE	(1ULL << SPA_MAXBLOCKSHIFT)
125199767f8SToomas Soome 
126199767f8SToomas Soome /*
127199767f8SToomas Soome  * The DVA size encodings for LSIZE and PSIZE support blocks up to 32MB.
128199767f8SToomas Soome  * The ASIZE encoding should be at least 64 times larger (6 more bits)
129199767f8SToomas Soome  * to support up to 4-way RAID-Z mirror mode with worst-case gang block
130199767f8SToomas Soome  * overhead, three DVAs per bp, plus one more bit in case we do anything
131199767f8SToomas Soome  * else that expands the ASIZE.
132199767f8SToomas Soome  */
133199767f8SToomas Soome #define	SPA_LSIZEBITS		16	/* LSIZE up to 32M (2^16 * 512)	*/
134199767f8SToomas Soome #define	SPA_PSIZEBITS		16	/* PSIZE up to 32M (2^16 * 512)	*/
135199767f8SToomas Soome #define	SPA_ASIZEBITS		24	/* ASIZE up to 64 times larger	*/
136199767f8SToomas Soome 
137199767f8SToomas Soome /*
138199767f8SToomas Soome  * All SPA data is represented by 128-bit data virtual addresses (DVAs).
139199767f8SToomas Soome  * The members of the dva_t should be considered opaque outside the SPA.
140199767f8SToomas Soome  */
141199767f8SToomas Soome typedef struct dva {
142199767f8SToomas Soome 	uint64_t	dva_word[2];
143199767f8SToomas Soome } dva_t;
144199767f8SToomas Soome 
145199767f8SToomas Soome /*
146199767f8SToomas Soome  * Each block has a 256-bit checksum -- strong enough for cryptographic hashes.
147199767f8SToomas Soome  */
148199767f8SToomas Soome typedef struct zio_cksum {
149199767f8SToomas Soome 	uint64_t	zc_word[4];
150199767f8SToomas Soome } zio_cksum_t;
151199767f8SToomas Soome 
152199767f8SToomas Soome /*
153199767f8SToomas Soome  * Some checksums/hashes need a 256-bit initialization salt. This salt is kept
154199767f8SToomas Soome  * secret and is suitable for use in MAC algorithms as the key.
155199767f8SToomas Soome  */
156199767f8SToomas Soome typedef struct zio_cksum_salt {
157199767f8SToomas Soome 	uint8_t		zcs_bytes[32];
158199767f8SToomas Soome } zio_cksum_salt_t;
159199767f8SToomas Soome 
160199767f8SToomas Soome /*
161199767f8SToomas Soome  * Each block is described by its DVAs, time of birth, checksum, etc.
162199767f8SToomas Soome  * The word-by-word, bit-by-bit layout of the blkptr is as follows:
163199767f8SToomas Soome  *
164199767f8SToomas Soome  *	64	56	48	40	32	24	16	8	0
165199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
166199767f8SToomas Soome  * 0	|		vdev1		| GRID  |	  ASIZE		|
167199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
168199767f8SToomas Soome  * 1	|G|			 offset1				|
169199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
170199767f8SToomas Soome  * 2	|		vdev2		| GRID  |	  ASIZE		|
171199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
172199767f8SToomas Soome  * 3	|G|			 offset2				|
173199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
174199767f8SToomas Soome  * 4	|		vdev3		| GRID  |	  ASIZE		|
175199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
176199767f8SToomas Soome  * 5	|G|			 offset3				|
177199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
178199767f8SToomas Soome  * 6	|BDX|lvl| type	| cksum |E| comp|    PSIZE	|     LSIZE	|
179199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
180199767f8SToomas Soome  * 7	|			padding					|
181199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
182199767f8SToomas Soome  * 8	|			padding					|
183199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
184199767f8SToomas Soome  * 9	|			physical birth txg			|
185199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
186199767f8SToomas Soome  * a	|			logical birth txg			|
187199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
188199767f8SToomas Soome  * b	|			fill count				|
189199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
190199767f8SToomas Soome  * c	|			checksum[0]				|
191199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
192199767f8SToomas Soome  * d	|			checksum[1]				|
193199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
194199767f8SToomas Soome  * e	|			checksum[2]				|
195199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
196199767f8SToomas Soome  * f	|			checksum[3]				|
197199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
198199767f8SToomas Soome  *
199199767f8SToomas Soome  * Legend:
200199767f8SToomas Soome  *
201199767f8SToomas Soome  * vdev		virtual device ID
202199767f8SToomas Soome  * offset	offset into virtual device
203199767f8SToomas Soome  * LSIZE	logical size
204199767f8SToomas Soome  * PSIZE	physical size (after compression)
205199767f8SToomas Soome  * ASIZE	allocated size (including RAID-Z parity and gang block headers)
206199767f8SToomas Soome  * GRID		RAID-Z layout information (reserved for future use)
207199767f8SToomas Soome  * cksum	checksum function
208199767f8SToomas Soome  * comp		compression function
209199767f8SToomas Soome  * G		gang block indicator
210199767f8SToomas Soome  * B		byteorder (endianness)
211199767f8SToomas Soome  * D		dedup
212199767f8SToomas Soome  * X		encryption (on version 30, which is not supported)
213199767f8SToomas Soome  * E		blkptr_t contains embedded data (see below)
214199767f8SToomas Soome  * lvl		level of indirection
215199767f8SToomas Soome  * type		DMU object type
216199767f8SToomas Soome  * phys birth	txg of block allocation; zero if same as logical birth txg
217199767f8SToomas Soome  * log. birth	transaction group in which the block was logically born
218199767f8SToomas Soome  * fill count	number of non-zero blocks under this bp
219199767f8SToomas Soome  * checksum[4]	256-bit checksum of the data this bp describes
220199767f8SToomas Soome  */
221199767f8SToomas Soome 
222199767f8SToomas Soome /*
223199767f8SToomas Soome  * "Embedded" blkptr_t's don't actually point to a block, instead they
224199767f8SToomas Soome  * have a data payload embedded in the blkptr_t itself.  See the comment
225199767f8SToomas Soome  * in blkptr.c for more details.
226199767f8SToomas Soome  *
227199767f8SToomas Soome  * The blkptr_t is laid out as follows:
228199767f8SToomas Soome  *
229199767f8SToomas Soome  *	64	56	48	40	32	24	16	8	0
230199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
231199767f8SToomas Soome  * 0	|      payload                                                  |
232199767f8SToomas Soome  * 1	|      payload                                                  |
233199767f8SToomas Soome  * 2	|      payload                                                  |
234199767f8SToomas Soome  * 3	|      payload                                                  |
235199767f8SToomas Soome  * 4	|      payload                                                  |
236199767f8SToomas Soome  * 5	|      payload                                                  |
237199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
238199767f8SToomas Soome  * 6	|BDX|lvl| type	| etype |E| comp| PSIZE|              LSIZE	|
239199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
240199767f8SToomas Soome  * 7	|      payload                                                  |
241199767f8SToomas Soome  * 8	|      payload                                                  |
242199767f8SToomas Soome  * 9	|      payload                                                  |
243199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
244199767f8SToomas Soome  * a	|			logical birth txg			|
245199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
246199767f8SToomas Soome  * b	|      payload                                                  |
247199767f8SToomas Soome  * c	|      payload                                                  |
248199767f8SToomas Soome  * d	|      payload                                                  |
249199767f8SToomas Soome  * e	|      payload                                                  |
250199767f8SToomas Soome  * f	|      payload                                                  |
251199767f8SToomas Soome  *	+-------+-------+-------+-------+-------+-------+-------+-------+
252199767f8SToomas Soome  *
253199767f8SToomas Soome  * Legend:
254199767f8SToomas Soome  *
255199767f8SToomas Soome  * payload		contains the embedded data
256199767f8SToomas Soome  * B (byteorder)	byteorder (endianness)
257199767f8SToomas Soome  * D (dedup)		padding (set to zero)
258199767f8SToomas Soome  * X			encryption (set to zero; see above)
259199767f8SToomas Soome  * E (embedded)		set to one
260199767f8SToomas Soome  * lvl			indirection level
261199767f8SToomas Soome  * type			DMU object type
262199767f8SToomas Soome  * etype		how to interpret embedded data (BP_EMBEDDED_TYPE_*)
263199767f8SToomas Soome  * comp			compression function of payload
264199767f8SToomas Soome  * PSIZE		size of payload after compression, in bytes
265199767f8SToomas Soome  * LSIZE		logical size of payload, in bytes
266199767f8SToomas Soome  *			note that 25 bits is enough to store the largest
267199767f8SToomas Soome  *			"normal" BP's LSIZE (2^16 * 2^9) in bytes
268199767f8SToomas Soome  * log. birth		transaction group in which the block was logically born
269199767f8SToomas Soome  *
270199767f8SToomas Soome  * Note that LSIZE and PSIZE are stored in bytes, whereas for non-embedded
271199767f8SToomas Soome  * bp's they are stored in units of SPA_MINBLOCKSHIFT.
272199767f8SToomas Soome  * Generally, the generic BP_GET_*() macros can be used on embedded BP's.
273199767f8SToomas Soome  * The B, D, X, lvl, type, and comp fields are stored the same as with normal
274199767f8SToomas Soome  * BP's so the BP_SET_* macros can be used with them.  etype, PSIZE, LSIZE must
275199767f8SToomas Soome  * be set with the BPE_SET_* macros.  BP_SET_EMBEDDED() should be called before
276199767f8SToomas Soome  * other macros, as they assert that they are only used on BP's of the correct
277199767f8SToomas Soome  * "embedded-ness".
278199767f8SToomas Soome  */
279199767f8SToomas Soome 
280199767f8SToomas Soome #define	BPE_GET_ETYPE(bp)	\
281199767f8SToomas Soome 	(ASSERT(BP_IS_EMBEDDED(bp)), \
282199767f8SToomas Soome 	BF64_GET((bp)->blk_prop, 40, 8))
283199767f8SToomas Soome #define	BPE_SET_ETYPE(bp, t)	do { \
284199767f8SToomas Soome 	ASSERT(BP_IS_EMBEDDED(bp)); \
285199767f8SToomas Soome 	BF64_SET((bp)->blk_prop, 40, 8, t); \
286199767f8SToomas Soome _NOTE(CONSTCOND) } while (0)
287199767f8SToomas Soome 
288199767f8SToomas Soome #define	BPE_GET_LSIZE(bp)	\
289199767f8SToomas Soome 	(ASSERT(BP_IS_EMBEDDED(bp)), \
290199767f8SToomas Soome 	BF64_GET_SB((bp)->blk_prop, 0, 25, 0, 1))
291199767f8SToomas Soome #define	BPE_SET_LSIZE(bp, x)	do { \
292199767f8SToomas Soome 	ASSERT(BP_IS_EMBEDDED(bp)); \
293199767f8SToomas Soome 	BF64_SET_SB((bp)->blk_prop, 0, 25, 0, 1, x); \
294199767f8SToomas Soome _NOTE(CONSTCOND) } while (0)
295199767f8SToomas Soome 
296199767f8SToomas Soome #define	BPE_GET_PSIZE(bp)	\
297199767f8SToomas Soome 	(ASSERT(BP_IS_EMBEDDED(bp)), \
298199767f8SToomas Soome 	BF64_GET_SB((bp)->blk_prop, 25, 7, 0, 1))
299199767f8SToomas Soome #define	BPE_SET_PSIZE(bp, x)	do { \
300199767f8SToomas Soome 	ASSERT(BP_IS_EMBEDDED(bp)); \
301199767f8SToomas Soome 	BF64_SET_SB((bp)->blk_prop, 25, 7, 0, 1, x); \
302199767f8SToomas Soome _NOTE(CONSTCOND) } while (0)
303199767f8SToomas Soome 
304199767f8SToomas Soome typedef enum bp_embedded_type {
305199767f8SToomas Soome 	BP_EMBEDDED_TYPE_DATA,
306199767f8SToomas Soome 	BP_EMBEDDED_TYPE_RESERVED, /* Reserved for an unintegrated feature. */
307199767f8SToomas Soome 	NUM_BP_EMBEDDED_TYPES = BP_EMBEDDED_TYPE_RESERVED
308199767f8SToomas Soome } bp_embedded_type_t;
309199767f8SToomas Soome 
310199767f8SToomas Soome #define	BPE_NUM_WORDS 14
311199767f8SToomas Soome #define	BPE_PAYLOAD_SIZE (BPE_NUM_WORDS * sizeof (uint64_t))
312199767f8SToomas Soome #define	BPE_IS_PAYLOADWORD(bp, wp) \
313199767f8SToomas Soome 	((wp) != &(bp)->blk_prop && (wp) != &(bp)->blk_birth)
314199767f8SToomas Soome 
315199767f8SToomas Soome #define	SPA_BLKPTRSHIFT	7		/* blkptr_t is 128 bytes	*/
316199767f8SToomas Soome #define	SPA_DVAS_PER_BP	3		/* Number of DVAs in a bp	*/
317199767f8SToomas Soome 
318199767f8SToomas Soome typedef struct blkptr {
319199767f8SToomas Soome 	dva_t		blk_dva[SPA_DVAS_PER_BP]; /* Data Virtual Addresses */
320199767f8SToomas Soome 	uint64_t	blk_prop;	/* size, compression, type, etc	    */
321199767f8SToomas Soome 	uint64_t	blk_pad[2];	/* Extra space for the future	    */
322199767f8SToomas Soome 	uint64_t	blk_phys_birth;	/* txg when block was allocated	    */
323199767f8SToomas Soome 	uint64_t	blk_birth;	/* transaction group at birth	    */
324199767f8SToomas Soome 	uint64_t	blk_fill;	/* fill count			    */
325199767f8SToomas Soome 	zio_cksum_t	blk_cksum;	/* 256-bit checksum		    */
326199767f8SToomas Soome } blkptr_t;
327199767f8SToomas Soome 
328199767f8SToomas Soome /*
329199767f8SToomas Soome  * Macros to get and set fields in a bp or DVA.
330199767f8SToomas Soome  */
331199767f8SToomas Soome #define	DVA_GET_ASIZE(dva)	\
332199767f8SToomas Soome 	BF64_GET_SB((dva)->dva_word[0], 0, SPA_ASIZEBITS, SPA_MINBLOCKSHIFT, 0)
333199767f8SToomas Soome #define	DVA_SET_ASIZE(dva, x)	\
334199767f8SToomas Soome 	BF64_SET_SB((dva)->dva_word[0], 0, SPA_ASIZEBITS, \
335199767f8SToomas Soome 	SPA_MINBLOCKSHIFT, 0, x)
336199767f8SToomas Soome 
337199767f8SToomas Soome #define	DVA_GET_GRID(dva)	BF64_GET((dva)->dva_word[0], 24, 8)
338199767f8SToomas Soome #define	DVA_SET_GRID(dva, x)	BF64_SET((dva)->dva_word[0], 24, 8, x)
339199767f8SToomas Soome 
340199767f8SToomas Soome #define	DVA_GET_VDEV(dva)	BF64_GET((dva)->dva_word[0], 32, 32)
341199767f8SToomas Soome #define	DVA_SET_VDEV(dva, x)	BF64_SET((dva)->dva_word[0], 32, 32, x)
342199767f8SToomas Soome 
343199767f8SToomas Soome #define	DVA_GET_OFFSET(dva)	\
344199767f8SToomas Soome 	BF64_GET_SB((dva)->dva_word[1], 0, 63, SPA_MINBLOCKSHIFT, 0)
345199767f8SToomas Soome #define	DVA_SET_OFFSET(dva, x)	\
346199767f8SToomas Soome 	BF64_SET_SB((dva)->dva_word[1], 0, 63, SPA_MINBLOCKSHIFT, 0, x)
347199767f8SToomas Soome 
348199767f8SToomas Soome #define	DVA_GET_GANG(dva)	BF64_GET((dva)->dva_word[1], 63, 1)
349199767f8SToomas Soome #define	DVA_SET_GANG(dva, x)	BF64_SET((dva)->dva_word[1], 63, 1, x)
350199767f8SToomas Soome 
351199767f8SToomas Soome #define	BP_GET_LSIZE(bp)	\
352199767f8SToomas Soome 	(BP_IS_EMBEDDED(bp) ?	\
353199767f8SToomas Soome 	(BPE_GET_ETYPE(bp) == BP_EMBEDDED_TYPE_DATA ? BPE_GET_LSIZE(bp) : 0): \
354199767f8SToomas Soome 	BF64_GET_SB((bp)->blk_prop, 0, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1))
355199767f8SToomas Soome #define	BP_SET_LSIZE(bp, x)	do { \
356199767f8SToomas Soome 	ASSERT(!BP_IS_EMBEDDED(bp)); \
357199767f8SToomas Soome 	BF64_SET_SB((bp)->blk_prop, \
358199767f8SToomas Soome 	    0, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1, x); \
359199767f8SToomas Soome _NOTE(CONSTCOND) } while (0)
360199767f8SToomas Soome 
361199767f8SToomas Soome #define	BP_GET_PSIZE(bp)	\
362199767f8SToomas Soome 	BF64_GET_SB((bp)->blk_prop, 16, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1)
363199767f8SToomas Soome #define	BP_SET_PSIZE(bp, x)	\
364199767f8SToomas Soome 	BF64_SET_SB((bp)->blk_prop, 16, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1, x)
365199767f8SToomas Soome 
366199767f8SToomas Soome #define	BP_GET_COMPRESS(bp)	BF64_GET((bp)->blk_prop, 32, 7)
367199767f8SToomas Soome #define	BP_SET_COMPRESS(bp, x)	BF64_SET((bp)->blk_prop, 32, 7, x)
368199767f8SToomas Soome 
369199767f8SToomas Soome #define	BP_GET_CHECKSUM(bp)	BF64_GET((bp)->blk_prop, 40, 8)
370199767f8SToomas Soome #define	BP_SET_CHECKSUM(bp, x)	BF64_SET((bp)->blk_prop, 40, 8, x)
371199767f8SToomas Soome 
372199767f8SToomas Soome #define	BP_GET_TYPE(bp)		BF64_GET((bp)->blk_prop, 48, 8)
373199767f8SToomas Soome #define	BP_SET_TYPE(bp, x)	BF64_SET((bp)->blk_prop, 48, 8, x)
374199767f8SToomas Soome 
375199767f8SToomas Soome #define	BP_GET_LEVEL(bp)	BF64_GET((bp)->blk_prop, 56, 5)
376199767f8SToomas Soome #define	BP_SET_LEVEL(bp, x)	BF64_SET((bp)->blk_prop, 56, 5, x)
377199767f8SToomas Soome 
378199767f8SToomas Soome #define	BP_IS_EMBEDDED(bp)	BF64_GET((bp)->blk_prop, 39, 1)
379199767f8SToomas Soome 
380199767f8SToomas Soome #define	BP_GET_DEDUP(bp)	BF64_GET((bp)->blk_prop, 62, 1)
381199767f8SToomas Soome #define	BP_SET_DEDUP(bp, x)	BF64_SET((bp)->blk_prop, 62, 1, x)
382199767f8SToomas Soome 
383199767f8SToomas Soome #define	BP_GET_BYTEORDER(bp)	BF64_GET((bp)->blk_prop, 63, 1)
384199767f8SToomas Soome #define	BP_SET_BYTEORDER(bp, x)	BF64_SET((bp)->blk_prop, 63, 1, x)
385199767f8SToomas Soome 
386199767f8SToomas Soome #define	BP_PHYSICAL_BIRTH(bp)		\
387199767f8SToomas Soome 	((bp)->blk_phys_birth ? (bp)->blk_phys_birth : (bp)->blk_birth)
388199767f8SToomas Soome 
389199767f8SToomas Soome #define	BP_GET_ASIZE(bp)	\
390199767f8SToomas Soome 	(DVA_GET_ASIZE(&(bp)->blk_dva[0]) + DVA_GET_ASIZE(&(bp)->blk_dva[1]) + \
391199767f8SToomas Soome 		DVA_GET_ASIZE(&(bp)->blk_dva[2]))
392199767f8SToomas Soome 
393199767f8SToomas Soome #define	BP_GET_UCSIZE(bp) \
394199767f8SToomas Soome 	((BP_GET_LEVEL(bp) > 0 || dmu_ot[BP_GET_TYPE(bp)].ot_metadata) ? \
395199767f8SToomas Soome 	BP_GET_PSIZE(bp) : BP_GET_LSIZE(bp));
396199767f8SToomas Soome 
397199767f8SToomas Soome #define	BP_GET_NDVAS(bp)	\
398199767f8SToomas Soome 	(!!DVA_GET_ASIZE(&(bp)->blk_dva[0]) + \
399199767f8SToomas Soome 	!!DVA_GET_ASIZE(&(bp)->blk_dva[1]) + \
400199767f8SToomas Soome 	!!DVA_GET_ASIZE(&(bp)->blk_dva[2]))
401199767f8SToomas Soome 
402199767f8SToomas Soome #define	DVA_EQUAL(dva1, dva2)	\
403199767f8SToomas Soome 	((dva1)->dva_word[1] == (dva2)->dva_word[1] && \
404199767f8SToomas Soome 	(dva1)->dva_word[0] == (dva2)->dva_word[0])
405199767f8SToomas Soome 
406199767f8SToomas Soome #define	ZIO_CHECKSUM_EQUAL(zc1, zc2) \
407199767f8SToomas Soome 	(0 == (((zc1).zc_word[0] - (zc2).zc_word[0]) | \
408199767f8SToomas Soome 	((zc1).zc_word[1] - (zc2).zc_word[1]) | \
409199767f8SToomas Soome 	((zc1).zc_word[2] - (zc2).zc_word[2]) | \
410199767f8SToomas Soome 	((zc1).zc_word[3] - (zc2).zc_word[3])))
411199767f8SToomas Soome 
412199767f8SToomas Soome 
413199767f8SToomas Soome #define	DVA_IS_VALID(dva)	(DVA_GET_ASIZE(dva) != 0)
414199767f8SToomas Soome 
415199767f8SToomas Soome #define	ZIO_SET_CHECKSUM(zcp, w0, w1, w2, w3)	\
416199767f8SToomas Soome {						\
417199767f8SToomas Soome 	(zcp)->zc_word[0] = w0;			\
418199767f8SToomas Soome 	(zcp)->zc_word[1] = w1;			\
419199767f8SToomas Soome 	(zcp)->zc_word[2] = w2;			\
420199767f8SToomas Soome 	(zcp)->zc_word[3] = w3;			\
421199767f8SToomas Soome }
422199767f8SToomas Soome 
423199767f8SToomas Soome #define	BP_IDENTITY(bp)		(&(bp)->blk_dva[0])
424199767f8SToomas Soome #define	BP_IS_GANG(bp)		DVA_GET_GANG(BP_IDENTITY(bp))
425199767f8SToomas Soome #define	DVA_IS_EMPTY(dva)	((dva)->dva_word[0] == 0ULL &&  \
426199767f8SToomas Soome 	(dva)->dva_word[1] == 0ULL)
427199767f8SToomas Soome #define	BP_IS_HOLE(bp)		DVA_IS_EMPTY(BP_IDENTITY(bp))
428199767f8SToomas Soome #define	BP_IS_OLDER(bp, txg)	(!BP_IS_HOLE(bp) && (bp)->blk_birth < (txg))
429199767f8SToomas Soome 
430199767f8SToomas Soome #define	BP_ZERO(bp)				\
431199767f8SToomas Soome {						\
432199767f8SToomas Soome 	(bp)->blk_dva[0].dva_word[0] = 0;	\
433199767f8SToomas Soome 	(bp)->blk_dva[0].dva_word[1] = 0;	\
434199767f8SToomas Soome 	(bp)->blk_dva[1].dva_word[0] = 0;	\
435199767f8SToomas Soome 	(bp)->blk_dva[1].dva_word[1] = 0;	\
436199767f8SToomas Soome 	(bp)->blk_dva[2].dva_word[0] = 0;	\
437199767f8SToomas Soome 	(bp)->blk_dva[2].dva_word[1] = 0;	\
438199767f8SToomas Soome 	(bp)->blk_prop = 0;			\
439199767f8SToomas Soome 	(bp)->blk_pad[0] = 0;			\
440199767f8SToomas Soome 	(bp)->blk_pad[1] = 0;			\
441199767f8SToomas Soome 	(bp)->blk_phys_birth = 0;		\
442199767f8SToomas Soome 	(bp)->blk_birth = 0;			\
443199767f8SToomas Soome 	(bp)->blk_fill = 0;			\
444199767f8SToomas Soome 	ZIO_SET_CHECKSUM(&(bp)->blk_cksum, 0, 0, 0, 0);	\
445199767f8SToomas Soome }
446199767f8SToomas Soome 
447199767f8SToomas Soome #define	BPE_NUM_WORDS 14
448199767f8SToomas Soome #define	BPE_PAYLOAD_SIZE (BPE_NUM_WORDS * sizeof (uint64_t))
449199767f8SToomas Soome #define	BPE_IS_PAYLOADWORD(bp, wp) \
450199767f8SToomas Soome 	((wp) != &(bp)->blk_prop && (wp) != &(bp)->blk_birth)
451199767f8SToomas Soome 
452199767f8SToomas Soome /*
453199767f8SToomas Soome  * Embedded checksum
454199767f8SToomas Soome  */
455199767f8SToomas Soome #define	ZEC_MAGIC	0x210da7ab10c7a11ULL
456199767f8SToomas Soome 
457199767f8SToomas Soome typedef struct zio_eck {
458199767f8SToomas Soome 	uint64_t	zec_magic;	/* for validation, endianness	*/
459199767f8SToomas Soome 	zio_cksum_t	zec_cksum;	/* 256-bit checksum		*/
460199767f8SToomas Soome } zio_eck_t;
461199767f8SToomas Soome 
462199767f8SToomas Soome /*
463199767f8SToomas Soome  * Gang block headers are self-checksumming and contain an array
464199767f8SToomas Soome  * of block pointers.
465199767f8SToomas Soome  */
466199767f8SToomas Soome #define	SPA_GANGBLOCKSIZE	SPA_MINBLOCKSIZE
467199767f8SToomas Soome #define	SPA_GBH_NBLKPTRS	((SPA_GANGBLOCKSIZE - \
468199767f8SToomas Soome 	sizeof (zio_eck_t)) / sizeof (blkptr_t))
469199767f8SToomas Soome #define	SPA_GBH_FILLER		((SPA_GANGBLOCKSIZE - \
470199767f8SToomas Soome 	sizeof (zio_eck_t) - \
471199767f8SToomas Soome 	(SPA_GBH_NBLKPTRS * sizeof (blkptr_t))) /\
472199767f8SToomas Soome 	sizeof (uint64_t))
473199767f8SToomas Soome 
474199767f8SToomas Soome typedef struct zio_gbh {
475199767f8SToomas Soome 	blkptr_t		zg_blkptr[SPA_GBH_NBLKPTRS];
476199767f8SToomas Soome 	uint64_t		zg_filler[SPA_GBH_FILLER];
477199767f8SToomas Soome 	zio_eck_t		zg_tail;
478199767f8SToomas Soome } zio_gbh_phys_t;
479199767f8SToomas Soome 
480199767f8SToomas Soome #define	VDEV_RAIDZ_MAXPARITY	3
481199767f8SToomas Soome 
482199767f8SToomas Soome #define	VDEV_PAD_SIZE		(8 << 10)
483199767f8SToomas Soome /* 2 padding areas (vl_pad1 and vl_pad2) to skip */
484199767f8SToomas Soome #define	VDEV_SKIP_SIZE		VDEV_PAD_SIZE * 2
485199767f8SToomas Soome #define	VDEV_PHYS_SIZE		(112 << 10)
486199767f8SToomas Soome #define	VDEV_UBERBLOCK_RING	(128 << 10)
487199767f8SToomas Soome 
488199767f8SToomas Soome #define	VDEV_UBERBLOCK_SHIFT(vd)	\
489199767f8SToomas Soome 	MAX((vd)->v_top->v_ashift, UBERBLOCK_SHIFT)
490199767f8SToomas Soome #define	VDEV_UBERBLOCK_COUNT(vd)	\
491199767f8SToomas Soome 	(VDEV_UBERBLOCK_RING >> VDEV_UBERBLOCK_SHIFT(vd))
492199767f8SToomas Soome #define	VDEV_UBERBLOCK_OFFSET(vd, n)	\
493199767f8SToomas Soome 	offsetof(vdev_label_t, vl_uberblock[(n) << VDEV_UBERBLOCK_SHIFT(vd)])
494199767f8SToomas Soome #define	VDEV_UBERBLOCK_SIZE(vd)		(1ULL << VDEV_UBERBLOCK_SHIFT(vd))
495199767f8SToomas Soome 
496199767f8SToomas Soome typedef struct vdev_phys {
497199767f8SToomas Soome 	char		vp_nvlist[VDEV_PHYS_SIZE - sizeof (zio_eck_t)];
498199767f8SToomas Soome 	zio_eck_t	vp_zbt;
499199767f8SToomas Soome } vdev_phys_t;
500199767f8SToomas Soome 
501199767f8SToomas Soome typedef struct vdev_label {
502199767f8SToomas Soome 	char		vl_pad1[VDEV_PAD_SIZE];			/*  8K  */
503199767f8SToomas Soome 	char		vl_pad2[VDEV_PAD_SIZE];			/*  8K  */
504199767f8SToomas Soome 	vdev_phys_t	vl_vdev_phys;				/* 112K	*/
505199767f8SToomas Soome 	char		vl_uberblock[VDEV_UBERBLOCK_RING];	/* 128K	*/
506199767f8SToomas Soome } vdev_label_t;							/* 256K total */
507199767f8SToomas Soome 
508199767f8SToomas Soome /*
509199767f8SToomas Soome  * vdev_dirty() flags
510199767f8SToomas Soome  */
511199767f8SToomas Soome #define	VDD_METASLAB	0x01
512199767f8SToomas Soome #define	VDD_DTL		0x02
513199767f8SToomas Soome 
514199767f8SToomas Soome /*
515199767f8SToomas Soome  * Size and offset of embedded boot loader region on each label.
516199767f8SToomas Soome  * The total size of the first two labels plus the boot area is 4MB.
517199767f8SToomas Soome  */
518199767f8SToomas Soome #define	VDEV_BOOT_OFFSET	(2 * sizeof (vdev_label_t))
519199767f8SToomas Soome #define	VDEV_BOOT_SIZE		(7ULL << 19)			/* 3.5M	*/
520199767f8SToomas Soome 
521199767f8SToomas Soome /*
522199767f8SToomas Soome  * Size of label regions at the start and end of each leaf device.
523199767f8SToomas Soome  */
524199767f8SToomas Soome #define	VDEV_LABEL_START_SIZE	(2 * sizeof (vdev_label_t) + VDEV_BOOT_SIZE)
525199767f8SToomas Soome #define	VDEV_LABEL_END_SIZE	(2 * sizeof (vdev_label_t))
526199767f8SToomas Soome #define	VDEV_LABELS		4
527199767f8SToomas Soome 
528199767f8SToomas Soome enum zio_checksum {
529199767f8SToomas Soome 	ZIO_CHECKSUM_INHERIT = 0,
530199767f8SToomas Soome 	ZIO_CHECKSUM_ON,
531199767f8SToomas Soome 	ZIO_CHECKSUM_OFF,
532199767f8SToomas Soome 	ZIO_CHECKSUM_LABEL,
533199767f8SToomas Soome 	ZIO_CHECKSUM_GANG_HEADER,
534199767f8SToomas Soome 	ZIO_CHECKSUM_ZILOG,
535199767f8SToomas Soome 	ZIO_CHECKSUM_FLETCHER_2,
536199767f8SToomas Soome 	ZIO_CHECKSUM_FLETCHER_4,
537199767f8SToomas Soome 	ZIO_CHECKSUM_SHA256,
538199767f8SToomas Soome 	ZIO_CHECKSUM_ZILOG2,
539199767f8SToomas Soome 	ZIO_CHECKSUM_NOPARITY,
540199767f8SToomas Soome 	ZIO_CHECKSUM_SHA512,
541199767f8SToomas Soome 	ZIO_CHECKSUM_SKEIN,
542199767f8SToomas Soome 	ZIO_CHECKSUM_EDONR,
543199767f8SToomas Soome 	ZIO_CHECKSUM_FUNCTIONS
544199767f8SToomas Soome };
545199767f8SToomas Soome 
546199767f8SToomas Soome #define	ZIO_CHECKSUM_ON_VALUE	ZIO_CHECKSUM_FLETCHER_4
547199767f8SToomas Soome #define	ZIO_CHECKSUM_DEFAULT	ZIO_CHECKSUM_ON
548199767f8SToomas Soome 
549199767f8SToomas Soome enum zio_compress {
550199767f8SToomas Soome 	ZIO_COMPRESS_INHERIT = 0,
551199767f8SToomas Soome 	ZIO_COMPRESS_ON,
552199767f8SToomas Soome 	ZIO_COMPRESS_OFF,
553199767f8SToomas Soome 	ZIO_COMPRESS_LZJB,
554199767f8SToomas Soome 	ZIO_COMPRESS_EMPTY,
555199767f8SToomas Soome 	ZIO_COMPRESS_GZIP_1,
556199767f8SToomas Soome 	ZIO_COMPRESS_GZIP_2,
557199767f8SToomas Soome 	ZIO_COMPRESS_GZIP_3,
558199767f8SToomas Soome 	ZIO_COMPRESS_GZIP_4,
559199767f8SToomas Soome 	ZIO_COMPRESS_GZIP_5,
560199767f8SToomas Soome 	ZIO_COMPRESS_GZIP_6,
561199767f8SToomas Soome 	ZIO_COMPRESS_GZIP_7,
562199767f8SToomas Soome 	ZIO_COMPRESS_GZIP_8,
563199767f8SToomas Soome 	ZIO_COMPRESS_GZIP_9,
564199767f8SToomas Soome 	ZIO_COMPRESS_ZLE,
565199767f8SToomas Soome 	ZIO_COMPRESS_LZ4,
566199767f8SToomas Soome 	ZIO_COMPRESS_FUNCTIONS
567199767f8SToomas Soome };
568199767f8SToomas Soome 
569199767f8SToomas Soome #define	ZIO_COMPRESS_ON_VALUE	ZIO_COMPRESS_LZJB
570199767f8SToomas Soome #define	ZIO_COMPRESS_DEFAULT	ZIO_COMPRESS_OFF
571199767f8SToomas Soome 
572199767f8SToomas Soome /* nvlist pack encoding */
573199767f8SToomas Soome #define	NV_ENCODE_NATIVE	0
574199767f8SToomas Soome #define	NV_ENCODE_XDR		1
575199767f8SToomas Soome 
576199767f8SToomas Soome typedef enum {
577199767f8SToomas Soome 	DATA_TYPE_UNKNOWN = 0,
578199767f8SToomas Soome 	DATA_TYPE_BOOLEAN,
579199767f8SToomas Soome 	DATA_TYPE_BYTE,
580199767f8SToomas Soome 	DATA_TYPE_INT16,
581199767f8SToomas Soome 	DATA_TYPE_UINT16,
582199767f8SToomas Soome 	DATA_TYPE_INT32,
583199767f8SToomas Soome 	DATA_TYPE_UINT32,
584199767f8SToomas Soome 	DATA_TYPE_INT64,
585199767f8SToomas Soome 	DATA_TYPE_UINT64,
586199767f8SToomas Soome 	DATA_TYPE_STRING,
587199767f8SToomas Soome 	DATA_TYPE_BYTE_ARRAY,
588199767f8SToomas Soome 	DATA_TYPE_INT16_ARRAY,
589199767f8SToomas Soome 	DATA_TYPE_UINT16_ARRAY,
590199767f8SToomas Soome 	DATA_TYPE_INT32_ARRAY,
591199767f8SToomas Soome 	DATA_TYPE_UINT32_ARRAY,
592199767f8SToomas Soome 	DATA_TYPE_INT64_ARRAY,
593199767f8SToomas Soome 	DATA_TYPE_UINT64_ARRAY,
594199767f8SToomas Soome 	DATA_TYPE_STRING_ARRAY,
595199767f8SToomas Soome 	DATA_TYPE_HRTIME,
596199767f8SToomas Soome 	DATA_TYPE_NVLIST,
597199767f8SToomas Soome 	DATA_TYPE_NVLIST_ARRAY,
598199767f8SToomas Soome 	DATA_TYPE_BOOLEAN_VALUE,
599199767f8SToomas Soome 	DATA_TYPE_INT8,
600199767f8SToomas Soome 	DATA_TYPE_UINT8,
601199767f8SToomas Soome 	DATA_TYPE_BOOLEAN_ARRAY,
602199767f8SToomas Soome 	DATA_TYPE_INT8_ARRAY,
603199767f8SToomas Soome 	DATA_TYPE_UINT8_ARRAY
604199767f8SToomas Soome } data_type_t;
605199767f8SToomas Soome 
606199767f8SToomas Soome /*
607199767f8SToomas Soome  * On-disk version number.
608199767f8SToomas Soome  */
609199767f8SToomas Soome #define	SPA_VERSION_1			1ULL
610199767f8SToomas Soome #define	SPA_VERSION_2			2ULL
611199767f8SToomas Soome #define	SPA_VERSION_3			3ULL
612199767f8SToomas Soome #define	SPA_VERSION_4			4ULL
613199767f8SToomas Soome #define	SPA_VERSION_5			5ULL
614199767f8SToomas Soome #define	SPA_VERSION_6			6ULL
615199767f8SToomas Soome #define	SPA_VERSION_7			7ULL
616199767f8SToomas Soome #define	SPA_VERSION_8			8ULL
617199767f8SToomas Soome #define	SPA_VERSION_9			9ULL
618199767f8SToomas Soome #define	SPA_VERSION_10			10ULL
619199767f8SToomas Soome #define	SPA_VERSION_11			11ULL
620199767f8SToomas Soome #define	SPA_VERSION_12			12ULL
621199767f8SToomas Soome #define	SPA_VERSION_13			13ULL
622199767f8SToomas Soome #define	SPA_VERSION_14			14ULL
623199767f8SToomas Soome #define	SPA_VERSION_15			15ULL
624199767f8SToomas Soome #define	SPA_VERSION_16			16ULL
625199767f8SToomas Soome #define	SPA_VERSION_17			17ULL
626199767f8SToomas Soome #define	SPA_VERSION_18			18ULL
627199767f8SToomas Soome #define	SPA_VERSION_19			19ULL
628199767f8SToomas Soome #define	SPA_VERSION_20			20ULL
629199767f8SToomas Soome #define	SPA_VERSION_21			21ULL
630199767f8SToomas Soome #define	SPA_VERSION_22			22ULL
631199767f8SToomas Soome #define	SPA_VERSION_23			23ULL
632199767f8SToomas Soome #define	SPA_VERSION_24			24ULL
633199767f8SToomas Soome #define	SPA_VERSION_25			25ULL
634199767f8SToomas Soome #define	SPA_VERSION_26			26ULL
635199767f8SToomas Soome #define	SPA_VERSION_27			27ULL
636199767f8SToomas Soome #define	SPA_VERSION_28			28ULL
637199767f8SToomas Soome #define	SPA_VERSION_5000		5000ULL
638199767f8SToomas Soome 
639199767f8SToomas Soome /*
640199767f8SToomas Soome  * When bumping up SPA_VERSION, make sure GRUB ZFS understands the on-disk
641199767f8SToomas Soome  * format change. Go to usr/src/grub/grub-0.97/stage2/{zfs-include/, fsys_zfs*},
642199767f8SToomas Soome  * and do the appropriate changes.  Also bump the version number in
643199767f8SToomas Soome  * usr/src/grub/capability.
644199767f8SToomas Soome  */
645199767f8SToomas Soome #define	SPA_VERSION			SPA_VERSION_5000
646199767f8SToomas Soome #define	SPA_VERSION_STRING		"5000"
647199767f8SToomas Soome 
648199767f8SToomas Soome /*
649199767f8SToomas Soome  * Symbolic names for the changes that caused a SPA_VERSION switch.
650199767f8SToomas Soome  * Used in the code when checking for presence or absence of a feature.
651199767f8SToomas Soome  * Feel free to define multiple symbolic names for each version if there
652199767f8SToomas Soome  * were multiple changes to on-disk structures during that version.
653199767f8SToomas Soome  *
654199767f8SToomas Soome  * NOTE: When checking the current SPA_VERSION in your code, be sure
655199767f8SToomas Soome  *       to use spa_version() since it reports the version of the
656199767f8SToomas Soome  *       last synced uberblock.  Checking the in-flight version can
657199767f8SToomas Soome  *       be dangerous in some cases.
658199767f8SToomas Soome  */
659199767f8SToomas Soome #define	SPA_VERSION_INITIAL		SPA_VERSION_1
660199767f8SToomas Soome #define	SPA_VERSION_DITTO_BLOCKS	SPA_VERSION_2
661199767f8SToomas Soome #define	SPA_VERSION_SPARES		SPA_VERSION_3
662199767f8SToomas Soome #define	SPA_VERSION_RAID6		SPA_VERSION_3
663199767f8SToomas Soome #define	SPA_VERSION_BPLIST_ACCOUNT	SPA_VERSION_3
664199767f8SToomas Soome #define	SPA_VERSION_RAIDZ_DEFLATE	SPA_VERSION_3
665199767f8SToomas Soome #define	SPA_VERSION_DNODE_BYTES		SPA_VERSION_3
666199767f8SToomas Soome #define	SPA_VERSION_ZPOOL_HISTORY	SPA_VERSION_4
667199767f8SToomas Soome #define	SPA_VERSION_GZIP_COMPRESSION	SPA_VERSION_5
668199767f8SToomas Soome #define	SPA_VERSION_BOOTFS		SPA_VERSION_6
669199767f8SToomas Soome #define	SPA_VERSION_SLOGS		SPA_VERSION_7
670199767f8SToomas Soome #define	SPA_VERSION_DELEGATED_PERMS	SPA_VERSION_8
671199767f8SToomas Soome #define	SPA_VERSION_FUID		SPA_VERSION_9
672199767f8SToomas Soome #define	SPA_VERSION_REFRESERVATION	SPA_VERSION_9
673199767f8SToomas Soome #define	SPA_VERSION_REFQUOTA		SPA_VERSION_9
674199767f8SToomas Soome #define	SPA_VERSION_UNIQUE_ACCURATE	SPA_VERSION_9
675199767f8SToomas Soome #define	SPA_VERSION_L2CACHE		SPA_VERSION_10
676199767f8SToomas Soome #define	SPA_VERSION_NEXT_CLONES		SPA_VERSION_11
677199767f8SToomas Soome #define	SPA_VERSION_ORIGIN		SPA_VERSION_11
678199767f8SToomas Soome #define	SPA_VERSION_DSL_SCRUB		SPA_VERSION_11
679199767f8SToomas Soome #define	SPA_VERSION_SNAP_PROPS		SPA_VERSION_12
680199767f8SToomas Soome #define	SPA_VERSION_USED_BREAKDOWN	SPA_VERSION_13
681199767f8SToomas Soome #define	SPA_VERSION_PASSTHROUGH_X	SPA_VERSION_14
682*08487eeaSToomas Soome #define	SPA_VERSION_USERSPACE		SPA_VERSION_15
683199767f8SToomas Soome #define	SPA_VERSION_STMF_PROP		SPA_VERSION_16
684199767f8SToomas Soome #define	SPA_VERSION_RAIDZ3		SPA_VERSION_17
685199767f8SToomas Soome #define	SPA_VERSION_USERREFS		SPA_VERSION_18
686199767f8SToomas Soome #define	SPA_VERSION_HOLES		SPA_VERSION_19
687199767f8SToomas Soome #define	SPA_VERSION_ZLE_COMPRESSION	SPA_VERSION_20
688199767f8SToomas Soome #define	SPA_VERSION_DEDUP		SPA_VERSION_21
689199767f8SToomas Soome #define	SPA_VERSION_RECVD_PROPS		SPA_VERSION_22
690199767f8SToomas Soome #define	SPA_VERSION_SLIM_ZIL		SPA_VERSION_23
691199767f8SToomas Soome #define	SPA_VERSION_SA			SPA_VERSION_24
692199767f8SToomas Soome #define	SPA_VERSION_SCAN		SPA_VERSION_25
693199767f8SToomas Soome #define	SPA_VERSION_DIR_CLONES		SPA_VERSION_26
694199767f8SToomas Soome #define	SPA_VERSION_DEADLISTS		SPA_VERSION_26
695199767f8SToomas Soome #define	SPA_VERSION_FAST_SNAP		SPA_VERSION_27
696199767f8SToomas Soome #define	SPA_VERSION_MULTI_REPLACE	SPA_VERSION_28
697199767f8SToomas Soome #define	SPA_VERSION_BEFORE_FEATURES	SPA_VERSION_28
698199767f8SToomas Soome #define	SPA_VERSION_FEATURES		SPA_VERSION_5000
699199767f8SToomas Soome 
700199767f8SToomas Soome #define	SPA_VERSION_IS_SUPPORTED(v) \
701199767f8SToomas Soome 	(((v) >= SPA_VERSION_INITIAL && (v) <= SPA_VERSION_BEFORE_FEATURES) || \
702199767f8SToomas Soome 	((v) >= SPA_VERSION_FEATURES && (v) <= SPA_VERSION))
703199767f8SToomas Soome 
704199767f8SToomas Soome /*
705199767f8SToomas Soome  * The following are configuration names used in the nvlist describing a pool's
706199767f8SToomas Soome  * configuration.
707199767f8SToomas Soome  */
708199767f8SToomas Soome #define	ZPOOL_CONFIG_VERSION		"version"
709199767f8SToomas Soome #define	ZPOOL_CONFIG_POOL_NAME		"name"
710199767f8SToomas Soome #define	ZPOOL_CONFIG_POOL_STATE		"state"
711199767f8SToomas Soome #define	ZPOOL_CONFIG_POOL_TXG		"txg"
712199767f8SToomas Soome #define	ZPOOL_CONFIG_POOL_GUID		"pool_guid"
713199767f8SToomas Soome #define	ZPOOL_CONFIG_CREATE_TXG		"create_txg"
714199767f8SToomas Soome #define	ZPOOL_CONFIG_TOP_GUID		"top_guid"
715199767f8SToomas Soome #define	ZPOOL_CONFIG_VDEV_TREE		"vdev_tree"
716199767f8SToomas Soome #define	ZPOOL_CONFIG_TYPE		"type"
717199767f8SToomas Soome #define	ZPOOL_CONFIG_CHILDREN		"children"
718199767f8SToomas Soome #define	ZPOOL_CONFIG_ID			"id"
719199767f8SToomas Soome #define	ZPOOL_CONFIG_GUID		"guid"
720199767f8SToomas Soome #define	ZPOOL_CONFIG_PATH		"path"
721199767f8SToomas Soome #define	ZPOOL_CONFIG_DEVID		"devid"
722199767f8SToomas Soome #define	ZPOOL_CONFIG_PHYS_PATH		"phys_path"
723199767f8SToomas Soome #define	ZPOOL_CONFIG_METASLAB_ARRAY	"metaslab_array"
724199767f8SToomas Soome #define	ZPOOL_CONFIG_METASLAB_SHIFT	"metaslab_shift"
725199767f8SToomas Soome #define	ZPOOL_CONFIG_ASHIFT		"ashift"
726199767f8SToomas Soome #define	ZPOOL_CONFIG_ASIZE		"asize"
727199767f8SToomas Soome #define	ZPOOL_CONFIG_DTL		"DTL"
728199767f8SToomas Soome #define	ZPOOL_CONFIG_STATS		"stats"
729199767f8SToomas Soome #define	ZPOOL_CONFIG_WHOLE_DISK		"whole_disk"
730199767f8SToomas Soome #define	ZPOOL_CONFIG_ERRCOUNT		"error_count"
731199767f8SToomas Soome #define	ZPOOL_CONFIG_NOT_PRESENT	"not_present"
732199767f8SToomas Soome #define	ZPOOL_CONFIG_SPARES		"spares"
733199767f8SToomas Soome #define	ZPOOL_CONFIG_IS_SPARE		"is_spare"
734199767f8SToomas Soome #define	ZPOOL_CONFIG_NPARITY		"nparity"
735199767f8SToomas Soome #define	ZPOOL_CONFIG_HOSTID		"hostid"
736199767f8SToomas Soome #define	ZPOOL_CONFIG_HOSTNAME		"hostname"
737199767f8SToomas Soome #define	ZPOOL_CONFIG_IS_LOG		"is_log"
738199767f8SToomas Soome #define	ZPOOL_CONFIG_TIMESTAMP		"timestamp" /* not stored on disk */
739199767f8SToomas Soome #define	ZPOOL_CONFIG_FEATURES_FOR_READ	"features_for_read"
740199767f8SToomas Soome 
741199767f8SToomas Soome /*
742199767f8SToomas Soome  * The persistent vdev state is stored as separate values rather than a single
743199767f8SToomas Soome  * 'vdev_state' entry.  This is because a device can be in multiple states, such
744199767f8SToomas Soome  * as offline and degraded.
745199767f8SToomas Soome  */
746*08487eeaSToomas Soome #define	ZPOOL_CONFIG_OFFLINE		"offline"
747*08487eeaSToomas Soome #define	ZPOOL_CONFIG_FAULTED		"faulted"
748*08487eeaSToomas Soome #define	ZPOOL_CONFIG_DEGRADED		"degraded"
749*08487eeaSToomas Soome #define	ZPOOL_CONFIG_REMOVED		"removed"
750199767f8SToomas Soome #define	ZPOOL_CONFIG_FRU		"fru"
751199767f8SToomas Soome #define	ZPOOL_CONFIG_AUX_STATE		"aux_state"
752199767f8SToomas Soome 
753199767f8SToomas Soome #define	VDEV_TYPE_ROOT			"root"
754199767f8SToomas Soome #define	VDEV_TYPE_MIRROR		"mirror"
755199767f8SToomas Soome #define	VDEV_TYPE_REPLACING		"replacing"
756199767f8SToomas Soome #define	VDEV_TYPE_RAIDZ			"raidz"
757199767f8SToomas Soome #define	VDEV_TYPE_DISK			"disk"
758199767f8SToomas Soome #define	VDEV_TYPE_FILE			"file"
759199767f8SToomas Soome #define	VDEV_TYPE_MISSING		"missing"
760199767f8SToomas Soome #define	VDEV_TYPE_HOLE			"hole"
761199767f8SToomas Soome #define	VDEV_TYPE_SPARE			"spare"
762199767f8SToomas Soome #define	VDEV_TYPE_LOG			"log"
763199767f8SToomas Soome #define	VDEV_TYPE_L2CACHE		"l2cache"
764199767f8SToomas Soome 
765199767f8SToomas Soome /*
766199767f8SToomas Soome  * This is needed in userland to report the minimum necessary device size.
767199767f8SToomas Soome  */
768199767f8SToomas Soome #define	SPA_MINDEVSIZE		(64ULL << 20)
769199767f8SToomas Soome 
770199767f8SToomas Soome /*
771199767f8SToomas Soome  * The location of the pool configuration repository, shared between kernel and
772199767f8SToomas Soome  * userland.
773199767f8SToomas Soome  */
774199767f8SToomas Soome #define	ZPOOL_CACHE		"/boot/zfs/zpool.cache"
775199767f8SToomas Soome 
776199767f8SToomas Soome /*
777199767f8SToomas Soome  * vdev states are ordered from least to most healthy.
778199767f8SToomas Soome  * A vdev that's CANT_OPEN or below is considered unusable.
779199767f8SToomas Soome  */
780199767f8SToomas Soome typedef enum vdev_state {
781199767f8SToomas Soome 	VDEV_STATE_UNKNOWN = 0,	/* Uninitialized vdev			*/
782199767f8SToomas Soome 	VDEV_STATE_CLOSED,	/* Not currently open			*/
783199767f8SToomas Soome 	VDEV_STATE_OFFLINE,	/* Not allowed to open			*/
784199767f8SToomas Soome 	VDEV_STATE_REMOVED,	/* Explicitly removed from system	*/
785199767f8SToomas Soome 	VDEV_STATE_CANT_OPEN,	/* Tried to open, but failed		*/
786199767f8SToomas Soome 	VDEV_STATE_FAULTED,	/* External request to fault device	*/
787199767f8SToomas Soome 	VDEV_STATE_DEGRADED,	/* Replicated vdev with unhealthy kids	*/
788199767f8SToomas Soome 	VDEV_STATE_HEALTHY	/* Presumed good			*/
789199767f8SToomas Soome } vdev_state_t;
790199767f8SToomas Soome 
791199767f8SToomas Soome /*
792199767f8SToomas Soome  * vdev aux states.  When a vdev is in the CANT_OPEN state, the aux field
793199767f8SToomas Soome  * of the vdev stats structure uses these constants to distinguish why.
794199767f8SToomas Soome  */
795199767f8SToomas Soome typedef enum vdev_aux {
796199767f8SToomas Soome 	VDEV_AUX_NONE,		/* no error				*/
797199767f8SToomas Soome 	VDEV_AUX_OPEN_FAILED,	/* ldi_open_*() or vn_open() failed	*/
798199767f8SToomas Soome 	VDEV_AUX_CORRUPT_DATA,	/* bad label or disk contents		*/
799199767f8SToomas Soome 	VDEV_AUX_NO_REPLICAS,	/* insufficient number of replicas	*/
800199767f8SToomas Soome 	VDEV_AUX_BAD_GUID_SUM,	/* vdev guid sum doesn't match		*/
801199767f8SToomas Soome 	VDEV_AUX_TOO_SMALL,	/* vdev size is too small		*/
802199767f8SToomas Soome 	VDEV_AUX_BAD_LABEL,	/* the label is OK but invalid		*/
803199767f8SToomas Soome 	VDEV_AUX_VERSION_NEWER,	/* on-disk version is too new		*/
804199767f8SToomas Soome 	VDEV_AUX_VERSION_OLDER,	/* on-disk version is too old		*/
805199767f8SToomas Soome 	VDEV_AUX_SPARED		/* hot spare used in another pool	*/
806199767f8SToomas Soome } vdev_aux_t;
807199767f8SToomas Soome 
808199767f8SToomas Soome /*
809199767f8SToomas Soome  * pool state.  The following states are written to disk as part of the normal
810199767f8SToomas Soome  * SPA lifecycle: ACTIVE, EXPORTED, DESTROYED, SPARE.  The remaining states are
811199767f8SToomas Soome  * software abstractions used at various levels to communicate pool state.
812199767f8SToomas Soome  */
813199767f8SToomas Soome typedef enum pool_state {
814199767f8SToomas Soome 	POOL_STATE_ACTIVE = 0,		/* In active use		*/
815199767f8SToomas Soome 	POOL_STATE_EXPORTED,		/* Explicitly exported		*/
816199767f8SToomas Soome 	POOL_STATE_DESTROYED,		/* Explicitly destroyed		*/
817199767f8SToomas Soome 	POOL_STATE_SPARE,		/* Reserved for hot spare use	*/
818199767f8SToomas Soome 	POOL_STATE_UNINITIALIZED,	/* Internal spa_t state		*/
819199767f8SToomas Soome 	POOL_STATE_UNAVAIL,		/* Internal libzfs state	*/
820199767f8SToomas Soome 	POOL_STATE_POTENTIALLY_ACTIVE	/* Internal libzfs state	*/
821199767f8SToomas Soome } pool_state_t;
822199767f8SToomas Soome 
823199767f8SToomas Soome /*
824199767f8SToomas Soome  * The uberblock version is incremented whenever an incompatible on-disk
825199767f8SToomas Soome  * format change is made to the SPA, DMU, or ZAP.
826199767f8SToomas Soome  *
827199767f8SToomas Soome  * Note: the first two fields should never be moved.  When a storage pool
828199767f8SToomas Soome  * is opened, the uberblock must be read off the disk before the version
829199767f8SToomas Soome  * can be checked.  If the ub_version field is moved, we may not detect
830199767f8SToomas Soome  * version mismatch.  If the ub_magic field is moved, applications that
831199767f8SToomas Soome  * expect the magic number in the first word won't work.
832199767f8SToomas Soome  */
833199767f8SToomas Soome #define	UBERBLOCK_MAGIC		0x00bab10c		/* oo-ba-bloc!	*/
834199767f8SToomas Soome #define	UBERBLOCK_SHIFT		10			/* up to 1K	*/
835199767f8SToomas Soome 
836199767f8SToomas Soome struct uberblock {
837199767f8SToomas Soome 	uint64_t	ub_magic;	/* UBERBLOCK_MAGIC		*/
838199767f8SToomas Soome 	uint64_t	ub_version;	/* SPA_VERSION			*/
839199767f8SToomas Soome 	uint64_t	ub_txg;		/* txg of last sync		*/
840199767f8SToomas Soome 	uint64_t	ub_guid_sum;	/* sum of all vdev guids	*/
841199767f8SToomas Soome 	uint64_t	ub_timestamp;	/* UTC time of last sync	*/
842199767f8SToomas Soome 	blkptr_t	ub_rootbp;	/* MOS objset_phys_t		*/
843199767f8SToomas Soome };
844199767f8SToomas Soome 
845199767f8SToomas Soome /*
846199767f8SToomas Soome  * Flags.
847199767f8SToomas Soome  */
848199767f8SToomas Soome #define	DNODE_MUST_BE_ALLOCATED	1
849199767f8SToomas Soome #define	DNODE_MUST_BE_FREE	2
850199767f8SToomas Soome 
851199767f8SToomas Soome /*
852199767f8SToomas Soome  * Fixed constants.
853199767f8SToomas Soome  */
854199767f8SToomas Soome #define	DNODE_SHIFT		9	/* 512 bytes */
855199767f8SToomas Soome #define	DN_MIN_INDBLKSHIFT	12	/* 4k */
856199767f8SToomas Soome #define	DN_MAX_INDBLKSHIFT	14	/* 16k */
857199767f8SToomas Soome #define	DNODE_BLOCK_SHIFT	14	/* 16k */
858199767f8SToomas Soome #define	DNODE_CORE_SIZE		64	/* 64 bytes for dnode sans blkptrs */
859199767f8SToomas Soome #define	DN_MAX_OBJECT_SHIFT	48	/* 256 trillion (zfs_fid_t limit) */
860199767f8SToomas Soome #define	DN_MAX_OFFSET_SHIFT	64	/* 2^64 bytes in a dnode */
861199767f8SToomas Soome 
862199767f8SToomas Soome /*
863199767f8SToomas Soome  * Derived constants.
864199767f8SToomas Soome  */
865f905073dSToomas Soome #define	DNODE_MIN_SIZE		(1 << DNODE_SHIFT)
866f905073dSToomas Soome #define	DNODE_MAX_SIZE		(1 << DNODE_BLOCK_SHIFT)
867f905073dSToomas Soome #define	DNODE_BLOCK_SIZE	(1 << DNODE_BLOCK_SHIFT)
868f905073dSToomas Soome #define	DNODE_MIN_SLOTS		(DNODE_MIN_SIZE >> DNODE_SHIFT)
869f905073dSToomas Soome #define	DNODE_MAX_SLOTS		(DNODE_MAX_SIZE >> DNODE_SHIFT)
870f905073dSToomas Soome #define	DN_BONUS_SIZE(dnsize)	((dnsize) - DNODE_CORE_SIZE - \
871f905073dSToomas Soome 	(1 << SPA_BLKPTRSHIFT))
872f905073dSToomas Soome #define	DN_SLOTS_TO_BONUSLEN(slots)	DN_BONUS_SIZE((slots) << DNODE_SHIFT)
873f905073dSToomas Soome #define	DN_OLD_MAX_BONUSLEN		(DN_BONUS_SIZE(DNODE_MIN_SIZE))
874f905073dSToomas Soome #define	DN_MAX_NBLKPTR		((DNODE_MIN_SIZE - DNODE_CORE_SIZE) >> \
875f905073dSToomas Soome 	SPA_BLKPTRSHIFT)
876f905073dSToomas Soome #define	DN_MAX_OBJECT		(1ULL << DN_MAX_OBJECT_SHIFT)
877f905073dSToomas Soome #define	DN_ZERO_BONUSLEN	(DN_BONUS_SIZE(DNODE_MAX_SIZE) + 1)
878199767f8SToomas Soome 
879199767f8SToomas Soome #define	DNODES_PER_BLOCK_SHIFT	(DNODE_BLOCK_SHIFT - DNODE_SHIFT)
880199767f8SToomas Soome #define	DNODES_PER_BLOCK	(1ULL << DNODES_PER_BLOCK_SHIFT)
881199767f8SToomas Soome #define	DNODES_PER_LEVEL_SHIFT	(DN_MAX_INDBLKSHIFT - SPA_BLKPTRSHIFT)
882199767f8SToomas Soome 
883199767f8SToomas Soome /* The +2 here is a cheesy way to round up */
884199767f8SToomas Soome #define	DN_MAX_LEVELS	(2 + ((DN_MAX_OFFSET_SHIFT - SPA_MINBLOCKSHIFT) / \
885199767f8SToomas Soome 	(DN_MIN_INDBLKSHIFT - SPA_BLKPTRSHIFT)))
886199767f8SToomas Soome 
887199767f8SToomas Soome #define	DN_BONUS(dnp)	((void*)((dnp)->dn_bonus + \
888199767f8SToomas Soome 	(((dnp)->dn_nblkptr - 1) * sizeof (blkptr_t))))
889199767f8SToomas Soome 
890199767f8SToomas Soome #define	DN_USED_BYTES(dnp) (((dnp)->dn_flags & DNODE_FLAG_USED_BYTES) ? \
891199767f8SToomas Soome 	(dnp)->dn_used : (dnp)->dn_used << SPA_MINBLOCKSHIFT)
892199767f8SToomas Soome 
893199767f8SToomas Soome #define	EPB(blkshift, typeshift)	(1 << (blkshift - typeshift))
894199767f8SToomas Soome 
895199767f8SToomas Soome /* Is dn_used in bytes?  if not, it's in multiples of SPA_MINBLOCKSIZE */
896199767f8SToomas Soome #define	DNODE_FLAG_USED_BYTES		(1<<0)
897199767f8SToomas Soome #define	DNODE_FLAG_USERUSED_ACCOUNTED	(1<<1)
898199767f8SToomas Soome 
899199767f8SToomas Soome /* Does dnode have a SA spill blkptr in bonus? */
900199767f8SToomas Soome #define	DNODE_FLAG_SPILL_BLKPTR	(1<<2)
901199767f8SToomas Soome 
902199767f8SToomas Soome typedef struct dnode_phys {
903199767f8SToomas Soome 	uint8_t dn_type;		/* dmu_object_type_t */
904199767f8SToomas Soome 	uint8_t dn_indblkshift;		/* ln2(indirect block size) */
905199767f8SToomas Soome 	uint8_t dn_nlevels;		/* 1=dn_blkptr->data blocks */
906199767f8SToomas Soome 	uint8_t dn_nblkptr;		/* length of dn_blkptr */
907199767f8SToomas Soome 	uint8_t dn_bonustype;		/* type of data in bonus buffer */
908199767f8SToomas Soome 	uint8_t	dn_checksum;		/* ZIO_CHECKSUM type */
909199767f8SToomas Soome 	uint8_t	dn_compress;		/* ZIO_COMPRESS type */
910199767f8SToomas Soome 	uint8_t dn_flags;		/* DNODE_FLAG_* */
911199767f8SToomas Soome 	uint16_t dn_datablkszsec;	/* data block size in 512b sectors */
912199767f8SToomas Soome 	uint16_t dn_bonuslen;		/* length of dn_bonus */
913f905073dSToomas Soome 	uint8_t dn_extra_slots;		/* # of subsequent slots consumed */
914f905073dSToomas Soome 	uint8_t dn_pad2[3];
915199767f8SToomas Soome 
916199767f8SToomas Soome 	/* accounting is protected by dn_dirty_mtx */
917199767f8SToomas Soome 	uint64_t dn_maxblkid;		/* largest allocated block ID */
918199767f8SToomas Soome 	uint64_t dn_used;		/* bytes (or sectors) of disk space */
919199767f8SToomas Soome 
920199767f8SToomas Soome 	uint64_t dn_pad3[4];
921199767f8SToomas Soome 
922f905073dSToomas Soome 	/*
923f905073dSToomas Soome 	 * The tail region is 448 bytes for a 512 byte dnode, and
924f905073dSToomas Soome 	 * correspondingly larger for larger dnode sizes. The spill
925f905073dSToomas Soome 	 * block pointer, when present, is always at the end of the tail
926f905073dSToomas Soome 	 * region. There are three ways this space may be used, using
927f905073dSToomas Soome 	 * a 512 byte dnode for this diagram:
928f905073dSToomas Soome 	 *
929f905073dSToomas Soome 	 * 0       64      128     192     256     320     384     448 (offset)
930f905073dSToomas Soome 	 * +---------------+---------------+---------------+-------+
931f905073dSToomas Soome 	 * | dn_blkptr[0]  | dn_blkptr[1]  | dn_blkptr[2]  | /     |
932f905073dSToomas Soome 	 * +---------------+---------------+---------------+-------+
933f905073dSToomas Soome 	 * | dn_blkptr[0]  | dn_bonus[0..319]                      |
934f905073dSToomas Soome 	 * +---------------+-----------------------+---------------+
935f905073dSToomas Soome 	 * | dn_blkptr[0]  | dn_bonus[0..191]      | dn_spill      |
936f905073dSToomas Soome 	 * +---------------+-----------------------+---------------+
937f905073dSToomas Soome 	 */
938f905073dSToomas Soome 	union {
939f905073dSToomas Soome 		blkptr_t dn_blkptr[1+DN_OLD_MAX_BONUSLEN/sizeof (blkptr_t)];
940f905073dSToomas Soome 		struct {
941f905073dSToomas Soome 			blkptr_t __dn_ignore1;
942f905073dSToomas Soome 			uint8_t dn_bonus[DN_OLD_MAX_BONUSLEN];
943f905073dSToomas Soome 		};
944f905073dSToomas Soome 		struct {
945f905073dSToomas Soome 			blkptr_t __dn_ignore2;
946f905073dSToomas Soome 			uint8_t __dn_ignore3[DN_OLD_MAX_BONUSLEN -
947f905073dSToomas Soome 			    sizeof (blkptr_t)];
948f905073dSToomas Soome 			blkptr_t dn_spill;
949f905073dSToomas Soome 		};
950f905073dSToomas Soome 	};
951199767f8SToomas Soome } dnode_phys_t;
952199767f8SToomas Soome 
953f905073dSToomas Soome #define	DN_SPILL_BLKPTR(dnp)	(blkptr_t *)((char *)(dnp) + \
954f905073dSToomas Soome 	(((dnp)->dn_extra_slots + 1) << DNODE_SHIFT) - (1 << SPA_BLKPTRSHIFT))
955f905073dSToomas Soome 
956199767f8SToomas Soome typedef enum dmu_object_byteswap {
957199767f8SToomas Soome 	DMU_BSWAP_UINT8,
958199767f8SToomas Soome 	DMU_BSWAP_UINT16,
959199767f8SToomas Soome 	DMU_BSWAP_UINT32,
960199767f8SToomas Soome 	DMU_BSWAP_UINT64,
961199767f8SToomas Soome 	DMU_BSWAP_ZAP,
962199767f8SToomas Soome 	DMU_BSWAP_DNODE,
963199767f8SToomas Soome 	DMU_BSWAP_OBJSET,
964199767f8SToomas Soome 	DMU_BSWAP_ZNODE,
965199767f8SToomas Soome 	DMU_BSWAP_OLDACL,
966199767f8SToomas Soome 	DMU_BSWAP_ACL,
967199767f8SToomas Soome 	/*
968199767f8SToomas Soome 	 * Allocating a new byteswap type number makes the on-disk format
969199767f8SToomas Soome 	 * incompatible with any other format that uses the same number.
970199767f8SToomas Soome 	 *
971199767f8SToomas Soome 	 * Data can usually be structured to work with one of the
972199767f8SToomas Soome 	 * DMU_BSWAP_UINT* or DMU_BSWAP_ZAP types.
973199767f8SToomas Soome 	 */
974199767f8SToomas Soome 	DMU_BSWAP_NUMFUNCS
975199767f8SToomas Soome } dmu_object_byteswap_t;
976199767f8SToomas Soome 
977199767f8SToomas Soome #define	DMU_OT_NEWTYPE 0x80
978199767f8SToomas Soome #define	DMU_OT_METADATA 0x40
979199767f8SToomas Soome #define	DMU_OT_BYTESWAP_MASK 0x3f
980199767f8SToomas Soome 
981199767f8SToomas Soome /*
982199767f8SToomas Soome  * Defines a uint8_t object type. Object types specify if the data
983199767f8SToomas Soome  * in the object is metadata (boolean) and how to byteswap the data
984199767f8SToomas Soome  * (dmu_object_byteswap_t).
985199767f8SToomas Soome  */
986199767f8SToomas Soome #define	DMU_OT(byteswap, metadata) \
987199767f8SToomas Soome 	(DMU_OT_NEWTYPE | \
988199767f8SToomas Soome 	((metadata) ? DMU_OT_METADATA : 0) | \
989199767f8SToomas Soome 	((byteswap) & DMU_OT_BYTESWAP_MASK))
990199767f8SToomas Soome 
991199767f8SToomas Soome typedef enum dmu_object_type {
992199767f8SToomas Soome 	DMU_OT_NONE,
993199767f8SToomas Soome 	/* general: */
994199767f8SToomas Soome 	DMU_OT_OBJECT_DIRECTORY,	/* ZAP */
995199767f8SToomas Soome 	DMU_OT_OBJECT_ARRAY,		/* UINT64 */
996199767f8SToomas Soome 	DMU_OT_PACKED_NVLIST,		/* UINT8 (XDR by nvlist_pack/unpack) */
997199767f8SToomas Soome 	DMU_OT_PACKED_NVLIST_SIZE,	/* UINT64 */
998199767f8SToomas Soome 	DMU_OT_BPLIST,			/* UINT64 */
999199767f8SToomas Soome 	DMU_OT_BPLIST_HDR,		/* UINT64 */
1000199767f8SToomas Soome 	/* spa: */
1001199767f8SToomas Soome 	DMU_OT_SPACE_MAP_HEADER,	/* UINT64 */
1002199767f8SToomas Soome 	DMU_OT_SPACE_MAP,		/* UINT64 */
1003199767f8SToomas Soome 	/* zil: */
1004199767f8SToomas Soome 	DMU_OT_INTENT_LOG,		/* UINT64 */
1005199767f8SToomas Soome 	/* dmu: */
1006199767f8SToomas Soome 	DMU_OT_DNODE,			/* DNODE */
1007199767f8SToomas Soome 	DMU_OT_OBJSET,			/* OBJSET */
1008199767f8SToomas Soome 	/* dsl: */
1009199767f8SToomas Soome 	DMU_OT_DSL_DIR,			/* UINT64 */
1010199767f8SToomas Soome 	DMU_OT_DSL_DIR_CHILD_MAP,	/* ZAP */
1011199767f8SToomas Soome 	DMU_OT_DSL_DS_SNAP_MAP,		/* ZAP */
1012199767f8SToomas Soome 	DMU_OT_DSL_PROPS,		/* ZAP */
1013199767f8SToomas Soome 	DMU_OT_DSL_DATASET,		/* UINT64 */
1014199767f8SToomas Soome 	/* zpl: */
1015199767f8SToomas Soome 	DMU_OT_ZNODE,			/* ZNODE */
1016199767f8SToomas Soome 	DMU_OT_OLDACL,			/* Old ACL */
1017199767f8SToomas Soome 	DMU_OT_PLAIN_FILE_CONTENTS,	/* UINT8 */
1018199767f8SToomas Soome 	DMU_OT_DIRECTORY_CONTENTS,	/* ZAP */
1019199767f8SToomas Soome 	DMU_OT_MASTER_NODE,		/* ZAP */
1020199767f8SToomas Soome 	DMU_OT_UNLINKED_SET,		/* ZAP */
1021199767f8SToomas Soome 	/* zvol: */
1022199767f8SToomas Soome 	DMU_OT_ZVOL,			/* UINT8 */
1023199767f8SToomas Soome 	DMU_OT_ZVOL_PROP,		/* ZAP */
1024199767f8SToomas Soome 	/* other; for testing only! */
1025199767f8SToomas Soome 	DMU_OT_PLAIN_OTHER,		/* UINT8 */
1026199767f8SToomas Soome 	DMU_OT_UINT64_OTHER,		/* UINT64 */
1027199767f8SToomas Soome 	DMU_OT_ZAP_OTHER,		/* ZAP */
1028199767f8SToomas Soome 	/* new object types: */
1029199767f8SToomas Soome 	DMU_OT_ERROR_LOG,		/* ZAP */
1030199767f8SToomas Soome 	DMU_OT_SPA_HISTORY,		/* UINT8 */
1031199767f8SToomas Soome 	DMU_OT_SPA_HISTORY_OFFSETS,	/* spa_his_phys_t */
1032199767f8SToomas Soome 	DMU_OT_POOL_PROPS,		/* ZAP */
1033199767f8SToomas Soome 	DMU_OT_DSL_PERMS,		/* ZAP */
1034199767f8SToomas Soome 	DMU_OT_ACL,			/* ACL */
1035199767f8SToomas Soome 	DMU_OT_SYSACL,			/* SYSACL */
1036199767f8SToomas Soome 	DMU_OT_FUID,			/* FUID table (Packed NVLIST UINT8) */
1037199767f8SToomas Soome 	DMU_OT_FUID_SIZE,		/* FUID table size UINT64 */
1038199767f8SToomas Soome 	DMU_OT_NEXT_CLONES,		/* ZAP */
1039199767f8SToomas Soome 	DMU_OT_SCAN_QUEUE,		/* ZAP */
1040199767f8SToomas Soome 	DMU_OT_USERGROUP_USED,		/* ZAP */
1041199767f8SToomas Soome 	DMU_OT_USERGROUP_QUOTA,		/* ZAP */
1042199767f8SToomas Soome 	DMU_OT_USERREFS,		/* ZAP */
1043199767f8SToomas Soome 	DMU_OT_DDT_ZAP,			/* ZAP */
1044199767f8SToomas Soome 	DMU_OT_DDT_STATS,		/* ZAP */
1045199767f8SToomas Soome 	DMU_OT_SA,			/* System attr */
1046199767f8SToomas Soome 	DMU_OT_SA_MASTER_NODE,		/* ZAP */
1047199767f8SToomas Soome 	DMU_OT_SA_ATTR_REGISTRATION,	/* ZAP */
1048199767f8SToomas Soome 	DMU_OT_SA_ATTR_LAYOUTS,		/* ZAP */
1049199767f8SToomas Soome 	DMU_OT_SCAN_XLATE,		/* ZAP */
1050199767f8SToomas Soome 	DMU_OT_DEDUP,			/* fake dedup BP from ddt_bp_create() */
1051199767f8SToomas Soome 	DMU_OT_NUMTYPES,
1052199767f8SToomas Soome 
1053199767f8SToomas Soome 	/*
1054199767f8SToomas Soome 	 * Names for valid types declared with DMU_OT().
1055199767f8SToomas Soome 	 */
1056199767f8SToomas Soome 	DMU_OTN_UINT8_DATA = DMU_OT(DMU_BSWAP_UINT8, B_FALSE),
1057199767f8SToomas Soome 	DMU_OTN_UINT8_METADATA = DMU_OT(DMU_BSWAP_UINT8, B_TRUE),
1058199767f8SToomas Soome 	DMU_OTN_UINT16_DATA = DMU_OT(DMU_BSWAP_UINT16, B_FALSE),
1059199767f8SToomas Soome 	DMU_OTN_UINT16_METADATA = DMU_OT(DMU_BSWAP_UINT16, B_TRUE),
1060199767f8SToomas Soome 	DMU_OTN_UINT32_DATA = DMU_OT(DMU_BSWAP_UINT32, B_FALSE),
1061199767f8SToomas Soome 	DMU_OTN_UINT32_METADATA = DMU_OT(DMU_BSWAP_UINT32, B_TRUE),
1062199767f8SToomas Soome 	DMU_OTN_UINT64_DATA = DMU_OT(DMU_BSWAP_UINT64, B_FALSE),
1063199767f8SToomas Soome 	DMU_OTN_UINT64_METADATA = DMU_OT(DMU_BSWAP_UINT64, B_TRUE),
1064199767f8SToomas Soome 	DMU_OTN_ZAP_DATA = DMU_OT(DMU_BSWAP_ZAP, B_FALSE),
1065199767f8SToomas Soome 	DMU_OTN_ZAP_METADATA = DMU_OT(DMU_BSWAP_ZAP, B_TRUE)
1066199767f8SToomas Soome } dmu_object_type_t;
1067199767f8SToomas Soome 
1068199767f8SToomas Soome typedef enum dmu_objset_type {
1069199767f8SToomas Soome 	DMU_OST_NONE,
1070199767f8SToomas Soome 	DMU_OST_META,
1071199767f8SToomas Soome 	DMU_OST_ZFS,
1072199767f8SToomas Soome 	DMU_OST_ZVOL,
1073199767f8SToomas Soome 	DMU_OST_OTHER,			/* For testing only! */
1074199767f8SToomas Soome 	DMU_OST_ANY,			/* Be careful! */
1075199767f8SToomas Soome 	DMU_OST_NUMTYPES
1076199767f8SToomas Soome } dmu_objset_type_t;
1077199767f8SToomas Soome 
10784a04e8dbSToomas Soome #define	ZAP_MAXVALUELEN	(1024 * 8)
10794a04e8dbSToomas Soome 
1080199767f8SToomas Soome /*
1081199767f8SToomas Soome  * header for all bonus and spill buffers.
1082199767f8SToomas Soome  * The header has a fixed portion with a variable number
1083199767f8SToomas Soome  * of "lengths" depending on the number of variable sized
1084199767f8SToomas Soome  * attribues which are determined by the "layout number"
1085199767f8SToomas Soome  */
1086199767f8SToomas Soome 
1087199767f8SToomas Soome #define	SA_MAGIC	0x2F505A  /* ZFS SA */
1088199767f8SToomas Soome typedef struct sa_hdr_phys {
1089199767f8SToomas Soome 	uint32_t sa_magic;
1090199767f8SToomas Soome 	uint16_t sa_layout_info;  /* Encoded with hdrsize and layout number */
1091199767f8SToomas Soome 	uint16_t sa_lengths[1];	/* optional sizes for variable length attrs */
1092199767f8SToomas Soome 	/* ... Data follows the lengths.  */
1093199767f8SToomas Soome } sa_hdr_phys_t;
1094199767f8SToomas Soome 
1095199767f8SToomas Soome /*
1096199767f8SToomas Soome  * sa_hdr_phys -> sa_layout_info
1097199767f8SToomas Soome  *
1098199767f8SToomas Soome  * 16      10       0
1099199767f8SToomas Soome  * +--------+-------+
1100199767f8SToomas Soome  * | hdrsz  |layout |
1101199767f8SToomas Soome  * +--------+-------+
1102199767f8SToomas Soome  *
1103199767f8SToomas Soome  * Bits 0-10 are the layout number
1104199767f8SToomas Soome  * Bits 11-16 are the size of the header.
1105199767f8SToomas Soome  * The hdrsize is the number * 8
1106199767f8SToomas Soome  *
1107199767f8SToomas Soome  * For example.
1108199767f8SToomas Soome  * hdrsz of 1 ==> 8 byte header
1109199767f8SToomas Soome  *          2 ==> 16 byte header
1110199767f8SToomas Soome  *
1111199767f8SToomas Soome  */
1112199767f8SToomas Soome 
1113199767f8SToomas Soome #define	SA_HDR_LAYOUT_NUM(hdr) BF32_GET(hdr->sa_layout_info, 0, 10)
1114199767f8SToomas Soome #define	SA_HDR_SIZE(hdr) BF32_GET_SB(hdr->sa_layout_info, 10, 16, 3, 0)
1115199767f8SToomas Soome #define	SA_HDR_LAYOUT_INFO_ENCODE(x, num, size) \
1116199767f8SToomas Soome { \
1117199767f8SToomas Soome 	BF32_SET_SB(x, 10, 6, 3, 0, size); \
1118199767f8SToomas Soome 	BF32_SET(x, 0, 10, num); \
1119199767f8SToomas Soome }
1120199767f8SToomas Soome 
1121199767f8SToomas Soome #define	SA_MODE_OFFSET		0
1122199767f8SToomas Soome #define	SA_SIZE_OFFSET		8
1123199767f8SToomas Soome #define	SA_GEN_OFFSET		16
1124199767f8SToomas Soome #define	SA_UID_OFFSET		24
1125199767f8SToomas Soome #define	SA_GID_OFFSET		32
1126199767f8SToomas Soome #define	SA_PARENT_OFFSET	40
1127fae4f9e0SToomas Soome #define	SA_SYMLINK_OFFSET	160
1128199767f8SToomas Soome 
1129*08487eeaSToomas Soome #define	ZIO_OBJSET_MAC_LEN	32
1130*08487eeaSToomas Soome 
1131199767f8SToomas Soome /*
1132199767f8SToomas Soome  * Intent log header - this on disk structure holds fields to manage
1133199767f8SToomas Soome  * the log.  All fields are 64 bit to easily handle cross architectures.
1134199767f8SToomas Soome  */
1135199767f8SToomas Soome typedef struct zil_header {
1136199767f8SToomas Soome 	uint64_t zh_claim_txg;	/* txg in which log blocks were claimed */
1137199767f8SToomas Soome 	uint64_t zh_replay_seq;	/* highest replayed sequence number */
1138199767f8SToomas Soome 	blkptr_t zh_log;	/* log chain */
1139199767f8SToomas Soome 	uint64_t zh_claim_seq;	/* highest claimed sequence number */
1140199767f8SToomas Soome 	uint64_t zh_pad[5];
1141199767f8SToomas Soome } zil_header_t;
1142199767f8SToomas Soome 
1143*08487eeaSToomas Soome #define	OBJSET_PHYS_SIZE_V2 2048
1144*08487eeaSToomas Soome #define	OBJSET_PHYS_SIZE_V3 4096
1145*08487eeaSToomas Soome 
1146*08487eeaSToomas Soome #define	OBJSET_PHYS_PAD0_SIZE	\
1147*08487eeaSToomas Soome 	(OBJSET_PHYS_SIZE_V2 - sizeof (dnode_phys_t) * 3 -	\
1148*08487eeaSToomas Soome 	    sizeof (zil_header_t) - sizeof (uint64_t) * 2 -	\
1149*08487eeaSToomas Soome 	    2 * ZIO_OBJSET_MAC_LEN)
1150*08487eeaSToomas Soome #define	OBJSET_PHYS_PAD1_SIZE	\
1151*08487eeaSToomas Soome 	(OBJSET_PHYS_SIZE_V3 - OBJSET_PHYS_SIZE_V2 - sizeof (dnode_phys_t))
1152199767f8SToomas Soome 
1153199767f8SToomas Soome typedef struct objset_phys {
1154199767f8SToomas Soome 	dnode_phys_t os_meta_dnode;
1155199767f8SToomas Soome 	zil_header_t os_zil_header;
1156199767f8SToomas Soome 	uint64_t os_type;
1157199767f8SToomas Soome 	uint64_t os_flags;
1158*08487eeaSToomas Soome 	uint8_t os_portable_mac[ZIO_OBJSET_MAC_LEN];
1159*08487eeaSToomas Soome 	uint8_t os_local_mac[ZIO_OBJSET_MAC_LEN];
1160*08487eeaSToomas Soome 	char os_pad0[OBJSET_PHYS_PAD0_SIZE];
1161199767f8SToomas Soome 	dnode_phys_t os_userused_dnode;
1162199767f8SToomas Soome 	dnode_phys_t os_groupused_dnode;
1163*08487eeaSToomas Soome 	dnode_phys_t os_projectused_dnode;
1164*08487eeaSToomas Soome 	char os_pad1[OBJSET_PHYS_PAD1_SIZE];
1165199767f8SToomas Soome } objset_phys_t;
1166199767f8SToomas Soome 
1167199767f8SToomas Soome typedef struct dsl_dir_phys {
1168199767f8SToomas Soome 	uint64_t dd_creation_time; /* not actually used */
1169199767f8SToomas Soome 	uint64_t dd_head_dataset_obj;
1170199767f8SToomas Soome 	uint64_t dd_parent_obj;
1171199767f8SToomas Soome 	uint64_t dd_clone_parent_obj;
1172199767f8SToomas Soome 	uint64_t dd_child_dir_zapobj;
1173199767f8SToomas Soome 	/*
1174199767f8SToomas Soome 	 * how much space our children are accounting for; for leaf
1175199767f8SToomas Soome 	 * datasets, == physical space used by fs + snaps
1176199767f8SToomas Soome 	 */
1177199767f8SToomas Soome 	uint64_t dd_used_bytes;
1178199767f8SToomas Soome 	uint64_t dd_compressed_bytes;
1179199767f8SToomas Soome 	uint64_t dd_uncompressed_bytes;
1180199767f8SToomas Soome 	/* Administrative quota setting */
1181199767f8SToomas Soome 	uint64_t dd_quota;
1182199767f8SToomas Soome 	/* Administrative reservation setting */
1183199767f8SToomas Soome 	uint64_t dd_reserved;
1184199767f8SToomas Soome 	uint64_t dd_props_zapobj;
1185199767f8SToomas Soome 	uint64_t dd_pad[21]; /* pad out to 256 bytes for good measure */
1186199767f8SToomas Soome } dsl_dir_phys_t;
1187199767f8SToomas Soome 
1188199767f8SToomas Soome typedef struct dsl_dataset_phys {
1189199767f8SToomas Soome 	uint64_t ds_dir_obj;
1190199767f8SToomas Soome 	uint64_t ds_prev_snap_obj;
1191199767f8SToomas Soome 	uint64_t ds_prev_snap_txg;
1192199767f8SToomas Soome 	uint64_t ds_next_snap_obj;
1193199767f8SToomas Soome 	uint64_t ds_snapnames_zapobj;	/* zap obj of snaps; ==0 for snaps */
1194199767f8SToomas Soome 	uint64_t ds_num_children;	/* clone/snap children; ==0 for head */
1195199767f8SToomas Soome 	uint64_t ds_creation_time;	/* seconds since 1970 */
1196199767f8SToomas Soome 	uint64_t ds_creation_txg;
1197199767f8SToomas Soome 	uint64_t ds_deadlist_obj;
1198199767f8SToomas Soome 	uint64_t ds_used_bytes;
1199199767f8SToomas Soome 	uint64_t ds_compressed_bytes;
1200199767f8SToomas Soome 	uint64_t ds_uncompressed_bytes;
1201199767f8SToomas Soome 	uint64_t ds_unique_bytes;	/* only relevant to snapshots */
1202199767f8SToomas Soome 	/*
1203199767f8SToomas Soome 	 * The ds_fsid_guid is a 56-bit ID that can change to avoid
1204199767f8SToomas Soome 	 * collisions.  The ds_guid is a 64-bit ID that will never
1205199767f8SToomas Soome 	 * change, so there is a small probability that it will collide.
1206199767f8SToomas Soome 	 */
1207199767f8SToomas Soome 	uint64_t ds_fsid_guid;
1208199767f8SToomas Soome 	uint64_t ds_guid;
1209199767f8SToomas Soome 	uint64_t ds_flags;
1210199767f8SToomas Soome 	blkptr_t ds_bp;
1211199767f8SToomas Soome 	uint64_t ds_pad[8]; /* pad out to 320 bytes for good measure */
1212199767f8SToomas Soome } dsl_dataset_phys_t;
1213199767f8SToomas Soome 
1214199767f8SToomas Soome /*
1215199767f8SToomas Soome  * The names of zap entries in the DIRECTORY_OBJECT of the MOS.
1216199767f8SToomas Soome  */
1217199767f8SToomas Soome #define	DMU_POOL_DIRECTORY_OBJECT	1
1218199767f8SToomas Soome #define	DMU_POOL_CONFIG			"config"
1219199767f8SToomas Soome #define	DMU_POOL_FEATURES_FOR_READ	"features_for_read"
1220199767f8SToomas Soome #define	DMU_POOL_ROOT_DATASET		"root_dataset"
1221199767f8SToomas Soome #define	DMU_POOL_SYNC_BPLIST		"sync_bplist"
1222199767f8SToomas Soome #define	DMU_POOL_ERRLOG_SCRUB		"errlog_scrub"
1223199767f8SToomas Soome #define	DMU_POOL_ERRLOG_LAST		"errlog_last"
1224199767f8SToomas Soome #define	DMU_POOL_SPARES			"spares"
1225199767f8SToomas Soome #define	DMU_POOL_DEFLATE		"deflate"
1226199767f8SToomas Soome #define	DMU_POOL_HISTORY		"history"
1227199767f8SToomas Soome #define	DMU_POOL_PROPS			"pool_props"
12284a04e8dbSToomas Soome #define	DMU_POOL_CHECKSUM_SALT		"org.illumos:checksum_salt"
1229199767f8SToomas Soome 
1230199767f8SToomas Soome #define	ZAP_MAGIC 0x2F52AB2ABULL
1231199767f8SToomas Soome 
1232199767f8SToomas Soome #define	FZAP_BLOCK_SHIFT(zap)	((zap)->zap_block_shift)
1233199767f8SToomas Soome 
1234199767f8SToomas Soome #define	ZAP_MAXCD		(uint32_t)(-1)
1235199767f8SToomas Soome #define	ZAP_HASHBITS		28
1236199767f8SToomas Soome #define	MZAP_ENT_LEN		64
1237199767f8SToomas Soome #define	MZAP_NAME_LEN		(MZAP_ENT_LEN - 8 - 4 - 2)
1238199767f8SToomas Soome #define	MZAP_MAX_BLKSHIFT	SPA_MAXBLOCKSHIFT
1239199767f8SToomas Soome #define	MZAP_MAX_BLKSZ		(1 << MZAP_MAX_BLKSHIFT)
1240199767f8SToomas Soome 
1241199767f8SToomas Soome typedef struct mzap_ent_phys {
1242199767f8SToomas Soome 	uint64_t mze_value;
1243199767f8SToomas Soome 	uint32_t mze_cd;
1244199767f8SToomas Soome 	uint16_t mze_pad;	/* in case we want to chain them someday */
1245199767f8SToomas Soome 	char mze_name[MZAP_NAME_LEN];
1246199767f8SToomas Soome } mzap_ent_phys_t;
1247199767f8SToomas Soome 
1248199767f8SToomas Soome typedef struct mzap_phys {
1249199767f8SToomas Soome 	uint64_t mz_block_type;	/* ZBT_MICRO */
1250199767f8SToomas Soome 	uint64_t mz_salt;
1251199767f8SToomas Soome 	uint64_t mz_pad[6];
1252199767f8SToomas Soome 	mzap_ent_phys_t mz_chunk[1];
1253199767f8SToomas Soome 	/* actually variable size depending on block size */
1254199767f8SToomas Soome } mzap_phys_t;
1255199767f8SToomas Soome 
1256199767f8SToomas Soome /*
1257199767f8SToomas Soome  * The (fat) zap is stored in one object. It is an array of
1258199767f8SToomas Soome  * 1<<FZAP_BLOCK_SHIFT byte blocks. The layout looks like one of:
1259199767f8SToomas Soome  *
1260199767f8SToomas Soome  * ptrtbl fits in first block:
12619890ff83SToomas Soome  *	[zap_phys_t zap_ptrtbl_shift < 6] [zap_leaf_t] ...
1262199767f8SToomas Soome  *
1263199767f8SToomas Soome  * ptrtbl too big for first block:
12649890ff83SToomas Soome  *	[zap_phys_t zap_ptrtbl_shift >= 6] [zap_leaf_t] [ptrtbl] ...
1265199767f8SToomas Soome  *
1266199767f8SToomas Soome  */
1267199767f8SToomas Soome 
1268199767f8SToomas Soome #define	ZBT_LEAF		((1ULL << 63) + 0)
1269199767f8SToomas Soome #define	ZBT_HEADER		((1ULL << 63) + 1)
1270199767f8SToomas Soome #define	ZBT_MICRO		((1ULL << 63) + 3)
1271199767f8SToomas Soome /* any other values are ptrtbl blocks */
1272199767f8SToomas Soome 
1273199767f8SToomas Soome /*
1274199767f8SToomas Soome  * the embedded pointer table takes up half a block:
1275199767f8SToomas Soome  * block size / entry size (2^3) / 2
1276199767f8SToomas Soome  */
1277199767f8SToomas Soome #define	ZAP_EMBEDDED_PTRTBL_SHIFT(zap) (FZAP_BLOCK_SHIFT(zap) - 3 - 1)
1278199767f8SToomas Soome 
1279199767f8SToomas Soome /*
1280199767f8SToomas Soome  * The embedded pointer table starts half-way through the block.  Since
1281199767f8SToomas Soome  * the pointer table itself is half the block, it starts at (64-bit)
1282199767f8SToomas Soome  * word number (1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap)).
1283199767f8SToomas Soome  */
1284199767f8SToomas Soome #define	ZAP_EMBEDDED_PTRTBL_ENT(zap, idx) \
1285199767f8SToomas Soome 	((uint64_t *)(zap)->zap_phys) \
1286199767f8SToomas Soome 	[(idx) + (1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap))]
1287199767f8SToomas Soome 
1288199767f8SToomas Soome /*
1289199767f8SToomas Soome  * TAKE NOTE:
1290199767f8SToomas Soome  * If zap_phys_t is modified, zap_byteswap() must be modified.
1291199767f8SToomas Soome  */
1292199767f8SToomas Soome typedef struct zap_phys {
1293199767f8SToomas Soome 	uint64_t zap_block_type;	/* ZBT_HEADER */
1294199767f8SToomas Soome 	uint64_t zap_magic;		/* ZAP_MAGIC */
1295199767f8SToomas Soome 
1296199767f8SToomas Soome 	struct zap_table_phys {
1297199767f8SToomas Soome 		uint64_t zt_blk;	/* starting block number */
1298199767f8SToomas Soome 		uint64_t zt_numblks;	/* number of blocks */
1299199767f8SToomas Soome 		uint64_t zt_shift;	/* bits to index it */
1300199767f8SToomas Soome 		uint64_t zt_nextblk;	/* next (larger) copy start block */
1301199767f8SToomas Soome 		uint64_t zt_blks_copied; /* number source blocks copied */
1302199767f8SToomas Soome 	} zap_ptrtbl;
1303199767f8SToomas Soome 
1304199767f8SToomas Soome 	uint64_t zap_freeblk;		/* the next free block */
1305199767f8SToomas Soome 	uint64_t zap_num_leafs;		/* number of leafs */
1306199767f8SToomas Soome 	uint64_t zap_num_entries;	/* number of entries */
1307199767f8SToomas Soome 	uint64_t zap_salt;		/* salt to stir into hash function */
1308199767f8SToomas Soome 	/*
1309199767f8SToomas Soome 	 * This structure is followed by padding, and then the embedded
1310199767f8SToomas Soome 	 * pointer table.  The embedded pointer table takes up second
1311199767f8SToomas Soome 	 * half of the block.  It is accessed using the
1312199767f8SToomas Soome 	 * ZAP_EMBEDDED_PTRTBL_ENT() macro.
1313199767f8SToomas Soome 	 */
1314199767f8SToomas Soome } zap_phys_t;
1315199767f8SToomas Soome 
1316199767f8SToomas Soome typedef struct zap_table_phys zap_table_phys_t;
1317199767f8SToomas Soome 
1318199767f8SToomas Soome typedef struct fat_zap {
1319199767f8SToomas Soome 	int zap_block_shift;			/* block size shift */
1320199767f8SToomas Soome 	zap_phys_t *zap_phys;
1321199767f8SToomas Soome } fat_zap_t;
1322199767f8SToomas Soome 
1323199767f8SToomas Soome #define	ZAP_LEAF_MAGIC 0x2AB1EAF
1324199767f8SToomas Soome 
1325199767f8SToomas Soome /* chunk size = 24 bytes */
1326199767f8SToomas Soome #define	ZAP_LEAF_CHUNKSIZE 24
1327199767f8SToomas Soome 
1328199767f8SToomas Soome /*
1329199767f8SToomas Soome  * The amount of space available for chunks is:
1330199767f8SToomas Soome  * block size (1<<l->l_bs) - hash entry size (2) * number of hash
1331199767f8SToomas Soome  * entries - header space (2*chunksize)
1332199767f8SToomas Soome  */
1333199767f8SToomas Soome #define	ZAP_LEAF_NUMCHUNKS(l) \
1334199767f8SToomas Soome 	(((1<<(l)->l_bs) - 2*ZAP_LEAF_HASH_NUMENTRIES(l)) / \
1335199767f8SToomas Soome 	ZAP_LEAF_CHUNKSIZE - 2)
1336199767f8SToomas Soome 
1337199767f8SToomas Soome /*
1338199767f8SToomas Soome  * The amount of space within the chunk available for the array is:
1339199767f8SToomas Soome  * chunk size - space for type (1) - space for next pointer (2)
1340199767f8SToomas Soome  */
1341199767f8SToomas Soome #define	ZAP_LEAF_ARRAY_BYTES (ZAP_LEAF_CHUNKSIZE - 3)
1342199767f8SToomas Soome 
1343199767f8SToomas Soome #define	ZAP_LEAF_ARRAY_NCHUNKS(bytes) \
1344199767f8SToomas Soome 	(((bytes)+ZAP_LEAF_ARRAY_BYTES-1)/ZAP_LEAF_ARRAY_BYTES)
1345199767f8SToomas Soome 
1346199767f8SToomas Soome /*
1347199767f8SToomas Soome  * Low water mark:  when there are only this many chunks free, start
1348199767f8SToomas Soome  * growing the ptrtbl.  Ideally, this should be larger than a
1349199767f8SToomas Soome  * "reasonably-sized" entry.  20 chunks is more than enough for the
1350199767f8SToomas Soome  * largest directory entry (MAXNAMELEN (256) byte name, 8-byte value),
1351199767f8SToomas Soome  * while still being only around 3% for 16k blocks.
1352199767f8SToomas Soome  */
1353199767f8SToomas Soome #define	ZAP_LEAF_LOW_WATER (20)
1354199767f8SToomas Soome 
1355199767f8SToomas Soome /*
1356199767f8SToomas Soome  * The leaf hash table has block size / 2^5 (32) number of entries,
1357199767f8SToomas Soome  * which should be more than enough for the maximum number of entries,
1358199767f8SToomas Soome  * which is less than block size / CHUNKSIZE (24) / minimum number of
1359199767f8SToomas Soome  * chunks per entry (3).
1360199767f8SToomas Soome  */
1361199767f8SToomas Soome #define	ZAP_LEAF_HASH_SHIFT(l) ((l)->l_bs - 5)
1362199767f8SToomas Soome #define	ZAP_LEAF_HASH_NUMENTRIES(l) (1 << ZAP_LEAF_HASH_SHIFT(l))
1363199767f8SToomas Soome 
1364199767f8SToomas Soome /*
1365199767f8SToomas Soome  * The chunks start immediately after the hash table.  The end of the
1366199767f8SToomas Soome  * hash table is at l_hash + HASH_NUMENTRIES, which we simply cast to a
1367199767f8SToomas Soome  * chunk_t.
1368199767f8SToomas Soome  */
1369199767f8SToomas Soome #define	ZAP_LEAF_CHUNK(l, idx) \
1370199767f8SToomas Soome 	((zap_leaf_chunk_t *) \
1371199767f8SToomas Soome 	((l)->l_phys->l_hash + ZAP_LEAF_HASH_NUMENTRIES(l)))[idx]
1372199767f8SToomas Soome #define	ZAP_LEAF_ENTRY(l, idx) (&ZAP_LEAF_CHUNK(l, idx).l_entry)
1373199767f8SToomas Soome 
1374199767f8SToomas Soome typedef enum zap_chunk_type {
1375199767f8SToomas Soome 	ZAP_CHUNK_FREE = 253,
1376199767f8SToomas Soome 	ZAP_CHUNK_ENTRY = 252,
1377199767f8SToomas Soome 	ZAP_CHUNK_ARRAY = 251,
1378199767f8SToomas Soome 	ZAP_CHUNK_TYPE_MAX = 250
1379199767f8SToomas Soome } zap_chunk_type_t;
1380199767f8SToomas Soome 
1381199767f8SToomas Soome /*
1382199767f8SToomas Soome  * TAKE NOTE:
1383199767f8SToomas Soome  * If zap_leaf_phys_t is modified, zap_leaf_byteswap() must be modified.
1384199767f8SToomas Soome  */
1385199767f8SToomas Soome typedef struct zap_leaf_phys {
1386199767f8SToomas Soome 	struct zap_leaf_header {
1387199767f8SToomas Soome 		uint64_t lh_block_type;		/* ZBT_LEAF */
1388199767f8SToomas Soome 		uint64_t lh_pad1;
1389199767f8SToomas Soome 		uint64_t lh_prefix;		/* hash prefix of this leaf */
1390199767f8SToomas Soome 		uint32_t lh_magic;		/* ZAP_LEAF_MAGIC */
1391199767f8SToomas Soome 		uint16_t lh_nfree;		/* number free chunks */
1392199767f8SToomas Soome 		uint16_t lh_nentries;		/* number of entries */
1393199767f8SToomas Soome 		uint16_t lh_prefix_len;		/* num bits used to id this */
1394199767f8SToomas Soome 
1395199767f8SToomas Soome /* above is accessable to zap, below is zap_leaf private */
1396199767f8SToomas Soome 
1397199767f8SToomas Soome 		uint16_t lh_freelist;		/* chunk head of free list */
1398199767f8SToomas Soome 		uint8_t lh_pad2[12];
1399199767f8SToomas Soome 	} l_hdr; /* 2 24-byte chunks */
1400199767f8SToomas Soome 
1401199767f8SToomas Soome 	/*
1402199767f8SToomas Soome 	 * The header is followed by a hash table with
1403199767f8SToomas Soome 	 * ZAP_LEAF_HASH_NUMENTRIES(zap) entries.  The hash table is
1404199767f8SToomas Soome 	 * followed by an array of ZAP_LEAF_NUMCHUNKS(zap)
1405199767f8SToomas Soome 	 * zap_leaf_chunk structures.  These structures are accessed
1406199767f8SToomas Soome 	 * with the ZAP_LEAF_CHUNK() macro.
1407199767f8SToomas Soome 	 */
1408199767f8SToomas Soome 
1409199767f8SToomas Soome 	uint16_t l_hash[1];
1410199767f8SToomas Soome } zap_leaf_phys_t;
1411199767f8SToomas Soome 
1412199767f8SToomas Soome typedef union zap_leaf_chunk {
1413199767f8SToomas Soome 	struct zap_leaf_entry {
14149890ff83SToomas Soome 		uint8_t le_type;		/* always ZAP_CHUNK_ENTRY */
1415199767f8SToomas Soome 		uint8_t le_value_intlen;	/* size of ints */
1416199767f8SToomas Soome 		uint16_t le_next;		/* next entry in hash chain */
1417199767f8SToomas Soome 		uint16_t le_name_chunk;		/* first chunk of the name */
1418199767f8SToomas Soome 		uint16_t le_name_numints;	/* bytes in name, incl null */
1419199767f8SToomas Soome 		uint16_t le_value_chunk;	/* first chunk of the value */
1420199767f8SToomas Soome 		uint16_t le_value_numints;	/* value length in ints */
1421199767f8SToomas Soome 		uint32_t le_cd;			/* collision differentiator */
1422199767f8SToomas Soome 		uint64_t le_hash;		/* hash value of the name */
1423199767f8SToomas Soome 	} l_entry;
1424199767f8SToomas Soome 	struct zap_leaf_array {
1425199767f8SToomas Soome 		uint8_t la_type;		/* always ZAP_CHUNK_ARRAY */
1426199767f8SToomas Soome 		uint8_t la_array[ZAP_LEAF_ARRAY_BYTES];
1427199767f8SToomas Soome 		uint16_t la_next;		/* next blk or CHAIN_END */
1428199767f8SToomas Soome 	} l_array;
1429199767f8SToomas Soome 	struct zap_leaf_free {
1430199767f8SToomas Soome 		uint8_t lf_type;		/* always ZAP_CHUNK_FREE */
1431199767f8SToomas Soome 		uint8_t lf_pad[ZAP_LEAF_ARRAY_BYTES];
1432199767f8SToomas Soome 		uint16_t lf_next;	/* next in free list, or CHAIN_END */
1433199767f8SToomas Soome 	} l_free;
1434199767f8SToomas Soome } zap_leaf_chunk_t;
1435199767f8SToomas Soome 
1436199767f8SToomas Soome typedef struct zap_leaf {
1437199767f8SToomas Soome 	int l_bs;			/* block size shift */
1438199767f8SToomas Soome 	zap_leaf_phys_t *l_phys;
1439199767f8SToomas Soome } zap_leaf_t;
1440199767f8SToomas Soome 
1441199767f8SToomas Soome /*
1442199767f8SToomas Soome  * Define special zfs pflags
1443199767f8SToomas Soome  */
1444199767f8SToomas Soome #define	ZFS_XATTR	0x1		/* is an extended attribute */
1445199767f8SToomas Soome #define	ZFS_INHERIT_ACE	0x2		/* ace has inheritable ACEs */
1446199767f8SToomas Soome #define	ZFS_ACL_TRIVIAL 0x4		/* files ACL is trivial */
1447199767f8SToomas Soome 
1448199767f8SToomas Soome #define	MASTER_NODE_OBJ	1
1449199767f8SToomas Soome 
1450199767f8SToomas Soome /*
1451199767f8SToomas Soome  * special attributes for master node.
1452199767f8SToomas Soome  */
1453199767f8SToomas Soome 
1454199767f8SToomas Soome #define	ZFS_FSID		"FSID"
1455199767f8SToomas Soome #define	ZFS_UNLINKED_SET	"DELETE_QUEUE"
1456199767f8SToomas Soome #define	ZFS_ROOT_OBJ		"ROOT"
1457199767f8SToomas Soome #define	ZPL_VERSION_OBJ		"VERSION"
1458199767f8SToomas Soome #define	ZFS_PROP_BLOCKPERPAGE	"BLOCKPERPAGE"
1459199767f8SToomas Soome #define	ZFS_PROP_NOGROWBLOCKS	"NOGROWBLOCKS"
1460199767f8SToomas Soome 
1461199767f8SToomas Soome #define	ZFS_FLAG_BLOCKPERPAGE	0x1
1462199767f8SToomas Soome #define	ZFS_FLAG_NOGROWBLOCKS	0x2
1463199767f8SToomas Soome 
1464199767f8SToomas Soome /*
1465199767f8SToomas Soome  * ZPL version - rev'd whenever an incompatible on-disk format change
1466199767f8SToomas Soome  * occurs.  Independent of SPA/DMU/ZAP versioning.
1467199767f8SToomas Soome  */
1468199767f8SToomas Soome 
1469199767f8SToomas Soome #define	ZPL_VERSION		1ULL
1470199767f8SToomas Soome 
1471199767f8SToomas Soome /*
1472199767f8SToomas Soome  * The directory entry has the type (currently unused on Solaris) in the
1473199767f8SToomas Soome  * top 4 bits, and the object number in the low 48 bits.  The "middle"
1474199767f8SToomas Soome  * 12 bits are unused.
1475199767f8SToomas Soome  */
1476199767f8SToomas Soome #define	ZFS_DIRENT_TYPE(de) BF64_GET(de, 60, 4)
1477199767f8SToomas Soome #define	ZFS_DIRENT_OBJ(de) BF64_GET(de, 0, 48)
1478199767f8SToomas Soome #define	ZFS_DIRENT_MAKE(type, obj) (((uint64_t)type << 60) | obj)
1479199767f8SToomas Soome 
1480199767f8SToomas Soome typedef struct ace {
1481199767f8SToomas Soome 	uid_t		a_who;		/* uid or gid */
1482199767f8SToomas Soome 	uint32_t	a_access_mask;	/* read,write,... */
1483199767f8SToomas Soome 	uint16_t	a_flags;	/* see below */
1484199767f8SToomas Soome 	uint16_t	a_type;		/* allow or deny */
1485199767f8SToomas Soome } ace_t;
1486199767f8SToomas Soome 
1487*08487eeaSToomas Soome #define	ACE_SLOT_CNT	6
1488199767f8SToomas Soome 
1489199767f8SToomas Soome typedef struct zfs_znode_acl {
1490199767f8SToomas Soome 	uint64_t	z_acl_extern_obj;	  /* ext acl pieces */
1491199767f8SToomas Soome 	uint32_t	z_acl_count;		  /* Number of ACEs */
1492199767f8SToomas Soome 	uint16_t	z_acl_version;		  /* acl version */
1493199767f8SToomas Soome 	uint16_t	z_acl_pad;		  /* pad */
1494199767f8SToomas Soome 	ace_t		z_ace_data[ACE_SLOT_CNT]; /* 6 standard ACEs */
1495199767f8SToomas Soome } zfs_znode_acl_t;
1496199767f8SToomas Soome 
1497199767f8SToomas Soome /*
1498199767f8SToomas Soome  * This is the persistent portion of the znode.  It is stored
1499199767f8SToomas Soome  * in the "bonus buffer" of the file.  Short symbolic links
1500199767f8SToomas Soome  * are also stored in the bonus buffer.
1501199767f8SToomas Soome  */
1502199767f8SToomas Soome typedef struct znode_phys {
1503199767f8SToomas Soome 	uint64_t zp_atime[2];		/*  0 - last file access time */
1504199767f8SToomas Soome 	uint64_t zp_mtime[2];		/* 16 - last file modification time */
1505199767f8SToomas Soome 	uint64_t zp_ctime[2];		/* 32 - last file change time */
1506199767f8SToomas Soome 	uint64_t zp_crtime[2];		/* 48 - creation time */
1507199767f8SToomas Soome 	uint64_t zp_gen;		/* 64 - generation (txg of creation) */
1508199767f8SToomas Soome 	uint64_t zp_mode;		/* 72 - file mode bits */
1509199767f8SToomas Soome 	uint64_t zp_size;		/* 80 - size of file */
1510199767f8SToomas Soome 	uint64_t zp_parent;		/* 88 - directory parent (`..') */
1511199767f8SToomas Soome 	uint64_t zp_links;		/* 96 - number of links to file */
1512199767f8SToomas Soome 	uint64_t zp_xattr;		/* 104 - DMU object for xattrs */
1513199767f8SToomas Soome 	uint64_t zp_rdev;		/* 112 - dev_t for VBLK & VCHR files */
1514199767f8SToomas Soome 	uint64_t zp_flags;		/* 120 - persistent flags */
1515199767f8SToomas Soome 	uint64_t zp_uid;		/* 128 - file owner */
1516199767f8SToomas Soome 	uint64_t zp_gid;		/* 136 - owning group */
1517199767f8SToomas Soome 	uint64_t zp_pad[4];		/* 144 - future */
1518199767f8SToomas Soome 	zfs_znode_acl_t zp_acl;		/* 176 - 263 ACL */
1519199767f8SToomas Soome 	/*
1520199767f8SToomas Soome 	 * Data may pad out any remaining bytes in the znode buffer, eg:
1521199767f8SToomas Soome 	 *
1522199767f8SToomas Soome 	 * |<---------------------- dnode_phys (512) ------------------------>|
1523199767f8SToomas Soome 	 * |<-- dnode (192) --->|<----------- "bonus" buffer (320) ---------->|
1524199767f8SToomas Soome 	 *			|<---- znode (264) ---->|<---- data (56) ---->|
1525199767f8SToomas Soome 	 *
1526199767f8SToomas Soome 	 * At present, we only use this space to store symbolic links.
1527199767f8SToomas Soome 	 */
1528199767f8SToomas Soome } znode_phys_t;
1529199767f8SToomas Soome 
1530199767f8SToomas Soome /*
1531199767f8SToomas Soome  * In-core vdev representation.
1532199767f8SToomas Soome  */
1533199767f8SToomas Soome struct vdev;
15344a04e8dbSToomas Soome struct spa;
1535199767f8SToomas Soome typedef int vdev_phys_read_t(struct vdev *vdev, void *priv,
1536199767f8SToomas Soome     off_t offset, void *buf, size_t bytes);
1537199767f8SToomas Soome typedef int vdev_read_t(struct vdev *vdev, const blkptr_t *bp,
1538199767f8SToomas Soome     void *buf, off_t offset, size_t bytes);
1539199767f8SToomas Soome 
1540199767f8SToomas Soome typedef STAILQ_HEAD(vdev_list, vdev) vdev_list_t;
1541199767f8SToomas Soome 
1542199767f8SToomas Soome typedef struct vdev {
1543199767f8SToomas Soome 	STAILQ_ENTRY(vdev) v_childlink;	/* link in parent's child list */
1544199767f8SToomas Soome 	STAILQ_ENTRY(vdev) v_alllink;	/* link in global vdev list */
1545199767f8SToomas Soome 	vdev_list_t	v_children;	/* children of this vdev */
1546199767f8SToomas Soome 	const char	*v_name;	/* vdev name */
1547199767f8SToomas Soome 	const char	*v_phys_path;	/* vdev bootpath */
1548199767f8SToomas Soome 	const char	*v_devid;	/* vdev devid */
1549199767f8SToomas Soome 	uint64_t	v_guid;		/* vdev guid */
1550199767f8SToomas Soome 	int		v_id;		/* index in parent */
1551199767f8SToomas Soome 	int		v_ashift;	/* offset to block shift */
1552199767f8SToomas Soome 	int		v_nparity;	/* # parity for raidz */
1553199767f8SToomas Soome 	struct vdev	*v_top;		/* parent vdev */
1554199767f8SToomas Soome 	int		v_nchildren;	/* # children */
1555199767f8SToomas Soome 	vdev_state_t	v_state;	/* current state */
1556199767f8SToomas Soome 	vdev_phys_read_t *v_phys_read;	/* read from raw leaf vdev */
1557199767f8SToomas Soome 	vdev_read_t	*v_read;	/* read from vdev */
1558199767f8SToomas Soome 	void		*v_read_priv;	/* private data for read function */
15594a04e8dbSToomas Soome 	struct spa	*spa;		/* link to spa */
1560199767f8SToomas Soome } vdev_t;
1561199767f8SToomas Soome 
1562199767f8SToomas Soome /*
1563199767f8SToomas Soome  * In-core pool representation.
1564199767f8SToomas Soome  */
1565199767f8SToomas Soome typedef STAILQ_HEAD(spa_list, spa) spa_list_t;
1566199767f8SToomas Soome 
1567199767f8SToomas Soome typedef struct spa {
1568199767f8SToomas Soome 	STAILQ_ENTRY(spa) spa_link;	/* link in global pool list */
1569199767f8SToomas Soome 	char		*spa_name;	/* pool name */
1570199767f8SToomas Soome 	uint64_t	spa_guid;	/* pool guid */
1571199767f8SToomas Soome 	uint64_t	spa_txg;	/* most recent transaction */
1572199767f8SToomas Soome 	struct uberblock spa_uberblock;	/* best uberblock so far */
1573199767f8SToomas Soome 	vdev_list_t	spa_vdevs;	/* list of all toplevel vdevs */
1574199767f8SToomas Soome 	objset_phys_t	spa_mos;	/* MOS for this pool */
15754a04e8dbSToomas Soome 	zio_cksum_salt_t spa_cksum_salt;	/* secret salt for cksum */
15764a04e8dbSToomas Soome 	void		*spa_cksum_tmpls[ZIO_CHECKSUM_FUNCTIONS];
1577199767f8SToomas Soome 	int		spa_inited;	/* initialized */
157845137058SToomas Soome 	vdev_t		*spa_boot_vdev;	/* boot device for kernel */
1579199767f8SToomas Soome } spa_t;
1580199767f8SToomas Soome 
1581199767f8SToomas Soome static void decode_embedded_bp_compressed(const blkptr_t *, void *);
1582*08487eeaSToomas Soome 
1583*08487eeaSToomas Soome #endif	/* _ZFSIMPL_H */
1584