Deleted Added
sdiff udiff text old ( 254591 ) new ( 260150 )
full compact
spa.h (254591) spa.h (260150)
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

--- 6 unchanged lines hidden (view full) ---

15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21/*
22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

--- 6 unchanged lines hidden (view full) ---

15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21/*
22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright (c) 2012 by Delphix. All rights reserved.
23 * Copyright (c) 2013 by Delphix. All rights reserved.
24 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
25 */
26
27#ifndef _SYS_SPA_H
28#define _SYS_SPA_H
29
30#include <sys/avl.h>
31#include <sys/zfs_context.h>

--- 28 unchanged lines hidden (view full) ---

60#define BF32_DECODE(x, low, len) P2PHASE((x) >> (low), 1U << (len))
61#define BF64_DECODE(x, low, len) P2PHASE((x) >> (low), 1ULL << (len))
62#define BF32_ENCODE(x, low, len) (P2PHASE((x), 1U << (len)) << (low))
63#define BF64_ENCODE(x, low, len) (P2PHASE((x), 1ULL << (len)) << (low))
64
65#define BF32_GET(x, low, len) BF32_DECODE(x, low, len)
66#define BF64_GET(x, low, len) BF64_DECODE(x, low, len)
67
24 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
25 */
26
27#ifndef _SYS_SPA_H
28#define _SYS_SPA_H
29
30#include <sys/avl.h>
31#include <sys/zfs_context.h>

--- 28 unchanged lines hidden (view full) ---

60#define BF32_DECODE(x, low, len) P2PHASE((x) >> (low), 1U << (len))
61#define BF64_DECODE(x, low, len) P2PHASE((x) >> (low), 1ULL << (len))
62#define BF32_ENCODE(x, low, len) (P2PHASE((x), 1U << (len)) << (low))
63#define BF64_ENCODE(x, low, len) (P2PHASE((x), 1ULL << (len)) << (low))
64
65#define BF32_GET(x, low, len) BF32_DECODE(x, low, len)
66#define BF64_GET(x, low, len) BF64_DECODE(x, low, len)
67
68#define BF32_SET(x, low, len, val) \
69 ((x) ^= BF32_ENCODE((x >> low) ^ (val), low, len))
70#define BF64_SET(x, low, len, val) \
71 ((x) ^= BF64_ENCODE((x >> low) ^ (val), low, len))
68#define BF32_SET(x, low, len, val) do { \
69 ASSERT3U(val, <, 1U << (len)); \
70 ASSERT3U(low + len, <=, 32); \
71 (x) ^= BF32_ENCODE((x >> low) ^ (val), low, len); \
72_NOTE(CONSTCOND) } while (0)
72
73
74#define BF64_SET(x, low, len, val) do { \
75 ASSERT3U(val, <, 1ULL << (len)); \
76 ASSERT3U(low + len, <=, 64); \
77 ((x) ^= BF64_ENCODE((x >> low) ^ (val), low, len)); \
78_NOTE(CONSTCOND) } while (0)
79
73#define BF32_GET_SB(x, low, len, shift, bias) \
74 ((BF32_GET(x, low, len) + (bias)) << (shift))
75#define BF64_GET_SB(x, low, len, shift, bias) \
76 ((BF64_GET(x, low, len) + (bias)) << (shift))
77
80#define BF32_GET_SB(x, low, len, shift, bias) \
81 ((BF32_GET(x, low, len) + (bias)) << (shift))
82#define BF64_GET_SB(x, low, len, shift, bias) \
83 ((BF64_GET(x, low, len) + (bias)) << (shift))
84
78#define BF32_SET_SB(x, low, len, shift, bias, val) \
79 BF32_SET(x, low, len, ((val) >> (shift)) - (bias))
80#define BF64_SET_SB(x, low, len, shift, bias, val) \
81 BF64_SET(x, low, len, ((val) >> (shift)) - (bias))
85#define BF32_SET_SB(x, low, len, shift, bias, val) do { \
86 ASSERT(IS_P2ALIGNED(val, 1U << shift)); \
87 ASSERT3S((val) >> (shift), >=, bias); \
88 BF32_SET(x, low, len, ((val) >> (shift)) - (bias)); \
89_NOTE(CONSTCOND) } while (0)
90#define BF64_SET_SB(x, low, len, shift, bias, val) do { \
91 ASSERT(IS_P2ALIGNED(val, 1ULL << shift)); \
92 ASSERT3S((val) >> (shift), >=, bias); \
93 BF64_SET(x, low, len, ((val) >> (shift)) - (bias)); \
94_NOTE(CONSTCOND) } while (0)
82
83/*
84 * We currently support nine block sizes, from 512 bytes to 128K.
85 * We could go higher, but the benefits are near-zero and the cost
86 * of COWing a giant block to modify one byte would become excessive.
87 */
88#define SPA_MINBLOCKSHIFT 9
89#define SPA_MAXBLOCKSHIFT 17

--- 102 unchanged lines hidden (view full) ---

192 * phys birth txg of block allocation; zero if same as logical birth txg
193 * log. birth transaction group in which the block was logically born
194 * fill count number of non-zero blocks under this bp
195 * checksum[4] 256-bit checksum of the data this bp describes
196 */
197#define SPA_BLKPTRSHIFT 7 /* blkptr_t is 128 bytes */
198#define SPA_DVAS_PER_BP 3 /* Number of DVAs in a bp */
199
95
96/*
97 * We currently support nine block sizes, from 512 bytes to 128K.
98 * We could go higher, but the benefits are near-zero and the cost
99 * of COWing a giant block to modify one byte would become excessive.
100 */
101#define SPA_MINBLOCKSHIFT 9
102#define SPA_MAXBLOCKSHIFT 17

--- 102 unchanged lines hidden (view full) ---

205 * phys birth txg of block allocation; zero if same as logical birth txg
206 * log. birth transaction group in which the block was logically born
207 * fill count number of non-zero blocks under this bp
208 * checksum[4] 256-bit checksum of the data this bp describes
209 */
210#define SPA_BLKPTRSHIFT 7 /* blkptr_t is 128 bytes */
211#define SPA_DVAS_PER_BP 3 /* Number of DVAs in a bp */
212
213/*
214 * A block is a hole when it has either 1) never been written to, or
215 * 2) is zero-filled. In both cases, ZFS can return all zeroes for all reads
216 * without physically allocating disk space. Holes are represented in the
217 * blkptr_t structure by zeroed blk_dva. Correct checking for holes is
218 * done through the BP_IS_HOLE macro. For holes, the logical size, level,
219 * DMU object type, and birth times are all also stored for holes that
220 * were written to at some point (i.e. were punched after having been filled).
221 */
200typedef struct blkptr {
201 dva_t blk_dva[SPA_DVAS_PER_BP]; /* Data Virtual Addresses */
202 uint64_t blk_prop; /* size, compression, type, etc */
203 uint64_t blk_pad[2]; /* Extra space for the future */
204 uint64_t blk_phys_birth; /* txg when block was allocated */
205 uint64_t blk_birth; /* transaction group at birth */
206 uint64_t blk_fill; /* fill count */
207 zio_cksum_t blk_cksum; /* 256-bit checksum */
208} blkptr_t;
209
210/*
211 * Macros to get and set fields in a bp or DVA.
212 */
213#define DVA_GET_ASIZE(dva) \
222typedef struct blkptr {
223 dva_t blk_dva[SPA_DVAS_PER_BP]; /* Data Virtual Addresses */
224 uint64_t blk_prop; /* size, compression, type, etc */
225 uint64_t blk_pad[2]; /* Extra space for the future */
226 uint64_t blk_phys_birth; /* txg when block was allocated */
227 uint64_t blk_birth; /* transaction group at birth */
228 uint64_t blk_fill; /* fill count */
229 zio_cksum_t blk_cksum; /* 256-bit checksum */
230} blkptr_t;
231
232/*
233 * Macros to get and set fields in a bp or DVA.
234 */
235#define DVA_GET_ASIZE(dva) \
214 BF64_GET_SB((dva)->dva_word[0], 0, 24, SPA_MINBLOCKSHIFT, 0)
236 BF64_GET_SB((dva)->dva_word[0], 0, SPA_ASIZEBITS, SPA_MINBLOCKSHIFT, 0)
215#define DVA_SET_ASIZE(dva, x) \
237#define DVA_SET_ASIZE(dva, x) \
216 BF64_SET_SB((dva)->dva_word[0], 0, 24, SPA_MINBLOCKSHIFT, 0, x)
238 BF64_SET_SB((dva)->dva_word[0], 0, SPA_ASIZEBITS, \
239 SPA_MINBLOCKSHIFT, 0, x)
217
218#define DVA_GET_GRID(dva) BF64_GET((dva)->dva_word[0], 24, 8)
219#define DVA_SET_GRID(dva, x) BF64_SET((dva)->dva_word[0], 24, 8, x)
220
221#define DVA_GET_VDEV(dva) BF64_GET((dva)->dva_word[0], 32, 32)
222#define DVA_SET_VDEV(dva, x) BF64_SET((dva)->dva_word[0], 32, 32, x)
223
224#define DVA_GET_OFFSET(dva) \
225 BF64_GET_SB((dva)->dva_word[1], 0, 63, SPA_MINBLOCKSHIFT, 0)
226#define DVA_SET_OFFSET(dva, x) \
227 BF64_SET_SB((dva)->dva_word[1], 0, 63, SPA_MINBLOCKSHIFT, 0, x)
228
229#define DVA_GET_GANG(dva) BF64_GET((dva)->dva_word[1], 63, 1)
230#define DVA_SET_GANG(dva, x) BF64_SET((dva)->dva_word[1], 63, 1, x)
231
232#define BP_GET_LSIZE(bp) \
240
241#define DVA_GET_GRID(dva) BF64_GET((dva)->dva_word[0], 24, 8)
242#define DVA_SET_GRID(dva, x) BF64_SET((dva)->dva_word[0], 24, 8, x)
243
244#define DVA_GET_VDEV(dva) BF64_GET((dva)->dva_word[0], 32, 32)
245#define DVA_SET_VDEV(dva, x) BF64_SET((dva)->dva_word[0], 32, 32, x)
246
247#define DVA_GET_OFFSET(dva) \
248 BF64_GET_SB((dva)->dva_word[1], 0, 63, SPA_MINBLOCKSHIFT, 0)
249#define DVA_SET_OFFSET(dva, x) \
250 BF64_SET_SB((dva)->dva_word[1], 0, 63, SPA_MINBLOCKSHIFT, 0, x)
251
252#define DVA_GET_GANG(dva) BF64_GET((dva)->dva_word[1], 63, 1)
253#define DVA_SET_GANG(dva, x) BF64_SET((dva)->dva_word[1], 63, 1, x)
254
255#define BP_GET_LSIZE(bp) \
233 BF64_GET_SB((bp)->blk_prop, 0, 16, SPA_MINBLOCKSHIFT, 1)
256 BF64_GET_SB((bp)->blk_prop, 0, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1)
234#define BP_SET_LSIZE(bp, x) \
257#define BP_SET_LSIZE(bp, x) \
235 BF64_SET_SB((bp)->blk_prop, 0, 16, SPA_MINBLOCKSHIFT, 1, x)
258 BF64_SET_SB((bp)->blk_prop, 0, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1, x)
236
237#define BP_GET_PSIZE(bp) \
259
260#define BP_GET_PSIZE(bp) \
238 BF64_GET_SB((bp)->blk_prop, 16, 16, SPA_MINBLOCKSHIFT, 1)
261 BF64_GET_SB((bp)->blk_prop, 16, SPA_PSIZEBITS, SPA_MINBLOCKSHIFT, 1)
239#define BP_SET_PSIZE(bp, x) \
262#define BP_SET_PSIZE(bp, x) \
240 BF64_SET_SB((bp)->blk_prop, 16, 16, SPA_MINBLOCKSHIFT, 1, x)
263 BF64_SET_SB((bp)->blk_prop, 16, SPA_PSIZEBITS, SPA_MINBLOCKSHIFT, 1, x)
241
242#define BP_GET_COMPRESS(bp) BF64_GET((bp)->blk_prop, 32, 8)
243#define BP_SET_COMPRESS(bp, x) BF64_SET((bp)->blk_prop, 32, 8, x)
244
245#define BP_GET_CHECKSUM(bp) BF64_GET((bp)->blk_prop, 40, 8)
246#define BP_SET_CHECKSUM(bp, x) BF64_SET((bp)->blk_prop, 40, 8, x)
247
248#define BP_GET_TYPE(bp) BF64_GET((bp)->blk_prop, 48, 8)
249#define BP_SET_TYPE(bp, x) BF64_SET((bp)->blk_prop, 48, 8, x)
250
251#define BP_GET_LEVEL(bp) BF64_GET((bp)->blk_prop, 56, 5)
252#define BP_SET_LEVEL(bp, x) BF64_SET((bp)->blk_prop, 56, 5, x)
253
254#define BP_GET_PROP_BIT_61(bp) BF64_GET((bp)->blk_prop, 61, 1)
255#define BP_SET_PROP_BIT_61(bp, x) BF64_SET((bp)->blk_prop, 61, 1, x)
256
257#define BP_GET_DEDUP(bp) BF64_GET((bp)->blk_prop, 62, 1)
258#define BP_SET_DEDUP(bp, x) BF64_SET((bp)->blk_prop, 62, 1, x)
259
264
265#define BP_GET_COMPRESS(bp) BF64_GET((bp)->blk_prop, 32, 8)
266#define BP_SET_COMPRESS(bp, x) BF64_SET((bp)->blk_prop, 32, 8, x)
267
268#define BP_GET_CHECKSUM(bp) BF64_GET((bp)->blk_prop, 40, 8)
269#define BP_SET_CHECKSUM(bp, x) BF64_SET((bp)->blk_prop, 40, 8, x)
270
271#define BP_GET_TYPE(bp) BF64_GET((bp)->blk_prop, 48, 8)
272#define BP_SET_TYPE(bp, x) BF64_SET((bp)->blk_prop, 48, 8, x)
273
274#define BP_GET_LEVEL(bp) BF64_GET((bp)->blk_prop, 56, 5)
275#define BP_SET_LEVEL(bp, x) BF64_SET((bp)->blk_prop, 56, 5, x)
276
277#define BP_GET_PROP_BIT_61(bp) BF64_GET((bp)->blk_prop, 61, 1)
278#define BP_SET_PROP_BIT_61(bp, x) BF64_SET((bp)->blk_prop, 61, 1, x)
279
280#define BP_GET_DEDUP(bp) BF64_GET((bp)->blk_prop, 62, 1)
281#define BP_SET_DEDUP(bp, x) BF64_SET((bp)->blk_prop, 62, 1, x)
282
260#define BP_GET_BYTEORDER(bp) (0 - BF64_GET((bp)->blk_prop, 63, 1))
283#define BP_GET_BYTEORDER(bp) BF64_GET((bp)->blk_prop, 63, 1)
261#define BP_SET_BYTEORDER(bp, x) BF64_SET((bp)->blk_prop, 63, 1, x)
262
263#define BP_PHYSICAL_BIRTH(bp) \
264 ((bp)->blk_phys_birth ? (bp)->blk_phys_birth : (bp)->blk_birth)
265
266#define BP_SET_BIRTH(bp, logical, physical) \
267{ \
268 (bp)->blk_birth = (logical); \

--- 41 unchanged lines hidden (view full) ---

310 (zcp)->zc_word[0] = w0; \
311 (zcp)->zc_word[1] = w1; \
312 (zcp)->zc_word[2] = w2; \
313 (zcp)->zc_word[3] = w3; \
314}
315
316#define BP_IDENTITY(bp) (&(bp)->blk_dva[0])
317#define BP_IS_GANG(bp) DVA_GET_GANG(BP_IDENTITY(bp))
284#define BP_SET_BYTEORDER(bp, x) BF64_SET((bp)->blk_prop, 63, 1, x)
285
286#define BP_PHYSICAL_BIRTH(bp) \
287 ((bp)->blk_phys_birth ? (bp)->blk_phys_birth : (bp)->blk_birth)
288
289#define BP_SET_BIRTH(bp, logical, physical) \
290{ \
291 (bp)->blk_birth = (logical); \

--- 41 unchanged lines hidden (view full) ---

333 (zcp)->zc_word[0] = w0; \
334 (zcp)->zc_word[1] = w1; \
335 (zcp)->zc_word[2] = w2; \
336 (zcp)->zc_word[3] = w3; \
337}
338
339#define BP_IDENTITY(bp) (&(bp)->blk_dva[0])
340#define BP_IS_GANG(bp) DVA_GET_GANG(BP_IDENTITY(bp))
318#define BP_IS_HOLE(bp) ((bp)->blk_birth == 0)
341#define DVA_IS_EMPTY(dva) ((dva)->dva_word[0] == 0ULL && \
342 (dva)->dva_word[1] == 0ULL)
343#define BP_IS_HOLE(bp) DVA_IS_EMPTY(BP_IDENTITY(bp))
319
320/* BP_IS_RAIDZ(bp) assumes no block compression */
321#define BP_IS_RAIDZ(bp) (DVA_GET_ASIZE(&(bp)->blk_dva[0]) > \
322 BP_GET_PSIZE(bp))
323
324#define BP_ZERO(bp) \
325{ \
326 (bp)->blk_dva[0].dva_word[0] = 0; \

--- 6 unchanged lines hidden (view full) ---

333 (bp)->blk_pad[0] = 0; \
334 (bp)->blk_pad[1] = 0; \
335 (bp)->blk_phys_birth = 0; \
336 (bp)->blk_birth = 0; \
337 (bp)->blk_fill = 0; \
338 ZIO_SET_CHECKSUM(&(bp)->blk_cksum, 0, 0, 0, 0); \
339}
340
344
345/* BP_IS_RAIDZ(bp) assumes no block compression */
346#define BP_IS_RAIDZ(bp) (DVA_GET_ASIZE(&(bp)->blk_dva[0]) > \
347 BP_GET_PSIZE(bp))
348
349#define BP_ZERO(bp) \
350{ \
351 (bp)->blk_dva[0].dva_word[0] = 0; \

--- 6 unchanged lines hidden (view full) ---

358 (bp)->blk_pad[0] = 0; \
359 (bp)->blk_pad[1] = 0; \
360 (bp)->blk_phys_birth = 0; \
361 (bp)->blk_birth = 0; \
362 (bp)->blk_fill = 0; \
363 ZIO_SET_CHECKSUM(&(bp)->blk_cksum, 0, 0, 0, 0); \
364}
365
341/*
342 * Note: the byteorder is either 0 or -1, both of which are palindromes.
343 * This simplifies the endianness handling a bit.
344 */
345#if BYTE_ORDER == _BIG_ENDIAN
346#define ZFS_HOST_BYTEORDER (0ULL)
347#else
366#if BYTE_ORDER == _BIG_ENDIAN
367#define ZFS_HOST_BYTEORDER (0ULL)
368#else
348#define ZFS_HOST_BYTEORDER (-1ULL)
369#define ZFS_HOST_BYTEORDER (1ULL)
349#endif
350
351#define BP_SHOULD_BYTESWAP(bp) (BP_GET_BYTEORDER(bp) != ZFS_HOST_BYTEORDER)
352
353#define BP_SPRINTF_LEN 320
354
355/*
356 * This macro allows code sharing between zfs, libzpool, and mdb.
357 * 'func' is either snprintf() or mdb_snprintf().
358 * 'ws' (whitespace) can be ' ' for single-line format, '\n' for multi-line.
359 */
370#endif
371
372#define BP_SHOULD_BYTESWAP(bp) (BP_GET_BYTEORDER(bp) != ZFS_HOST_BYTEORDER)
373
374#define BP_SPRINTF_LEN 320
375
376/*
377 * This macro allows code sharing between zfs, libzpool, and mdb.
378 * 'func' is either snprintf() or mdb_snprintf().
379 * 'ws' (whitespace) can be ' ' for single-line format, '\n' for multi-line.
380 */
360#define SPRINTF_BLKPTR(func, ws, buf, bp, type, checksum, compress) \
381#define SNPRINTF_BLKPTR(func, ws, buf, size, bp, type, checksum, compress) \
361{ \
362 static const char *copyname[] = \
363 { "zero", "single", "double", "triple" }; \
382{ \
383 static const char *copyname[] = \
384 { "zero", "single", "double", "triple" }; \
364 int size = BP_SPRINTF_LEN; \
365 int len = 0; \
366 int copies = 0; \
367 \
368 if (bp == NULL) { \
385 int len = 0; \
386 int copies = 0; \
387 \
388 if (bp == NULL) { \
369 len = func(buf + len, size - len, ""); \
389 len += func(buf + len, size - len, "<NULL>"); \
370 } else if (BP_IS_HOLE(bp)) { \
390 } else if (BP_IS_HOLE(bp)) { \
371 len = func(buf + len, size - len, ""); \
391 len += func(buf + len, size - len, "<hole>"); \
392 if (bp->blk_birth > 0) { \
393 len += func(buf + len, size - len, \
394 " birth=%lluL", \
395 (u_longlong_t)bp->blk_birth); \
396 } \
372 } else { \
373 for (int d = 0; d < BP_GET_NDVAS(bp); d++) { \
374 const dva_t *dva = &bp->blk_dva[d]; \
375 if (DVA_IS_VALID(dva)) \
376 copies++; \
377 len += func(buf + len, size - len, \
378 "DVA[%d]=<%llu:%llx:%llx>%c", d, \
379 (u_longlong_t)DVA_GET_VDEV(dva), \

--- 229 unchanged lines hidden (view full) ---

609extern uint8_t spa_get_failmode(spa_t *spa);
610extern boolean_t spa_suspended(spa_t *spa);
611extern uint64_t spa_bootfs(spa_t *spa);
612extern uint64_t spa_delegation(spa_t *spa);
613extern objset_t *spa_meta_objset(spa_t *spa);
614extern uint64_t spa_deadman_synctime(spa_t *spa);
615
616/* Miscellaneous support routines */
397 } else { \
398 for (int d = 0; d < BP_GET_NDVAS(bp); d++) { \
399 const dva_t *dva = &bp->blk_dva[d]; \
400 if (DVA_IS_VALID(dva)) \
401 copies++; \
402 len += func(buf + len, size - len, \
403 "DVA[%d]=<%llu:%llx:%llx>%c", d, \
404 (u_longlong_t)DVA_GET_VDEV(dva), \

--- 229 unchanged lines hidden (view full) ---

634extern uint8_t spa_get_failmode(spa_t *spa);
635extern boolean_t spa_suspended(spa_t *spa);
636extern uint64_t spa_bootfs(spa_t *spa);
637extern uint64_t spa_delegation(spa_t *spa);
638extern objset_t *spa_meta_objset(spa_t *spa);
639extern uint64_t spa_deadman_synctime(spa_t *spa);
640
641/* Miscellaneous support routines */
617extern void spa_activate_mos_feature(spa_t *spa, const char *feature);
642extern void spa_activate_mos_feature(spa_t *spa, const char *feature,
643 dmu_tx_t *tx);
618extern void spa_deactivate_mos_feature(spa_t *spa, const char *feature);
619extern int spa_rename(const char *oldname, const char *newname);
620extern spa_t *spa_by_guid(uint64_t pool_guid, uint64_t device_guid);
621extern boolean_t spa_guid_exists(uint64_t pool_guid, uint64_t device_guid);
622extern char *spa_strdup(const char *);
623extern void spa_strfree(char *);
624extern uint64_t spa_get_random(uint64_t range);
625extern uint64_t spa_generate_guid(spa_t *spa);
644extern void spa_deactivate_mos_feature(spa_t *spa, const char *feature);
645extern int spa_rename(const char *oldname, const char *newname);
646extern spa_t *spa_by_guid(uint64_t pool_guid, uint64_t device_guid);
647extern boolean_t spa_guid_exists(uint64_t pool_guid, uint64_t device_guid);
648extern char *spa_strdup(const char *);
649extern void spa_strfree(char *);
650extern uint64_t spa_get_random(uint64_t range);
651extern uint64_t spa_generate_guid(spa_t *spa);
626extern void sprintf_blkptr(char *buf, const blkptr_t *bp);
652extern void snprintf_blkptr(char *buf, size_t buflen, const blkptr_t *bp);
627extern void spa_freeze(spa_t *spa);
628extern int spa_change_guid(spa_t *spa);
629extern void spa_upgrade(spa_t *spa, uint64_t version);
630extern void spa_evict_all(void);
631extern vdev_t *spa_lookup_by_guid(spa_t *spa, uint64_t guid,
632 boolean_t l2cache);
633extern boolean_t spa_has_spare(spa_t *, uint64_t guid);
634extern uint64_t dva_get_dsize_sync(spa_t *spa, const dva_t *dva);

--- 52 unchanged lines hidden (view full) ---

687extern void spa_prop_clear_bootfs(spa_t *spa, uint64_t obj, dmu_tx_t *tx);
688extern void spa_configfile_set(spa_t *, nvlist_t *, boolean_t);
689
690/* asynchronous event notification */
691extern void spa_event_notify(spa_t *spa, vdev_t *vdev, const char *name);
692
693#ifdef ZFS_DEBUG
694#define dprintf_bp(bp, fmt, ...) do { \
653extern void spa_freeze(spa_t *spa);
654extern int spa_change_guid(spa_t *spa);
655extern void spa_upgrade(spa_t *spa, uint64_t version);
656extern void spa_evict_all(void);
657extern vdev_t *spa_lookup_by_guid(spa_t *spa, uint64_t guid,
658 boolean_t l2cache);
659extern boolean_t spa_has_spare(spa_t *, uint64_t guid);
660extern uint64_t dva_get_dsize_sync(spa_t *spa, const dva_t *dva);

--- 52 unchanged lines hidden (view full) ---

713extern void spa_prop_clear_bootfs(spa_t *spa, uint64_t obj, dmu_tx_t *tx);
714extern void spa_configfile_set(spa_t *, nvlist_t *, boolean_t);
715
716/* asynchronous event notification */
717extern void spa_event_notify(spa_t *spa, vdev_t *vdev, const char *name);
718
719#ifdef ZFS_DEBUG
720#define dprintf_bp(bp, fmt, ...) do { \
695 if (zfs_flags & ZFS_DEBUG_DPRINTF) { \
721 if (zfs_flags & ZFS_DEBUG_DPRINTF) { \
696 char *__blkbuf = kmem_alloc(BP_SPRINTF_LEN, KM_SLEEP); \
722 char *__blkbuf = kmem_alloc(BP_SPRINTF_LEN, KM_SLEEP); \
697 sprintf_blkptr(__blkbuf, (bp)); \
723 snprintf_blkptr(__blkbuf, BP_SPRINTF_LEN, (bp)); \
698 dprintf(fmt " %s\n", __VA_ARGS__, __blkbuf); \
699 kmem_free(__blkbuf, BP_SPRINTF_LEN); \
700 } \
701_NOTE(CONSTCOND) } while (0)
702#else
703#define dprintf_bp(bp, fmt, ...)
704#endif
705

--- 14 unchanged lines hidden --- 		724 dprintf(fmt " %s\n", __VA_ARGS__, __blkbuf); \
725 kmem_free(__blkbuf, BP_SPRINTF_LEN); \
726 } \
727_NOTE(CONSTCOND) } while (0)
728#else
729#define dprintf_bp(bp, fmt, ...)
730#endif
731

--- 14 unchanged lines hidden ---