Print this page
usr/src/uts/common/fs/zfs/autosnap.c
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/fs/zfs/sys/spa.h
+++ new/usr/src/uts/common/fs/zfs/sys/spa.h
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23 - * Copyright (c) 2011, 2018 by Delphix. All rights reserved.
24 - * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
23 + * Copyright 2013 Saso Kiselkov. All rights reserved.
24 + * Copyright (c) 2011, 2016 by Delphix. All rights reserved.
25 25 * Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
26 + * Copyright 2016 Nexenta Systems, Inc. All rights reserved.
26 27 * Copyright 2013 Saso Kiselkov. All rights reserved.
27 28 * Copyright (c) 2014 Integros [integros.com]
28 29 * Copyright 2017 Joyent, Inc.
29 30 * Copyright (c) 2017 Datto Inc.
30 31 */
31 32
32 33 #ifndef _SYS_SPA_H
33 34 #define _SYS_SPA_H
34 35
35 36 #include <sys/avl.h>
36 37 #include <sys/zfs_context.h>
37 38 #include <sys/nvpair.h>
38 -#include <sys/sysevent.h>
39 39 #include <sys/sysmacros.h>
40 40 #include <sys/types.h>
41 41 #include <sys/fs/zfs.h>
42 42 #include <sys/dmu.h>
43 43
44 44 #ifdef __cplusplus
45 45 extern "C" {
46 46 #endif
47 47
48 48 /*
49 49 * Forward references that lots of things need.
50 50 */
51 51 typedef struct spa spa_t;
52 52 typedef struct vdev vdev_t;
53 53 typedef struct metaslab metaslab_t;
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
54 54 typedef struct metaslab_group metaslab_group_t;
55 55 typedef struct metaslab_class metaslab_class_t;
56 56 typedef struct zio zio_t;
57 57 typedef struct zilog zilog_t;
58 58 typedef struct spa_aux_vdev spa_aux_vdev_t;
59 59 typedef struct ddt ddt_t;
60 60 typedef struct ddt_entry ddt_entry_t;
61 61 struct dsl_pool;
62 62 struct dsl_dataset;
63 63
64 +struct zfs_autosnap;
65 +
64 66 /*
65 67 * General-purpose 32-bit and 64-bit bitfield encodings.
66 68 */
67 69 #define BF32_DECODE(x, low, len) P2PHASE((x) >> (low), 1U << (len))
68 70 #define BF64_DECODE(x, low, len) P2PHASE((x) >> (low), 1ULL << (len))
69 71 #define BF32_ENCODE(x, low, len) (P2PHASE((x), 1U << (len)) << (low))
70 72 #define BF64_ENCODE(x, low, len) (P2PHASE((x), 1ULL << (len)) << (low))
71 73
72 74 #define BF32_GET(x, low, len) BF32_DECODE(x, low, len)
73 75 #define BF64_GET(x, low, len) BF64_DECODE(x, low, len)
74 76
75 77 #define BF32_SET(x, low, len, val) do { \
76 78 ASSERT3U(val, <, 1U << (len)); \
77 79 ASSERT3U(low + len, <=, 32); \
78 80 (x) ^= BF32_ENCODE((x >> low) ^ (val), low, len); \
79 81 _NOTE(CONSTCOND) } while (0)
80 82
81 83 #define BF64_SET(x, low, len, val) do { \
82 84 ASSERT3U(val, <, 1ULL << (len)); \
83 85 ASSERT3U(low + len, <=, 64); \
84 86 ((x) ^= BF64_ENCODE((x >> low) ^ (val), low, len)); \
85 87 _NOTE(CONSTCOND) } while (0)
86 88
87 89 #define BF32_GET_SB(x, low, len, shift, bias) \
88 90 ((BF32_GET(x, low, len) + (bias)) << (shift))
89 91 #define BF64_GET_SB(x, low, len, shift, bias) \
90 92 ((BF64_GET(x, low, len) + (bias)) << (shift))
91 93
92 94 #define BF32_SET_SB(x, low, len, shift, bias, val) do { \
93 95 ASSERT(IS_P2ALIGNED(val, 1U << shift)); \
94 96 ASSERT3S((val) >> (shift), >=, bias); \
95 97 BF32_SET(x, low, len, ((val) >> (shift)) - (bias)); \
96 98 _NOTE(CONSTCOND) } while (0)
97 99 #define BF64_SET_SB(x, low, len, shift, bias, val) do { \
98 100 ASSERT(IS_P2ALIGNED(val, 1ULL << shift)); \
99 101 ASSERT3S((val) >> (shift), >=, bias); \
100 102 BF64_SET(x, low, len, ((val) >> (shift)) - (bias)); \
101 103 _NOTE(CONSTCOND) } while (0)
102 104
103 105 /*
104 106 * We currently support block sizes from 512 bytes to 16MB.
105 107 * The benefits of larger blocks, and thus larger IO, need to be weighed
106 108 * against the cost of COWing a giant block to modify one byte, and the
107 109 * large latency of reading or writing a large block.
108 110 *
109 111 * Note that although blocks up to 16MB are supported, the recordsize
110 112 * property can not be set larger than zfs_max_recordsize (default 1MB).
111 113 * See the comment near zfs_max_recordsize in dsl_dataset.c for details.
112 114 *
113 115 * Note that although the LSIZE field of the blkptr_t can store sizes up
114 116 * to 32MB, the dnode's dn_datablkszsec can only store sizes up to
115 117 * 32MB - 512 bytes. Therefore, we limit SPA_MAXBLOCKSIZE to 16MB.
116 118 */
117 119 #define SPA_MINBLOCKSHIFT 9
118 120 #define SPA_OLD_MAXBLOCKSHIFT 17
119 121 #define SPA_MAXBLOCKSHIFT 24
120 122 #define SPA_MINBLOCKSIZE (1ULL << SPA_MINBLOCKSHIFT)
121 123 #define SPA_OLD_MAXBLOCKSIZE (1ULL << SPA_OLD_MAXBLOCKSHIFT)
122 124 #define SPA_MAXBLOCKSIZE (1ULL << SPA_MAXBLOCKSHIFT)
123 125
124 126 /*
125 127 * Size of block to hold the configuration data (a packed nvlist)
126 128 */
127 129 #define SPA_CONFIG_BLOCKSIZE (1ULL << 14)
128 130
129 131 /*
130 132 * The DVA size encodings for LSIZE and PSIZE support blocks up to 32MB.
131 133 * The ASIZE encoding should be at least 64 times larger (6 more bits)
132 134 * to support up to 4-way RAID-Z mirror mode with worst-case gang block
133 135 * overhead, three DVAs per bp, plus one more bit in case we do anything
134 136 * else that expands the ASIZE.
135 137 */
136 138 #define SPA_LSIZEBITS 16 /* LSIZE up to 32M (2^16 * 512) */
137 139 #define SPA_PSIZEBITS 16 /* PSIZE up to 32M (2^16 * 512) */
138 140 #define SPA_ASIZEBITS 24 /* ASIZE up to 64 times larger */
139 141
140 142 #define SPA_COMPRESSBITS 7
141 143
142 144 /*
143 145 * All SPA data is represented by 128-bit data virtual addresses (DVAs).
144 146 * The members of the dva_t should be considered opaque outside the SPA.
145 147 */
146 148 typedef struct dva {
147 149 uint64_t dva_word[2];
148 150 } dva_t;
149 151
150 152 /*
151 153 * Each block has a 256-bit checksum -- strong enough for cryptographic hashes.
152 154 */
153 155 typedef struct zio_cksum {
154 156 uint64_t zc_word[4];
155 157 } zio_cksum_t;
156 158
157 159 /*
158 160 * Some checksums/hashes need a 256-bit initialization salt. This salt is kept
159 161 * secret and is suitable for use in MAC algorithms as the key.
160 162 */
161 163 typedef struct zio_cksum_salt {
162 164 uint8_t zcs_bytes[32];
163 165 } zio_cksum_salt_t;
164 166
165 167 /*
166 168 * Each block is described by its DVAs, time of birth, checksum, etc.
167 169 * The word-by-word, bit-by-bit layout of the blkptr is as follows:
168 170 *
169 171 * 64 56 48 40 32 24 16 8 0
170 172 * +-------+-------+-------+-------+-------+-------+-------+-------+
171 173 * 0 | vdev1 | GRID | ASIZE |
172 174 * +-------+-------+-------+-------+-------+-------+-------+-------+
|
↓ open down ↓ |
99 lines elided |
↑ open up ↑ |
173 175 * 1 |G| offset1 |
174 176 * +-------+-------+-------+-------+-------+-------+-------+-------+
175 177 * 2 | vdev2 | GRID | ASIZE |
176 178 * +-------+-------+-------+-------+-------+-------+-------+-------+
177 179 * 3 |G| offset2 |
178 180 * +-------+-------+-------+-------+-------+-------+-------+-------+
179 181 * 4 | vdev3 | GRID | ASIZE |
180 182 * +-------+-------+-------+-------+-------+-------+-------+-------+
181 183 * 5 |G| offset3 |
182 184 * +-------+-------+-------+-------+-------+-------+-------+-------+
183 - * 6 |BDX|lvl| type | cksum |E| comp| PSIZE | LSIZE |
185 + * 6 |BDS|lvl| type | cksum |E| comp| PSIZE | LSIZE |
184 186 * +-------+-------+-------+-------+-------+-------+-------+-------+
185 187 * 7 | padding |
186 188 * +-------+-------+-------+-------+-------+-------+-------+-------+
187 189 * 8 | padding |
188 190 * +-------+-------+-------+-------+-------+-------+-------+-------+
189 191 * 9 | physical birth txg |
190 192 * +-------+-------+-------+-------+-------+-------+-------+-------+
191 193 * a | logical birth txg |
192 194 * +-------+-------+-------+-------+-------+-------+-------+-------+
193 195 * b | fill count |
194 196 * +-------+-------+-------+-------+-------+-------+-------+-------+
195 197 * c | checksum[0] |
196 198 * +-------+-------+-------+-------+-------+-------+-------+-------+
197 199 * d | checksum[1] |
198 200 * +-------+-------+-------+-------+-------+-------+-------+-------+
199 201 * e | checksum[2] |
200 202 * +-------+-------+-------+-------+-------+-------+-------+-------+
201 203 * f | checksum[3] |
202 204 * +-------+-------+-------+-------+-------+-------+-------+-------+
203 205 *
204 206 * Legend:
205 207 *
206 208 * vdev virtual device ID
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
207 209 * offset offset into virtual device
208 210 * LSIZE logical size
209 211 * PSIZE physical size (after compression)
210 212 * ASIZE allocated size (including RAID-Z parity and gang block headers)
211 213 * GRID RAID-Z layout information (reserved for future use)
212 214 * cksum checksum function
213 215 * comp compression function
214 216 * G gang block indicator
215 217 * B byteorder (endianness)
216 218 * D dedup
217 - * X encryption (on version 30, which is not supported)
219 + * S special WBC block (unused for embedded blocks)
218 220 * E blkptr_t contains embedded data (see below)
219 221 * lvl level of indirection
220 222 * type DMU object type
221 - * phys birth txg when dva[0] was written; zero if same as logical birth txg
222 - * note that typically all the dva's would be written in this
223 - * txg, but they could be different if they were moved by
224 - * device removal.
223 + * phys birth txg of block allocation; zero if same as logical birth txg
225 224 * log. birth transaction group in which the block was logically born
226 225 * fill count number of non-zero blocks under this bp
227 226 * checksum[4] 256-bit checksum of the data this bp describes
228 227 */
229 228
230 229 /*
231 230 * "Embedded" blkptr_t's don't actually point to a block, instead they
232 231 * have a data payload embedded in the blkptr_t itself. See the comment
233 232 * in blkptr.c for more details.
234 233 *
235 234 * The blkptr_t is laid out as follows:
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
236 235 *
237 236 * 64 56 48 40 32 24 16 8 0
238 237 * +-------+-------+-------+-------+-------+-------+-------+-------+
239 238 * 0 | payload |
240 239 * 1 | payload |
241 240 * 2 | payload |
242 241 * 3 | payload |
243 242 * 4 | payload |
244 243 * 5 | payload |
245 244 * +-------+-------+-------+-------+-------+-------+-------+-------+
246 - * 6 |BDX|lvl| type | etype |E| comp| PSIZE| LSIZE |
245 + * 6 |BDS|lvl| type | etype |E| comp| PSIZE| LSIZE |
247 246 * +-------+-------+-------+-------+-------+-------+-------+-------+
248 247 * 7 | payload |
249 248 * 8 | payload |
250 249 * 9 | payload |
251 250 * +-------+-------+-------+-------+-------+-------+-------+-------+
252 251 * a | logical birth txg |
253 252 * +-------+-------+-------+-------+-------+-------+-------+-------+
254 253 * b | payload |
255 254 * c | payload |
256 255 * d | payload |
257 256 * e | payload |
258 257 * f | payload |
259 258 * +-------+-------+-------+-------+-------+-------+-------+-------+
260 259 *
261 260 * Legend:
262 261 *
263 262 * payload contains the embedded data
264 263 * B (byteorder) byteorder (endianness)
265 264 * D (dedup) padding (set to zero)
266 - * X encryption (set to zero; see above)
265 + * S special WBC block (unused for embedded blocks)
267 266 * E (embedded) set to one
268 267 * lvl indirection level
269 268 * type DMU object type
270 269 * etype how to interpret embedded data (BP_EMBEDDED_TYPE_*)
271 270 * comp compression function of payload
272 271 * PSIZE size of payload after compression, in bytes
273 272 * LSIZE logical size of payload, in bytes
274 273 * note that 25 bits is enough to store the largest
275 274 * "normal" BP's LSIZE (2^16 * 2^9) in bytes
276 275 * log. birth transaction group in which the block was logically born
277 276 *
278 277 * Note that LSIZE and PSIZE are stored in bytes, whereas for non-embedded
279 278 * bp's they are stored in units of SPA_MINBLOCKSHIFT.
280 279 * Generally, the generic BP_GET_*() macros can be used on embedded BP's.
281 280 * The B, D, X, lvl, type, and comp fields are stored the same as with normal
282 281 * BP's so the BP_SET_* macros can be used with them. etype, PSIZE, LSIZE must
283 282 * be set with the BPE_SET_* macros. BP_SET_EMBEDDED() should be called before
284 283 * other macros, as they assert that they are only used on BP's of the correct
285 284 * "embedded-ness".
286 285 */
287 286
288 287 #define BPE_GET_ETYPE(bp) \
289 288 (ASSERT(BP_IS_EMBEDDED(bp)), \
290 289 BF64_GET((bp)->blk_prop, 40, 8))
291 290 #define BPE_SET_ETYPE(bp, t) do { \
292 291 ASSERT(BP_IS_EMBEDDED(bp)); \
293 292 BF64_SET((bp)->blk_prop, 40, 8, t); \
294 293 _NOTE(CONSTCOND) } while (0)
295 294
296 295 #define BPE_GET_LSIZE(bp) \
297 296 (ASSERT(BP_IS_EMBEDDED(bp)), \
298 297 BF64_GET_SB((bp)->blk_prop, 0, 25, 0, 1))
299 298 #define BPE_SET_LSIZE(bp, x) do { \
300 299 ASSERT(BP_IS_EMBEDDED(bp)); \
301 300 BF64_SET_SB((bp)->blk_prop, 0, 25, 0, 1, x); \
302 301 _NOTE(CONSTCOND) } while (0)
303 302
304 303 #define BPE_GET_PSIZE(bp) \
305 304 (ASSERT(BP_IS_EMBEDDED(bp)), \
306 305 BF64_GET_SB((bp)->blk_prop, 25, 7, 0, 1))
307 306 #define BPE_SET_PSIZE(bp, x) do { \
308 307 ASSERT(BP_IS_EMBEDDED(bp)); \
309 308 BF64_SET_SB((bp)->blk_prop, 25, 7, 0, 1, x); \
310 309 _NOTE(CONSTCOND) } while (0)
311 310
312 311 typedef enum bp_embedded_type {
313 312 BP_EMBEDDED_TYPE_DATA,
314 313 BP_EMBEDDED_TYPE_RESERVED, /* Reserved for an unintegrated feature. */
|
↓ open down ↓ |
38 lines elided |
↑ open up ↑ |
315 314 NUM_BP_EMBEDDED_TYPES = BP_EMBEDDED_TYPE_RESERVED
316 315 } bp_embedded_type_t;
317 316
318 317 #define BPE_NUM_WORDS 14
319 318 #define BPE_PAYLOAD_SIZE (BPE_NUM_WORDS * sizeof (uint64_t))
320 319 #define BPE_IS_PAYLOADWORD(bp, wp) \
321 320 ((wp) != &(bp)->blk_prop && (wp) != &(bp)->blk_birth)
322 321
323 322 #define SPA_BLKPTRSHIFT 7 /* blkptr_t is 128 bytes */
324 323 #define SPA_DVAS_PER_BP 3 /* Number of DVAs in a bp */
325 -#define SPA_SYNC_MIN_VDEVS 3 /* min vdevs to update during sync */
326 324
327 325 /*
328 326 * A block is a hole when it has either 1) never been written to, or
329 327 * 2) is zero-filled. In both cases, ZFS can return all zeroes for all reads
330 328 * without physically allocating disk space. Holes are represented in the
331 329 * blkptr_t structure by zeroed blk_dva. Correct checking for holes is
332 330 * done through the BP_IS_HOLE macro. For holes, the logical size, level,
333 331 * DMU object type, and birth times are all also stored for holes that
334 332 * were written to at some point (i.e. were punched after having been filled).
335 333 */
336 334 typedef struct blkptr {
337 335 dva_t blk_dva[SPA_DVAS_PER_BP]; /* Data Virtual Addresses */
338 336 uint64_t blk_prop; /* size, compression, type, etc */
339 337 uint64_t blk_pad[2]; /* Extra space for the future */
340 338 uint64_t blk_phys_birth; /* txg when block was allocated */
341 339 uint64_t blk_birth; /* transaction group at birth */
342 340 uint64_t blk_fill; /* fill count */
343 341 zio_cksum_t blk_cksum; /* 256-bit checksum */
344 342 } blkptr_t;
345 343
346 344 /*
347 345 * Macros to get and set fields in a bp or DVA.
348 346 */
349 347 #define DVA_GET_ASIZE(dva) \
350 348 BF64_GET_SB((dva)->dva_word[0], 0, SPA_ASIZEBITS, SPA_MINBLOCKSHIFT, 0)
351 349 #define DVA_SET_ASIZE(dva, x) \
352 350 BF64_SET_SB((dva)->dva_word[0], 0, SPA_ASIZEBITS, \
353 351 SPA_MINBLOCKSHIFT, 0, x)
354 352
355 353 #define DVA_GET_GRID(dva) BF64_GET((dva)->dva_word[0], 24, 8)
356 354 #define DVA_SET_GRID(dva, x) BF64_SET((dva)->dva_word[0], 24, 8, x)
357 355
358 356 #define DVA_GET_VDEV(dva) BF64_GET((dva)->dva_word[0], 32, 32)
359 357 #define DVA_SET_VDEV(dva, x) BF64_SET((dva)->dva_word[0], 32, 32, x)
360 358
361 359 #define DVA_GET_OFFSET(dva) \
362 360 BF64_GET_SB((dva)->dva_word[1], 0, 63, SPA_MINBLOCKSHIFT, 0)
363 361 #define DVA_SET_OFFSET(dva, x) \
364 362 BF64_SET_SB((dva)->dva_word[1], 0, 63, SPA_MINBLOCKSHIFT, 0, x)
365 363
366 364 #define DVA_GET_GANG(dva) BF64_GET((dva)->dva_word[1], 63, 1)
367 365 #define DVA_SET_GANG(dva, x) BF64_SET((dva)->dva_word[1], 63, 1, x)
368 366
369 367 #define BP_GET_LSIZE(bp) \
370 368 (BP_IS_EMBEDDED(bp) ? \
371 369 (BPE_GET_ETYPE(bp) == BP_EMBEDDED_TYPE_DATA ? BPE_GET_LSIZE(bp) : 0): \
372 370 BF64_GET_SB((bp)->blk_prop, 0, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1))
373 371 #define BP_SET_LSIZE(bp, x) do { \
374 372 ASSERT(!BP_IS_EMBEDDED(bp)); \
375 373 BF64_SET_SB((bp)->blk_prop, \
376 374 0, SPA_LSIZEBITS, SPA_MINBLOCKSHIFT, 1, x); \
377 375 _NOTE(CONSTCOND) } while (0)
378 376
379 377 #define BP_GET_PSIZE(bp) \
380 378 (BP_IS_EMBEDDED(bp) ? 0 : \
381 379 BF64_GET_SB((bp)->blk_prop, 16, SPA_PSIZEBITS, SPA_MINBLOCKSHIFT, 1))
382 380 #define BP_SET_PSIZE(bp, x) do { \
383 381 ASSERT(!BP_IS_EMBEDDED(bp)); \
384 382 BF64_SET_SB((bp)->blk_prop, \
385 383 16, SPA_PSIZEBITS, SPA_MINBLOCKSHIFT, 1, x); \
386 384 _NOTE(CONSTCOND) } while (0)
387 385
388 386 #define BP_GET_COMPRESS(bp) \
389 387 BF64_GET((bp)->blk_prop, 32, SPA_COMPRESSBITS)
390 388 #define BP_SET_COMPRESS(bp, x) \
391 389 BF64_SET((bp)->blk_prop, 32, SPA_COMPRESSBITS, x)
392 390
393 391 #define BP_IS_EMBEDDED(bp) BF64_GET((bp)->blk_prop, 39, 1)
394 392 #define BP_SET_EMBEDDED(bp, x) BF64_SET((bp)->blk_prop, 39, 1, x)
395 393
396 394 #define BP_GET_CHECKSUM(bp) \
397 395 (BP_IS_EMBEDDED(bp) ? ZIO_CHECKSUM_OFF : \
398 396 BF64_GET((bp)->blk_prop, 40, 8))
399 397 #define BP_SET_CHECKSUM(bp, x) do { \
|
↓ open down ↓ |
64 lines elided |
↑ open up ↑ |
400 398 ASSERT(!BP_IS_EMBEDDED(bp)); \
401 399 BF64_SET((bp)->blk_prop, 40, 8, x); \
402 400 _NOTE(CONSTCOND) } while (0)
403 401
404 402 #define BP_GET_TYPE(bp) BF64_GET((bp)->blk_prop, 48, 8)
405 403 #define BP_SET_TYPE(bp, x) BF64_SET((bp)->blk_prop, 48, 8, x)
406 404
407 405 #define BP_GET_LEVEL(bp) BF64_GET((bp)->blk_prop, 56, 5)
408 406 #define BP_SET_LEVEL(bp, x) BF64_SET((bp)->blk_prop, 56, 5, x)
409 407
408 +#define BP_IS_SPECIAL(bp) BF64_GET((bp)->blk_prop, 61, 1)
409 +#define BP_SET_SPECIAL(bp, x) BF64_SET((bp)->blk_prop, 61, 1, x)
410 +
410 411 #define BP_GET_DEDUP(bp) BF64_GET((bp)->blk_prop, 62, 1)
411 412 #define BP_SET_DEDUP(bp, x) BF64_SET((bp)->blk_prop, 62, 1, x)
412 413
413 414 #define BP_GET_BYTEORDER(bp) BF64_GET((bp)->blk_prop, 63, 1)
414 415 #define BP_SET_BYTEORDER(bp, x) BF64_SET((bp)->blk_prop, 63, 1, x)
415 416
416 417 #define BP_PHYSICAL_BIRTH(bp) \
417 418 (BP_IS_EMBEDDED(bp) ? 0 : \
418 419 (bp)->blk_phys_birth ? (bp)->blk_phys_birth : (bp)->blk_birth)
419 420
420 421 #define BP_SET_BIRTH(bp, logical, physical) \
421 422 { \
422 423 ASSERT(!BP_IS_EMBEDDED(bp)); \
423 424 (bp)->blk_birth = (logical); \
424 425 (bp)->blk_phys_birth = ((logical) == (physical) ? 0 : (physical)); \
425 426 }
426 427
427 428 #define BP_GET_FILL(bp) (BP_IS_EMBEDDED(bp) ? 1 : (bp)->blk_fill)
428 429
429 430 #define BP_IS_METADATA(bp) \
430 431 (BP_GET_LEVEL(bp) > 0 || DMU_OT_IS_METADATA(BP_GET_TYPE(bp)))
431 432
432 433 #define BP_GET_ASIZE(bp) \
433 434 (BP_IS_EMBEDDED(bp) ? 0 : \
434 435 DVA_GET_ASIZE(&(bp)->blk_dva[0]) + \
435 436 DVA_GET_ASIZE(&(bp)->blk_dva[1]) + \
436 437 DVA_GET_ASIZE(&(bp)->blk_dva[2]))
437 438
438 439 #define BP_GET_UCSIZE(bp) \
439 440 (BP_IS_METADATA(bp) ? BP_GET_PSIZE(bp) : BP_GET_LSIZE(bp))
440 441
441 442 #define BP_GET_NDVAS(bp) \
442 443 (BP_IS_EMBEDDED(bp) ? 0 : \
443 444 !!DVA_GET_ASIZE(&(bp)->blk_dva[0]) + \
444 445 !!DVA_GET_ASIZE(&(bp)->blk_dva[1]) + \
445 446 !!DVA_GET_ASIZE(&(bp)->blk_dva[2]))
446 447
447 448 #define BP_COUNT_GANG(bp) \
448 449 (BP_IS_EMBEDDED(bp) ? 0 : \
449 450 (DVA_GET_GANG(&(bp)->blk_dva[0]) + \
450 451 DVA_GET_GANG(&(bp)->blk_dva[1]) + \
451 452 DVA_GET_GANG(&(bp)->blk_dva[2])))
452 453
453 454 #define DVA_EQUAL(dva1, dva2) \
454 455 ((dva1)->dva_word[1] == (dva2)->dva_word[1] && \
455 456 (dva1)->dva_word[0] == (dva2)->dva_word[0])
456 457
457 458 #define BP_EQUAL(bp1, bp2) \
458 459 (BP_PHYSICAL_BIRTH(bp1) == BP_PHYSICAL_BIRTH(bp2) && \
459 460 (bp1)->blk_birth == (bp2)->blk_birth && \
|
↓ open down ↓ |
40 lines elided |
↑ open up ↑ |
460 461 DVA_EQUAL(&(bp1)->blk_dva[0], &(bp2)->blk_dva[0]) && \
461 462 DVA_EQUAL(&(bp1)->blk_dva[1], &(bp2)->blk_dva[1]) && \
462 463 DVA_EQUAL(&(bp1)->blk_dva[2], &(bp2)->blk_dva[2]))
463 464
464 465 #define ZIO_CHECKSUM_EQUAL(zc1, zc2) \
465 466 (0 == (((zc1).zc_word[0] - (zc2).zc_word[0]) | \
466 467 ((zc1).zc_word[1] - (zc2).zc_word[1]) | \
467 468 ((zc1).zc_word[2] - (zc2).zc_word[2]) | \
468 469 ((zc1).zc_word[3] - (zc2).zc_word[3])))
469 470
471 +#define ZIO_CHECKSUM_BSWAP(_zc) \
472 + do { \
473 + zio_cksum_t *zc = (_zc); \
474 + zc->zc_word[0] = BSWAP_64(zc->zc_word[0]); \
475 + zc->zc_word[1] = BSWAP_64(zc->zc_word[1]); \
476 + zc->zc_word[2] = BSWAP_64(zc->zc_word[2]); \
477 + zc->zc_word[3] = BSWAP_64(zc->zc_word[3]); \
478 + _NOTE(NOTREACHED) \
479 + _NOTE(CONSTCOND) \
480 + } while (0)
481 +
470 482 #define ZIO_CHECKSUM_IS_ZERO(zc) \
471 483 (0 == ((zc)->zc_word[0] | (zc)->zc_word[1] | \
472 484 (zc)->zc_word[2] | (zc)->zc_word[3]))
473 485
474 -#define ZIO_CHECKSUM_BSWAP(zcp) \
475 -{ \
476 - (zcp)->zc_word[0] = BSWAP_64((zcp)->zc_word[0]); \
477 - (zcp)->zc_word[1] = BSWAP_64((zcp)->zc_word[1]); \
478 - (zcp)->zc_word[2] = BSWAP_64((zcp)->zc_word[2]); \
479 - (zcp)->zc_word[3] = BSWAP_64((zcp)->zc_word[3]); \
480 -}
481 -
482 -
483 486 #define DVA_IS_VALID(dva) (DVA_GET_ASIZE(dva) != 0)
484 487
485 488 #define ZIO_SET_CHECKSUM(zcp, w0, w1, w2, w3) \
486 489 { \
487 490 (zcp)->zc_word[0] = w0; \
488 491 (zcp)->zc_word[1] = w1; \
489 492 (zcp)->zc_word[2] = w2; \
490 493 (zcp)->zc_word[3] = w3; \
491 494 }
492 495
493 496 #define BP_IDENTITY(bp) (ASSERT(!BP_IS_EMBEDDED(bp)), &(bp)->blk_dva[0])
494 497 #define BP_IS_GANG(bp) \
495 498 (BP_IS_EMBEDDED(bp) ? B_FALSE : DVA_GET_GANG(BP_IDENTITY(bp)))
496 499 #define DVA_IS_EMPTY(dva) ((dva)->dva_word[0] == 0ULL && \
497 500 (dva)->dva_word[1] == 0ULL)
498 501 #define BP_IS_HOLE(bp) \
499 502 (!BP_IS_EMBEDDED(bp) && DVA_IS_EMPTY(BP_IDENTITY(bp)))
500 503
501 504 /* BP_IS_RAIDZ(bp) assumes no block compression */
502 505 #define BP_IS_RAIDZ(bp) (DVA_GET_ASIZE(&(bp)->blk_dva[0]) > \
503 506 BP_GET_PSIZE(bp))
504 507
505 508 #define BP_ZERO(bp) \
506 509 { \
507 510 (bp)->blk_dva[0].dva_word[0] = 0; \
508 511 (bp)->blk_dva[0].dva_word[1] = 0; \
509 512 (bp)->blk_dva[1].dva_word[0] = 0; \
510 513 (bp)->blk_dva[1].dva_word[1] = 0; \
511 514 (bp)->blk_dva[2].dva_word[0] = 0; \
512 515 (bp)->blk_dva[2].dva_word[1] = 0; \
513 516 (bp)->blk_prop = 0; \
514 517 (bp)->blk_pad[0] = 0; \
515 518 (bp)->blk_pad[1] = 0; \
516 519 (bp)->blk_phys_birth = 0; \
517 520 (bp)->blk_birth = 0; \
518 521 (bp)->blk_fill = 0; \
519 522 ZIO_SET_CHECKSUM(&(bp)->blk_cksum, 0, 0, 0, 0); \
520 523 }
521 524
522 525 #ifdef _BIG_ENDIAN
523 526 #define ZFS_HOST_BYTEORDER (0ULL)
524 527 #else
525 528 #define ZFS_HOST_BYTEORDER (1ULL)
526 529 #endif
527 530
528 531 #define BP_SHOULD_BYTESWAP(bp) (BP_GET_BYTEORDER(bp) != ZFS_HOST_BYTEORDER)
529 532
530 533 #define BP_SPRINTF_LEN 320
531 534
532 535 /*
533 536 * This macro allows code sharing between zfs, libzpool, and mdb.
534 537 * 'func' is either snprintf() or mdb_snprintf().
535 538 * 'ws' (whitespace) can be ' ' for single-line format, '\n' for multi-line.
536 539 */
537 540 #define SNPRINTF_BLKPTR(func, ws, buf, size, bp, type, checksum, compress) \
538 541 { \
539 542 static const char *copyname[] = \
540 543 { "zero", "single", "double", "triple" }; \
541 544 int len = 0; \
542 545 int copies = 0; \
543 546 \
544 547 if (bp == NULL) { \
545 548 len += func(buf + len, size - len, "<NULL>"); \
546 549 } else if (BP_IS_HOLE(bp)) { \
547 550 len += func(buf + len, size - len, \
548 551 "HOLE [L%llu %s] " \
549 552 "size=%llxL birth=%lluL", \
550 553 (u_longlong_t)BP_GET_LEVEL(bp), \
551 554 type, \
552 555 (u_longlong_t)BP_GET_LSIZE(bp), \
553 556 (u_longlong_t)bp->blk_birth); \
554 557 } else if (BP_IS_EMBEDDED(bp)) { \
555 558 len = func(buf + len, size - len, \
556 559 "EMBEDDED [L%llu %s] et=%u %s " \
557 560 "size=%llxL/%llxP birth=%lluL", \
558 561 (u_longlong_t)BP_GET_LEVEL(bp), \
559 562 type, \
560 563 (int)BPE_GET_ETYPE(bp), \
561 564 compress, \
562 565 (u_longlong_t)BPE_GET_LSIZE(bp), \
563 566 (u_longlong_t)BPE_GET_PSIZE(bp), \
564 567 (u_longlong_t)bp->blk_birth); \
565 568 } else { \
566 569 for (int d = 0; d < BP_GET_NDVAS(bp); d++) { \
567 570 const dva_t *dva = &bp->blk_dva[d]; \
568 571 if (DVA_IS_VALID(dva)) \
569 572 copies++; \
570 573 len += func(buf + len, size - len, \
571 574 "DVA[%d]=<%llu:%llx:%llx>%c", d, \
572 575 (u_longlong_t)DVA_GET_VDEV(dva), \
573 576 (u_longlong_t)DVA_GET_OFFSET(dva), \
574 577 (u_longlong_t)DVA_GET_ASIZE(dva), \
575 578 ws); \
576 579 } \
577 580 if (BP_IS_GANG(bp) && \
578 581 DVA_GET_ASIZE(&bp->blk_dva[2]) <= \
579 582 DVA_GET_ASIZE(&bp->blk_dva[1]) / 2) \
580 583 copies--; \
581 584 len += func(buf + len, size - len, \
582 585 "[L%llu %s] %s %s %s %s %s %s%c" \
583 586 "size=%llxL/%llxP birth=%lluL/%lluP fill=%llu%c" \
584 587 "cksum=%llx:%llx:%llx:%llx", \
585 588 (u_longlong_t)BP_GET_LEVEL(bp), \
586 589 type, \
587 590 checksum, \
588 591 compress, \
589 592 BP_GET_BYTEORDER(bp) == 0 ? "BE" : "LE", \
590 593 BP_IS_GANG(bp) ? "gang" : "contiguous", \
591 594 BP_GET_DEDUP(bp) ? "dedup" : "unique", \
592 595 copyname[copies], \
593 596 ws, \
594 597 (u_longlong_t)BP_GET_LSIZE(bp), \
595 598 (u_longlong_t)BP_GET_PSIZE(bp), \
596 599 (u_longlong_t)bp->blk_birth, \
597 600 (u_longlong_t)BP_PHYSICAL_BIRTH(bp), \
598 601 (u_longlong_t)BP_GET_FILL(bp), \
|
↓ open down ↓ |
106 lines elided |
↑ open up ↑ |
599 602 ws, \
600 603 (u_longlong_t)bp->blk_cksum.zc_word[0], \
601 604 (u_longlong_t)bp->blk_cksum.zc_word[1], \
602 605 (u_longlong_t)bp->blk_cksum.zc_word[2], \
603 606 (u_longlong_t)bp->blk_cksum.zc_word[3]); \
604 607 } \
605 608 ASSERT(len < size); \
606 609 }
607 610
608 611 #define BP_GET_BUFC_TYPE(bp) \
609 - (BP_IS_METADATA(bp) ? ARC_BUFC_METADATA : ARC_BUFC_DATA)
612 + ((BP_GET_TYPE(bp) == DMU_OT_DDT_ZAP || \
613 + BP_GET_TYPE(bp) == DMU_OT_DDT_STATS) ? ARC_BUFC_DDT : \
614 + (BP_IS_METADATA(bp) ? ARC_BUFC_METADATA : ARC_BUFC_DATA))
610 615
611 616 typedef enum spa_import_type {
612 617 SPA_IMPORT_EXISTING,
613 618 SPA_IMPORT_ASSEMBLE
614 619 } spa_import_type_t;
615 620
621 +/*
622 + * Should we force sending TRIM commands even to devices which evidently
623 + * don't support it?
624 + * OFF: no, only send to devices which indicated support
625 + * ON: yes, force send to everybody
626 + */
627 +typedef enum {
628 + SPA_FORCE_TRIM_OFF = 0, /* default */
629 + SPA_FORCE_TRIM_ON
630 +} spa_force_trim_t;
631 +
632 +/*
633 + * Should we send TRIM commands in-line during normal pool operation while
634 + * deleting stuff?
635 + * OFF: no
636 + * ON: yes
637 + */
638 +typedef enum {
639 + SPA_AUTO_TRIM_OFF = 0, /* default */
640 + SPA_AUTO_TRIM_ON
641 +} spa_auto_trim_t;
642 +
616 643 /* state manipulation functions */
617 644 extern int spa_open(const char *pool, spa_t **, void *tag);
618 645 extern int spa_open_rewind(const char *pool, spa_t **, void *tag,
619 646 nvlist_t *policy, nvlist_t **config);
620 -extern int spa_get_stats(const char *pool, nvlist_t **config, char *altroot,
621 - size_t buflen);
647 +extern int spa_get_stats(const char *name, nvlist_t **config,
648 + char *altroot, size_t buflen);
622 649 extern int spa_create(const char *pool, nvlist_t *config, nvlist_t *props,
623 650 nvlist_t *zplprops);
624 651 extern int spa_import_rootpool(char *devpath, char *devid);
625 652 extern int spa_import(const char *pool, nvlist_t *config, nvlist_t *props,
626 653 uint64_t flags);
627 654 extern nvlist_t *spa_tryimport(nvlist_t *tryconfig);
628 655 extern int spa_destroy(char *pool);
629 656 extern int spa_export(char *pool, nvlist_t **oldconfig, boolean_t force,
630 - boolean_t hardforce);
657 + boolean_t hardforce, boolean_t saveconfig);
631 658 extern int spa_reset(char *pool);
632 659 extern void spa_async_request(spa_t *spa, int flag);
633 660 extern void spa_async_unrequest(spa_t *spa, int flag);
634 661 extern void spa_async_suspend(spa_t *spa);
635 662 extern void spa_async_resume(spa_t *spa);
636 663 extern spa_t *spa_inject_addref(char *pool);
637 664 extern void spa_inject_delref(spa_t *spa);
638 665 extern void spa_scan_stat_init(spa_t *spa);
639 666 extern int spa_scan_get_stats(spa_t *spa, pool_scan_stat_t *ps);
640 667
641 -#define SPA_ASYNC_CONFIG_UPDATE 0x01
642 -#define SPA_ASYNC_REMOVE 0x02
643 -#define SPA_ASYNC_PROBE 0x04
644 -#define SPA_ASYNC_RESILVER_DONE 0x08
645 -#define SPA_ASYNC_RESILVER 0x10
646 -#define SPA_ASYNC_AUTOEXPAND 0x20
647 -#define SPA_ASYNC_REMOVE_DONE 0x40
648 -#define SPA_ASYNC_REMOVE_STOP 0x80
668 +#define SPA_ASYNC_CONFIG_UPDATE 0x01
669 +#define SPA_ASYNC_REMOVE 0x02
670 +#define SPA_ASYNC_PROBE 0x04
671 +#define SPA_ASYNC_RESILVER_DONE 0x08
672 +#define SPA_ASYNC_RESILVER 0x10
673 +#define SPA_ASYNC_AUTOEXPAND 0x20
674 +#define SPA_ASYNC_REMOVE_DONE 0x40
675 +#define SPA_ASYNC_REMOVE_STOP 0x80
676 +#define SPA_ASYNC_L2CACHE_REBUILD 0x100
677 +#define SPA_ASYNC_MAN_TRIM_TASKQ_DESTROY 0x200
649 678
650 679 /*
651 680 * Controls the behavior of spa_vdev_remove().
652 681 */
653 682 #define SPA_REMOVE_UNSPARE 0x01
654 683 #define SPA_REMOVE_DONE 0x02
655 684
656 685 /* device manipulation */
657 686 extern int spa_vdev_add(spa_t *spa, nvlist_t *nvroot);
658 687 extern int spa_vdev_attach(spa_t *spa, uint64_t guid, nvlist_t *nvroot,
659 688 int replacing);
660 689 extern int spa_vdev_detach(spa_t *spa, uint64_t guid, uint64_t pguid,
661 690 int replace_done);
662 691 extern int spa_vdev_remove(spa_t *spa, uint64_t guid, boolean_t unspare);
663 692 extern boolean_t spa_vdev_remove_active(spa_t *spa);
693 +extern int spa_vdev_setl2adddt(spa_t *spa, uint64_t guid, const char *newval);
664 694 extern int spa_vdev_setpath(spa_t *spa, uint64_t guid, const char *newpath);
665 695 extern int spa_vdev_setfru(spa_t *spa, uint64_t guid, const char *newfru);
666 696 extern int spa_vdev_split_mirror(spa_t *spa, char *newname, nvlist_t *config,
667 697 nvlist_t *props, boolean_t exp);
668 698
699 +extern int spa_load_vdev_props(spa_t *spa);
700 +
701 +extern int spa_vdev_prop_validate(spa_t *spa, uint64_t vdev_guid,
702 + nvlist_t *nvp);
703 +extern int spa_vdev_prop_set(spa_t *spa, uint64_t vdev_guid, nvlist_t *nvp);
704 +extern int spa_vdev_prop_get(spa_t *spa, uint64_t vdev_guid, nvlist_t **nvp);
705 +extern int spa_vdev_props_sync_task_do(spa_t *spa);
706 +
669 707 /* spare state (which is global across all pools) */
670 708 extern void spa_spare_add(vdev_t *vd);
671 709 extern void spa_spare_remove(vdev_t *vd);
672 710 extern boolean_t spa_spare_exists(uint64_t guid, uint64_t *pool, int *refcnt);
673 711 extern void spa_spare_activate(vdev_t *vd);
674 712
675 713 /* L2ARC state (which is global across all pools) */
676 714 extern void spa_l2cache_add(vdev_t *vd);
677 715 extern void spa_l2cache_remove(vdev_t *vd);
678 716 extern boolean_t spa_l2cache_exists(uint64_t guid, uint64_t *pool);
679 717 extern void spa_l2cache_activate(vdev_t *vd);
680 718 extern void spa_l2cache_drop(spa_t *spa);
681 719
682 720 /* scanning */
683 721 extern int spa_scan(spa_t *spa, pool_scan_func_t func);
684 722 extern int spa_scan_stop(spa_t *spa);
685 723 extern int spa_scrub_pause_resume(spa_t *spa, pool_scrub_cmd_t flag);
686 724
725 +/* trimming */
726 +extern void spa_man_trim(spa_t *spa, uint64_t rate);
727 +extern void spa_man_trim_stop(spa_t *spa);
728 +extern void spa_get_trim_prog(spa_t *spa, uint64_t *prog, uint64_t *rate,
729 + uint64_t *start_time, uint64_t *stop_time);
730 +extern void spa_trim_stop_wait(spa_t *spa);
731 +
687 732 /* spa syncing */
688 733 extern void spa_sync(spa_t *spa, uint64_t txg); /* only for DMU use */
689 734 extern void spa_sync_allpools(void);
690 735
691 736 /* spa namespace global mutex */
692 737 extern kmutex_t spa_namespace_lock;
693 738
694 739 /*
695 740 * SPA configuration functions in spa_config.c
696 741 */
697 742
698 743 #define SPA_CONFIG_UPDATE_POOL 0
699 744 #define SPA_CONFIG_UPDATE_VDEVS 1
700 745
701 -extern void spa_write_cachefile(spa_t *, boolean_t, boolean_t);
746 +extern void spa_config_sync(spa_t *, boolean_t, boolean_t);
702 747 extern void spa_config_load(void);
703 748 extern nvlist_t *spa_all_configs(uint64_t *);
704 749 extern void spa_config_set(spa_t *spa, nvlist_t *config);
705 750 extern nvlist_t *spa_config_generate(spa_t *spa, vdev_t *vd, uint64_t txg,
706 751 int getstats);
707 752 extern void spa_config_update(spa_t *spa, int what);
708 753
709 754 /*
710 755 * Miscellaneous SPA routines in spa_misc.c
711 756 */
712 757
758 +/* dedup ceiling helper functions */
759 +extern uint64_t spa_get_ddts_size(spa_t *spa, boolean_t phys);
760 +extern int spa_get_l2arc_ddt_utilization(spa_t *spa);
761 +extern boolean_t spa_enable_dedup_cap(spa_t *spa);
762 +
713 763 /* Namespace manipulation */
714 764 extern spa_t *spa_lookup(const char *name);
715 765 extern spa_t *spa_add(const char *name, nvlist_t *config, const char *altroot);
716 766 extern void spa_remove(spa_t *spa);
717 767 extern spa_t *spa_next(spa_t *prev);
718 768
719 769 /* Refcount functions */
720 770 extern void spa_open_ref(spa_t *spa, void *tag);
721 771 extern void spa_close(spa_t *spa, void *tag);
722 772 extern void spa_async_close(spa_t *spa, void *tag);
723 773 extern boolean_t spa_refcount_zero(spa_t *spa);
724 774
725 775 #define SCL_NONE 0x00
726 776 #define SCL_CONFIG 0x01
727 777 #define SCL_STATE 0x02
728 778 #define SCL_L2ARC 0x04 /* hack until L2ARC 2.0 */
729 779 #define SCL_ALLOC 0x08
730 780 #define SCL_ZIO 0x10
731 781 #define SCL_FREE 0x20
732 782 #define SCL_VDEV 0x40
733 783 #define SCL_LOCKS 7
734 784 #define SCL_ALL ((1 << SCL_LOCKS) - 1)
735 785 #define SCL_STATE_ALL (SCL_STATE | SCL_L2ARC | SCL_ZIO)
736 786
737 787 /* Pool configuration locks */
738 788 extern int spa_config_tryenter(spa_t *spa, int locks, void *tag, krw_t rw);
739 789 extern void spa_config_enter(spa_t *spa, int locks, void *tag, krw_t rw);
740 790 extern void spa_config_exit(spa_t *spa, int locks, void *tag);
741 791 extern int spa_config_held(spa_t *spa, int locks, krw_t rw);
742 792
743 793 /* Pool vdev add/remove lock */
744 794 extern uint64_t spa_vdev_enter(spa_t *spa);
745 795 extern uint64_t spa_vdev_config_enter(spa_t *spa);
746 796 extern void spa_vdev_config_exit(spa_t *spa, vdev_t *vd, uint64_t txg,
747 797 int error, char *tag);
748 798 extern int spa_vdev_exit(spa_t *spa, vdev_t *vd, uint64_t txg, int error);
749 799
750 800 /* Pool vdev state change lock */
751 801 extern void spa_vdev_state_enter(spa_t *spa, int oplock);
752 802 extern int spa_vdev_state_exit(spa_t *spa, vdev_t *vd, int error);
753 803
|
↓ open down ↓ |
31 lines elided |
↑ open up ↑ |
754 804 /* Log state */
755 805 typedef enum spa_log_state {
756 806 SPA_LOG_UNKNOWN = 0, /* unknown log state */
757 807 SPA_LOG_MISSING, /* missing log(s) */
758 808 SPA_LOG_CLEAR, /* clear the log(s) */
759 809 SPA_LOG_GOOD, /* log(s) are good */
760 810 } spa_log_state_t;
761 811
762 812 extern spa_log_state_t spa_get_log_state(spa_t *spa);
763 813 extern void spa_set_log_state(spa_t *spa, spa_log_state_t state);
764 -extern int spa_reset_logs(spa_t *spa);
814 +extern int spa_offline_log(spa_t *spa);
765 815
766 816 /* Log claim callback */
767 817 extern void spa_claim_notify(zio_t *zio);
768 818
769 819 /* Accessor functions */
770 820 extern boolean_t spa_shutting_down(spa_t *spa);
771 821 extern struct dsl_pool *spa_get_dsl(spa_t *spa);
772 822 extern boolean_t spa_is_initializing(spa_t *spa);
773 -extern boolean_t spa_indirect_vdevs_loaded(spa_t *spa);
774 823 extern blkptr_t *spa_get_rootblkptr(spa_t *spa);
775 824 extern void spa_set_rootblkptr(spa_t *spa, const blkptr_t *bp);
776 825 extern void spa_altroot(spa_t *, char *, size_t);
777 826 extern int spa_sync_pass(spa_t *spa);
778 827 extern char *spa_name(spa_t *spa);
779 828 extern uint64_t spa_guid(spa_t *spa);
780 829 extern uint64_t spa_load_guid(spa_t *spa);
781 830 extern uint64_t spa_last_synced_txg(spa_t *spa);
782 831 extern uint64_t spa_first_txg(spa_t *spa);
783 832 extern uint64_t spa_syncing_txg(spa_t *spa);
784 833 extern uint64_t spa_final_dirty_txg(spa_t *spa);
785 834 extern uint64_t spa_version(spa_t *spa);
835 +extern int spa_get_obj_mtx_sz(spa_t *spa);
786 836 extern pool_state_t spa_state(spa_t *spa);
787 837 extern spa_load_state_t spa_load_state(spa_t *spa);
788 838 extern uint64_t spa_freeze_txg(spa_t *spa);
789 839 extern uint64_t spa_get_worst_case_asize(spa_t *spa, uint64_t lsize);
790 840 extern uint64_t spa_get_dspace(spa_t *spa);
791 841 extern uint64_t spa_get_slop_space(spa_t *spa);
792 842 extern void spa_update_dspace(spa_t *spa);
843 +extern void spa_update_latency(spa_t *spa);
793 844 extern uint64_t spa_version(spa_t *spa);
794 845 extern boolean_t spa_deflate(spa_t *spa);
795 846 extern metaslab_class_t *spa_normal_class(spa_t *spa);
796 847 extern metaslab_class_t *spa_log_class(spa_t *spa);
848 +extern metaslab_class_t *spa_special_class(spa_t *spa);
797 849 extern void spa_evicting_os_register(spa_t *, objset_t *os);
798 850 extern void spa_evicting_os_deregister(spa_t *, objset_t *os);
799 851 extern void spa_evicting_os_wait(spa_t *spa);
852 +extern uint64_t spa_class_alloc_percentage(metaslab_class_t *mc);
800 853 extern int spa_max_replication(spa_t *spa);
801 854 extern int spa_prev_software_version(spa_t *spa);
802 855 extern int spa_busy(void);
803 856 extern uint8_t spa_get_failmode(spa_t *spa);
804 857 extern boolean_t spa_suspended(spa_t *spa);
805 858 extern uint64_t spa_bootfs(spa_t *spa);
806 859 extern uint64_t spa_delegation(spa_t *spa);
807 860 extern objset_t *spa_meta_objset(spa_t *spa);
808 861 extern uint64_t spa_deadman_synctime(spa_t *spa);
862 +extern spa_force_trim_t spa_get_force_trim(spa_t *spa);
863 +extern spa_auto_trim_t spa_get_auto_trim(spa_t *spa);
809 864
810 865 /* Miscellaneous support routines */
811 -extern void spa_load_failed(spa_t *spa, const char *fmt, ...);
812 -extern void spa_load_note(spa_t *spa, const char *fmt, ...);
813 866 extern void spa_activate_mos_feature(spa_t *spa, const char *feature,
814 867 dmu_tx_t *tx);
815 868 extern void spa_deactivate_mos_feature(spa_t *spa, const char *feature);
816 869 extern int spa_rename(const char *oldname, const char *newname);
817 870 extern spa_t *spa_by_guid(uint64_t pool_guid, uint64_t device_guid);
818 871 extern boolean_t spa_guid_exists(uint64_t pool_guid, uint64_t device_guid);
872 +extern boolean_t spa_config_guid_exists(uint64_t pool_guid);
819 873 extern char *spa_strdup(const char *);
820 874 extern void spa_strfree(char *);
821 875 extern uint64_t spa_get_random(uint64_t range);
822 876 extern uint64_t spa_generate_guid(spa_t *spa);
823 877 extern void snprintf_blkptr(char *buf, size_t buflen, const blkptr_t *bp);
824 878 extern void spa_freeze(spa_t *spa);
825 879 extern int spa_change_guid(spa_t *spa);
826 880 extern void spa_upgrade(spa_t *spa, uint64_t version);
827 881 extern void spa_evict_all(void);
828 882 extern vdev_t *spa_lookup_by_guid(spa_t *spa, uint64_t guid,
829 883 boolean_t l2cache);
830 884 extern boolean_t spa_has_spare(spa_t *, uint64_t guid);
831 885 extern uint64_t dva_get_dsize_sync(spa_t *spa, const dva_t *dva);
832 886 extern uint64_t bp_get_dsize_sync(spa_t *spa, const blkptr_t *bp);
833 887 extern uint64_t bp_get_dsize(spa_t *spa, const blkptr_t *bp);
834 888 extern boolean_t spa_has_slogs(spa_t *spa);
835 889 extern boolean_t spa_is_root(spa_t *spa);
836 890 extern boolean_t spa_writeable(spa_t *spa);
837 891 extern boolean_t spa_has_pending_synctask(spa_t *spa);
892 +extern boolean_t spa_has_special(spa_t *spa);
838 893 extern int spa_maxblocksize(spa_t *spa);
839 894 extern void zfs_blkptr_verify(spa_t *spa, const blkptr_t *bp);
840 -extern boolean_t zfs_dva_valid(spa_t *spa, const dva_t *dva,
841 - const blkptr_t *bp);
842 -typedef void (*spa_remap_cb_t)(uint64_t vdev, uint64_t offset, uint64_t size,
843 - void *arg);
844 -extern boolean_t spa_remap_blkptr(spa_t *spa, blkptr_t *bp,
845 - spa_remap_cb_t callback, void *arg);
846 -extern uint64_t spa_get_last_removal_txg(spa_t *spa);
847 -extern boolean_t spa_trust_config(spa_t *spa);
848 -extern uint64_t spa_missing_tvds_allowed(spa_t *spa);
849 -extern void spa_set_missing_tvds(spa_t *spa, uint64_t missing);
895 +extern boolean_t spa_wbc_present(spa_t *spa);
896 +extern boolean_t spa_wbc_active(spa_t *spa);
897 +extern struct zfs_autosnap *spa_get_autosnap(spa_t *spa);
898 +extern void wbc_purge_window(spa_t *spa, dmu_tx_t *tx);
850 899
851 900 extern int spa_mode(spa_t *spa);
852 901 extern uint64_t zfs_strtonum(const char *str, char **nptr);
853 902
903 +/* Selector for dynamic I/O balancing between special and regular vdevs */
904 +extern boolean_t spa_use_special_class(spa_t *spa);
905 +
906 +/* Pool perfmon thread management */
907 +extern void spa_start_perfmon_thread(spa_t *spa);
908 +extern boolean_t spa_stop_perfmon_thread(spa_t *spa);
909 +
854 910 extern char *spa_his_ievent_table[];
855 911
856 912 extern void spa_history_create_obj(spa_t *spa, dmu_tx_t *tx);
857 913 extern int spa_history_get(spa_t *spa, uint64_t *offset, uint64_t *len_read,
858 914 char *his_buf);
859 915 extern int spa_history_log(spa_t *spa, const char *his_buf);
860 916 extern int spa_history_log_nvl(spa_t *spa, nvlist_t *nvl);
861 917 extern void spa_history_log_version(spa_t *spa, const char *operation);
862 918 extern void spa_history_log_internal(spa_t *spa, const char *operation,
863 919 dmu_tx_t *tx, const char *fmt, ...);
864 920 extern void spa_history_log_internal_ds(struct dsl_dataset *ds, const char *op,
865 921 dmu_tx_t *tx, const char *fmt, ...);
866 922 extern void spa_history_log_internal_dd(dsl_dir_t *dd, const char *operation,
867 923 dmu_tx_t *tx, const char *fmt, ...);
868 924
869 925 /* error handling */
870 926 struct zbookmark_phys;
871 927 extern void spa_log_error(spa_t *spa, zio_t *zio);
872 928 extern void zfs_ereport_post(const char *class, spa_t *spa, vdev_t *vd,
873 929 zio_t *zio, uint64_t stateoroffset, uint64_t length);
874 930 extern void zfs_post_remove(spa_t *spa, vdev_t *vd);
875 931 extern void zfs_post_state_change(spa_t *spa, vdev_t *vd);
876 932 extern void zfs_post_autoreplace(spa_t *spa, vdev_t *vd);
877 933 extern uint64_t spa_get_errlog_size(spa_t *spa);
878 934 extern int spa_get_errlog(spa_t *spa, void *uaddr, size_t *count);
879 935 extern void spa_errlog_rotate(spa_t *spa);
880 936 extern void spa_errlog_drain(spa_t *spa);
881 937 extern void spa_errlog_sync(spa_t *spa, uint64_t txg);
882 938 extern void spa_get_errlists(spa_t *spa, avl_tree_t *last, avl_tree_t *scrub);
883 939
884 940 /* vdev cache */
885 941 extern void vdev_cache_stat_init(void);
886 942 extern void vdev_cache_stat_fini(void);
887 943
888 944 /* Initialization and termination */
889 945 extern void spa_init(int flags);
890 946 extern void spa_fini(void);
891 947 extern void spa_boot_init(void);
|
↓ open down ↓ |
28 lines elided |
↑ open up ↑ |
892 948
893 949 /* properties */
894 950 extern int spa_prop_set(spa_t *spa, nvlist_t *nvp);
895 951 extern int spa_prop_get(spa_t *spa, nvlist_t **nvp);
896 952 extern void spa_prop_clear_bootfs(spa_t *spa, uint64_t obj, dmu_tx_t *tx);
897 953 extern void spa_configfile_set(spa_t *, nvlist_t *, boolean_t);
898 954
899 955 /* asynchronous event notification */
900 956 extern void spa_event_notify(spa_t *spa, vdev_t *vdev, nvlist_t *hist_nvl,
901 957 const char *name);
902 -extern sysevent_t *spa_event_create(spa_t *spa, vdev_t *vd, nvlist_t *hist_nvl,
903 - const char *name);
904 -extern void spa_event_post(sysevent_t *ev);
905 -extern void spa_event_discard(sysevent_t *ev);
906 958
959 +extern int spa_wbc_mode(const char *name);
960 +
961 +typedef enum spa_wbc_mode {
962 + WBC_MODE_OFF,
963 + WBC_MODE_ACTIVE,
964 + WBC_MODE_PASSIVE
965 +} spa_wbc_mode_t;
966 +
967 +/* TRIM/UNMAP kstat update */
968 +extern void spa_trimstats_update(spa_t *spa, uint64_t extents, uint64_t bytes,
969 + uint64_t extents_skipped, uint64_t bytes_skipped);
970 +extern void spa_trimstats_auto_slow_incr(spa_t *spa);
971 +
907 972 #ifdef ZFS_DEBUG
908 973 #define dprintf_bp(bp, fmt, ...) do { \
909 974 if (zfs_flags & ZFS_DEBUG_DPRINTF) { \
910 975 char *__blkbuf = kmem_alloc(BP_SPRINTF_LEN, KM_SLEEP); \
911 976 snprintf_blkptr(__blkbuf, BP_SPRINTF_LEN, (bp)); \
912 977 dprintf(fmt " %s\n", __VA_ARGS__, __blkbuf); \
913 978 kmem_free(__blkbuf, BP_SPRINTF_LEN); \
914 979 } \
915 980 _NOTE(CONSTCOND) } while (0)
916 981 #else
917 982 #define dprintf_bp(bp, fmt, ...)
918 983 #endif
919 984
920 985 extern boolean_t spa_debug_enabled(spa_t *spa);
921 986 #define spa_dbgmsg(spa, ...) \
922 987 { \
923 988 if (spa_debug_enabled(spa)) \
924 989 zfs_dbgmsg(__VA_ARGS__); \
925 990 }
926 991
927 992 extern int spa_mode_global; /* mode, e.g. FREAD | FWRITE */
928 993
929 994 #ifdef __cplusplus
930 995 }
931 996 #endif
932 997
933 998 #endif /* _SYS_SPA_H */
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX