]>
Commit | Line | Data |
---|---|---|
fb8e5b4c KO |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | ||
3 | #include "bcachefs.h" | |
27c15ed2 | 4 | #include "btree_cache.h" |
fb8e5b4c | 5 | #include "disk_groups.h" |
40f7914e | 6 | #include "opts.h" |
fb8e5b4c KO |
7 | #include "replicas.h" |
8 | #include "sb-members.h" | |
9 | #include "super-io.h" | |
10 | ||
94119eeb KO |
11 | #define x(t, n, ...) [n] = #t, |
12 | static const char * const bch2_iops_measurements[] = { | |
13 | BCH_IOPS_MEASUREMENTS() | |
14 | NULL | |
15 | }; | |
16 | ||
17 | char * const bch2_member_error_strs[] = { | |
18 | BCH_MEMBER_ERROR_TYPES() | |
19 | NULL | |
20 | }; | |
21 | #undef x | |
22 | ||
9af26120 | 23 | /* Code for bch_sb_field_members_v1: */ |
3f7b9713 | 24 | |
3f7b9713 HS |
25 | struct bch_member *bch2_members_v2_get_mut(struct bch_sb *sb, int i) |
26 | { | |
0f0fc312 | 27 | return __bch2_members_v2_get_mut(bch2_sb_field_get(sb, members_v2), i); |
3f7b9713 HS |
28 | } |
29 | ||
30 | static struct bch_member members_v2_get(struct bch_sb_field_members_v2 *mi, int i) | |
31 | { | |
0f0fc312 | 32 | struct bch_member ret, *p = __bch2_members_v2_get_mut(mi, i); |
3f7b9713 HS |
33 | memset(&ret, 0, sizeof(ret)); |
34 | memcpy(&ret, p, min_t(size_t, le16_to_cpu(mi->member_bytes), sizeof(ret))); | |
35 | return ret; | |
36 | } | |
37 | ||
9af26120 | 38 | static struct bch_member *members_v1_get_mut(struct bch_sb_field_members_v1 *mi, int i) |
1241df58 | 39 | { |
3f7b9713 | 40 | return (void *) mi->_members + (i * BCH_MEMBER_V1_BYTES); |
1241df58 HS |
41 | } |
42 | ||
9af26120 | 43 | static struct bch_member members_v1_get(struct bch_sb_field_members_v1 *mi, int i) |
1241df58 HS |
44 | { |
45 | struct bch_member ret, *p = members_v1_get_mut(mi, i); | |
46 | memset(&ret, 0, sizeof(ret)); | |
5c1ab40e KO |
47 | memcpy(&ret, p, min_t(size_t, BCH_MEMBER_V1_BYTES, sizeof(ret))); |
48 | return ret; | |
1241df58 HS |
49 | } |
50 | ||
51 | struct bch_member bch2_sb_member_get(struct bch_sb *sb, int i) | |
52 | { | |
4637429e | 53 | struct bch_sb_field_members_v2 *mi2 = bch2_sb_field_get(sb, members_v2); |
3f7b9713 HS |
54 | if (mi2) |
55 | return members_v2_get(mi2, i); | |
4637429e | 56 | struct bch_sb_field_members_v1 *mi1 = bch2_sb_field_get(sb, members_v1); |
1241df58 HS |
57 | return members_v1_get(mi1, i); |
58 | } | |
fb8e5b4c | 59 | |
3f7b9713 HS |
60 | static int sb_members_v2_resize_entries(struct bch_fs *c) |
61 | { | |
4637429e | 62 | struct bch_sb_field_members_v2 *mi = bch2_sb_field_get(c->disk_sb.sb, members_v2); |
3f7b9713 HS |
63 | |
64 | if (le16_to_cpu(mi->member_bytes) < sizeof(struct bch_member)) { | |
65 | unsigned u64s = DIV_ROUND_UP((sizeof(*mi) + sizeof(mi->_members[0]) * | |
66 | c->disk_sb.sb->nr_devices), 8); | |
67 | ||
4637429e | 68 | mi = bch2_sb_field_resize(&c->disk_sb, members_v2, u64s); |
3f7b9713 HS |
69 | if (!mi) |
70 | return -BCH_ERR_ENOSPC_sb_members_v2; | |
71 | ||
72 | for (int i = c->disk_sb.sb->nr_devices - 1; i >= 0; --i) { | |
73 | void *dst = (void *) mi->_members + (i * sizeof(struct bch_member)); | |
0f0fc312 | 74 | memmove(dst, __bch2_members_v2_get_mut(mi, i), le16_to_cpu(mi->member_bytes)); |
3f7b9713 HS |
75 | memset(dst + le16_to_cpu(mi->member_bytes), |
76 | 0, (sizeof(struct bch_member) - le16_to_cpu(mi->member_bytes))); | |
77 | } | |
78 | mi->member_bytes = cpu_to_le16(sizeof(struct bch_member)); | |
79 | } | |
80 | return 0; | |
81 | } | |
82 | ||
f5d26fa3 | 83 | int bch2_sb_members_v2_init(struct bch_fs *c) |
3f7b9713 | 84 | { |
9af26120 | 85 | struct bch_sb_field_members_v1 *mi1; |
3f7b9713 HS |
86 | struct bch_sb_field_members_v2 *mi2; |
87 | ||
4637429e KO |
88 | if (!bch2_sb_field_get(c->disk_sb.sb, members_v2)) { |
89 | mi2 = bch2_sb_field_resize(&c->disk_sb, members_v2, | |
3f7b9713 HS |
90 | DIV_ROUND_UP(sizeof(*mi2) + |
91 | sizeof(struct bch_member) * c->sb.nr_devices, | |
92 | sizeof(u64))); | |
4637429e | 93 | mi1 = bch2_sb_field_get(c->disk_sb.sb, members_v1); |
3f7b9713 HS |
94 | memcpy(&mi2->_members[0], &mi1->_members[0], |
95 | BCH_MEMBER_V1_BYTES * c->sb.nr_devices); | |
96 | memset(&mi2->pad[0], 0, sizeof(mi2->pad)); | |
97 | mi2->member_bytes = cpu_to_le16(BCH_MEMBER_V1_BYTES); | |
98 | } | |
99 | ||
100 | return sb_members_v2_resize_entries(c); | |
101 | } | |
102 | ||
94119eeb | 103 | int bch2_sb_members_cpy_v2_v1(struct bch_sb_handle *disk_sb) |
3f7b9713 | 104 | { |
9af26120 | 105 | struct bch_sb_field_members_v1 *mi1; |
3f7b9713 HS |
106 | struct bch_sb_field_members_v2 *mi2; |
107 | ||
4637429e | 108 | mi1 = bch2_sb_field_resize(disk_sb, members_v1, |
3f7b9713 HS |
109 | DIV_ROUND_UP(sizeof(*mi1) + BCH_MEMBER_V1_BYTES * |
110 | disk_sb->sb->nr_devices, sizeof(u64))); | |
111 | if (!mi1) | |
112 | return -BCH_ERR_ENOSPC_sb_members; | |
113 | ||
4637429e | 114 | mi2 = bch2_sb_field_get(disk_sb->sb, members_v2); |
3f7b9713 HS |
115 | |
116 | for (unsigned i = 0; i < disk_sb->sb->nr_devices; i++) | |
0f0fc312 | 117 | memcpy(members_v1_get_mut(mi1, i), __bch2_members_v2_get_mut(mi2, i), BCH_MEMBER_V1_BYTES); |
3f7b9713 HS |
118 | |
119 | return 0; | |
120 | } | |
121 | ||
122 | static int validate_member(struct printbuf *err, | |
123 | struct bch_member m, | |
124 | struct bch_sb *sb, | |
125 | int i) | |
126 | { | |
127 | if (le64_to_cpu(m.nbuckets) > LONG_MAX) { | |
128 | prt_printf(err, "device %u: too many buckets (got %llu, max %lu)", | |
129 | i, le64_to_cpu(m.nbuckets), LONG_MAX); | |
130 | return -BCH_ERR_invalid_sb_members; | |
131 | } | |
132 | ||
133 | if (le64_to_cpu(m.nbuckets) - | |
134 | le16_to_cpu(m.first_bucket) < BCH_MIN_NR_NBUCKETS) { | |
135 | prt_printf(err, "device %u: not enough buckets (got %llu, max %u)", | |
136 | i, le64_to_cpu(m.nbuckets), BCH_MIN_NR_NBUCKETS); | |
137 | return -BCH_ERR_invalid_sb_members; | |
138 | } | |
139 | ||
140 | if (le16_to_cpu(m.bucket_size) < | |
141 | le16_to_cpu(sb->block_size)) { | |
142 | prt_printf(err, "device %u: bucket size %u smaller than block size %u", | |
143 | i, le16_to_cpu(m.bucket_size), le16_to_cpu(sb->block_size)); | |
144 | return -BCH_ERR_invalid_sb_members; | |
145 | } | |
146 | ||
147 | if (le16_to_cpu(m.bucket_size) < | |
148 | BCH_SB_BTREE_NODE_SIZE(sb)) { | |
149 | prt_printf(err, "device %u: bucket size %u smaller than btree node size %llu", | |
150 | i, le16_to_cpu(m.bucket_size), BCH_SB_BTREE_NODE_SIZE(sb)); | |
151 | return -BCH_ERR_invalid_sb_members; | |
152 | } | |
153 | ||
154 | return 0; | |
155 | } | |
156 | ||
157 | static void member_to_text(struct printbuf *out, | |
158 | struct bch_member m, | |
159 | struct bch_sb_field_disk_groups *gi, | |
160 | struct bch_sb *sb, | |
161 | int i) | |
162 | { | |
163 | unsigned data_have = bch2_sb_dev_has_data(sb, i); | |
164 | u64 bucket_size = le16_to_cpu(m.bucket_size); | |
165 | u64 device_size = le64_to_cpu(m.nbuckets) * bucket_size; | |
166 | ||
dc7a15fb KO |
167 | if (!bch2_member_exists(&m)) |
168 | return; | |
169 | ||
3f7b9713 HS |
170 | prt_printf(out, "Device:"); |
171 | prt_tab(out); | |
172 | prt_printf(out, "%u", i); | |
173 | prt_newline(out); | |
174 | ||
175 | printbuf_indent_add(out, 2); | |
176 | ||
94119eeb KO |
177 | prt_printf(out, "Label:"); |
178 | prt_tab(out); | |
179 | if (BCH_MEMBER_GROUP(&m)) { | |
180 | unsigned idx = BCH_MEMBER_GROUP(&m) - 1; | |
181 | ||
182 | if (idx < disk_groups_nr(gi)) | |
183 | prt_printf(out, "%s (%u)", | |
184 | gi->entries[idx].label, idx); | |
185 | else | |
186 | prt_printf(out, "(bad disk labels section)"); | |
187 | } else { | |
188 | prt_printf(out, "(none)"); | |
189 | } | |
190 | prt_newline(out); | |
191 | ||
3f7b9713 HS |
192 | prt_printf(out, "UUID:"); |
193 | prt_tab(out); | |
194 | pr_uuid(out, m.uuid.b); | |
195 | prt_newline(out); | |
196 | ||
197 | prt_printf(out, "Size:"); | |
198 | prt_tab(out); | |
199 | prt_units_u64(out, device_size << 9); | |
200 | prt_newline(out); | |
201 | ||
94119eeb KO |
202 | for (unsigned i = 0; i < BCH_MEMBER_ERROR_NR; i++) { |
203 | prt_printf(out, "%s errors:", bch2_member_error_strs[i]); | |
204 | prt_tab(out); | |
205 | prt_u64(out, le64_to_cpu(m.errors[i])); | |
206 | prt_newline(out); | |
207 | } | |
208 | ||
40f7914e HS |
209 | for (unsigned i = 0; i < BCH_IOPS_NR; i++) { |
210 | prt_printf(out, "%s iops:", bch2_iops_measurements[i]); | |
211 | prt_tab(out); | |
212 | prt_printf(out, "%u", le32_to_cpu(m.iops[i])); | |
213 | prt_newline(out); | |
214 | } | |
215 | ||
3f7b9713 HS |
216 | prt_printf(out, "Bucket size:"); |
217 | prt_tab(out); | |
218 | prt_units_u64(out, bucket_size << 9); | |
219 | prt_newline(out); | |
220 | ||
221 | prt_printf(out, "First bucket:"); | |
222 | prt_tab(out); | |
223 | prt_printf(out, "%u", le16_to_cpu(m.first_bucket)); | |
224 | prt_newline(out); | |
225 | ||
226 | prt_printf(out, "Buckets:"); | |
227 | prt_tab(out); | |
228 | prt_printf(out, "%llu", le64_to_cpu(m.nbuckets)); | |
229 | prt_newline(out); | |
230 | ||
231 | prt_printf(out, "Last mount:"); | |
232 | prt_tab(out); | |
233 | if (m.last_mount) | |
59154f2c | 234 | bch2_prt_datetime(out, le64_to_cpu(m.last_mount)); |
3f7b9713 HS |
235 | else |
236 | prt_printf(out, "(never)"); | |
237 | prt_newline(out); | |
6b00de06 KO |
238 | |
239 | prt_printf(out, "Last superblock write:"); | |
240 | prt_tab(out); | |
241 | prt_u64(out, le64_to_cpu(m.seq)); | |
242 | prt_newline(out); | |
3f7b9713 HS |
243 | |
244 | prt_printf(out, "State:"); | |
245 | prt_tab(out); | |
246 | prt_printf(out, "%s", | |
247 | BCH_MEMBER_STATE(&m) < BCH_MEMBER_STATE_NR | |
248 | ? bch2_member_states[BCH_MEMBER_STATE(&m)] | |
249 | : "unknown"); | |
250 | prt_newline(out); | |
251 | ||
3f7b9713 HS |
252 | prt_printf(out, "Data allowed:"); |
253 | prt_tab(out); | |
254 | if (BCH_MEMBER_DATA_ALLOWED(&m)) | |
e58f963c | 255 | prt_bitflags(out, __bch2_data_types, BCH_MEMBER_DATA_ALLOWED(&m)); |
3f7b9713 HS |
256 | else |
257 | prt_printf(out, "(none)"); | |
258 | prt_newline(out); | |
259 | ||
260 | prt_printf(out, "Has data:"); | |
261 | prt_tab(out); | |
262 | if (data_have) | |
e58f963c | 263 | prt_bitflags(out, __bch2_data_types, data_have); |
3f7b9713 HS |
264 | else |
265 | prt_printf(out, "(none)"); | |
266 | prt_newline(out); | |
267 | ||
d05db127 KO |
268 | prt_str(out, "Durability:"); |
269 | prt_tab(out); | |
f60250de | 270 | prt_printf(out, "%llu", BCH_MEMBER_DURABILITY(&m) ? BCH_MEMBER_DURABILITY(&m) - 1 : 1); |
d05db127 KO |
271 | prt_newline(out); |
272 | ||
3f7b9713 HS |
273 | prt_printf(out, "Discard:"); |
274 | prt_tab(out); | |
275 | prt_printf(out, "%llu", BCH_MEMBER_DISCARD(&m)); | |
276 | prt_newline(out); | |
277 | ||
278 | prt_printf(out, "Freespace initialized:"); | |
279 | prt_tab(out); | |
280 | prt_printf(out, "%llu", BCH_MEMBER_FREESPACE_INITIALIZED(&m)); | |
281 | prt_newline(out); | |
282 | ||
283 | printbuf_indent_sub(out, 2); | |
284 | } | |
285 | ||
286 | static int bch2_sb_members_v1_validate(struct bch_sb *sb, | |
fb8e5b4c KO |
287 | struct bch_sb_field *f, |
288 | struct printbuf *err) | |
289 | { | |
9af26120 | 290 | struct bch_sb_field_members_v1 *mi = field_to_type(f, members_v1); |
fb8e5b4c KO |
291 | unsigned i; |
292 | ||
5c1ab40e | 293 | if ((void *) members_v1_get_mut(mi, sb->nr_devices) > vstruct_end(&mi->field)) { |
fb8e5b4c KO |
294 | prt_printf(err, "too many devices for section size"); |
295 | return -BCH_ERR_invalid_sb_members; | |
296 | } | |
297 | ||
298 | for (i = 0; i < sb->nr_devices; i++) { | |
3f7b9713 | 299 | struct bch_member m = members_v1_get(mi, i); |
fb8e5b4c | 300 | |
3f7b9713 HS |
301 | int ret = validate_member(err, m, sb, i); |
302 | if (ret) | |
303 | return ret; | |
fb8e5b4c KO |
304 | } |
305 | ||
306 | return 0; | |
307 | } | |
308 | ||
3f7b9713 HS |
309 | static void bch2_sb_members_v1_to_text(struct printbuf *out, struct bch_sb *sb, |
310 | struct bch_sb_field *f) | |
fb8e5b4c | 311 | { |
9af26120 | 312 | struct bch_sb_field_members_v1 *mi = field_to_type(f, members_v1); |
4637429e | 313 | struct bch_sb_field_disk_groups *gi = bch2_sb_field_get(sb, disk_groups); |
fb8e5b4c KO |
314 | unsigned i; |
315 | ||
dc7a15fb KO |
316 | for (i = 0; i < sb->nr_devices; i++) |
317 | member_to_text(out, members_v1_get(mi, i), gi, sb, i); | |
3f7b9713 | 318 | } |
fb8e5b4c | 319 | |
9af26120 | 320 | const struct bch_sb_field_ops bch_sb_field_ops_members_v1 = { |
3f7b9713 HS |
321 | .validate = bch2_sb_members_v1_validate, |
322 | .to_text = bch2_sb_members_v1_to_text, | |
323 | }; | |
fb8e5b4c | 324 | |
3f7b9713 HS |
325 | static void bch2_sb_members_v2_to_text(struct printbuf *out, struct bch_sb *sb, |
326 | struct bch_sb_field *f) | |
327 | { | |
328 | struct bch_sb_field_members_v2 *mi = field_to_type(f, members_v2); | |
4637429e | 329 | struct bch_sb_field_disk_groups *gi = bch2_sb_field_get(sb, disk_groups); |
3f7b9713 | 330 | unsigned i; |
fb8e5b4c | 331 | |
dc7a15fb KO |
332 | for (i = 0; i < sb->nr_devices; i++) |
333 | member_to_text(out, members_v2_get(mi, i), gi, sb, i); | |
3f7b9713 HS |
334 | } |
335 | ||
336 | static int bch2_sb_members_v2_validate(struct bch_sb *sb, | |
337 | struct bch_sb_field *f, | |
338 | struct printbuf *err) | |
339 | { | |
340 | struct bch_sb_field_members_v2 *mi = field_to_type(f, members_v2); | |
0f0fc312 | 341 | size_t mi_bytes = (void *) __bch2_members_v2_get_mut(mi, sb->nr_devices) - |
3f7b9713 | 342 | (void *) mi; |
fb8e5b4c | 343 | |
3f7b9713 HS |
344 | if (mi_bytes > vstruct_bytes(&mi->field)) { |
345 | prt_printf(err, "section too small (%zu > %zu)", | |
346 | mi_bytes, vstruct_bytes(&mi->field)); | |
347 | return -BCH_ERR_invalid_sb_members; | |
348 | } | |
fb8e5b4c | 349 | |
3f7b9713 HS |
350 | for (unsigned i = 0; i < sb->nr_devices; i++) { |
351 | int ret = validate_member(err, members_v2_get(mi, i), sb, i); | |
352 | if (ret) | |
353 | return ret; | |
fb8e5b4c | 354 | } |
3f7b9713 HS |
355 | |
356 | return 0; | |
fb8e5b4c KO |
357 | } |
358 | ||
3f7b9713 HS |
359 | const struct bch_sb_field_ops bch_sb_field_ops_members_v2 = { |
360 | .validate = bch2_sb_members_v2_validate, | |
361 | .to_text = bch2_sb_members_v2_to_text, | |
fb8e5b4c | 362 | }; |
94119eeb KO |
363 | |
364 | void bch2_sb_members_from_cpu(struct bch_fs *c) | |
365 | { | |
366 | struct bch_sb_field_members_v2 *mi = bch2_sb_field_get(c->disk_sb.sb, members_v2); | |
94119eeb KO |
367 | |
368 | rcu_read_lock(); | |
41b84fb4 KO |
369 | for_each_member_device_rcu(c, ca, NULL) { |
370 | struct bch_member *m = __bch2_members_v2_get_mut(mi, ca->dev_idx); | |
94119eeb | 371 | |
41b84fb4 | 372 | for (unsigned e = 0; e < BCH_MEMBER_ERROR_NR; e++) |
94119eeb KO |
373 | m->errors[e] = cpu_to_le64(atomic64_read(&ca->errors[e])); |
374 | } | |
375 | rcu_read_unlock(); | |
376 | } | |
377 | ||
378 | void bch2_dev_io_errors_to_text(struct printbuf *out, struct bch_dev *ca) | |
379 | { | |
380 | struct bch_fs *c = ca->fs; | |
381 | struct bch_member m; | |
382 | ||
383 | mutex_lock(&ca->fs->sb_lock); | |
384 | m = bch2_sb_member_get(c->disk_sb.sb, ca->dev_idx); | |
385 | mutex_unlock(&ca->fs->sb_lock); | |
386 | ||
387 | printbuf_tabstop_push(out, 12); | |
388 | ||
389 | prt_str(out, "IO errors since filesystem creation"); | |
390 | prt_newline(out); | |
391 | ||
392 | printbuf_indent_add(out, 2); | |
393 | for (unsigned i = 0; i < BCH_MEMBER_ERROR_NR; i++) { | |
394 | prt_printf(out, "%s:", bch2_member_error_strs[i]); | |
395 | prt_tab(out); | |
396 | prt_u64(out, atomic64_read(&ca->errors[i])); | |
397 | prt_newline(out); | |
398 | } | |
399 | printbuf_indent_sub(out, 2); | |
400 | ||
401 | prt_str(out, "IO errors since "); | |
402 | bch2_pr_time_units(out, (ktime_get_real_seconds() - le64_to_cpu(m.errors_reset_time)) * NSEC_PER_SEC); | |
403 | prt_str(out, " ago"); | |
404 | prt_newline(out); | |
405 | ||
406 | printbuf_indent_add(out, 2); | |
407 | for (unsigned i = 0; i < BCH_MEMBER_ERROR_NR; i++) { | |
408 | prt_printf(out, "%s:", bch2_member_error_strs[i]); | |
409 | prt_tab(out); | |
410 | prt_u64(out, atomic64_read(&ca->errors[i]) - le64_to_cpu(m.errors_at_reset[i])); | |
411 | prt_newline(out); | |
412 | } | |
413 | printbuf_indent_sub(out, 2); | |
414 | } | |
415 | ||
416 | void bch2_dev_errors_reset(struct bch_dev *ca) | |
417 | { | |
418 | struct bch_fs *c = ca->fs; | |
419 | struct bch_member *m; | |
420 | ||
421 | mutex_lock(&c->sb_lock); | |
422 | m = bch2_members_v2_get_mut(c->disk_sb.sb, ca->dev_idx); | |
423 | for (unsigned i = 0; i < ARRAY_SIZE(m->errors_at_reset); i++) | |
424 | m->errors_at_reset[i] = cpu_to_le64(atomic64_read(&ca->errors[i])); | |
04eb5793 | 425 | m->errors_reset_time = cpu_to_le64(ktime_get_real_seconds()); |
94119eeb KO |
426 | |
427 | bch2_write_super(c); | |
428 | mutex_unlock(&c->sb_lock); | |
429 | } | |
27c15ed2 KO |
430 | |
431 | /* | |
432 | * Per member "range has btree nodes" bitmap: | |
433 | * | |
434 | * This is so that if we ever have to run the btree node scan to repair we don't | |
435 | * have to scan full devices: | |
436 | */ | |
437 | ||
438 | bool bch2_dev_btree_bitmap_marked(struct bch_fs *c, struct bkey_s_c k) | |
439 | { | |
440 | bkey_for_each_ptr(bch2_bkey_ptrs_c(k), ptr) | |
441 | if (!bch2_dev_btree_bitmap_marked_sectors(bch_dev_bkey_exists(c, ptr->dev), | |
442 | ptr->offset, btree_sectors(c))) | |
443 | return false; | |
444 | return true; | |
445 | } | |
446 | ||
447 | static void __bch2_dev_btree_bitmap_mark(struct bch_sb_field_members_v2 *mi, unsigned dev, | |
448 | u64 start, unsigned sectors) | |
449 | { | |
450 | struct bch_member *m = __bch2_members_v2_get_mut(mi, dev); | |
451 | u64 bitmap = le64_to_cpu(m->btree_allocated_bitmap); | |
452 | ||
453 | u64 end = start + sectors; | |
454 | ||
455 | int resize = ilog2(roundup_pow_of_two(end)) - (m->btree_bitmap_shift + 6); | |
456 | if (resize > 0) { | |
457 | u64 new_bitmap = 0; | |
458 | ||
459 | for (unsigned i = 0; i < 64; i++) | |
460 | if (bitmap & BIT_ULL(i)) | |
461 | new_bitmap |= BIT_ULL(i >> resize); | |
462 | bitmap = new_bitmap; | |
463 | m->btree_bitmap_shift += resize; | |
464 | } | |
465 | ||
fa845c73 KO |
466 | for (unsigned bit = start >> m->btree_bitmap_shift; |
467 | (u64) bit << m->btree_bitmap_shift < end; | |
27c15ed2 KO |
468 | bit++) |
469 | bitmap |= BIT_ULL(bit); | |
470 | ||
471 | m->btree_allocated_bitmap = cpu_to_le64(bitmap); | |
472 | } | |
473 | ||
474 | void bch2_dev_btree_bitmap_mark(struct bch_fs *c, struct bkey_s_c k) | |
475 | { | |
476 | lockdep_assert_held(&c->sb_lock); | |
477 | ||
478 | struct bch_sb_field_members_v2 *mi = bch2_sb_field_get(c->disk_sb.sb, members_v2); | |
479 | bkey_for_each_ptr(bch2_bkey_ptrs_c(k), ptr) | |
480 | __bch2_dev_btree_bitmap_mark(mi, ptr->dev, ptr->offset, btree_sectors(c)); | |
481 | } |