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