1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (C) 2007 Oracle. All rights reserved. |
4 | */ |
5 | |
6 | #include "messages.h" |
7 | #include "ctree.h" |
8 | #include "disk-io.h" |
9 | #include "print-tree.h" |
10 | #include "accessors.h" |
11 | #include "tree-checker.h" |
12 | #include "volumes.h" |
13 | #include "raid-stripe-tree.h" |
14 | |
15 | struct root_name_map { |
16 | u64 id; |
17 | char name[16]; |
18 | }; |
19 | |
20 | static const struct root_name_map root_map[] = { |
21 | { BTRFS_ROOT_TREE_OBJECTID, "ROOT_TREE" }, |
22 | { BTRFS_EXTENT_TREE_OBJECTID, "EXTENT_TREE" }, |
23 | { BTRFS_CHUNK_TREE_OBJECTID, "CHUNK_TREE" }, |
24 | { BTRFS_DEV_TREE_OBJECTID, "DEV_TREE" }, |
25 | { BTRFS_FS_TREE_OBJECTID, "FS_TREE" }, |
26 | { BTRFS_CSUM_TREE_OBJECTID, "CSUM_TREE" }, |
27 | { BTRFS_TREE_LOG_OBJECTID, "TREE_LOG" }, |
28 | { BTRFS_QUOTA_TREE_OBJECTID, "QUOTA_TREE" }, |
29 | { BTRFS_UUID_TREE_OBJECTID, "UUID_TREE" }, |
30 | { BTRFS_FREE_SPACE_TREE_OBJECTID, "FREE_SPACE_TREE" }, |
31 | { BTRFS_BLOCK_GROUP_TREE_OBJECTID, "BLOCK_GROUP_TREE" }, |
32 | { BTRFS_DATA_RELOC_TREE_OBJECTID, "DATA_RELOC_TREE" }, |
33 | { BTRFS_RAID_STRIPE_TREE_OBJECTID, "RAID_STRIPE_TREE" }, |
34 | }; |
35 | |
36 | const char *btrfs_root_name(const struct btrfs_key *key, char *buf) |
37 | { |
38 | int i; |
39 | |
40 | if (key->objectid == BTRFS_TREE_RELOC_OBJECTID) { |
41 | snprintf(buf, BTRFS_ROOT_NAME_BUF_LEN, |
42 | fmt: "TREE_RELOC offset=%llu" , key->offset); |
43 | return buf; |
44 | } |
45 | |
46 | for (i = 0; i < ARRAY_SIZE(root_map); i++) { |
47 | if (root_map[i].id == key->objectid) |
48 | return root_map[i].name; |
49 | } |
50 | |
51 | snprintf(buf, BTRFS_ROOT_NAME_BUF_LEN, fmt: "%llu" , key->objectid); |
52 | return buf; |
53 | } |
54 | |
55 | static void print_chunk(const struct extent_buffer *eb, struct btrfs_chunk *chunk) |
56 | { |
57 | int num_stripes = btrfs_chunk_num_stripes(eb, s: chunk); |
58 | int i; |
59 | pr_info("\t\tchunk length %llu owner %llu type %llu num_stripes %d\n" , |
60 | btrfs_chunk_length(eb, chunk), btrfs_chunk_owner(eb, chunk), |
61 | btrfs_chunk_type(eb, chunk), num_stripes); |
62 | for (i = 0 ; i < num_stripes ; i++) { |
63 | pr_info("\t\t\tstripe %d devid %llu offset %llu\n" , i, |
64 | btrfs_stripe_devid_nr(eb, chunk, i), |
65 | btrfs_stripe_offset_nr(eb, chunk, i)); |
66 | } |
67 | } |
68 | static void print_dev_item(const struct extent_buffer *eb, |
69 | struct btrfs_dev_item *dev_item) |
70 | { |
71 | pr_info("\t\tdev item devid %llu total_bytes %llu bytes used %llu\n" , |
72 | btrfs_device_id(eb, dev_item), |
73 | btrfs_device_total_bytes(eb, dev_item), |
74 | btrfs_device_bytes_used(eb, dev_item)); |
75 | } |
76 | static void print_extent_data_ref(const struct extent_buffer *eb, |
77 | struct btrfs_extent_data_ref *ref) |
78 | { |
79 | pr_cont("extent data backref root %llu objectid %llu offset %llu count %u\n" , |
80 | btrfs_extent_data_ref_root(eb, ref), |
81 | btrfs_extent_data_ref_objectid(eb, ref), |
82 | btrfs_extent_data_ref_offset(eb, ref), |
83 | btrfs_extent_data_ref_count(eb, ref)); |
84 | } |
85 | |
86 | static void print_extent_owner_ref(const struct extent_buffer *eb, |
87 | const struct btrfs_extent_owner_ref *ref) |
88 | { |
89 | ASSERT(btrfs_fs_incompat(eb->fs_info, SIMPLE_QUOTA)); |
90 | pr_cont("extent data owner root %llu\n" , btrfs_extent_owner_ref_root_id(eb, ref)); |
91 | } |
92 | |
93 | static void print_extent_item(const struct extent_buffer *eb, int slot, int type) |
94 | { |
95 | struct btrfs_extent_item *ei; |
96 | struct btrfs_extent_inline_ref *iref; |
97 | struct btrfs_extent_data_ref *dref; |
98 | struct btrfs_shared_data_ref *sref; |
99 | struct btrfs_extent_owner_ref *oref; |
100 | struct btrfs_disk_key key; |
101 | unsigned long end; |
102 | unsigned long ptr; |
103 | u32 item_size = btrfs_item_size(eb, slot); |
104 | u64 flags; |
105 | u64 offset; |
106 | int ref_index = 0; |
107 | |
108 | if (unlikely(item_size < sizeof(*ei))) { |
109 | btrfs_err(eb->fs_info, |
110 | "unexpected extent item size, has %u expect >= %zu" , |
111 | item_size, sizeof(*ei)); |
112 | btrfs_handle_fs_error(eb->fs_info, -EUCLEAN, NULL); |
113 | } |
114 | |
115 | ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item); |
116 | flags = btrfs_extent_flags(eb, s: ei); |
117 | |
118 | pr_info("\t\textent refs %llu gen %llu flags %llu\n" , |
119 | btrfs_extent_refs(eb, ei), btrfs_extent_generation(eb, ei), |
120 | flags); |
121 | |
122 | if ((type == BTRFS_EXTENT_ITEM_KEY) && |
123 | flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) { |
124 | struct btrfs_tree_block_info *info; |
125 | info = (struct btrfs_tree_block_info *)(ei + 1); |
126 | btrfs_tree_block_key(eb, item: info, key: &key); |
127 | pr_info("\t\ttree block key (%llu %u %llu) level %d\n" , |
128 | btrfs_disk_key_objectid(&key), key.type, |
129 | btrfs_disk_key_offset(&key), |
130 | btrfs_tree_block_level(eb, info)); |
131 | iref = (struct btrfs_extent_inline_ref *)(info + 1); |
132 | } else { |
133 | iref = (struct btrfs_extent_inline_ref *)(ei + 1); |
134 | } |
135 | |
136 | ptr = (unsigned long)iref; |
137 | end = (unsigned long)ei + item_size; |
138 | while (ptr < end) { |
139 | iref = (struct btrfs_extent_inline_ref *)ptr; |
140 | type = btrfs_extent_inline_ref_type(eb, s: iref); |
141 | offset = btrfs_extent_inline_ref_offset(eb, s: iref); |
142 | pr_info("\t\tref#%d: " , ref_index++); |
143 | switch (type) { |
144 | case BTRFS_TREE_BLOCK_REF_KEY: |
145 | pr_cont("tree block backref root %llu\n" , offset); |
146 | break; |
147 | case BTRFS_SHARED_BLOCK_REF_KEY: |
148 | pr_cont("shared block backref parent %llu\n" , offset); |
149 | /* |
150 | * offset is supposed to be a tree block which |
151 | * must be aligned to nodesize. |
152 | */ |
153 | if (!IS_ALIGNED(offset, eb->fs_info->sectorsize)) |
154 | pr_info( |
155 | "\t\t\t(parent %llu not aligned to sectorsize %u)\n" , |
156 | offset, eb->fs_info->sectorsize); |
157 | break; |
158 | case BTRFS_EXTENT_DATA_REF_KEY: |
159 | dref = (struct btrfs_extent_data_ref *)(&iref->offset); |
160 | print_extent_data_ref(eb, ref: dref); |
161 | break; |
162 | case BTRFS_SHARED_DATA_REF_KEY: |
163 | sref = (struct btrfs_shared_data_ref *)(iref + 1); |
164 | pr_cont("shared data backref parent %llu count %u\n" , |
165 | offset, btrfs_shared_data_ref_count(eb, sref)); |
166 | /* |
167 | * Offset is supposed to be a tree block which must be |
168 | * aligned to sectorsize. |
169 | */ |
170 | if (!IS_ALIGNED(offset, eb->fs_info->sectorsize)) |
171 | pr_info( |
172 | "\t\t\t(parent %llu not aligned to sectorsize %u)\n" , |
173 | offset, eb->fs_info->sectorsize); |
174 | break; |
175 | case BTRFS_EXTENT_OWNER_REF_KEY: |
176 | oref = (struct btrfs_extent_owner_ref *)(&iref->offset); |
177 | print_extent_owner_ref(eb, ref: oref); |
178 | break; |
179 | default: |
180 | pr_cont("(extent %llu has INVALID ref type %d)\n" , |
181 | eb->start, type); |
182 | return; |
183 | } |
184 | ptr += btrfs_extent_inline_ref_size(type); |
185 | } |
186 | WARN_ON(ptr > end); |
187 | } |
188 | |
189 | static void print_uuid_item(const struct extent_buffer *l, unsigned long offset, |
190 | u32 item_size) |
191 | { |
192 | if (!IS_ALIGNED(item_size, sizeof(u64))) { |
193 | pr_warn("BTRFS: uuid item with illegal size %lu!\n" , |
194 | (unsigned long)item_size); |
195 | return; |
196 | } |
197 | while (item_size) { |
198 | __le64 subvol_id; |
199 | |
200 | read_extent_buffer(eb: l, dst: &subvol_id, start: offset, len: sizeof(subvol_id)); |
201 | pr_info("\t\tsubvol_id %llu\n" , le64_to_cpu(subvol_id)); |
202 | item_size -= sizeof(u64); |
203 | offset += sizeof(u64); |
204 | } |
205 | } |
206 | |
207 | static void print_raid_stripe_key(const struct extent_buffer *eb, u32 item_size, |
208 | struct btrfs_stripe_extent *stripe) |
209 | { |
210 | const int num_stripes = btrfs_num_raid_stripes(item_size); |
211 | const u8 encoding = btrfs_stripe_extent_encoding(eb, s: stripe); |
212 | |
213 | pr_info("\t\t\tencoding: %s\n" , |
214 | (encoding && encoding < BTRFS_NR_RAID_TYPES) ? |
215 | btrfs_raid_array[encoding].raid_name : "unknown" ); |
216 | |
217 | for (int i = 0; i < num_stripes; i++) |
218 | pr_info("\t\t\tstride %d devid %llu physical %llu\n" , |
219 | i, btrfs_raid_stride_devid(eb, &stripe->strides[i]), |
220 | btrfs_raid_stride_physical(eb, &stripe->strides[i])); |
221 | } |
222 | |
223 | /* |
224 | * Helper to output refs and locking status of extent buffer. Useful to debug |
225 | * race condition related problems. |
226 | */ |
227 | static void print_eb_refs_lock(const struct extent_buffer *eb) |
228 | { |
229 | #ifdef CONFIG_BTRFS_DEBUG |
230 | btrfs_info(eb->fs_info, "refs %u lock_owner %u current %u" , |
231 | atomic_read(&eb->refs), eb->lock_owner, current->pid); |
232 | #endif |
233 | } |
234 | |
235 | void btrfs_print_leaf(const struct extent_buffer *l) |
236 | { |
237 | struct btrfs_fs_info *fs_info; |
238 | int i; |
239 | u32 type, nr; |
240 | struct btrfs_root_item *ri; |
241 | struct btrfs_dir_item *di; |
242 | struct btrfs_inode_item *ii; |
243 | struct btrfs_block_group_item *bi; |
244 | struct btrfs_file_extent_item *fi; |
245 | struct btrfs_extent_data_ref *dref; |
246 | struct btrfs_shared_data_ref *sref; |
247 | struct btrfs_dev_extent *dev_extent; |
248 | struct btrfs_key key; |
249 | struct btrfs_key found_key; |
250 | |
251 | if (!l) |
252 | return; |
253 | |
254 | fs_info = l->fs_info; |
255 | nr = btrfs_header_nritems(eb: l); |
256 | |
257 | btrfs_info(fs_info, |
258 | "leaf %llu gen %llu total ptrs %d free space %d owner %llu" , |
259 | btrfs_header_bytenr(l), btrfs_header_generation(l), nr, |
260 | btrfs_leaf_free_space(l), btrfs_header_owner(l)); |
261 | print_eb_refs_lock(eb: l); |
262 | for (i = 0 ; i < nr ; i++) { |
263 | btrfs_item_key_to_cpu(eb: l, cpu_key: &key, nr: i); |
264 | type = key.type; |
265 | pr_info("\titem %d key (%llu %u %llu) itemoff %d itemsize %d\n" , |
266 | i, key.objectid, type, key.offset, |
267 | btrfs_item_offset(l, i), btrfs_item_size(l, i)); |
268 | switch (type) { |
269 | case BTRFS_INODE_ITEM_KEY: |
270 | ii = btrfs_item_ptr(l, i, struct btrfs_inode_item); |
271 | pr_info("\t\tinode generation %llu size %llu mode %o\n" , |
272 | btrfs_inode_generation(l, ii), |
273 | btrfs_inode_size(l, ii), |
274 | btrfs_inode_mode(l, ii)); |
275 | break; |
276 | case BTRFS_DIR_ITEM_KEY: |
277 | di = btrfs_item_ptr(l, i, struct btrfs_dir_item); |
278 | btrfs_dir_item_key_to_cpu(eb: l, item: di, cpu_key: &found_key); |
279 | pr_info("\t\tdir oid %llu flags %u\n" , |
280 | found_key.objectid, |
281 | btrfs_dir_flags(l, di)); |
282 | break; |
283 | case BTRFS_ROOT_ITEM_KEY: |
284 | ri = btrfs_item_ptr(l, i, struct btrfs_root_item); |
285 | pr_info("\t\troot data bytenr %llu refs %u\n" , |
286 | btrfs_disk_root_bytenr(l, ri), |
287 | btrfs_disk_root_refs(l, ri)); |
288 | break; |
289 | case BTRFS_EXTENT_ITEM_KEY: |
290 | case BTRFS_METADATA_ITEM_KEY: |
291 | print_extent_item(eb: l, slot: i, type); |
292 | break; |
293 | case BTRFS_TREE_BLOCK_REF_KEY: |
294 | pr_info("\t\ttree block backref\n" ); |
295 | break; |
296 | case BTRFS_SHARED_BLOCK_REF_KEY: |
297 | pr_info("\t\tshared block backref\n" ); |
298 | break; |
299 | case BTRFS_EXTENT_DATA_REF_KEY: |
300 | dref = btrfs_item_ptr(l, i, |
301 | struct btrfs_extent_data_ref); |
302 | print_extent_data_ref(eb: l, ref: dref); |
303 | break; |
304 | case BTRFS_SHARED_DATA_REF_KEY: |
305 | sref = btrfs_item_ptr(l, i, |
306 | struct btrfs_shared_data_ref); |
307 | pr_info("\t\tshared data backref count %u\n" , |
308 | btrfs_shared_data_ref_count(l, sref)); |
309 | break; |
310 | case BTRFS_EXTENT_DATA_KEY: |
311 | fi = btrfs_item_ptr(l, i, |
312 | struct btrfs_file_extent_item); |
313 | if (btrfs_file_extent_type(eb: l, s: fi) == |
314 | BTRFS_FILE_EXTENT_INLINE) { |
315 | pr_info("\t\tinline extent data size %llu\n" , |
316 | btrfs_file_extent_ram_bytes(l, fi)); |
317 | break; |
318 | } |
319 | pr_info("\t\textent data disk bytenr %llu nr %llu\n" , |
320 | btrfs_file_extent_disk_bytenr(l, fi), |
321 | btrfs_file_extent_disk_num_bytes(l, fi)); |
322 | pr_info("\t\textent data offset %llu nr %llu ram %llu\n" , |
323 | btrfs_file_extent_offset(l, fi), |
324 | btrfs_file_extent_num_bytes(l, fi), |
325 | btrfs_file_extent_ram_bytes(l, fi)); |
326 | break; |
327 | case BTRFS_BLOCK_GROUP_ITEM_KEY: |
328 | bi = btrfs_item_ptr(l, i, |
329 | struct btrfs_block_group_item); |
330 | pr_info( |
331 | "\t\tblock group used %llu chunk_objectid %llu flags %llu\n" , |
332 | btrfs_block_group_used(l, bi), |
333 | btrfs_block_group_chunk_objectid(l, bi), |
334 | btrfs_block_group_flags(l, bi)); |
335 | break; |
336 | case BTRFS_CHUNK_ITEM_KEY: |
337 | print_chunk(eb: l, btrfs_item_ptr(l, i, |
338 | struct btrfs_chunk)); |
339 | break; |
340 | case BTRFS_DEV_ITEM_KEY: |
341 | print_dev_item(eb: l, btrfs_item_ptr(l, i, |
342 | struct btrfs_dev_item)); |
343 | break; |
344 | case BTRFS_DEV_EXTENT_KEY: |
345 | dev_extent = btrfs_item_ptr(l, i, |
346 | struct btrfs_dev_extent); |
347 | pr_info("\t\tdev extent chunk_tree %llu\n\t\tchunk objectid %llu chunk offset %llu length %llu\n" , |
348 | btrfs_dev_extent_chunk_tree(l, dev_extent), |
349 | btrfs_dev_extent_chunk_objectid(l, dev_extent), |
350 | btrfs_dev_extent_chunk_offset(l, dev_extent), |
351 | btrfs_dev_extent_length(l, dev_extent)); |
352 | break; |
353 | case BTRFS_PERSISTENT_ITEM_KEY: |
354 | pr_info("\t\tpersistent item objectid %llu offset %llu\n" , |
355 | key.objectid, key.offset); |
356 | switch (key.objectid) { |
357 | case BTRFS_DEV_STATS_OBJECTID: |
358 | pr_info("\t\tdevice stats\n" ); |
359 | break; |
360 | default: |
361 | pr_info("\t\tunknown persistent item\n" ); |
362 | } |
363 | break; |
364 | case BTRFS_TEMPORARY_ITEM_KEY: |
365 | pr_info("\t\ttemporary item objectid %llu offset %llu\n" , |
366 | key.objectid, key.offset); |
367 | switch (key.objectid) { |
368 | case BTRFS_BALANCE_OBJECTID: |
369 | pr_info("\t\tbalance status\n" ); |
370 | break; |
371 | default: |
372 | pr_info("\t\tunknown temporary item\n" ); |
373 | } |
374 | break; |
375 | case BTRFS_DEV_REPLACE_KEY: |
376 | pr_info("\t\tdev replace\n" ); |
377 | break; |
378 | case BTRFS_UUID_KEY_SUBVOL: |
379 | case BTRFS_UUID_KEY_RECEIVED_SUBVOL: |
380 | print_uuid_item(l, btrfs_item_ptr_offset(l, i), |
381 | item_size: btrfs_item_size(eb: l, slot: i)); |
382 | break; |
383 | case BTRFS_RAID_STRIPE_KEY: |
384 | print_raid_stripe_key(eb: l, item_size: btrfs_item_size(eb: l, slot: i), |
385 | btrfs_item_ptr(l, i, struct btrfs_stripe_extent)); |
386 | break; |
387 | } |
388 | } |
389 | } |
390 | |
391 | void btrfs_print_tree(const struct extent_buffer *c, bool follow) |
392 | { |
393 | struct btrfs_fs_info *fs_info; |
394 | int i; u32 nr; |
395 | struct btrfs_key key; |
396 | int level; |
397 | |
398 | if (!c) |
399 | return; |
400 | fs_info = c->fs_info; |
401 | nr = btrfs_header_nritems(eb: c); |
402 | level = btrfs_header_level(eb: c); |
403 | if (level == 0) { |
404 | btrfs_print_leaf(l: c); |
405 | return; |
406 | } |
407 | btrfs_info(fs_info, |
408 | "node %llu level %d gen %llu total ptrs %d free spc %u owner %llu" , |
409 | btrfs_header_bytenr(c), level, btrfs_header_generation(c), |
410 | nr, (u32)BTRFS_NODEPTRS_PER_BLOCK(fs_info) - nr, |
411 | btrfs_header_owner(c)); |
412 | print_eb_refs_lock(eb: c); |
413 | for (i = 0; i < nr; i++) { |
414 | btrfs_node_key_to_cpu(eb: c, cpu_key: &key, nr: i); |
415 | pr_info("\tkey %d (%llu %u %llu) block %llu gen %llu\n" , |
416 | i, key.objectid, key.type, key.offset, |
417 | btrfs_node_blockptr(c, i), |
418 | btrfs_node_ptr_generation(c, i)); |
419 | } |
420 | if (!follow) |
421 | return; |
422 | for (i = 0; i < nr; i++) { |
423 | struct btrfs_tree_parent_check check = { |
424 | .level = level - 1, |
425 | .transid = btrfs_node_ptr_generation(eb: c, nr: i), |
426 | .owner_root = btrfs_header_owner(eb: c), |
427 | .has_first_key = true |
428 | }; |
429 | struct extent_buffer *next; |
430 | |
431 | btrfs_node_key_to_cpu(eb: c, cpu_key: &check.first_key, nr: i); |
432 | next = read_tree_block(fs_info, bytenr: btrfs_node_blockptr(eb: c, nr: i), check: &check); |
433 | if (IS_ERR(ptr: next)) |
434 | continue; |
435 | if (!extent_buffer_uptodate(eb: next)) { |
436 | free_extent_buffer(eb: next); |
437 | continue; |
438 | } |
439 | |
440 | if (btrfs_is_leaf(eb: next) && |
441 | level != 1) |
442 | BUG(); |
443 | if (btrfs_header_level(eb: next) != |
444 | level - 1) |
445 | BUG(); |
446 | btrfs_print_tree(c: next, follow); |
447 | free_extent_buffer(eb: next); |
448 | } |
449 | } |
450 | |