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