]>
Commit | Line | Data |
---|---|---|
34dc7c2f BB |
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 | |
1d3ba0bf | 9 | * or https://opensource.org/licenses/CDDL-1.0. |
34dc7c2f BB |
10 | * See the License for the specific language governing permissions |
11 | * and limitations under the License. | |
12 | * | |
13 | * When distributing Covered Code, include this CDDL HEADER in each | |
14 | * file and include the License file at usr/src/OPENSOLARIS.LICENSE. | |
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 | /* | |
9babb374 | 22 | * Copyright 2009 Sun Microsystems, Inc. All rights reserved. |
34dc7c2f BB |
23 | * Use is subject to license terms. |
24 | */ | |
25 | ||
55d85d5a | 26 | /* |
93e28d66 | 27 | * Copyright (c) 2012, 2019 by Delphix. All rights reserved. |
55d85d5a GW |
28 | */ |
29 | ||
34dc7c2f BB |
30 | #ifndef _SYS_SPACE_MAP_H |
31 | #define _SYS_SPACE_MAP_H | |
32 | ||
34dc7c2f | 33 | #include <sys/avl.h> |
93cf2076 | 34 | #include <sys/range_tree.h> |
34dc7c2f BB |
35 | #include <sys/dmu.h> |
36 | ||
37 | #ifdef __cplusplus | |
38 | extern "C" { | |
39 | #endif | |
40 | ||
93cf2076 GW |
41 | /* |
42 | * The size of the space map object has increased to include a histogram. | |
43 | * The SPACE_MAP_SIZE_V0 designates the original size and is used to | |
44 | * maintain backward compatibility. | |
45 | */ | |
46 | #define SPACE_MAP_SIZE_V0 (3 * sizeof (uint64_t)) | |
f3a7f661 | 47 | #define SPACE_MAP_HISTOGRAM_SIZE 32 |
93cf2076 GW |
48 | |
49 | /* | |
50 | * The space_map_phys is the on-disk representation of the space map. | |
51 | * Consumers of space maps should never reference any of the members of this | |
52 | * structure directly. These members may only be updated in syncing context. | |
53 | * | |
54 | * Note the smp_object is no longer used but remains in the structure | |
55 | * for backward compatibility. | |
56 | */ | |
57 | typedef struct space_map_phys { | |
425d3237 SD |
58 | /* object number: not needed but kept for backwards compatibility */ |
59 | uint64_t smp_object; | |
60 | ||
61 | /* length of the object in bytes */ | |
62 | uint64_t smp_length; | |
63 | ||
64 | /* space allocated from the map */ | |
65 | int64_t smp_alloc; | |
66 | ||
67 | /* reserved */ | |
68 | uint64_t smp_pad[5]; | |
93cf2076 GW |
69 | |
70 | /* | |
71 | * The smp_histogram maintains a histogram of free regions. Each | |
72 | * bucket, smp_histogram[i], contains the number of free regions | |
73 | * whose size is: | |
74 | * 2^(i+sm_shift) <= size of free region in bytes < 2^(i+sm_shift+1) | |
93e28d66 SD |
75 | * |
76 | * Note that, if log space map feature is enabled, histograms of | |
77 | * space maps that belong to metaslabs will take into account any | |
78 | * unflushed changes for their metaslabs, even though the actual | |
79 | * space map doesn't have entries for these changes. | |
93cf2076 | 80 | */ |
f3a7f661 | 81 | uint64_t smp_histogram[SPACE_MAP_HISTOGRAM_SIZE]; |
93cf2076 | 82 | } space_map_phys_t; |
34dc7c2f | 83 | |
93cf2076 GW |
84 | /* |
85 | * The space map object defines a region of space, its size, how much is | |
86 | * allocated, and the on-disk object that stores this information. | |
87 | * Consumers of space maps may only access the members of this structure. | |
a1d477c2 MA |
88 | * |
89 | * Note: the space_map may not be accessed concurrently; consumers | |
90 | * must provide external locking if required. | |
93cf2076 | 91 | */ |
34dc7c2f | 92 | typedef struct space_map { |
34dc7c2f BB |
93 | uint64_t sm_start; /* start of map */ |
94 | uint64_t sm_size; /* size of map */ | |
95 | uint8_t sm_shift; /* unit shift */ | |
93cf2076 GW |
96 | objset_t *sm_os; /* objset for this map */ |
97 | uint64_t sm_object; /* object id for this map */ | |
98 | uint32_t sm_blksz; /* block size for space map */ | |
99 | dmu_buf_t *sm_dbuf; /* space_map_phys_t dbuf */ | |
100 | space_map_phys_t *sm_phys; /* on-disk space map */ | |
34dc7c2f BB |
101 | } space_map_t; |
102 | ||
34dc7c2f BB |
103 | /* |
104 | * debug entry | |
105 | * | |
4d044c4c SD |
106 | * 2 2 10 50 |
107 | * +-----+-----+------------+----------------------------------+ | |
108 | * | 1 0 | act | syncpass | txg (lower bits) | | |
109 | * +-----+-----+------------+----------------------------------+ | |
110 | * 63 62 61 60 59 50 49 0 | |
34dc7c2f BB |
111 | * |
112 | * | |
4d044c4c | 113 | * one-word entry |
34dc7c2f BB |
114 | * |
115 | * 1 47 1 15 | |
4d044c4c | 116 | * +-----------------------------------------------------------+ |
34dc7c2f | 117 | * | 0 | offset (sm_shift units) | type | run | |
4d044c4c SD |
118 | * +-----------------------------------------------------------+ |
119 | * 63 62 16 15 14 0 | |
120 | * | |
121 | * | |
122 | * two-word entry | |
123 | * | |
124 | * 2 2 36 24 | |
125 | * +-----+-----+---------------------------+-------------------+ | |
126 | * | 1 1 | pad | run | vdev | | |
127 | * +-----+-----+---------------------------+-------------------+ | |
128 | * 63 62 61 60 59 24 23 0 | |
129 | * | |
130 | * 1 63 | |
131 | * +------+----------------------------------------------------+ | |
132 | * | type | offset | | |
133 | * +------+----------------------------------------------------+ | |
134 | * 63 62 0 | |
135 | * | |
136 | * Note that a two-word entry will not straddle a block boundary. | |
137 | * If necessary, the last word of a block will be padded with a | |
138 | * debug entry (with act = syncpass = txg = 0). | |
34dc7c2f BB |
139 | */ |
140 | ||
4d044c4c SD |
141 | typedef enum { |
142 | SM_ALLOC, | |
143 | SM_FREE | |
144 | } maptype_t; | |
145 | ||
146 | typedef struct space_map_entry { | |
147 | maptype_t sme_type; | |
148 | uint32_t sme_vdev; /* max is 2^24-1; SM_NO_VDEVID if not present */ | |
149 | uint64_t sme_offset; /* max is 2^63-1; units of sm_shift */ | |
150 | uint64_t sme_run; /* max is 2^36; units of sm_shift */ | |
6774931d MA |
151 | |
152 | /* | |
153 | * The following fields are not part of the actual space map entry | |
154 | * on-disk and they are populated with the values from the debug | |
155 | * entry most recently visited starting from the beginning to the | |
156 | * end of the space map. | |
157 | */ | |
158 | uint64_t sme_txg; | |
159 | uint64_t sme_sync_pass; | |
4d044c4c SD |
160 | } space_map_entry_t; |
161 | ||
162 | #define SM_NO_VDEVID (1 << SPA_VDEVBITS) | |
34dc7c2f | 163 | |
4d044c4c SD |
164 | /* one-word entry constants */ |
165 | #define SM_DEBUG_PREFIX 2 | |
166 | #define SM_OFFSET_BITS 47 | |
167 | #define SM_RUN_BITS 15 | |
34dc7c2f | 168 | |
4d044c4c SD |
169 | /* two-word entry constants */ |
170 | #define SM2_PREFIX 3 | |
171 | #define SM2_OFFSET_BITS 63 | |
172 | #define SM2_RUN_BITS 36 | |
173 | ||
174 | #define SM_PREFIX_DECODE(x) BF64_DECODE(x, 62, 2) | |
175 | #define SM_PREFIX_ENCODE(x) BF64_ENCODE(x, 62, 2) | |
176 | ||
177 | #define SM_DEBUG_ACTION_DECODE(x) BF64_DECODE(x, 60, 2) | |
178 | #define SM_DEBUG_ACTION_ENCODE(x) BF64_ENCODE(x, 60, 2) | |
34dc7c2f BB |
179 | #define SM_DEBUG_SYNCPASS_DECODE(x) BF64_DECODE(x, 50, 10) |
180 | #define SM_DEBUG_SYNCPASS_ENCODE(x) BF64_ENCODE(x, 50, 10) | |
34dc7c2f BB |
181 | #define SM_DEBUG_TXG_DECODE(x) BF64_DECODE(x, 0, 50) |
182 | #define SM_DEBUG_TXG_ENCODE(x) BF64_ENCODE(x, 0, 50) | |
183 | ||
4d044c4c SD |
184 | #define SM_OFFSET_DECODE(x) BF64_DECODE(x, 16, SM_OFFSET_BITS) |
185 | #define SM_OFFSET_ENCODE(x) BF64_ENCODE(x, 16, SM_OFFSET_BITS) | |
186 | #define SM_TYPE_DECODE(x) BF64_DECODE(x, 15, 1) | |
187 | #define SM_TYPE_ENCODE(x) BF64_ENCODE(x, 15, 1) | |
188 | #define SM_RUN_DECODE(x) (BF64_DECODE(x, 0, SM_RUN_BITS) + 1) | |
189 | #define SM_RUN_ENCODE(x) BF64_ENCODE((x) - 1, 0, SM_RUN_BITS) | |
190 | #define SM_RUN_MAX SM_RUN_DECODE(~0ULL) | |
191 | #define SM_OFFSET_MAX SM_OFFSET_DECODE(~0ULL) | |
192 | ||
193 | #define SM2_RUN_DECODE(x) (BF64_DECODE(x, SPA_VDEVBITS, SM2_RUN_BITS) + 1) | |
194 | #define SM2_RUN_ENCODE(x) BF64_ENCODE((x) - 1, SPA_VDEVBITS, SM2_RUN_BITS) | |
195 | #define SM2_VDEV_DECODE(x) BF64_DECODE(x, 0, SPA_VDEVBITS) | |
196 | #define SM2_VDEV_ENCODE(x) BF64_ENCODE(x, 0, SPA_VDEVBITS) | |
197 | #define SM2_TYPE_DECODE(x) BF64_DECODE(x, SM2_OFFSET_BITS, 1) | |
198 | #define SM2_TYPE_ENCODE(x) BF64_ENCODE(x, SM2_OFFSET_BITS, 1) | |
199 | #define SM2_OFFSET_DECODE(x) BF64_DECODE(x, 0, SM2_OFFSET_BITS) | |
200 | #define SM2_OFFSET_ENCODE(x) BF64_ENCODE(x, 0, SM2_OFFSET_BITS) | |
201 | #define SM2_RUN_MAX SM2_RUN_DECODE(~0ULL) | |
202 | #define SM2_OFFSET_MAX SM2_OFFSET_DECODE(~0ULL) | |
203 | ||
204 | boolean_t sm_entry_is_debug(uint64_t e); | |
205 | boolean_t sm_entry_is_single_word(uint64_t e); | |
206 | boolean_t sm_entry_is_double_word(uint64_t e); | |
207 | ||
208 | typedef int (*sm_cb_t)(space_map_entry_t *sme, void *arg); | |
a1d477c2 | 209 | |
93cf2076 | 210 | int space_map_load(space_map_t *sm, range_tree_t *rt, maptype_t maptype); |
425d3237 SD |
211 | int space_map_load_length(space_map_t *sm, range_tree_t *rt, maptype_t maptype, |
212 | uint64_t length); | |
213 | int space_map_iterate(space_map_t *sm, uint64_t length, | |
214 | sm_cb_t callback, void *arg); | |
d2734cce SD |
215 | int space_map_incremental_destroy(space_map_t *sm, sm_cb_t callback, void *arg, |
216 | dmu_tx_t *tx); | |
93cf2076 | 217 | |
928e8ad4 | 218 | boolean_t space_map_histogram_verify(space_map_t *sm, range_tree_t *rt); |
93cf2076 GW |
219 | void space_map_histogram_clear(space_map_t *sm); |
220 | void space_map_histogram_add(space_map_t *sm, range_tree_t *rt, | |
221 | dmu_tx_t *tx); | |
222 | ||
93cf2076 | 223 | uint64_t space_map_object(space_map_t *sm); |
425d3237 | 224 | int64_t space_map_allocated(space_map_t *sm); |
93cf2076 | 225 | uint64_t space_map_length(space_map_t *sm); |
93e28d66 SD |
226 | uint64_t space_map_entries(space_map_t *sm, range_tree_t *rt); |
227 | uint64_t space_map_nblocks(space_map_t *sm); | |
93cf2076 GW |
228 | |
229 | void space_map_write(space_map_t *sm, range_tree_t *rt, maptype_t maptype, | |
4d044c4c SD |
230 | uint64_t vdev_id, dmu_tx_t *tx); |
231 | uint64_t space_map_estimate_optimal_size(space_map_t *sm, range_tree_t *rt, | |
232 | uint64_t vdev_id); | |
d2734cce SD |
233 | void space_map_truncate(space_map_t *sm, int blocksize, dmu_tx_t *tx); |
234 | uint64_t space_map_alloc(objset_t *os, int blocksize, dmu_tx_t *tx); | |
93cf2076 | 235 | void space_map_free(space_map_t *sm, dmu_tx_t *tx); |
a1d477c2 | 236 | void space_map_free_obj(objset_t *os, uint64_t smobj, dmu_tx_t *tx); |
93cf2076 GW |
237 | |
238 | int space_map_open(space_map_t **smp, objset_t *os, uint64_t object, | |
a1d477c2 | 239 | uint64_t start, uint64_t size, uint8_t shift); |
93cf2076 GW |
240 | void space_map_close(space_map_t *sm); |
241 | ||
34dc7c2f BB |
242 | #ifdef __cplusplus |
243 | } | |
244 | #endif | |
245 | ||
246 | #endif /* _SYS_SPACE_MAP_H */ |