xref: /freebsd/sys/cddl/boot/zfs/zfsimpl.h (revision 643ac419fafba89f5adda0e0ea75b538727453fb)
1 /*-
2  * Copyright (c) 2002 McAfee, Inc.
3  * All rights reserved.
4  *
5  * This software was developed for the FreeBSD Project by Marshall
6  * Kirk McKusick and McAfee Research,, the Security Research Division of
7  * McAfee, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as
8  * part of the DARPA CHATS research program
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  */
31 /*
32  * CDDL HEADER START
33  *
34  * The contents of this file are subject to the terms of the
35  * Common Development and Distribution License (the "License").
36  * You may not use this file except in compliance with the License.
37  *
38  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
39  * or http://www.opensolaris.org/os/licensing.
40  * See the License for the specific language governing permissions
41  * and limitations under the License.
42  *
43  * When distributing Covered Code, include this CDDL HEADER in each
44  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
45  * If applicable, add the following below this CDDL HEADER, with the
46  * fields enclosed by brackets "[]" replaced with your own identifying
47  * information: Portions Copyright [yyyy] [name of copyright owner]
48  *
49  * CDDL HEADER END
50  */
51 /*
52  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
53  * Use is subject to license terms.
54  */
55 /*
56  * Copyright 2013 by Saso Kiselkov. All rights reserved.
57  */
58 /*
59  * Copyright (c) 2020 by Delphix. All rights reserved.
60  */
61 
62 #include <sys/queue.h>
63 
64 #ifndef _ZFSIMPL_H_
65 #define	_ZFSIMPL_H_
66 
67 #define	MAXNAMELEN	256
68 
69 #define _NOTE(s)
70 
71 /*
72  * AVL comparator helpers
73  */
74 #define	AVL_ISIGN(a)	(((a) > 0) - ((a) < 0))
75 #define	AVL_CMP(a, b)	(((a) > (b)) - ((a) < (b)))
76 #define	AVL_PCMP(a, b)	\
77 	(((uintptr_t)(a) > (uintptr_t)(b)) - ((uintptr_t)(a) < (uintptr_t)(b)))
78 
79 typedef enum { B_FALSE, B_TRUE } boolean_t;
80 
81 /* CRC64 table */
82 #define	ZFS_CRC64_POLY	0xC96C5795D7870F42ULL	/* ECMA-182, reflected form */
83 
84 /*
85  * Macros for various sorts of alignment and rounding when the alignment
86  * is known to be a power of 2.
87  */
88 #define	P2ALIGN(x, align)		((x) & -(align))
89 #define	P2PHASE(x, align)		((x) & ((align) - 1))
90 #define	P2NPHASE(x, align)		(-(x) & ((align) - 1))
91 #define	P2ROUNDUP(x, align)		(-(-(x) & -(align)))
92 #define	P2END(x, align)			(-(~(x) & -(align)))
93 #define	P2PHASEUP(x, align, phase)	((phase) - (((phase) - (x)) & -(align)))
94 #define	P2BOUNDARY(off, len, align)	(((off) ^ ((off) + (len) - 1)) > (align) - 1)
95 
96 /*
97  * General-purpose 32-bit and 64-bit bitfield encodings.
98  */
99 #define	BF32_DECODE(x, low, len)	P2PHASE((x) >> (low), 1U << (len))
100 #define	BF64_DECODE(x, low, len)	P2PHASE((x) >> (low), 1ULL << (len))
101 #define	BF32_ENCODE(x, low, len)	(P2PHASE((x), 1U << (len)) << (low))
102 #define	BF64_ENCODE(x, low, len)	(P2PHASE((x), 1ULL << (len)) << (low))
103 
104 #define	BF32_GET(x, low, len)		BF32_DECODE(x, low, len)
105 #define	BF64_GET(x, low, len)		BF64_DECODE(x, low, len)
106 
107 #define	BF32_SET(x, low, len, val)	\
108 	((x) ^= BF32_ENCODE((x >> low) ^ (val), low, len))
109 #define	BF64_SET(x, low, len, val)	\
110 	((x) ^= BF64_ENCODE((x >> low) ^ (val), low, len))
111 
112 #define	BF32_GET_SB(x, low, len, shift, bias)	\
113 	((BF32_GET(x, low, len) + (bias)) << (shift))
114 #define	BF64_GET_SB(x, low, len, shift, bias)	\
115 	((BF64_GET(x, low, len) + (bias)) << (shift))
116 
117 #define	BF32_SET_SB(x, low, len, shift, bias, val)	\
118 	BF32_SET(x, low, len, ((val) >> (shift)) - (bias))
119 #define	BF64_SET_SB(x, low, len, shift, bias, val)	\
120 	BF64_SET(x, low, len, ((val) >> (shift)) - (bias))
121 
122 /*
123  * Macros to reverse byte order
124  */
125 #define	BSWAP_8(x)	((x) & 0xff)
126 #define	BSWAP_16(x)	((BSWAP_8(x) << 8) | BSWAP_8((x) >> 8))
127 #define	BSWAP_32(x)	((BSWAP_16(x) << 16) | BSWAP_16((x) >> 16))
128 #define	BSWAP_64(x)	((BSWAP_32(x) << 32) | BSWAP_32((x) >> 32))
129 
130 #define	SPA_MINBLOCKSHIFT	9
131 #define	SPA_OLDMAXBLOCKSHIFT	17
132 #define	SPA_MAXBLOCKSHIFT	24
133 #define	SPA_MINBLOCKSIZE	(1ULL << SPA_MINBLOCKSHIFT)
134 #define	SPA_OLDMAXBLOCKSIZE	(1ULL << SPA_OLDMAXBLOCKSHIFT)
135 #define	SPA_MAXBLOCKSIZE	(1ULL << SPA_MAXBLOCKSHIFT)
136 
137 /*
138  * The DVA size encodings for LSIZE and PSIZE support blocks up to 32MB.
139  * The ASIZE encoding should be at least 64 times larger (6 more bits)
140  * to support up to 4-way RAID-Z mirror mode with worst-case gang block
141  * overhead, three DVAs per bp, plus one more bit in case we do anything
142  * else that expands the ASIZE.
143  */
144 #define	SPA_LSIZEBITS		16	/* LSIZE up to 32M (2^16 * 512)	*/
145 #define	SPA_PSIZEBITS		16	/* PSIZE up to 32M (2^16 * 512)	*/
146 #define	SPA_ASIZEBITS		24	/* ASIZE up to 64 times larger	*/
147 
148 /*
149  * All SPA data is represented by 128-bit data virtual addresses (DVAs).
150  * The members of the dva_t should be considered opaque outside the SPA.
151  */
152 typedef struct dva {
153 	uint64_t	dva_word[2];
154 } dva_t;
155 
156 /*
157  * Each block has a 256-bit checksum -- strong enough for cryptographic hashes.
158  */
159 typedef struct zio_cksum {
160 	uint64_t	zc_word[4];
161 } zio_cksum_t;
162 
163 /*
164  * Some checksums/hashes need a 256-bit initialization salt. This salt is kept
165  * secret and is suitable for use in MAC algorithms as the key.
166  */
167 typedef struct zio_cksum_salt {
168 	uint8_t		zcs_bytes[32];
169 } zio_cksum_salt_t;
170 
171 /*
172  * Each block is described by its DVAs, time of birth, checksum, etc.
173  * The word-by-word, bit-by-bit layout of the blkptr is as follows:
174  *
175  *	64	56	48	40	32	24	16	8	0
176  *	+-------+-------+-------+-------+-------+-------+-------+-------+
177  * 0	|		vdev1		| GRID  |	  ASIZE		|
178  *	+-------+-------+-------+-------+-------+-------+-------+-------+
179  * 1	|G|			 offset1				|
180  *	+-------+-------+-------+-------+-------+-------+-------+-------+
181  * 2	|		vdev2		| GRID  |	  ASIZE		|
182  *	+-------+-------+-------+-------+-------+-------+-------+-------+
183  * 3	|G|			 offset2				|
184  *	+-------+-------+-------+-------+-------+-------+-------+-------+
185  * 4	|		vdev3		| GRID  |	  ASIZE		|
186  *	+-------+-------+-------+-------+-------+-------+-------+-------+
187  * 5	|G|			 offset3				|
188  *	+-------+-------+-------+-------+-------+-------+-------+-------+
189  * 6	|BDX|lvl| type	| cksum |E| comp|    PSIZE	|     LSIZE	|
190  *	+-------+-------+-------+-------+-------+-------+-------+-------+
191  * 7	|			padding					|
192  *	+-------+-------+-------+-------+-------+-------+-------+-------+
193  * 8	|			padding					|
194  *	+-------+-------+-------+-------+-------+-------+-------+-------+
195  * 9	|			physical birth txg			|
196  *	+-------+-------+-------+-------+-------+-------+-------+-------+
197  * a	|			logical birth txg			|
198  *	+-------+-------+-------+-------+-------+-------+-------+-------+
199  * b	|			fill count				|
200  *	+-------+-------+-------+-------+-------+-------+-------+-------+
201  * c	|			checksum[0]				|
202  *	+-------+-------+-------+-------+-------+-------+-------+-------+
203  * d	|			checksum[1]				|
204  *	+-------+-------+-------+-------+-------+-------+-------+-------+
205  * e	|			checksum[2]				|
206  *	+-------+-------+-------+-------+-------+-------+-------+-------+
207  * f	|			checksum[3]				|
208  *	+-------+-------+-------+-------+-------+-------+-------+-------+
209  *
210  * Legend:
211  *
212  * vdev		virtual device ID
213  * offset	offset into virtual device
214  * LSIZE	logical size
215  * PSIZE	physical size (after compression)
216  * ASIZE	allocated size (including RAID-Z parity and gang block headers)
217  * GRID		RAID-Z layout information (reserved for future use)
218  * cksum	checksum function
219  * comp		compression function
220  * G		gang block indicator
221  * B		byteorder (endianness)
222  * D		dedup
223  * X		encryption (on version 30, which is not supported)
224  * E		blkptr_t contains embedded data (see below)
225  * lvl		level of indirection
226  * type		DMU object type
227  * phys birth	txg of block allocation; zero if same as logical birth txg
228  * log. birth	transaction group in which the block was logically born
229  * fill count	number of non-zero blocks under this bp
230  * checksum[4]	256-bit checksum of the data this bp describes
231  */
232 
233 /*
234  * "Embedded" blkptr_t's don't actually point to a block, instead they
235  * have a data payload embedded in the blkptr_t itself.  See the comment
236  * in blkptr.c for more details.
237  *
238  * The blkptr_t is laid out as follows:
239  *
240  *	64	56	48	40	32	24	16	8	0
241  *	+-------+-------+-------+-------+-------+-------+-------+-------+
242  * 0	|      payload                                                  |
243  * 1	|      payload                                                  |
244  * 2	|      payload                                                  |
245  * 3	|      payload                                                  |
246  * 4	|      payload                                                  |
247  * 5	|      payload                                                  |
248  *	+-------+-------+-------+-------+-------+-------+-------+-------+
249  * 6	|BDX|lvl| type	| etype |E| comp| PSIZE|              LSIZE	|
250  *	+-------+-------+-------+-------+-------+-------+-------+-------+
251  * 7	|      payload                                                  |
252  * 8	|      payload                                                  |
253  * 9	|      payload                                                  |
254  *	+-------+-------+-------+-------+-------+-------+-------+-------+
255  * a	|			logical birth txg			|
256  *	+-------+-------+-------+-------+-------+-------+-------+-------+
257  * b	|      payload                                                  |
258  * c	|      payload                                                  |
259  * d	|      payload                                                  |
260  * e	|      payload                                                  |
261  * f	|      payload                                                  |
262  *	+-------+-------+-------+-------+-------+-------+-------+-------+
263  *
264  * Legend:
265  *
266  * payload		contains the embedded data
267  * B (byteorder)	byteorder (endianness)
268  * D (dedup)		padding (set to zero)
269  * X			encryption (set to zero; see above)
270  * E (embedded)		set to one
271  * lvl			indirection level
272  * type			DMU object type
273  * etype		how to interpret embedded data (BP_EMBEDDED_TYPE_*)
274  * comp			compression function of payload
275  * PSIZE		size of payload after compression, in bytes
276  * LSIZE		logical size of payload, in bytes
277  *			note that 25 bits is enough to store the largest
278  *			"normal" BP's LSIZE (2^16 * 2^9) in bytes
279  * log. birth		transaction group in which the block was logically born
280  *
281  * Note that LSIZE and PSIZE are stored in bytes, whereas for non-embedded
282  * bp's they are stored in units of SPA_MINBLOCKSHIFT.
283  * Generally, the generic BP_GET_*() macros can be used on embedded BP's.
284  * The B, D, X, lvl, type, and comp fields are stored the same as with normal
285  * BP's so the BP_SET_* macros can be used with them.  etype, PSIZE, LSIZE must
286  * be set with the BPE_SET_* macros.  BP_SET_EMBEDDED() should be called before
287  * other macros, as they assert that they are only used on BP's of the correct
288  * "embedded-ness".
289  */
290 
291 #define	BPE_GET_ETYPE(bp)	\
292 	(ASSERT(BP_IS_EMBEDDED(bp)), \
293 	BF64_GET((bp)->blk_prop, 40, 8))
294 #define	BPE_SET_ETYPE(bp, t)	do { \
295 	ASSERT(BP_IS_EMBEDDED(bp)); \
296 	BF64_SET((bp)->blk_prop, 40, 8, t); \
297 _NOTE(CONSTCOND) } while (0)
298 
299 #define	BPE_GET_LSIZE(bp)	\
300 	(ASSERT(BP_IS_EMBEDDED(bp)), \
301 	BF64_GET_SB((bp)->blk_prop, 0, 25, 0, 1))
302 #define	BPE_SET_LSIZE(bp, x)	do { \
303 	ASSERT(BP_IS_EMBEDDED(bp)); \
304 	BF64_SET_SB((bp)->blk_prop, 0, 25, 0, 1, x); \
305 _NOTE(CONSTCOND) } while (0)
306 
307 #define	BPE_GET_PSIZE(bp)	\
308 	(ASSERT(BP_IS_EMBEDDED(bp)), \
309 	BF64_GET_SB((bp)->blk_prop, 25, 7, 0, 1))
310 #define	BPE_SET_PSIZE(bp, x)	do { \
311 	ASSERT(BP_IS_EMBEDDED(bp)); \
312 	BF64_SET_SB((bp)->blk_prop, 25, 7, 0, 1, x); \
313 _NOTE(CONSTCOND) } while (0)
314 
315 typedef enum bp_embedded_type {
316 	BP_EMBEDDED_TYPE_DATA,
317 	BP_EMBEDDED_TYPE_RESERVED, /* Reserved for an unintegrated feature. */
318 	NUM_BP_EMBEDDED_TYPES = BP_EMBEDDED_TYPE_RESERVED
319 } bp_embedded_type_t;
320 
321 #define	BPE_NUM_WORDS 14
322 #define	BPE_PAYLOAD_SIZE (BPE_NUM_WORDS * sizeof (uint64_t))
323 #define	BPE_IS_PAYLOADWORD(bp, wp) \
324 	((wp) != &(bp)->blk_prop && (wp) != &(bp)->blk_birth)
325 
326 #define	SPA_BLKPTRSHIFT	7		/* blkptr_t is 128 bytes	*/
327 #define	SPA_DVAS_PER_BP	3		/* Number of DVAs in a bp	*/
328 
329 typedef struct blkptr {
330 	dva_t		blk_dva[SPA_DVAS_PER_BP]; /* Data Virtual Addresses */
331 	uint64_t	blk_prop;	/* size, compression, type, etc	    */
332 	uint64_t	blk_pad[2];	/* Extra space for the future	    */
333 	uint64_t	blk_phys_birth;	/* txg when block was allocated	    */
334 	uint64_t	blk_birth;	/* transaction group at birth	    */
335 	uint64_t	blk_fill;	/* fill count			    */
336 	zio_cksum_t	blk_cksum;	/* 256-bit checksum		    */
337 } blkptr_t;
338 
339 /*
340  * Macros to get and set fields in a bp or DVA.
341  */
342 #define	DVA_GET_ASIZE(dva)	\
343 	BF64_GET_SB((dva)->dva_word[0], 0, SPA_ASIZEBITS, SPA_MINBLOCKSHIFT, 0)
344 #define	DVA_SET_ASIZE(dva, x)	\
345 	BF64_SET_SB((dva)->dva_word[0], 0, SPA_ASIZEBITS, \
346 	SPA_MINBLOCKSHIFT, 0, x)
347 
348 #define	DVA_GET_GRID(dva)	BF64_GET((dva)->dva_word[0], 24, 8)
349 #define	DVA_SET_GRID(dva, x)	BF64_SET((dva)->dva_word[0], 24, 8, x)
350 
351 #define	DVA_GET_VDEV(dva)	BF64_GET((dva)->dva_word[0], 32, 32)
352 #define	DVA_SET_VDEV(dva, x)	BF64_SET((dva)->dva_word[0], 32, 32, x)
353 
354 #define	DVA_GET_OFFSET(dva)	\
355 	BF64_GET_SB((dva)->dva_word[1], 0, 63, SPA_MINBLOCKSHIFT, 0)
356 #define	DVA_SET_OFFSET(dva, x)	\
357 	BF64_SET_SB((dva)->dva_word[1], 0, 63, SPA_MINBLOCKSHIFT, 0, x)
358 
359 #define	DVA_GET_GANG(dva)	BF64_GET((dva)->dva_word[1], 63, 1)
360 #define	DVA_SET_GANG(dva, x)	BF64_SET((dva)->dva_word[1], 63, 1, x)
361 
362 #define	BP_GET_LSIZE(bp)	\
363 	(BP_IS_EMBEDDED(bp) ?	\
364 	(BPE_GET_ETYPE(bp) == BP_EMBEDDED_TYPE_DATA ? BPE_GET_LSIZE(bp) : 0): \
365 	BF64_GET_SB((bp)->blk_prop, 0, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1))
366 #define	BP_SET_LSIZE(bp, x)	do { \
367 	ASSERT(!BP_IS_EMBEDDED(bp)); \
368 	BF64_SET_SB((bp)->blk_prop, \
369 	    0, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1, x); \
370 _NOTE(CONSTCOND) } while (0)
371 
372 #define	BP_GET_PSIZE(bp)	\
373 	BF64_GET_SB((bp)->blk_prop, 16, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1)
374 #define	BP_SET_PSIZE(bp, x)	\
375 	BF64_SET_SB((bp)->blk_prop, 16, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1, x)
376 
377 #define	BP_GET_COMPRESS(bp)	BF64_GET((bp)->blk_prop, 32, 7)
378 #define	BP_SET_COMPRESS(bp, x)	BF64_SET((bp)->blk_prop, 32, 7, x)
379 
380 #define	BP_GET_CHECKSUM(bp)	BF64_GET((bp)->blk_prop, 40, 8)
381 #define	BP_SET_CHECKSUM(bp, x)	BF64_SET((bp)->blk_prop, 40, 8, x)
382 
383 #define	BP_GET_TYPE(bp)		BF64_GET((bp)->blk_prop, 48, 8)
384 #define	BP_SET_TYPE(bp, x)	BF64_SET((bp)->blk_prop, 48, 8, x)
385 
386 #define	BP_GET_LEVEL(bp)	BF64_GET((bp)->blk_prop, 56, 5)
387 #define	BP_SET_LEVEL(bp, x)	BF64_SET((bp)->blk_prop, 56, 5, x)
388 
389 #define	BP_IS_EMBEDDED(bp)	BF64_GET((bp)->blk_prop, 39, 1)
390 
391 #define	BP_GET_DEDUP(bp)	BF64_GET((bp)->blk_prop, 62, 1)
392 #define	BP_SET_DEDUP(bp, x)	BF64_SET((bp)->blk_prop, 62, 1, x)
393 
394 #define	BP_GET_BYTEORDER(bp)	BF64_GET((bp)->blk_prop, 63, 1)
395 #define	BP_SET_BYTEORDER(bp, x)	BF64_SET((bp)->blk_prop, 63, 1, x)
396 
397 #define	BP_PHYSICAL_BIRTH(bp)		\
398 	((bp)->blk_phys_birth ? (bp)->blk_phys_birth : (bp)->blk_birth)
399 
400 #define	BP_SET_BIRTH(bp, logical, physical)	\
401 {						\
402 	ASSERT(!BP_IS_EMBEDDED(bp));		\
403 	(bp)->blk_birth = (logical);		\
404 	(bp)->blk_phys_birth = ((logical) == (physical) ? 0 : (physical)); \
405 }
406 
407 #define	BP_GET_FILL(bp)				\
408 	((BP_IS_EMBEDDED(bp)) ? 1 : (bp)->blk_fill)
409 
410 #define	BP_SET_FILL(bp, fill)			\
411 {						\
412 	(bp)->blk_fill = fill;			\
413 }
414 
415 #define	BP_GET_ASIZE(bp)	\
416 	(DVA_GET_ASIZE(&(bp)->blk_dva[0]) + DVA_GET_ASIZE(&(bp)->blk_dva[1]) + \
417 		DVA_GET_ASIZE(&(bp)->blk_dva[2]))
418 
419 #define	BP_GET_UCSIZE(bp) \
420 	((BP_GET_LEVEL(bp) > 0 || dmu_ot[BP_GET_TYPE(bp)].ot_metadata) ? \
421 	BP_GET_PSIZE(bp) : BP_GET_LSIZE(bp));
422 
423 #define	BP_GET_NDVAS(bp)	\
424 	(!!DVA_GET_ASIZE(&(bp)->blk_dva[0]) + \
425 	!!DVA_GET_ASIZE(&(bp)->blk_dva[1]) + \
426 	!!DVA_GET_ASIZE(&(bp)->blk_dva[2]))
427 
428 #define	DVA_EQUAL(dva1, dva2)	\
429 	((dva1)->dva_word[1] == (dva2)->dva_word[1] && \
430 	(dva1)->dva_word[0] == (dva2)->dva_word[0])
431 
432 #define	ZIO_CHECKSUM_EQUAL(zc1, zc2) \
433 	(0 == (((zc1).zc_word[0] - (zc2).zc_word[0]) | \
434 	((zc1).zc_word[1] - (zc2).zc_word[1]) | \
435 	((zc1).zc_word[2] - (zc2).zc_word[2]) | \
436 	((zc1).zc_word[3] - (zc2).zc_word[3])))
437 
438 
439 #define	DVA_IS_VALID(dva)	(DVA_GET_ASIZE(dva) != 0)
440 
441 #define	ZIO_SET_CHECKSUM(zcp, w0, w1, w2, w3)	\
442 {						\
443 	(zcp)->zc_word[0] = w0;			\
444 	(zcp)->zc_word[1] = w1;			\
445 	(zcp)->zc_word[2] = w2;			\
446 	(zcp)->zc_word[3] = w3;			\
447 }
448 
449 #define	BP_IDENTITY(bp)		(&(bp)->blk_dva[0])
450 #define	BP_IS_GANG(bp)		DVA_GET_GANG(BP_IDENTITY(bp))
451 #define	DVA_IS_EMPTY(dva)	((dva)->dva_word[0] == 0ULL &&  \
452 	(dva)->dva_word[1] == 0ULL)
453 #define	BP_IS_HOLE(bp)		DVA_IS_EMPTY(BP_IDENTITY(bp))
454 #define	BP_IS_OLDER(bp, txg)	(!BP_IS_HOLE(bp) && (bp)->blk_birth < (txg))
455 
456 #define	BP_ZERO(bp)				\
457 {						\
458 	(bp)->blk_dva[0].dva_word[0] = 0;	\
459 	(bp)->blk_dva[0].dva_word[1] = 0;	\
460 	(bp)->blk_dva[1].dva_word[0] = 0;	\
461 	(bp)->blk_dva[1].dva_word[1] = 0;	\
462 	(bp)->blk_dva[2].dva_word[0] = 0;	\
463 	(bp)->blk_dva[2].dva_word[1] = 0;	\
464 	(bp)->blk_prop = 0;			\
465 	(bp)->blk_pad[0] = 0;			\
466 	(bp)->blk_pad[1] = 0;			\
467 	(bp)->blk_phys_birth = 0;		\
468 	(bp)->blk_birth = 0;			\
469 	(bp)->blk_fill = 0;			\
470 	ZIO_SET_CHECKSUM(&(bp)->blk_cksum, 0, 0, 0, 0);	\
471 }
472 
473 #if BYTE_ORDER == _BIG_ENDIAN
474 #define	ZFS_HOST_BYTEORDER	(0ULL)
475 #else
476 #define	ZFS_HOST_BYTEORDER	(1ULL)
477 #endif
478 
479 #define	BP_SHOULD_BYTESWAP(bp)	(BP_GET_BYTEORDER(bp) != ZFS_HOST_BYTEORDER)
480 #define	BPE_NUM_WORDS 14
481 #define	BPE_PAYLOAD_SIZE (BPE_NUM_WORDS * sizeof (uint64_t))
482 #define	BPE_IS_PAYLOADWORD(bp, wp) \
483 	((wp) != &(bp)->blk_prop && (wp) != &(bp)->blk_birth)
484 
485 /*
486  * Embedded checksum
487  */
488 #define	ZEC_MAGIC	0x210da7ab10c7a11ULL
489 
490 typedef struct zio_eck {
491 	uint64_t	zec_magic;	/* for validation, endianness	*/
492 	zio_cksum_t	zec_cksum;	/* 256-bit checksum		*/
493 } zio_eck_t;
494 
495 /*
496  * Gang block headers are self-checksumming and contain an array
497  * of block pointers.
498  */
499 #define	SPA_GANGBLOCKSIZE	SPA_MINBLOCKSIZE
500 #define	SPA_GBH_NBLKPTRS	((SPA_GANGBLOCKSIZE - \
501 	sizeof (zio_eck_t)) / sizeof (blkptr_t))
502 #define	SPA_GBH_FILLER		((SPA_GANGBLOCKSIZE - \
503 	sizeof (zio_eck_t) - \
504 	(SPA_GBH_NBLKPTRS * sizeof (blkptr_t))) /\
505 	sizeof (uint64_t))
506 
507 typedef struct zio_gbh {
508 	blkptr_t		zg_blkptr[SPA_GBH_NBLKPTRS];
509 	uint64_t		zg_filler[SPA_GBH_FILLER];
510 	zio_eck_t		zg_tail;
511 } zio_gbh_phys_t;
512 
513 #define	VDEV_RAIDZ_MAXPARITY	3
514 
515 #define	VDEV_PAD_SIZE		(8 << 10)
516 /* 2 padding areas (vl_pad1 and vl_be) to skip */
517 #define	VDEV_SKIP_SIZE		VDEV_PAD_SIZE * 2
518 #define	VDEV_PHYS_SIZE		(112 << 10)
519 #define	VDEV_UBERBLOCK_RING	(128 << 10)
520 
521 /*
522  * MMP blocks occupy the last MMP_BLOCKS_PER_LABEL slots in the uberblock
523  * ring when MMP is enabled.
524  */
525 #define	MMP_BLOCKS_PER_LABEL	1
526 
527 /* The largest uberblock we support is 8k. */
528 #define	MAX_UBERBLOCK_SHIFT	(13)
529 #define	VDEV_UBERBLOCK_SHIFT(vd)	\
530 	MIN(MAX((vd)->v_top->v_ashift, UBERBLOCK_SHIFT), MAX_UBERBLOCK_SHIFT)
531 #define	VDEV_UBERBLOCK_COUNT(vd)	\
532 	(VDEV_UBERBLOCK_RING >> VDEV_UBERBLOCK_SHIFT(vd))
533 #define	VDEV_UBERBLOCK_OFFSET(vd, n)	\
534 	offsetof(vdev_label_t, vl_uberblock[(n) << VDEV_UBERBLOCK_SHIFT(vd)])
535 #define	VDEV_UBERBLOCK_SIZE(vd)		(1ULL << VDEV_UBERBLOCK_SHIFT(vd))
536 
537 typedef struct vdev_phys {
538 	char		vp_nvlist[VDEV_PHYS_SIZE - sizeof (zio_eck_t)];
539 	zio_eck_t	vp_zbt;
540 } vdev_phys_t;
541 
542 typedef enum vbe_vers {
543 	/* The bootenv file is stored as ascii text in the envblock */
544 	VB_RAW = 0,
545 
546 	/*
547 	 * The bootenv file is converted to an nvlist and then packed into the
548 	 * envblock.
549 	 */
550 	VB_NVLIST = 1
551 } vbe_vers_t;
552 
553 typedef struct vdev_boot_envblock {
554 	uint64_t	vbe_version;
555 	char		vbe_bootenv[VDEV_PAD_SIZE - sizeof (uint64_t) -
556 			sizeof (zio_eck_t)];
557  	zio_eck_t	vbe_zbt;
558 } vdev_boot_envblock_t;
559 
560 _Static_assert(sizeof (vdev_boot_envblock_t) == VDEV_PAD_SIZE,
561     "bad size for vdev_boot_envblock_t");
562 
563 typedef struct vdev_label {
564 	char		vl_pad1[VDEV_PAD_SIZE];			/*  8K  */
565 	vdev_boot_envblock_t	vl_be;				/*  8K  */
566 	vdev_phys_t	vl_vdev_phys;				/* 112K	*/
567 	char		vl_uberblock[VDEV_UBERBLOCK_RING];	/* 128K	*/
568 } vdev_label_t;							/* 256K total */
569 
570 /*
571  * vdev_dirty() flags
572  */
573 #define	VDD_METASLAB	0x01
574 #define	VDD_DTL		0x02
575 
576 /*
577  * Size and offset of embedded boot loader region on each label.
578  * The total size of the first two labels plus the boot area is 4MB.
579  */
580 #define	VDEV_BOOT_OFFSET	(2 * sizeof (vdev_label_t))
581 #define	VDEV_BOOT_SIZE		(7ULL << 19)			/* 3.5M	*/
582 
583 /*
584  * Size of label regions at the start and end of each leaf device.
585  */
586 #define	VDEV_LABEL_START_SIZE	(2 * sizeof (vdev_label_t) + VDEV_BOOT_SIZE)
587 #define	VDEV_LABEL_END_SIZE	(2 * sizeof (vdev_label_t))
588 #define	VDEV_LABELS		4
589 
590 enum zio_checksum {
591 	ZIO_CHECKSUM_INHERIT = 0,
592 	ZIO_CHECKSUM_ON,
593 	ZIO_CHECKSUM_OFF,
594 	ZIO_CHECKSUM_LABEL,
595 	ZIO_CHECKSUM_GANG_HEADER,
596 	ZIO_CHECKSUM_ZILOG,
597 	ZIO_CHECKSUM_FLETCHER_2,
598 	ZIO_CHECKSUM_FLETCHER_4,
599 	ZIO_CHECKSUM_SHA256,
600 	ZIO_CHECKSUM_ZILOG2,
601 	ZIO_CHECKSUM_NOPARITY,
602 	ZIO_CHECKSUM_SHA512,
603 	ZIO_CHECKSUM_SKEIN,
604 	ZIO_CHECKSUM_EDONR,
605 	ZIO_CHECKSUM_BLAKE3,
606 	ZIO_CHECKSUM_FUNCTIONS
607 };
608 
609 #define	ZIO_CHECKSUM_ON_VALUE	ZIO_CHECKSUM_FLETCHER_4
610 #define	ZIO_CHECKSUM_DEFAULT	ZIO_CHECKSUM_ON
611 
612 enum zio_compress {
613 	ZIO_COMPRESS_INHERIT = 0,
614 	ZIO_COMPRESS_ON,
615 	ZIO_COMPRESS_OFF,
616 	ZIO_COMPRESS_LZJB,
617 	ZIO_COMPRESS_EMPTY,
618 	ZIO_COMPRESS_GZIP_1,
619 	ZIO_COMPRESS_GZIP_2,
620 	ZIO_COMPRESS_GZIP_3,
621 	ZIO_COMPRESS_GZIP_4,
622 	ZIO_COMPRESS_GZIP_5,
623 	ZIO_COMPRESS_GZIP_6,
624 	ZIO_COMPRESS_GZIP_7,
625 	ZIO_COMPRESS_GZIP_8,
626 	ZIO_COMPRESS_GZIP_9,
627 	ZIO_COMPRESS_ZLE,
628 	ZIO_COMPRESS_LZ4,
629 	ZIO_COMPRESS_ZSTD,
630 	ZIO_COMPRESS_FUNCTIONS
631 };
632 
633 enum zio_zstd_levels {
634 	ZIO_ZSTD_LEVEL_INHERIT = 0,
635 	ZIO_ZSTD_LEVEL_1,
636 #define	ZIO_ZSTD_LEVEL_MIN	ZIO_ZSTD_LEVEL_1
637 	ZIO_ZSTD_LEVEL_2,
638 	ZIO_ZSTD_LEVEL_3,
639 #define	ZIO_ZSTD_LEVEL_DEFAULT	ZIO_ZSTD_LEVEL_3
640 	ZIO_ZSTD_LEVEL_4,
641 	ZIO_ZSTD_LEVEL_5,
642 	ZIO_ZSTD_LEVEL_6,
643 	ZIO_ZSTD_LEVEL_7,
644 	ZIO_ZSTD_LEVEL_8,
645 	ZIO_ZSTD_LEVEL_9,
646 	ZIO_ZSTD_LEVEL_10,
647 	ZIO_ZSTD_LEVEL_11,
648 	ZIO_ZSTD_LEVEL_12,
649 	ZIO_ZSTD_LEVEL_13,
650 	ZIO_ZSTD_LEVEL_14,
651 	ZIO_ZSTD_LEVEL_15,
652 	ZIO_ZSTD_LEVEL_16,
653 	ZIO_ZSTD_LEVEL_17,
654 	ZIO_ZSTD_LEVEL_18,
655 	ZIO_ZSTD_LEVEL_19,
656 #define	ZIO_ZSTD_LEVEL_MAX	ZIO_ZSTD_LEVEL_19
657 	ZIO_ZSTD_LEVEL_RESERVE = 101, /* Leave room for new positive levels */
658 	ZIO_ZSTD_LEVEL_FAST, /* Fast levels are negative */
659 	ZIO_ZSTD_LEVEL_FAST_1,
660 #define	ZIO_ZSTD_LEVEL_FAST_DEFAULT	ZIO_ZSTD_LEVEL_FAST_1
661 	ZIO_ZSTD_LEVEL_FAST_2,
662 	ZIO_ZSTD_LEVEL_FAST_3,
663 	ZIO_ZSTD_LEVEL_FAST_4,
664 	ZIO_ZSTD_LEVEL_FAST_5,
665 	ZIO_ZSTD_LEVEL_FAST_6,
666 	ZIO_ZSTD_LEVEL_FAST_7,
667 	ZIO_ZSTD_LEVEL_FAST_8,
668 	ZIO_ZSTD_LEVEL_FAST_9,
669 	ZIO_ZSTD_LEVEL_FAST_10,
670 	ZIO_ZSTD_LEVEL_FAST_20,
671 	ZIO_ZSTD_LEVEL_FAST_30,
672 	ZIO_ZSTD_LEVEL_FAST_40,
673 	ZIO_ZSTD_LEVEL_FAST_50,
674 	ZIO_ZSTD_LEVEL_FAST_60,
675 	ZIO_ZSTD_LEVEL_FAST_70,
676 	ZIO_ZSTD_LEVEL_FAST_80,
677 	ZIO_ZSTD_LEVEL_FAST_90,
678 	ZIO_ZSTD_LEVEL_FAST_100,
679 	ZIO_ZSTD_LEVEL_FAST_500,
680 	ZIO_ZSTD_LEVEL_FAST_1000,
681 #define	ZIO_ZSTD_LEVEL_FAST_MAX	ZIO_ZSTD_LEVEL_FAST_1000
682 	ZIO_ZSTD_LEVEL_AUTO = 251, /* Reserved for future use */
683 	ZIO_ZSTD_LEVEL_LEVELS
684 };
685 
686 #define	ZIO_COMPRESS_ON_VALUE	ZIO_COMPRESS_LZJB
687 #define	ZIO_COMPRESS_DEFAULT	ZIO_COMPRESS_OFF
688 
689 /*
690  * On-disk version number.
691  */
692 #define	SPA_VERSION_1			1ULL
693 #define	SPA_VERSION_2			2ULL
694 #define	SPA_VERSION_3			3ULL
695 #define	SPA_VERSION_4			4ULL
696 #define	SPA_VERSION_5			5ULL
697 #define	SPA_VERSION_6			6ULL
698 #define	SPA_VERSION_7			7ULL
699 #define	SPA_VERSION_8			8ULL
700 #define	SPA_VERSION_9			9ULL
701 #define	SPA_VERSION_10			10ULL
702 #define	SPA_VERSION_11			11ULL
703 #define	SPA_VERSION_12			12ULL
704 #define	SPA_VERSION_13			13ULL
705 #define	SPA_VERSION_14			14ULL
706 #define	SPA_VERSION_15			15ULL
707 #define	SPA_VERSION_16			16ULL
708 #define	SPA_VERSION_17			17ULL
709 #define	SPA_VERSION_18			18ULL
710 #define	SPA_VERSION_19			19ULL
711 #define	SPA_VERSION_20			20ULL
712 #define	SPA_VERSION_21			21ULL
713 #define	SPA_VERSION_22			22ULL
714 #define	SPA_VERSION_23			23ULL
715 #define	SPA_VERSION_24			24ULL
716 #define	SPA_VERSION_25			25ULL
717 #define	SPA_VERSION_26			26ULL
718 #define	SPA_VERSION_27			27ULL
719 #define	SPA_VERSION_28			28ULL
720 #define	SPA_VERSION_5000		5000ULL
721 
722 /*
723  * When bumping up SPA_VERSION, make sure GRUB ZFS understands the on-disk
724  * format change. Go to usr/src/grub/grub-0.97/stage2/{zfs-include/, fsys_zfs*},
725  * and do the appropriate changes.  Also bump the version number in
726  * usr/src/grub/capability.
727  */
728 #define	SPA_VERSION			SPA_VERSION_5000
729 #define	SPA_VERSION_STRING		"5000"
730 
731 /*
732  * Symbolic names for the changes that caused a SPA_VERSION switch.
733  * Used in the code when checking for presence or absence of a feature.
734  * Feel free to define multiple symbolic names for each version if there
735  * were multiple changes to on-disk structures during that version.
736  *
737  * NOTE: When checking the current SPA_VERSION in your code, be sure
738  *       to use spa_version() since it reports the version of the
739  *       last synced uberblock.  Checking the in-flight version can
740  *       be dangerous in some cases.
741  */
742 #define	SPA_VERSION_INITIAL		SPA_VERSION_1
743 #define	SPA_VERSION_DITTO_BLOCKS	SPA_VERSION_2
744 #define	SPA_VERSION_SPARES		SPA_VERSION_3
745 #define	SPA_VERSION_RAID6		SPA_VERSION_3
746 #define	SPA_VERSION_BPLIST_ACCOUNT	SPA_VERSION_3
747 #define	SPA_VERSION_RAIDZ_DEFLATE	SPA_VERSION_3
748 #define	SPA_VERSION_DNODE_BYTES		SPA_VERSION_3
749 #define	SPA_VERSION_ZPOOL_HISTORY	SPA_VERSION_4
750 #define	SPA_VERSION_GZIP_COMPRESSION	SPA_VERSION_5
751 #define	SPA_VERSION_BOOTFS		SPA_VERSION_6
752 #define	SPA_VERSION_SLOGS		SPA_VERSION_7
753 #define	SPA_VERSION_DELEGATED_PERMS	SPA_VERSION_8
754 #define	SPA_VERSION_FUID		SPA_VERSION_9
755 #define	SPA_VERSION_REFRESERVATION	SPA_VERSION_9
756 #define	SPA_VERSION_REFQUOTA		SPA_VERSION_9
757 #define	SPA_VERSION_UNIQUE_ACCURATE	SPA_VERSION_9
758 #define	SPA_VERSION_L2CACHE		SPA_VERSION_10
759 #define	SPA_VERSION_NEXT_CLONES		SPA_VERSION_11
760 #define	SPA_VERSION_ORIGIN		SPA_VERSION_11
761 #define	SPA_VERSION_DSL_SCRUB		SPA_VERSION_11
762 #define	SPA_VERSION_SNAP_PROPS		SPA_VERSION_12
763 #define	SPA_VERSION_USED_BREAKDOWN	SPA_VERSION_13
764 #define	SPA_VERSION_PASSTHROUGH_X	SPA_VERSION_14
765 #define SPA_VERSION_USERSPACE		SPA_VERSION_15
766 #define	SPA_VERSION_STMF_PROP		SPA_VERSION_16
767 #define	SPA_VERSION_RAIDZ3		SPA_VERSION_17
768 #define	SPA_VERSION_USERREFS		SPA_VERSION_18
769 #define	SPA_VERSION_HOLES		SPA_VERSION_19
770 #define	SPA_VERSION_ZLE_COMPRESSION	SPA_VERSION_20
771 #define	SPA_VERSION_DEDUP		SPA_VERSION_21
772 #define	SPA_VERSION_RECVD_PROPS		SPA_VERSION_22
773 #define	SPA_VERSION_SLIM_ZIL		SPA_VERSION_23
774 #define	SPA_VERSION_SA			SPA_VERSION_24
775 #define	SPA_VERSION_SCAN		SPA_VERSION_25
776 #define	SPA_VERSION_DIR_CLONES		SPA_VERSION_26
777 #define	SPA_VERSION_DEADLISTS		SPA_VERSION_26
778 #define	SPA_VERSION_FAST_SNAP		SPA_VERSION_27
779 #define	SPA_VERSION_MULTI_REPLACE	SPA_VERSION_28
780 #define	SPA_VERSION_BEFORE_FEATURES	SPA_VERSION_28
781 #define	SPA_VERSION_FEATURES		SPA_VERSION_5000
782 
783 #define	SPA_VERSION_IS_SUPPORTED(v) \
784 	(((v) >= SPA_VERSION_INITIAL && (v) <= SPA_VERSION_BEFORE_FEATURES) || \
785 	((v) >= SPA_VERSION_FEATURES && (v) <= SPA_VERSION))
786 
787 /*
788  * The following are configuration names used in the nvlist describing a pool's
789  * configuration.
790  */
791 #define	ZPOOL_CONFIG_VERSION		"version"
792 #define	ZPOOL_CONFIG_POOL_NAME		"name"
793 #define	ZPOOL_CONFIG_POOL_STATE		"state"
794 #define	ZPOOL_CONFIG_POOL_TXG		"txg"
795 #define	ZPOOL_CONFIG_POOL_GUID		"pool_guid"
796 #define	ZPOOL_CONFIG_CREATE_TXG		"create_txg"
797 #define	ZPOOL_CONFIG_TOP_GUID		"top_guid"
798 #define	ZPOOL_CONFIG_VDEV_TREE		"vdev_tree"
799 #define	ZPOOL_CONFIG_TYPE		"type"
800 #define	ZPOOL_CONFIG_CHILDREN		"children"
801 #define	ZPOOL_CONFIG_ID			"id"
802 #define	ZPOOL_CONFIG_GUID		"guid"
803 #define	ZPOOL_CONFIG_INDIRECT_OBJECT	"com.delphix:indirect_object"
804 #define	ZPOOL_CONFIG_INDIRECT_BIRTHS	"com.delphix:indirect_births"
805 #define	ZPOOL_CONFIG_PREV_INDIRECT_VDEV	"com.delphix:prev_indirect_vdev"
806 #define	ZPOOL_CONFIG_PATH		"path"
807 #define	ZPOOL_CONFIG_DEVID		"devid"
808 #define	ZPOOL_CONFIG_METASLAB_ARRAY	"metaslab_array"
809 #define	ZPOOL_CONFIG_METASLAB_SHIFT	"metaslab_shift"
810 #define	ZPOOL_CONFIG_ASHIFT		"ashift"
811 #define	ZPOOL_CONFIG_ASIZE		"asize"
812 #define	ZPOOL_CONFIG_DTL		"DTL"
813 #define	ZPOOL_CONFIG_STATS		"stats"
814 #define	ZPOOL_CONFIG_WHOLE_DISK		"whole_disk"
815 #define	ZPOOL_CONFIG_ERRCOUNT		"error_count"
816 #define	ZPOOL_CONFIG_NOT_PRESENT	"not_present"
817 #define	ZPOOL_CONFIG_SPARES		"spares"
818 #define	ZPOOL_CONFIG_IS_SPARE		"is_spare"
819 #define	ZPOOL_CONFIG_NPARITY		"nparity"
820 #define	ZPOOL_CONFIG_HOSTID		"hostid"
821 #define	ZPOOL_CONFIG_HOSTNAME		"hostname"
822 #define	ZPOOL_CONFIG_IS_LOG		"is_log"
823 #define	ZPOOL_CONFIG_TIMESTAMP		"timestamp" /* not stored on disk */
824 #define	ZPOOL_CONFIG_FEATURES_FOR_READ	"features_for_read"
825 #define	ZPOOL_CONFIG_VDEV_CHILDREN	"vdev_children"
826 
827 /*
828  * The persistent vdev state is stored as separate values rather than a single
829  * 'vdev_state' entry.  This is because a device can be in multiple states, such
830  * as offline and degraded.
831  */
832 #define	ZPOOL_CONFIG_OFFLINE            "offline"
833 #define	ZPOOL_CONFIG_FAULTED            "faulted"
834 #define	ZPOOL_CONFIG_DEGRADED           "degraded"
835 #define	ZPOOL_CONFIG_REMOVED            "removed"
836 #define	ZPOOL_CONFIG_FRU		"fru"
837 #define	ZPOOL_CONFIG_AUX_STATE		"aux_state"
838 
839 #define	VDEV_TYPE_ROOT			"root"
840 #define	VDEV_TYPE_MIRROR		"mirror"
841 #define	VDEV_TYPE_REPLACING		"replacing"
842 #define	VDEV_TYPE_RAIDZ			"raidz"
843 #define	VDEV_TYPE_DISK			"disk"
844 #define	VDEV_TYPE_FILE			"file"
845 #define	VDEV_TYPE_MISSING		"missing"
846 #define	VDEV_TYPE_HOLE			"hole"
847 #define	VDEV_TYPE_SPARE			"spare"
848 #define	VDEV_TYPE_LOG			"log"
849 #define	VDEV_TYPE_L2CACHE		"l2cache"
850 #define	VDEV_TYPE_INDIRECT		"indirect"
851 
852 /*
853  * This is needed in userland to report the minimum necessary device size.
854  */
855 #define	SPA_MINDEVSIZE		(64ULL << 20)
856 
857 /*
858  * The location of the pool configuration repository, shared between kernel and
859  * userland.
860  */
861 #define	ZPOOL_CACHE		"/boot/zfs/zpool.cache"
862 
863 /*
864  * vdev states are ordered from least to most healthy.
865  * A vdev that's CANT_OPEN or below is considered unusable.
866  */
867 typedef enum vdev_state {
868 	VDEV_STATE_UNKNOWN = 0,	/* Uninitialized vdev			*/
869 	VDEV_STATE_CLOSED,	/* Not currently open			*/
870 	VDEV_STATE_OFFLINE,	/* Not allowed to open			*/
871 	VDEV_STATE_REMOVED,	/* Explicitly removed from system	*/
872 	VDEV_STATE_CANT_OPEN,	/* Tried to open, but failed		*/
873 	VDEV_STATE_FAULTED,	/* External request to fault device	*/
874 	VDEV_STATE_DEGRADED,	/* Replicated vdev with unhealthy kids	*/
875 	VDEV_STATE_HEALTHY	/* Presumed good			*/
876 } vdev_state_t;
877 
878 /*
879  * vdev aux states.  When a vdev is in the CANT_OPEN state, the aux field
880  * of the vdev stats structure uses these constants to distinguish why.
881  */
882 typedef enum vdev_aux {
883 	VDEV_AUX_NONE,		/* no error				*/
884 	VDEV_AUX_OPEN_FAILED,	/* ldi_open_*() or vn_open() failed	*/
885 	VDEV_AUX_CORRUPT_DATA,	/* bad label or disk contents		*/
886 	VDEV_AUX_NO_REPLICAS,	/* insufficient number of replicas	*/
887 	VDEV_AUX_BAD_GUID_SUM,	/* vdev guid sum doesn't match		*/
888 	VDEV_AUX_TOO_SMALL,	/* vdev size is too small		*/
889 	VDEV_AUX_BAD_LABEL,	/* the label is OK but invalid		*/
890 	VDEV_AUX_VERSION_NEWER,	/* on-disk version is too new		*/
891 	VDEV_AUX_VERSION_OLDER,	/* on-disk version is too old		*/
892 	VDEV_AUX_SPARED		/* hot spare used in another pool	*/
893 } vdev_aux_t;
894 
895 /*
896  * pool state.  The following states are written to disk as part of the normal
897  * SPA lifecycle: ACTIVE, EXPORTED, DESTROYED, SPARE.  The remaining states are
898  * software abstractions used at various levels to communicate pool state.
899  */
900 typedef enum pool_state {
901 	POOL_STATE_ACTIVE = 0,		/* In active use		*/
902 	POOL_STATE_EXPORTED,		/* Explicitly exported		*/
903 	POOL_STATE_DESTROYED,		/* Explicitly destroyed		*/
904 	POOL_STATE_SPARE,		/* Reserved for hot spare use	*/
905 	POOL_STATE_UNINITIALIZED,	/* Internal spa_t state		*/
906 	POOL_STATE_UNAVAIL,		/* Internal libzfs state	*/
907 	POOL_STATE_POTENTIALLY_ACTIVE	/* Internal libzfs state	*/
908 } pool_state_t;
909 
910 /*
911  * The uberblock version is incremented whenever an incompatible on-disk
912  * format change is made to the SPA, DMU, or ZAP.
913  *
914  * Note: the first two fields should never be moved.  When a storage pool
915  * is opened, the uberblock must be read off the disk before the version
916  * can be checked.  If the ub_version field is moved, we may not detect
917  * version mismatch.  If the ub_magic field is moved, applications that
918  * expect the magic number in the first word won't work.
919  */
920 #define	UBERBLOCK_MAGIC		0x00bab10c		/* oo-ba-bloc!	*/
921 #define	UBERBLOCK_SHIFT		10			/* up to 1K	*/
922 
923 #define	MMP_MAGIC		0xa11cea11		/* all-see-all  */
924 
925 #define	MMP_INTERVAL_VALID_BIT	0x01
926 #define	MMP_SEQ_VALID_BIT	0x02
927 #define	MMP_FAIL_INT_VALID_BIT	0x04
928 
929 #define	MMP_VALID(ubp)		(ubp->ub_magic == UBERBLOCK_MAGIC && \
930 				    ubp->ub_mmp_magic == MMP_MAGIC)
931 #define	MMP_INTERVAL_VALID(ubp)	(MMP_VALID(ubp) && (ubp->ub_mmp_config & \
932 				    MMP_INTERVAL_VALID_BIT))
933 #define	MMP_SEQ_VALID(ubp)	(MMP_VALID(ubp) && (ubp->ub_mmp_config & \
934 				    MMP_SEQ_VALID_BIT))
935 #define	MMP_FAIL_INT_VALID(ubp)	(MMP_VALID(ubp) && (ubp->ub_mmp_config & \
936 				    MMP_FAIL_INT_VALID_BIT))
937 
938 #define	MMP_INTERVAL(ubp)	((ubp->ub_mmp_config & 0x00000000FFFFFF00) \
939 				    >> 8)
940 #define	MMP_SEQ(ubp)		((ubp->ub_mmp_config & 0x0000FFFF00000000) \
941 				    >> 32)
942 #define	MMP_FAIL_INT(ubp)	((ubp->ub_mmp_config & 0xFFFF000000000000) \
943 				    >> 48)
944 
945 typedef struct uberblock {
946 	uint64_t	ub_magic;	/* UBERBLOCK_MAGIC		*/
947 	uint64_t	ub_version;	/* SPA_VERSION			*/
948 	uint64_t	ub_txg;		/* txg of last sync		*/
949 	uint64_t	ub_guid_sum;	/* sum of all vdev guids	*/
950 	uint64_t	ub_timestamp;	/* UTC time of last sync	*/
951 	blkptr_t	ub_rootbp;	/* MOS objset_phys_t		*/
952 	/* highest SPA_VERSION supported by software that wrote this txg */
953 	uint64_t	ub_software_version;
954 	/* Maybe missing in uberblocks we read, but always written */
955 	uint64_t	ub_mmp_magic;
956 	/*
957 	 * If ub_mmp_delay == 0 and ub_mmp_magic is valid, MMP is off.
958 	 * Otherwise, nanosec since last MMP write.
959 	 */
960 	uint64_t	ub_mmp_delay;
961 
962 	/*
963 	 * The ub_mmp_config contains the multihost write interval, multihost
964 	 * fail intervals, sequence number for sub-second granularity, and
965 	 * valid bit mask.  This layout is as follows:
966 	 *
967 	 *   64      56      48      40      32      24      16      8       0
968 	 *   +-------+-------+-------+-------+-------+-------+-------+-------+
969 	 * 0 | Fail Intervals|      Seq      |   Write Interval (ms) | VALID |
970 	 *   +-------+-------+-------+-------+-------+-------+-------+-------+
971 	 *
972 	 * This allows a write_interval of (2^24/1000)s, over 4.5 hours
973 	 *
974 	 * VALID Bits:
975 	 * - 0x01 - Write Interval (ms)
976 	 * - 0x02 - Sequence number exists
977 	 * - 0x04 - Fail Intervals
978 	 * - 0xf8 - Reserved
979 	 */
980 	uint64_t	ub_mmp_config;
981 
982 	/*
983 	 * ub_checkpoint_txg indicates two things about the current uberblock:
984 	 *
985 	 * 1] If it is not zero then this uberblock is a checkpoint. If it is
986 	 *    zero, then this uberblock is not a checkpoint.
987 	 *
988 	 * 2] On checkpointed uberblocks, the value of ub_checkpoint_txg is
989 	 *    the ub_txg that the uberblock had at the time we moved it to
990 	 *    the MOS config.
991 	 *
992 	 * The field is set when we checkpoint the uberblock and continues to
993 	 * hold that value even after we've rewound (unlike the ub_txg that
994 	 * is reset to a higher value).
995 	 *
996 	 * Besides checks used to determine whether we are reopening the
997 	 * pool from a checkpointed uberblock [see spa_ld_select_uberblock()],
998 	 * the value of the field is used to determine which ZIL blocks have
999 	 * been allocated according to the ms_sm when we are rewinding to a
1000 	 * checkpoint. Specifically, if blk_birth > ub_checkpoint_txg, then
1001 	 * the ZIL block is not allocated [see uses of spa_min_claim_txg()].
1002 	 */
1003 	uint64_t	ub_checkpoint_txg;
1004 } uberblock_t;
1005 
1006 /*
1007  * Flags.
1008  */
1009 #define	DNODE_MUST_BE_ALLOCATED	1
1010 #define	DNODE_MUST_BE_FREE	2
1011 
1012 /*
1013  * Fixed constants.
1014  */
1015 #define	DNODE_SHIFT		9	/* 512 bytes */
1016 #define	DN_MIN_INDBLKSHIFT	12	/* 4k */
1017 #define	DN_MAX_INDBLKSHIFT	17	/* 128k */
1018 #define	DNODE_BLOCK_SHIFT	14	/* 16k */
1019 #define	DNODE_CORE_SIZE		64	/* 64 bytes for dnode sans blkptrs */
1020 #define	DN_MAX_OBJECT_SHIFT	48	/* 256 trillion (zfs_fid_t limit) */
1021 #define	DN_MAX_OFFSET_SHIFT	64	/* 2^64 bytes in a dnode */
1022 
1023 /*
1024  * Derived constants.
1025  */
1026 #define	DNODE_MIN_SIZE		(1 << DNODE_SHIFT)
1027 #define	DNODE_MAX_SIZE		(1 << DNODE_BLOCK_SHIFT)
1028 #define	DNODE_BLOCK_SIZE	(1 << DNODE_BLOCK_SHIFT)
1029 #define	DNODE_MIN_SLOTS		(DNODE_MIN_SIZE >> DNODE_SHIFT)
1030 #define	DNODE_MAX_SLOTS		(DNODE_MAX_SIZE >> DNODE_SHIFT)
1031 #define	DN_BONUS_SIZE(dnsize)	((dnsize) - DNODE_CORE_SIZE - \
1032 	(1 << SPA_BLKPTRSHIFT))
1033 #define	DN_SLOTS_TO_BONUSLEN(slots)	DN_BONUS_SIZE((slots) << DNODE_SHIFT)
1034 #define	DN_OLD_MAX_BONUSLEN		(DN_BONUS_SIZE(DNODE_MIN_SIZE))
1035 #define	DN_MAX_NBLKPTR		((DNODE_MIN_SIZE - DNODE_CORE_SIZE) >> \
1036 	SPA_BLKPTRSHIFT)
1037 #define	DN_MAX_OBJECT		(1ULL << DN_MAX_OBJECT_SHIFT)
1038 #define	DN_ZERO_BONUSLEN	(DN_BONUS_SIZE(DNODE_MAX_SIZE) + 1)
1039 
1040 #define	DNODES_PER_BLOCK_SHIFT	(DNODE_BLOCK_SHIFT - DNODE_SHIFT)
1041 #define	DNODES_PER_BLOCK	(1ULL << DNODES_PER_BLOCK_SHIFT)
1042 #define	DNODES_PER_LEVEL_SHIFT	(DN_MAX_INDBLKSHIFT - SPA_BLKPTRSHIFT)
1043 
1044 /* The +2 here is a cheesy way to round up */
1045 #define	DN_MAX_LEVELS	(2 + ((DN_MAX_OFFSET_SHIFT - SPA_MINBLOCKSHIFT) / \
1046 	(DN_MIN_INDBLKSHIFT - SPA_BLKPTRSHIFT)))
1047 
1048 #define	DN_BONUS(dnp)	((void*)((dnp)->dn_bonus + \
1049 	(((dnp)->dn_nblkptr - 1) * sizeof (blkptr_t))))
1050 
1051 #define	DN_USED_BYTES(dnp) (((dnp)->dn_flags & DNODE_FLAG_USED_BYTES) ? \
1052 	(dnp)->dn_used : (dnp)->dn_used << SPA_MINBLOCKSHIFT)
1053 
1054 #define	EPB(blkshift, typeshift)	(1 << (blkshift - typeshift))
1055 
1056 /* Is dn_used in bytes?  if not, it's in multiples of SPA_MINBLOCKSIZE */
1057 #define	DNODE_FLAG_USED_BYTES		(1<<0)
1058 #define	DNODE_FLAG_USERUSED_ACCOUNTED	(1<<1)
1059 
1060 /* Does dnode have a SA spill blkptr in bonus? */
1061 #define	DNODE_FLAG_SPILL_BLKPTR	(1<<2)
1062 
1063 typedef struct dnode_phys {
1064 	uint8_t dn_type;		/* dmu_object_type_t */
1065 	uint8_t dn_indblkshift;		/* ln2(indirect block size) */
1066 	uint8_t dn_nlevels;		/* 1=dn_blkptr->data blocks */
1067 	uint8_t dn_nblkptr;		/* length of dn_blkptr */
1068 	uint8_t dn_bonustype;		/* type of data in bonus buffer */
1069 	uint8_t	dn_checksum;		/* ZIO_CHECKSUM type */
1070 	uint8_t	dn_compress;		/* ZIO_COMPRESS type */
1071 	uint8_t dn_flags;		/* DNODE_FLAG_* */
1072 	uint16_t dn_datablkszsec;	/* data block size in 512b sectors */
1073 	uint16_t dn_bonuslen;		/* length of dn_bonus */
1074 	uint8_t dn_extra_slots;		/* # of subsequent slots consumed */
1075 	uint8_t dn_pad2[3];
1076 
1077 	/* accounting is protected by dn_dirty_mtx */
1078 	uint64_t dn_maxblkid;		/* largest allocated block ID */
1079 	uint64_t dn_used;		/* bytes (or sectors) of disk space */
1080 
1081 	uint64_t dn_pad3[4];
1082 
1083 	/*
1084 	 * The tail region is 448 bytes for a 512 byte dnode, and
1085 	 * correspondingly larger for larger dnode sizes. The spill
1086 	 * block pointer, when present, is always at the end of the tail
1087 	 * region. There are three ways this space may be used, using
1088 	 * a 512 byte dnode for this diagram:
1089 	 *
1090 	 * 0       64      128     192     256     320     384     448 (offset)
1091 	 * +---------------+---------------+---------------+-------+
1092 	 * | dn_blkptr[0]  | dn_blkptr[1]  | dn_blkptr[2]  | /     |
1093 	 * +---------------+---------------+---------------+-------+
1094 	 * | dn_blkptr[0]  | dn_bonus[0..319]                      |
1095 	 * +---------------+-----------------------+---------------+
1096 	 * | dn_blkptr[0]  | dn_bonus[0..191]      | dn_spill      |
1097 	 * +---------------+-----------------------+---------------+
1098 	 */
1099 	union {
1100 		blkptr_t dn_blkptr[1+DN_OLD_MAX_BONUSLEN/sizeof (blkptr_t)];
1101 		struct {
1102 			blkptr_t __dn_ignore1;
1103 			uint8_t dn_bonus[DN_OLD_MAX_BONUSLEN];
1104 		};
1105 		struct {
1106 			blkptr_t __dn_ignore2;
1107 			uint8_t __dn_ignore3[DN_OLD_MAX_BONUSLEN -
1108 			    sizeof (blkptr_t)];
1109 			blkptr_t dn_spill;
1110 		};
1111 	};
1112 } dnode_phys_t;
1113 
1114 #define	DN_SPILL_BLKPTR(dnp)	(blkptr_t *)((char *)(dnp) + \
1115 	(((dnp)->dn_extra_slots + 1) << DNODE_SHIFT) - (1 << SPA_BLKPTRSHIFT))
1116 
1117 typedef enum dmu_object_byteswap {
1118 	DMU_BSWAP_UINT8,
1119 	DMU_BSWAP_UINT16,
1120 	DMU_BSWAP_UINT32,
1121 	DMU_BSWAP_UINT64,
1122 	DMU_BSWAP_ZAP,
1123 	DMU_BSWAP_DNODE,
1124 	DMU_BSWAP_OBJSET,
1125 	DMU_BSWAP_ZNODE,
1126 	DMU_BSWAP_OLDACL,
1127 	DMU_BSWAP_ACL,
1128 	/*
1129 	 * Allocating a new byteswap type number makes the on-disk format
1130 	 * incompatible with any other format that uses the same number.
1131 	 *
1132 	 * Data can usually be structured to work with one of the
1133 	 * DMU_BSWAP_UINT* or DMU_BSWAP_ZAP types.
1134 	 */
1135 	DMU_BSWAP_NUMFUNCS
1136 } dmu_object_byteswap_t;
1137 
1138 #define	DMU_OT_NEWTYPE 0x80
1139 #define	DMU_OT_METADATA 0x40
1140 #define	DMU_OT_BYTESWAP_MASK 0x3f
1141 
1142 /*
1143  * Defines a uint8_t object type. Object types specify if the data
1144  * in the object is metadata (boolean) and how to byteswap the data
1145  * (dmu_object_byteswap_t).
1146  */
1147 #define	DMU_OT(byteswap, metadata) \
1148 	(DMU_OT_NEWTYPE | \
1149 	((metadata) ? DMU_OT_METADATA : 0) | \
1150 	((byteswap) & DMU_OT_BYTESWAP_MASK))
1151 
1152 typedef enum dmu_object_type {
1153 	DMU_OT_NONE,
1154 	/* general: */
1155 	DMU_OT_OBJECT_DIRECTORY,	/* ZAP */
1156 	DMU_OT_OBJECT_ARRAY,		/* UINT64 */
1157 	DMU_OT_PACKED_NVLIST,		/* UINT8 (XDR by nvlist_pack/unpack) */
1158 	DMU_OT_PACKED_NVLIST_SIZE,	/* UINT64 */
1159 	DMU_OT_BPOBJ,			/* UINT64 */
1160 	DMU_OT_BPOBJ_HDR,		/* UINT64 */
1161 	/* spa: */
1162 	DMU_OT_SPACE_MAP_HEADER,	/* UINT64 */
1163 	DMU_OT_SPACE_MAP,		/* UINT64 */
1164 	/* zil: */
1165 	DMU_OT_INTENT_LOG,		/* UINT64 */
1166 	/* dmu: */
1167 	DMU_OT_DNODE,			/* DNODE */
1168 	DMU_OT_OBJSET,			/* OBJSET */
1169 	/* dsl: */
1170 	DMU_OT_DSL_DIR,			/* UINT64 */
1171 	DMU_OT_DSL_DIR_CHILD_MAP,	/* ZAP */
1172 	DMU_OT_DSL_DS_SNAP_MAP,		/* ZAP */
1173 	DMU_OT_DSL_PROPS,		/* ZAP */
1174 	DMU_OT_DSL_DATASET,		/* UINT64 */
1175 	/* zpl: */
1176 	DMU_OT_ZNODE,			/* ZNODE */
1177 	DMU_OT_OLDACL,			/* Old ACL */
1178 	DMU_OT_PLAIN_FILE_CONTENTS,	/* UINT8 */
1179 	DMU_OT_DIRECTORY_CONTENTS,	/* ZAP */
1180 	DMU_OT_MASTER_NODE,		/* ZAP */
1181 	DMU_OT_UNLINKED_SET,		/* ZAP */
1182 	/* zvol: */
1183 	DMU_OT_ZVOL,			/* UINT8 */
1184 	DMU_OT_ZVOL_PROP,		/* ZAP */
1185 	/* other; for testing only! */
1186 	DMU_OT_PLAIN_OTHER,		/* UINT8 */
1187 	DMU_OT_UINT64_OTHER,		/* UINT64 */
1188 	DMU_OT_ZAP_OTHER,		/* ZAP */
1189 	/* new object types: */
1190 	DMU_OT_ERROR_LOG,		/* ZAP */
1191 	DMU_OT_SPA_HISTORY,		/* UINT8 */
1192 	DMU_OT_SPA_HISTORY_OFFSETS,	/* spa_his_phys_t */
1193 	DMU_OT_POOL_PROPS,		/* ZAP */
1194 	DMU_OT_DSL_PERMS,		/* ZAP */
1195 	DMU_OT_ACL,			/* ACL */
1196 	DMU_OT_SYSACL,			/* SYSACL */
1197 	DMU_OT_FUID,			/* FUID table (Packed NVLIST UINT8) */
1198 	DMU_OT_FUID_SIZE,		/* FUID table size UINT64 */
1199 	DMU_OT_NEXT_CLONES,		/* ZAP */
1200 	DMU_OT_SCAN_QUEUE,		/* ZAP */
1201 	DMU_OT_USERGROUP_USED,		/* ZAP */
1202 	DMU_OT_USERGROUP_QUOTA,		/* ZAP */
1203 	DMU_OT_USERREFS,		/* ZAP */
1204 	DMU_OT_DDT_ZAP,			/* ZAP */
1205 	DMU_OT_DDT_STATS,		/* ZAP */
1206 	DMU_OT_SA,			/* System attr */
1207 	DMU_OT_SA_MASTER_NODE,		/* ZAP */
1208 	DMU_OT_SA_ATTR_REGISTRATION,	/* ZAP */
1209 	DMU_OT_SA_ATTR_LAYOUTS,		/* ZAP */
1210 	DMU_OT_SCAN_XLATE,		/* ZAP */
1211 	DMU_OT_DEDUP,			/* fake dedup BP from ddt_bp_create() */
1212 	DMU_OT_DEADLIST,		/* ZAP */
1213 	DMU_OT_DEADLIST_HDR,		/* UINT64 */
1214 	DMU_OT_DSL_CLONES,		/* ZAP */
1215 	DMU_OT_BPOBJ_SUBOBJ,		/* UINT64 */
1216 	DMU_OT_NUMTYPES,
1217 
1218 	/*
1219 	 * Names for valid types declared with DMU_OT().
1220 	 */
1221 	DMU_OTN_UINT8_DATA = DMU_OT(DMU_BSWAP_UINT8, B_FALSE),
1222 	DMU_OTN_UINT8_METADATA = DMU_OT(DMU_BSWAP_UINT8, B_TRUE),
1223 	DMU_OTN_UINT16_DATA = DMU_OT(DMU_BSWAP_UINT16, B_FALSE),
1224 	DMU_OTN_UINT16_METADATA = DMU_OT(DMU_BSWAP_UINT16, B_TRUE),
1225 	DMU_OTN_UINT32_DATA = DMU_OT(DMU_BSWAP_UINT32, B_FALSE),
1226 	DMU_OTN_UINT32_METADATA = DMU_OT(DMU_BSWAP_UINT32, B_TRUE),
1227 	DMU_OTN_UINT64_DATA = DMU_OT(DMU_BSWAP_UINT64, B_FALSE),
1228 	DMU_OTN_UINT64_METADATA = DMU_OT(DMU_BSWAP_UINT64, B_TRUE),
1229 	DMU_OTN_ZAP_DATA = DMU_OT(DMU_BSWAP_ZAP, B_FALSE),
1230 	DMU_OTN_ZAP_METADATA = DMU_OT(DMU_BSWAP_ZAP, B_TRUE)
1231 } dmu_object_type_t;
1232 
1233 typedef enum dmu_objset_type {
1234 	DMU_OST_NONE,
1235 	DMU_OST_META,
1236 	DMU_OST_ZFS,
1237 	DMU_OST_ZVOL,
1238 	DMU_OST_OTHER,			/* For testing only! */
1239 	DMU_OST_ANY,			/* Be careful! */
1240 	DMU_OST_NUMTYPES
1241 } dmu_objset_type_t;
1242 
1243 #define	ZAP_MAXVALUELEN	(1024 * 8)
1244 
1245 /*
1246  * header for all bonus and spill buffers.
1247  * The header has a fixed portion with a variable number
1248  * of "lengths" depending on the number of variable sized
1249  * attribues which are determined by the "layout number"
1250  */
1251 
1252 #define	SA_MAGIC	0x2F505A  /* ZFS SA */
1253 typedef struct sa_hdr_phys {
1254 	uint32_t sa_magic;
1255 	uint16_t sa_layout_info;  /* Encoded with hdrsize and layout number */
1256 	uint16_t sa_lengths[1];	/* optional sizes for variable length attrs */
1257 	/* ... Data follows the lengths.  */
1258 } sa_hdr_phys_t;
1259 
1260 /*
1261  * sa_hdr_phys -> sa_layout_info
1262  *
1263  * 16      10       0
1264  * +--------+-------+
1265  * | hdrsz  |layout |
1266  * +--------+-------+
1267  *
1268  * Bits 0-10 are the layout number
1269  * Bits 11-16 are the size of the header.
1270  * The hdrsize is the number * 8
1271  *
1272  * For example.
1273  * hdrsz of 1 ==> 8 byte header
1274  *          2 ==> 16 byte header
1275  *
1276  */
1277 
1278 #define	SA_HDR_LAYOUT_NUM(hdr) BF32_GET(hdr->sa_layout_info, 0, 10)
1279 #define	SA_HDR_SIZE(hdr) BF32_GET_SB(hdr->sa_layout_info, 10, 16, 3, 0)
1280 #define	SA_HDR_LAYOUT_INFO_ENCODE(x, num, size) \
1281 { \
1282 	BF32_SET_SB(x, 10, 6, 3, 0, size); \
1283 	BF32_SET(x, 0, 10, num); \
1284 }
1285 
1286 #define	SA_ATTR_BSWAP(x)	BF32_GET(x, 16, 8)
1287 #define	SA_ATTR_LENGTH(x)	BF32_GET(x, 24, 16)
1288 #define	SA_ATTR_NUM(x)		BF32_GET(x, 0, 16)
1289 #define	SA_ATTR_ENCODE(x, attr, length, bswap) \
1290 { \
1291 	BF64_SET(x, 24, 16, length); \
1292 	BF64_SET(x, 16, 8, bswap); \
1293 	BF64_SET(x, 0, 16, attr); \
1294 }
1295 
1296 #define	SA_MODE_OFFSET		0
1297 #define	SA_SIZE_OFFSET		8
1298 #define	SA_GEN_OFFSET		16
1299 #define	SA_UID_OFFSET		24
1300 #define	SA_GID_OFFSET		32
1301 #define	SA_PARENT_OFFSET	40
1302 #define	SA_SYMLINK_OFFSET	160
1303 
1304 #define	SA_REGISTRY	"REGISTRY"
1305 #define	SA_LAYOUTS	"LAYOUTS"
1306 
1307 typedef enum sa_bswap_type {
1308 	SA_UINT64_ARRAY,
1309 	SA_UINT32_ARRAY,
1310 	SA_UINT16_ARRAY,
1311 	SA_UINT8_ARRAY,
1312 	SA_ACL,
1313 } sa_bswap_type_t;
1314 
1315 typedef uint16_t	sa_attr_type_t;
1316 
1317 #define	ZIO_OBJSET_MAC_LEN		32
1318 
1319 /*
1320  * Intent log header - this on disk structure holds fields to manage
1321  * the log.  All fields are 64 bit to easily handle cross architectures.
1322  */
1323 typedef struct zil_header {
1324 	uint64_t zh_claim_txg;	/* txg in which log blocks were claimed */
1325 	uint64_t zh_replay_seq;	/* highest replayed sequence number */
1326 	blkptr_t zh_log;	/* log chain */
1327 	uint64_t zh_claim_seq;	/* highest claimed sequence number */
1328 	uint64_t zh_pad[5];
1329 } zil_header_t;
1330 
1331 #define	OBJSET_PHYS_SIZE_V2 2048
1332 #define	OBJSET_PHYS_SIZE_V3 4096
1333 
1334 typedef struct objset_phys {
1335 	dnode_phys_t os_meta_dnode;
1336 	zil_header_t os_zil_header;
1337 	uint64_t os_type;
1338 	uint64_t os_flags;
1339 	uint8_t os_portable_mac[ZIO_OBJSET_MAC_LEN];
1340 	uint8_t os_local_mac[ZIO_OBJSET_MAC_LEN];
1341 	char os_pad0[OBJSET_PHYS_SIZE_V2 - sizeof (dnode_phys_t)*3 -
1342 		sizeof (zil_header_t) - sizeof (uint64_t)*2 -
1343 		2*ZIO_OBJSET_MAC_LEN];
1344 	dnode_phys_t os_userused_dnode;
1345 	dnode_phys_t os_groupused_dnode;
1346 	dnode_phys_t os_projectused_dnode;
1347 	char os_pad1[OBJSET_PHYS_SIZE_V3 - OBJSET_PHYS_SIZE_V2 -
1348 	    sizeof (dnode_phys_t)];
1349 } objset_phys_t;
1350 
1351 typedef struct space_map_phys {
1352 	/* object number: not needed but kept for backwards compatibility */
1353 	uint64_t	smp_object;
1354 
1355 	/* length of the object in bytes */
1356 	uint64_t	smp_length;
1357 
1358 	/* space allocated from the map */
1359 	int64_t		smp_alloc;
1360 } space_map_phys_t;
1361 
1362 typedef enum {
1363 	SM_ALLOC,
1364 	SM_FREE
1365 } maptype_t;
1366 
1367 /* one-word entry constants */
1368 #define	SM_DEBUG_PREFIX	2
1369 #define	SM_OFFSET_BITS	47
1370 #define	SM_RUN_BITS	15
1371 
1372 /* two-word entry constants */
1373 #define	SM2_PREFIX	3
1374 #define	SM2_OFFSET_BITS	63
1375 #define	SM2_RUN_BITS	36
1376 
1377 #define	SM_PREFIX_DECODE(x)	BF64_DECODE(x, 62, 2)
1378 #define	SM_PREFIX_ENCODE(x)	BF64_ENCODE(x, 62, 2)
1379 
1380 #define	SM_DEBUG_ACTION_DECODE(x)	BF64_DECODE(x, 60, 2)
1381 #define	SM_DEBUG_ACTION_ENCODE(x)	BF64_ENCODE(x, 60, 2)
1382 #define	SM_DEBUG_SYNCPASS_DECODE(x)	BF64_DECODE(x, 50, 10)
1383 #define	SM_DEBUG_SYNCPASS_ENCODE(x)	BF64_ENCODE(x, 50, 10)
1384 #define	SM_DEBUG_TXG_DECODE(x)		BF64_DECODE(x, 0, 50)
1385 #define	SM_DEBUG_TXG_ENCODE(x)		BF64_ENCODE(x, 0, 50)
1386 
1387 #define	SM_OFFSET_DECODE(x)	BF64_DECODE(x, 16, SM_OFFSET_BITS)
1388 #define	SM_OFFSET_ENCODE(x)	BF64_ENCODE(x, 16, SM_OFFSET_BITS)
1389 #define	SM_TYPE_DECODE(x)	BF64_DECODE(x, 15, 1)
1390 #define	SM_TYPE_ENCODE(x)	BF64_ENCODE(x, 15, 1)
1391 #define	SM_RUN_DECODE(x)	(BF64_DECODE(x, 0, SM_RUN_BITS) + 1)
1392 #define	SM_RUN_ENCODE(x)	BF64_ENCODE((x) - 1, 0, SM_RUN_BITS)
1393 #define	SM_RUN_MAX		SM_RUN_DECODE(~0ULL)
1394 #define	SM_OFFSET_MAX		SM_OFFSET_DECODE(~0ULL)
1395 
1396 #define	SM2_RUN_DECODE(x)	(BF64_DECODE(x, 24, SM2_RUN_BITS) + 1)
1397 #define	SM2_RUN_ENCODE(x)	BF64_ENCODE((x) - 1, 24, SM2_RUN_BITS)
1398 #define	SM2_VDEV_DECODE(x)	BF64_DECODE(x, 0, 24)
1399 #define	SM2_VDEV_ENCODE(x)	BF64_ENCODE(x, 0, 24)
1400 #define	SM2_TYPE_DECODE(x)	BF64_DECODE(x, SM2_OFFSET_BITS, 1)
1401 #define	SM2_TYPE_ENCODE(x)	BF64_ENCODE(x, SM2_OFFSET_BITS, 1)
1402 #define	SM2_OFFSET_DECODE(x)	BF64_DECODE(x, 0, SM2_OFFSET_BITS)
1403 #define	SM2_OFFSET_ENCODE(x)	BF64_ENCODE(x, 0, SM2_OFFSET_BITS)
1404 #define	SM2_RUN_MAX		SM2_RUN_DECODE(~0ULL)
1405 #define	SM2_OFFSET_MAX		SM2_OFFSET_DECODE(~0ULL)
1406 
1407 typedef struct dsl_dir_phys {
1408 	uint64_t dd_creation_time; /* not actually used */
1409 	uint64_t dd_head_dataset_obj;
1410 	uint64_t dd_parent_obj;
1411 	uint64_t dd_clone_parent_obj;
1412 	uint64_t dd_child_dir_zapobj;
1413 	/*
1414 	 * how much space our children are accounting for; for leaf
1415 	 * datasets, == physical space used by fs + snaps
1416 	 */
1417 	uint64_t dd_used_bytes;
1418 	uint64_t dd_compressed_bytes;
1419 	uint64_t dd_uncompressed_bytes;
1420 	/* Administrative quota setting */
1421 	uint64_t dd_quota;
1422 	/* Administrative reservation setting */
1423 	uint64_t dd_reserved;
1424 	uint64_t dd_props_zapobj;
1425 	uint64_t dd_pad[7];
1426 	uint64_t dd_clones;
1427 	uint64_t dd_pad1[13]; /* pad out to 256 bytes for good measure */
1428 } dsl_dir_phys_t;
1429 
1430 typedef struct dsl_dataset_phys {
1431 	uint64_t ds_dir_obj;
1432 	uint64_t ds_prev_snap_obj;
1433 	uint64_t ds_prev_snap_txg;
1434 	uint64_t ds_next_snap_obj;
1435 	uint64_t ds_snapnames_zapobj;	/* zap obj of snaps; ==0 for snaps */
1436 	uint64_t ds_num_children;	/* clone/snap children; ==0 for head */
1437 	uint64_t ds_creation_time;	/* seconds since 1970 */
1438 	uint64_t ds_creation_txg;
1439 	uint64_t ds_deadlist_obj;
1440 	uint64_t ds_used_bytes;
1441 	uint64_t ds_compressed_bytes;
1442 	uint64_t ds_uncompressed_bytes;
1443 	uint64_t ds_unique_bytes;	/* only relevant to snapshots */
1444 	/*
1445 	 * The ds_fsid_guid is a 56-bit ID that can change to avoid
1446 	 * collisions.  The ds_guid is a 64-bit ID that will never
1447 	 * change, so there is a small probability that it will collide.
1448 	 */
1449 	uint64_t ds_fsid_guid;
1450 	uint64_t ds_guid;
1451 	uint64_t ds_flags;
1452 	blkptr_t ds_bp;
1453 	uint64_t ds_pad[8]; /* pad out to 320 bytes for good measure */
1454 } dsl_dataset_phys_t;
1455 
1456 typedef struct dsl_deadlist_phys {
1457 	uint64_t dl_used;
1458 	uint64_t dl_comp;
1459 	uint64_t dl_uncomp;
1460 	uint64_t dl_pad[37]; /* pad out to 320b for future expansion */
1461 } dsl_deadlist_phys_t;
1462 
1463 #define	BPOBJ_SIZE_V2	(6 * sizeof (uint64_t))
1464 
1465 typedef struct bpobj_phys {
1466 	uint64_t	bpo_num_blkptrs;
1467 	uint64_t	bpo_bytes;
1468 	uint64_t	bpo_comp;
1469 	uint64_t	bpo_uncomp;
1470 	uint64_t	bpo_subobjs;
1471 	uint64_t	bpo_num_subobjs;
1472 	uint64_t	bpo_num_freed;
1473 } bpobj_phys_t;
1474 
1475 /*
1476  * The names of zap entries in the DIRECTORY_OBJECT of the MOS.
1477  */
1478 #define	DMU_POOL_DIRECTORY_OBJECT	1
1479 #define	DMU_POOL_CONFIG			"config"
1480 #define	DMU_POOL_FEATURES_FOR_READ	"features_for_read"
1481 #define	DMU_POOL_FEATURES_FOR_WRITE	"features_for_write"
1482 #define	DMU_POOL_FEATURE_DESCRIPTIONS	"feature_descriptions"
1483 #define	DMU_POOL_ROOT_DATASET		"root_dataset"
1484 #define	DMU_POOL_SYNC_BPLIST		"sync_bplist"
1485 #define	DMU_POOL_ERRLOG_SCRUB		"errlog_scrub"
1486 #define	DMU_POOL_ERRLOG_LAST		"errlog_last"
1487 #define	DMU_POOL_SPARES			"spares"
1488 #define	DMU_POOL_DEFLATE		"deflate"
1489 #define	DMU_POOL_HISTORY		"history"
1490 #define	DMU_POOL_PROPS			"pool_props"
1491 #define	DMU_POOL_FREE_BPOBJ		"free_bpobj"
1492 #define	DMU_POOL_BPTREE_OBJ		"bptree_obj"
1493 #define	DMU_POOL_EMPTY_BPOBJ		"empty_bpobj"
1494 #define	DMU_POOL_TMP_USERREFS		"tmp_userrefs"
1495 #define	DMU_POOL_CHECKSUM_SALT		"org.illumos:checksum_salt"
1496 #define	DMU_POOL_REMOVING		"com.delphix:removing"
1497 #define	DMU_POOL_OBSOLETE_BPOBJ		"com.delphix:obsolete_bpobj"
1498 #define	DMU_POOL_CONDENSING_INDIRECT	"com.delphix:condensing_indirect"
1499 #define	DMU_POOL_ZPOOL_CHECKPOINT       "com.delphix:zpool_checkpoint"
1500 
1501 #define	ZAP_MAGIC 0x2F52AB2ABULL
1502 
1503 #define	FZAP_BLOCK_SHIFT(zap)	((zap)->zap_block_shift)
1504 
1505 #define	ZAP_MAXCD		(uint32_t)(-1)
1506 #define	ZAP_HASHBITS		28
1507 #define	MZAP_ENT_LEN		64
1508 #define	MZAP_ENT_MAX		\
1509 	((MZAP_MAX_BLKSZ - sizeof(mzap_phys_t)) / sizeof(mzap_ent_phys_t) + 1)
1510 #define	MZAP_NAME_LEN		(MZAP_ENT_LEN - 8 - 4 - 2)
1511 #define	MZAP_MAX_BLKSZ		SPA_OLDMAXBLOCKSIZE
1512 
1513 typedef struct mzap_ent_phys {
1514 	uint64_t mze_value;
1515 	uint32_t mze_cd;
1516 	uint16_t mze_pad;	/* in case we want to chain them someday */
1517 	char mze_name[MZAP_NAME_LEN];
1518 } mzap_ent_phys_t;
1519 
1520 typedef struct mzap_phys {
1521 	uint64_t mz_block_type;	/* ZBT_MICRO */
1522 	uint64_t mz_salt;
1523 	uint64_t mz_normflags;
1524 	uint64_t mz_pad[5];
1525 	mzap_ent_phys_t mz_chunk[1];
1526 	/* actually variable size depending on block size */
1527 } mzap_phys_t;
1528 
1529 /*
1530  * The (fat) zap is stored in one object. It is an array of
1531  * 1<<FZAP_BLOCK_SHIFT byte blocks. The layout looks like one of:
1532  *
1533  * ptrtbl fits in first block:
1534  * 	[zap_phys_t zap_ptrtbl_shift < 6] [zap_leaf_t] ...
1535  *
1536  * ptrtbl too big for first block:
1537  * 	[zap_phys_t zap_ptrtbl_shift >= 6] [zap_leaf_t] [ptrtbl] ...
1538  *
1539  */
1540 
1541 #define	ZBT_LEAF		((1ULL << 63) + 0)
1542 #define	ZBT_HEADER		((1ULL << 63) + 1)
1543 #define	ZBT_MICRO		((1ULL << 63) + 3)
1544 /* any other values are ptrtbl blocks */
1545 
1546 /*
1547  * the embedded pointer table takes up half a block:
1548  * block size / entry size (2^3) / 2
1549  */
1550 #define	ZAP_EMBEDDED_PTRTBL_SHIFT(zap) (FZAP_BLOCK_SHIFT(zap) - 3 - 1)
1551 
1552 /*
1553  * The embedded pointer table starts half-way through the block.  Since
1554  * the pointer table itself is half the block, it starts at (64-bit)
1555  * word number (1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap)).
1556  */
1557 #define	ZAP_EMBEDDED_PTRTBL_ENT(zap, idx) \
1558 	((uint64_t *)(zap)->zap_phys) \
1559 	[(idx) + (1<<ZAP_EMBEDDED_PTRTBL_SHIFT(zap))]
1560 
1561 #define	ZAP_HASH_IDX(hash, n)	(((n) == 0) ? 0 : ((hash) >> (64 - (n))))
1562 
1563 /*
1564  * TAKE NOTE:
1565  * If zap_phys_t is modified, zap_byteswap() must be modified.
1566  */
1567 typedef struct zap_phys {
1568 	uint64_t zap_block_type;	/* ZBT_HEADER */
1569 	uint64_t zap_magic;		/* ZAP_MAGIC */
1570 
1571 	struct zap_table_phys {
1572 		uint64_t zt_blk;	/* starting block number */
1573 		uint64_t zt_numblks;	/* number of blocks */
1574 		uint64_t zt_shift;	/* bits to index it */
1575 		uint64_t zt_nextblk;	/* next (larger) copy start block */
1576 		uint64_t zt_blks_copied; /* number source blocks copied */
1577 	} zap_ptrtbl;
1578 
1579 	uint64_t zap_freeblk;		/* the next free block */
1580 	uint64_t zap_num_leafs;		/* number of leafs */
1581 	uint64_t zap_num_entries;	/* number of entries */
1582 	uint64_t zap_salt;		/* salt to stir into hash function */
1583 	uint64_t zap_normflags;		/* flags for u8_textprep_str() */
1584 	uint64_t zap_flags;		/* zap_flags_t */
1585 	/*
1586 	 * This structure is followed by padding, and then the embedded
1587 	 * pointer table.  The embedded pointer table takes up second
1588 	 * half of the block.  It is accessed using the
1589 	 * ZAP_EMBEDDED_PTRTBL_ENT() macro.
1590 	 */
1591 } zap_phys_t;
1592 
1593 typedef struct zap_table_phys zap_table_phys_t;
1594 
1595 struct spa;
1596 typedef struct fat_zap {
1597 	int zap_block_shift;			/* block size shift */
1598 	zap_phys_t *zap_phys;
1599 	const struct spa *zap_spa;
1600 	const dnode_phys_t *zap_dnode;
1601 } fat_zap_t;
1602 
1603 #define	ZAP_LEAF_MAGIC 0x2AB1EAF
1604 
1605 /* chunk size = 24 bytes */
1606 #define	ZAP_LEAF_CHUNKSIZE 24
1607 
1608 /*
1609  * The amount of space available for chunks is:
1610  * block size (1<<l->l_bs) - hash entry size (2) * number of hash
1611  * entries - header space (2*chunksize)
1612  */
1613 #define	ZAP_LEAF_NUMCHUNKS(l) \
1614 	(((1<<(l)->l_bs) - 2*ZAP_LEAF_HASH_NUMENTRIES(l)) / \
1615 	ZAP_LEAF_CHUNKSIZE - 2)
1616 
1617 /*
1618  * The amount of space within the chunk available for the array is:
1619  * chunk size - space for type (1) - space for next pointer (2)
1620  */
1621 #define	ZAP_LEAF_ARRAY_BYTES (ZAP_LEAF_CHUNKSIZE - 3)
1622 
1623 #define	ZAP_LEAF_ARRAY_NCHUNKS(bytes) \
1624 	(((bytes)+ZAP_LEAF_ARRAY_BYTES-1)/ZAP_LEAF_ARRAY_BYTES)
1625 
1626 /*
1627  * Low water mark:  when there are only this many chunks free, start
1628  * growing the ptrtbl.  Ideally, this should be larger than a
1629  * "reasonably-sized" entry.  20 chunks is more than enough for the
1630  * largest directory entry (MAXNAMELEN (256) byte name, 8-byte value),
1631  * while still being only around 3% for 16k blocks.
1632  */
1633 #define	ZAP_LEAF_LOW_WATER (20)
1634 
1635 /*
1636  * The leaf hash table has block size / 2^5 (32) number of entries,
1637  * which should be more than enough for the maximum number of entries,
1638  * which is less than block size / CHUNKSIZE (24) / minimum number of
1639  * chunks per entry (3).
1640  */
1641 #define	ZAP_LEAF_HASH_SHIFT(l) ((l)->l_bs - 5)
1642 #define	ZAP_LEAF_HASH_NUMENTRIES(l) (1 << ZAP_LEAF_HASH_SHIFT(l))
1643 
1644 /*
1645  * The chunks start immediately after the hash table.  The end of the
1646  * hash table is at l_hash + HASH_NUMENTRIES, which we simply cast to a
1647  * chunk_t.
1648  */
1649 #define	ZAP_LEAF_CHUNK(l, idx) \
1650 	((zap_leaf_chunk_t *)(void *) \
1651 	((l)->l_phys->l_hash + ZAP_LEAF_HASH_NUMENTRIES(l)))[idx]
1652 #define	ZAP_LEAF_ENTRY(l, idx) (&ZAP_LEAF_CHUNK(l, idx).l_entry)
1653 
1654 #define	ZAP_LEAF_HASH(l, h) \
1655 	((ZAP_LEAF_HASH_NUMENTRIES(l)-1) & \
1656 	((h) >> \
1657 	(64 - ZAP_LEAF_HASH_SHIFT(l) - (l)->l_phys->l_hdr.lh_prefix_len)))
1658 #define	ZAP_LEAF_HASH_ENTPTR(l, h) (&(l)->l_phys->l_hash[ZAP_LEAF_HASH(l, h)])
1659 
1660 typedef enum zap_chunk_type {
1661 	ZAP_CHUNK_FREE = 253,
1662 	ZAP_CHUNK_ENTRY = 252,
1663 	ZAP_CHUNK_ARRAY = 251,
1664 	ZAP_CHUNK_TYPE_MAX = 250
1665 } zap_chunk_type_t;
1666 
1667 /*
1668  * TAKE NOTE:
1669  * If zap_leaf_phys_t is modified, zap_leaf_byteswap() must be modified.
1670  */
1671 typedef struct zap_leaf_phys {
1672 	struct zap_leaf_header {
1673 		uint64_t lh_block_type;		/* ZBT_LEAF */
1674 		uint64_t lh_pad1;
1675 		uint64_t lh_prefix;		/* hash prefix of this leaf */
1676 		uint32_t lh_magic;		/* ZAP_LEAF_MAGIC */
1677 		uint16_t lh_nfree;		/* number free chunks */
1678 		uint16_t lh_nentries;		/* number of entries */
1679 		uint16_t lh_prefix_len;		/* num bits used to id this */
1680 
1681 /* above is accessable to zap, below is zap_leaf private */
1682 
1683 		uint16_t lh_freelist;		/* chunk head of free list */
1684 		uint8_t lh_pad2[12];
1685 	} l_hdr; /* 2 24-byte chunks */
1686 
1687 	/*
1688 	 * The header is followed by a hash table with
1689 	 * ZAP_LEAF_HASH_NUMENTRIES(zap) entries.  The hash table is
1690 	 * followed by an array of ZAP_LEAF_NUMCHUNKS(zap)
1691 	 * zap_leaf_chunk structures.  These structures are accessed
1692 	 * with the ZAP_LEAF_CHUNK() macro.
1693 	 */
1694 
1695 	uint16_t l_hash[1];
1696 } zap_leaf_phys_t;
1697 
1698 typedef union zap_leaf_chunk {
1699 	struct zap_leaf_entry {
1700 		uint8_t le_type; 		/* always ZAP_CHUNK_ENTRY */
1701 		uint8_t le_value_intlen;	/* size of ints */
1702 		uint16_t le_next;		/* next entry in hash chain */
1703 		uint16_t le_name_chunk;		/* first chunk of the name */
1704 		uint16_t le_name_numints;	/* bytes in name, incl null */
1705 		uint16_t le_value_chunk;	/* first chunk of the value */
1706 		uint16_t le_value_numints;	/* value length in ints */
1707 		uint32_t le_cd;			/* collision differentiator */
1708 		uint64_t le_hash;		/* hash value of the name */
1709 	} l_entry;
1710 	struct zap_leaf_array {
1711 		uint8_t la_type;		/* always ZAP_CHUNK_ARRAY */
1712 		uint8_t la_array[ZAP_LEAF_ARRAY_BYTES];
1713 		uint16_t la_next;		/* next blk or CHAIN_END */
1714 	} l_array;
1715 	struct zap_leaf_free {
1716 		uint8_t lf_type;		/* always ZAP_CHUNK_FREE */
1717 		uint8_t lf_pad[ZAP_LEAF_ARRAY_BYTES];
1718 		uint16_t lf_next;	/* next in free list, or CHAIN_END */
1719 	} l_free;
1720 } zap_leaf_chunk_t;
1721 
1722 typedef struct zap_leaf {
1723 	int l_bs;			/* block size shift */
1724 	zap_leaf_phys_t *l_phys;
1725 } zap_leaf_t;
1726 
1727 #define	ZAP_MAXNAMELEN 256
1728 #define	ZAP_MAXVALUELEN (1024 * 8)
1729 
1730 #define	ACE_READ_DATA		0x00000001	/* file: read data */
1731 #define	ACE_LIST_DIRECTORY	0x00000001	/* dir: list files */
1732 #define	ACE_WRITE_DATA		0x00000002	/* file: write data */
1733 #define	ACE_ADD_FILE		0x00000002	/* dir: create file */
1734 #define	ACE_APPEND_DATA		0x00000004	/* file: append data */
1735 #define	ACE_ADD_SUBDIRECTORY	0x00000004	/* dir: create subdir */
1736 #define	ACE_READ_NAMED_ATTRS	0x00000008	/* FILE_READ_EA */
1737 #define	ACE_WRITE_NAMED_ATTRS	0x00000010	/* FILE_WRITE_EA */
1738 #define	ACE_EXECUTE		0x00000020	/* file: execute */
1739 #define	ACE_TRAVERSE		0x00000020	/* dir: lookup name */
1740 #define	ACE_DELETE_CHILD	0x00000040	/* dir: unlink child */
1741 #define	ACE_READ_ATTRIBUTES	0x00000080	/* (all) stat, etc. */
1742 #define	ACE_WRITE_ATTRIBUTES	0x00000100	/* (all) utimes, etc. */
1743 #define	ACE_DELETE		0x00010000	/* (all) unlink self */
1744 #define	ACE_READ_ACL		0x00020000	/* (all) getsecattr */
1745 #define	ACE_WRITE_ACL		0x00040000	/* (all) setsecattr */
1746 #define	ACE_WRITE_OWNER		0x00080000	/* (all) chown */
1747 #define	ACE_SYNCHRONIZE		0x00100000	/* (all) */
1748 
1749 #define	ACE_FILE_INHERIT_ACE		0x0001
1750 #define	ACE_DIRECTORY_INHERIT_ACE	0x0002
1751 #define	ACE_NO_PROPAGATE_INHERIT_ACE	0x0004
1752 #define	ACE_INHERIT_ONLY_ACE		0x0008
1753 #define	ACE_SUCCESSFUL_ACCESS_ACE_FLAG	0x0010
1754 #define	ACE_FAILED_ACCESS_ACE_FLAG	0x0020
1755 #define	ACE_IDENTIFIER_GROUP		0x0040
1756 #define	ACE_INHERITED_ACE		0x0080
1757 #define	ACE_OWNER			0x1000
1758 #define	ACE_GROUP			0x2000
1759 #define	ACE_EVERYONE			0x4000
1760 
1761 #define	ACE_ACCESS_ALLOWED_ACE_TYPE	0x0000
1762 #define	ACE_ACCESS_DENIED_ACE_TYPE	0x0001
1763 #define	ACE_SYSTEM_AUDIT_ACE_TYPE	0x0002
1764 #define	ACE_SYSTEM_ALARM_ACE_TYPE	0x0003
1765 
1766 typedef struct zfs_ace_hdr {
1767 	uint16_t z_type;
1768 	uint16_t z_flags;
1769 	uint32_t z_access_mask;
1770 } zfs_ace_hdr_t;
1771 
1772 /*
1773  * Define special zfs pflags
1774  */
1775 #define	ZFS_XATTR		0x1		/* is an extended attribute */
1776 #define	ZFS_INHERIT_ACE		0x2		/* ace has inheritable ACEs */
1777 #define	ZFS_ACL_TRIVIAL		0x4		/* files ACL is trivial */
1778 #define	ZFS_ACL_OBJ_ACE		0x8		/* ACL has CMPLX Object ACE */
1779 #define	ZFS_ACL_PROTECTED	0x10		/* ACL protected */
1780 #define	ZFS_ACL_DEFAULTED	0x20		/* ACL should be defaulted */
1781 #define	ZFS_ACL_AUTO_INHERIT	0x40		/* ACL should be inherited */
1782 #define	ZFS_BONUS_SCANSTAMP	0x80		/* Scanstamp in bonus area */
1783 #define	ZFS_NO_EXECS_DENIED	0x100		/* exec was given to everyone */
1784 
1785 #define	ZFS_READONLY		0x0000000100000000ull
1786 #define	ZFS_HIDDEN		0x0000000200000000ull
1787 #define	ZFS_SYSTEM		0x0000000400000000ull
1788 #define	ZFS_ARCHIVE		0x0000000800000000ull
1789 #define	ZFS_IMMUTABLE		0x0000001000000000ull
1790 #define	ZFS_NOUNLINK		0x0000002000000000ull
1791 #define	ZFS_APPENDONLY		0x0000004000000000ull
1792 #define	ZFS_NODUMP		0x0000008000000000ull
1793 #define	ZFS_OPAQUE		0x0000010000000000ull
1794 #define	ZFS_AV_QUARANTINED	0x0000020000000000ull
1795 #define	ZFS_AV_MODIFIED		0x0000040000000000ull
1796 #define	ZFS_REPARSE		0x0000080000000000ull
1797 #define	ZFS_OFFLINE		0x0000100000000000ull
1798 #define	ZFS_SPARSE		0x0000200000000000ull
1799 
1800 #define	MASTER_NODE_OBJ	1
1801 
1802 /*
1803  * special attributes for master node.
1804  */
1805 
1806 #define	ZFS_FSID		"FSID"
1807 #define	ZFS_UNLINKED_SET	"DELETE_QUEUE"
1808 #define	ZFS_ROOT_OBJ		"ROOT"
1809 #define	ZPL_VERSION_OBJ		"VERSION"
1810 #define	ZFS_PROP_BLOCKPERPAGE	"BLOCKPERPAGE"
1811 #define	ZFS_PROP_NOGROWBLOCKS	"NOGROWBLOCKS"
1812 #define	ZFS_SA_ATTRS		"SA_ATTRS"
1813 
1814 #define	ZFS_FLAG_BLOCKPERPAGE	0x1
1815 #define	ZFS_FLAG_NOGROWBLOCKS	0x2
1816 
1817 /*
1818  * ZPL version - rev'd whenever an incompatible on-disk format change
1819  * occurs.  Independent of SPA/DMU/ZAP versioning.
1820  */
1821 
1822 #define	ZPL_VERSION		1ULL
1823 
1824 /*
1825  * The directory entry has the type (currently unused on Solaris) in the
1826  * top 4 bits, and the object number in the low 48 bits.  The "middle"
1827  * 12 bits are unused.
1828  */
1829 #define	ZFS_DIRENT_TYPE(de) BF64_GET(de, 60, 4)
1830 #define	ZFS_DIRENT_OBJ(de) BF64_GET(de, 0, 48)
1831 #define	ZFS_DIRENT_MAKE(type, obj) (((uint64_t)type << 60) | obj)
1832 
1833 typedef struct ace {
1834 	uid_t		a_who;		/* uid or gid */
1835 	uint32_t	a_access_mask;	/* read,write,... */
1836 	uint16_t	a_flags;	/* see below */
1837 	uint16_t	a_type;		/* allow or deny */
1838 } ace_t;
1839 
1840 #define ACE_SLOT_CNT	6
1841 
1842 typedef struct zfs_znode_acl {
1843 	uint64_t	z_acl_extern_obj;	  /* ext acl pieces */
1844 	uint32_t	z_acl_count;		  /* Number of ACEs */
1845 	uint16_t	z_acl_version;		  /* acl version */
1846 	uint16_t	z_acl_pad;		  /* pad */
1847 	ace_t		z_ace_data[ACE_SLOT_CNT]; /* 6 standard ACEs */
1848 } zfs_znode_acl_t;
1849 
1850 /*
1851  * This is the persistent portion of the znode.  It is stored
1852  * in the "bonus buffer" of the file.  Short symbolic links
1853  * are also stored in the bonus buffer.
1854  */
1855 typedef struct znode_phys {
1856 	uint64_t zp_atime[2];		/*  0 - last file access time */
1857 	uint64_t zp_mtime[2];		/* 16 - last file modification time */
1858 	uint64_t zp_ctime[2];		/* 32 - last file change time */
1859 	uint64_t zp_crtime[2];		/* 48 - creation time */
1860 	uint64_t zp_gen;		/* 64 - generation (txg of creation) */
1861 	uint64_t zp_mode;		/* 72 - file mode bits */
1862 	uint64_t zp_size;		/* 80 - size of file */
1863 	uint64_t zp_parent;		/* 88 - directory parent (`..') */
1864 	uint64_t zp_links;		/* 96 - number of links to file */
1865 	uint64_t zp_xattr;		/* 104 - DMU object for xattrs */
1866 	uint64_t zp_rdev;		/* 112 - dev_t for VBLK & VCHR files */
1867 	uint64_t zp_flags;		/* 120 - persistent flags */
1868 	uint64_t zp_uid;		/* 128 - file owner */
1869 	uint64_t zp_gid;		/* 136 - owning group */
1870 	uint64_t zp_pad[4];		/* 144 - future */
1871 	zfs_znode_acl_t zp_acl;		/* 176 - 263 ACL */
1872 	/*
1873 	 * Data may pad out any remaining bytes in the znode buffer, eg:
1874 	 *
1875 	 * |<---------------------- dnode_phys (512) ------------------------>|
1876 	 * |<-- dnode (192) --->|<----------- "bonus" buffer (320) ---------->|
1877 	 *			|<---- znode (264) ---->|<---- data (56) ---->|
1878 	 *
1879 	 * At present, we only use this space to store symbolic links.
1880 	 */
1881 } znode_phys_t;
1882 
1883 /*
1884  * In-core vdev representation.
1885  */
1886 struct vdev;
1887 struct spa;
1888 typedef int vdev_phys_read_t(struct vdev *, void *, off_t, void *, size_t);
1889 typedef int vdev_phys_write_t(struct vdev *, off_t, void *, size_t);
1890 typedef int vdev_read_t(struct vdev *, const blkptr_t *, void *, off_t, size_t);
1891 
1892 typedef STAILQ_HEAD(vdev_list, vdev) vdev_list_t;
1893 
1894 typedef struct vdev_indirect_mapping_entry_phys {
1895 	/*
1896 	 * Decode with DVA_MAPPING_* macros.
1897 	 * Contains:
1898 	 *   the source offset (low 63 bits)
1899 	 *   the one-bit "mark", used for garbage collection (by zdb)
1900 	 */
1901 	uint64_t vimep_src;
1902 
1903 	/*
1904 	 * Note: the DVA's asize is 24 bits, and can thus store ranges
1905 	 * up to 8GB.
1906 	 */
1907 	dva_t	vimep_dst;
1908 } vdev_indirect_mapping_entry_phys_t;
1909 
1910 #define	DVA_MAPPING_GET_SRC_OFFSET(vimep)	\
1911 	BF64_GET_SB((vimep)->vimep_src, 0, 63, SPA_MINBLOCKSHIFT, 0)
1912 #define	DVA_MAPPING_SET_SRC_OFFSET(vimep, x)	\
1913 	BF64_SET_SB((vimep)->vimep_src, 0, 63, SPA_MINBLOCKSHIFT, 0, x)
1914 
1915 /*
1916  * This is stored in the bonus buffer of the mapping object, see comment of
1917  * vdev_indirect_config for more details.
1918  */
1919 typedef struct vdev_indirect_mapping_phys {
1920 	uint64_t	vimp_max_offset;
1921 	uint64_t	vimp_bytes_mapped;
1922 	uint64_t	vimp_num_entries; /* number of v_i_m_entry_phys_t's */
1923 
1924 	/*
1925 	 * For each entry in the mapping object, this object contains an
1926 	 * entry representing the number of bytes of that mapping entry
1927 	 * that were no longer in use by the pool at the time this indirect
1928 	 * vdev was last condensed.
1929 	 */
1930 	uint64_t	vimp_counts_object;
1931 } vdev_indirect_mapping_phys_t;
1932 
1933 #define	VDEV_INDIRECT_MAPPING_SIZE_V0	(3 * sizeof (uint64_t))
1934 
1935 typedef struct vdev_indirect_mapping {
1936 	uint64_t	vim_object;
1937 	boolean_t	vim_havecounts;
1938 
1939 	/* vim_entries segment offset currently in memory. */
1940 	uint64_t	vim_entry_offset;
1941 	/* vim_entries segment size. */
1942 	size_t		vim_num_entries;
1943 
1944 	/* Needed by dnode_read() */
1945 	const void	*vim_spa;
1946 	dnode_phys_t	*vim_dn;
1947 
1948 	/*
1949 	 * An ordered array of mapping entries, sorted by source offset.
1950 	 * Note that vim_entries is needed during a removal (and contains
1951 	 * mappings that have been synced to disk so far) to handle frees
1952 	 * from the removing device.
1953 	 */
1954 	vdev_indirect_mapping_entry_phys_t *vim_entries;
1955 	objset_phys_t	*vim_objset;
1956 	vdev_indirect_mapping_phys_t	*vim_phys;
1957 } vdev_indirect_mapping_t;
1958 
1959 /*
1960  * On-disk indirect vdev state.
1961  *
1962  * An indirect vdev is described exclusively in the MOS config of a pool.
1963  * The config for an indirect vdev includes several fields, which are
1964  * accessed in memory by a vdev_indirect_config_t.
1965  */
1966 typedef struct vdev_indirect_config {
1967 	/*
1968 	 * Object (in MOS) which contains the indirect mapping. This object
1969 	 * contains an array of vdev_indirect_mapping_entry_phys_t ordered by
1970 	 * vimep_src. The bonus buffer for this object is a
1971 	 * vdev_indirect_mapping_phys_t. This object is allocated when a vdev
1972 	 * removal is initiated.
1973 	 *
1974 	 * Note that this object can be empty if none of the data on the vdev
1975 	 * has been copied yet.
1976 	 */
1977 	uint64_t	vic_mapping_object;
1978 
1979 	/*
1980 	 * Object (in MOS) which contains the birth times for the mapping
1981 	 * entries. This object contains an array of
1982 	 * vdev_indirect_birth_entry_phys_t sorted by vibe_offset. The bonus
1983 	 * buffer for this object is a vdev_indirect_birth_phys_t. This object
1984 	 * is allocated when a vdev removal is initiated.
1985 	 *
1986 	 * Note that this object can be empty if none of the vdev has yet been
1987 	 * copied.
1988 	 */
1989 	uint64_t	vic_births_object;
1990 
1991 /*
1992  * This is the vdev ID which was removed previous to this vdev, or
1993  * UINT64_MAX if there are no previously removed vdevs.
1994  */
1995 	uint64_t	vic_prev_indirect_vdev;
1996 } vdev_indirect_config_t;
1997 
1998 typedef struct vdev {
1999 	STAILQ_ENTRY(vdev) v_childlink;	/* link in parent's child list */
2000 	STAILQ_ENTRY(vdev) v_alllink;	/* link in global vdev list */
2001 	vdev_list_t	v_children;	/* children of this vdev */
2002 	const char	*v_name;	/* vdev name */
2003 	uint64_t	v_guid;		/* vdev guid */
2004 	uint64_t	v_id;		/* index in parent */
2005 	uint64_t	v_psize;	/* physical device capacity */
2006 	int		v_ashift;	/* offset to block shift */
2007 	int		v_nparity;	/* # parity for raidz */
2008 	struct vdev	*v_top;		/* parent vdev */
2009 	size_t		v_nchildren;	/* # children */
2010 	vdev_state_t	v_state;	/* current state */
2011 	vdev_phys_read_t *v_phys_read;	/* read from raw leaf vdev */
2012 	vdev_phys_write_t *v_phys_write; /* write to raw leaf vdev */
2013 	vdev_read_t	*v_read;	/* read from vdev */
2014 	void		*v_priv;	/* data for read/write function */
2015 	boolean_t	v_islog;
2016 	struct spa	*v_spa;		/* link to spa */
2017 	/*
2018 	 * Values stored in the config for an indirect or removing vdev.
2019 	 */
2020 	vdev_indirect_config_t vdev_indirect_config;
2021 	vdev_indirect_mapping_t *v_mapping;
2022 } vdev_t;
2023 
2024 /*
2025  * In-core pool representation.
2026  */
2027 typedef STAILQ_HEAD(spa_list, spa) spa_list_t;
2028 
2029 typedef struct spa {
2030 	STAILQ_ENTRY(spa) spa_link;	/* link in global pool list */
2031 	char		*spa_name;	/* pool name */
2032 	uint64_t	spa_guid;	/* pool guid */
2033 	uint64_t	spa_txg;	/* most recent transaction */
2034 	struct uberblock *spa_uberblock;	/* best uberblock so far */
2035 	vdev_t		*spa_root_vdev;	/* toplevel vdev container */
2036 	objset_phys_t	*spa_mos;	/* MOS for this pool */
2037 	zio_cksum_salt_t spa_cksum_salt;	/* secret salt for cksum */
2038 	void		*spa_cksum_tmpls[ZIO_CHECKSUM_FUNCTIONS];
2039 	boolean_t	spa_with_log;	/* this pool has log */
2040 
2041 	struct uberblock spa_uberblock_master;	/* best uberblock so far */
2042 	objset_phys_t	spa_mos_master;		/* MOS for this pool */
2043 	struct uberblock spa_uberblock_checkpoint; /* checkpoint uberblock */
2044 	objset_phys_t	spa_mos_checkpoint;	/* Checkpoint MOS */
2045 	void		*spa_bootenv;		/* bootenv from pool label */
2046 } spa_t;
2047 
2048 /* IO related arguments. */
2049 typedef struct zio {
2050 	spa_t		*io_spa;
2051 	blkptr_t	*io_bp;
2052 	void		*io_data;
2053 	uint64_t	io_size;
2054 	uint64_t	io_offset;
2055 
2056 	/* Stuff for the vdev stack */
2057 	vdev_t		*io_vd;
2058 	void		*io_vsd;
2059 
2060 	int		io_error;
2061 } zio_t;
2062 
2063 extern void decode_embedded_bp_compressed(const blkptr_t *, void *);
2064 
2065 #endif /* _ZFSIMPL_H_ */
2066