Commit | Line | Data |
---|---|---|
6cbd5570 CM |
1 | /* |
2 | * Copyright (C) 2007 Oracle. All rights reserved. | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or | |
5 | * modify it under the terms of the GNU General Public | |
6 | * License v2 as published by the Free Software Foundation. | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, | |
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
11 | * General Public License for more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public | |
14 | * License along with this program; if not, write to the | |
15 | * Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
16 | * Boston, MA 021110-1307, USA. | |
17 | */ | |
18 | ||
5de08d7d CM |
19 | #include "ctree.h" |
20 | #include "disk-io.h" | |
35b7e476 | 21 | #include "print-tree.h" |
5de08d7d | 22 | |
0b86a832 CM |
23 | static void print_chunk(struct extent_buffer *eb, struct btrfs_chunk *chunk) |
24 | { | |
25 | int num_stripes = btrfs_chunk_num_stripes(eb, chunk); | |
26 | int i; | |
62e85577 | 27 | pr_info("\t\tchunk length %llu owner %llu type %llu num_stripes %d\n", |
c1c9ff7c GU |
28 | btrfs_chunk_length(eb, chunk), btrfs_chunk_owner(eb, chunk), |
29 | btrfs_chunk_type(eb, chunk), num_stripes); | |
0b86a832 | 30 | for (i = 0 ; i < num_stripes ; i++) { |
62e85577 | 31 | pr_info("\t\t\tstripe %d devid %llu offset %llu\n", i, |
c1c9ff7c GU |
32 | btrfs_stripe_devid_nr(eb, chunk, i), |
33 | btrfs_stripe_offset_nr(eb, chunk, i)); | |
0b86a832 CM |
34 | } |
35 | } | |
36 | static void print_dev_item(struct extent_buffer *eb, | |
37 | struct btrfs_dev_item *dev_item) | |
38 | { | |
62e85577 | 39 | pr_info("\t\tdev item devid %llu total_bytes %llu bytes used %llu\n", |
c1c9ff7c GU |
40 | btrfs_device_id(eb, dev_item), |
41 | btrfs_device_total_bytes(eb, dev_item), | |
42 | btrfs_device_bytes_used(eb, dev_item)); | |
0b86a832 | 43 | } |
5d4f98a2 YZ |
44 | static void print_extent_data_ref(struct extent_buffer *eb, |
45 | struct btrfs_extent_data_ref *ref) | |
46 | { | |
64ecdb64 | 47 | pr_cont("extent data backref root %llu objectid %llu offset %llu count %u\n", |
c1c9ff7c GU |
48 | btrfs_extent_data_ref_root(eb, ref), |
49 | btrfs_extent_data_ref_objectid(eb, ref), | |
50 | btrfs_extent_data_ref_offset(eb, ref), | |
5d4f98a2 YZ |
51 | btrfs_extent_data_ref_count(eb, ref)); |
52 | } | |
53 | ||
be2c765d | 54 | static void print_extent_item(struct extent_buffer *eb, int slot, int type) |
5d4f98a2 YZ |
55 | { |
56 | struct btrfs_extent_item *ei; | |
57 | struct btrfs_extent_inline_ref *iref; | |
58 | struct btrfs_extent_data_ref *dref; | |
59 | struct btrfs_shared_data_ref *sref; | |
60 | struct btrfs_disk_key key; | |
61 | unsigned long end; | |
62 | unsigned long ptr; | |
5d4f98a2 YZ |
63 | u32 item_size = btrfs_item_size_nr(eb, slot); |
64 | u64 flags; | |
65 | u64 offset; | |
64ecdb64 | 66 | int ref_index = 0; |
5d4f98a2 YZ |
67 | |
68 | if (item_size < sizeof(*ei)) { | |
69 | #ifdef BTRFS_COMPAT_EXTENT_TREE_V0 | |
70 | struct btrfs_extent_item_v0 *ei0; | |
71 | BUG_ON(item_size != sizeof(*ei0)); | |
72 | ei0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_item_v0); | |
62e85577 | 73 | pr_info("\t\textent refs %u\n", |
5d4f98a2 YZ |
74 | btrfs_extent_refs_v0(eb, ei0)); |
75 | return; | |
76 | #else | |
77 | BUG(); | |
78 | #endif | |
79 | } | |
80 | ||
81 | ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item); | |
82 | flags = btrfs_extent_flags(eb, ei); | |
83 | ||
62e85577 | 84 | pr_info("\t\textent refs %llu gen %llu flags %llu\n", |
c1c9ff7c GU |
85 | btrfs_extent_refs(eb, ei), btrfs_extent_generation(eb, ei), |
86 | flags); | |
5d4f98a2 | 87 | |
be2c765d JB |
88 | if ((type == BTRFS_EXTENT_ITEM_KEY) && |
89 | flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) { | |
5d4f98a2 YZ |
90 | struct btrfs_tree_block_info *info; |
91 | info = (struct btrfs_tree_block_info *)(ei + 1); | |
92 | btrfs_tree_block_key(eb, info, &key); | |
62e85577 | 93 | pr_info("\t\ttree block key (%llu %u %llu) level %d\n", |
c1c9ff7c GU |
94 | btrfs_disk_key_objectid(&key), key.type, |
95 | btrfs_disk_key_offset(&key), | |
5d4f98a2 YZ |
96 | btrfs_tree_block_level(eb, info)); |
97 | iref = (struct btrfs_extent_inline_ref *)(info + 1); | |
98 | } else { | |
99 | iref = (struct btrfs_extent_inline_ref *)(ei + 1); | |
100 | } | |
101 | ||
102 | ptr = (unsigned long)iref; | |
103 | end = (unsigned long)ei + item_size; | |
104 | while (ptr < end) { | |
105 | iref = (struct btrfs_extent_inline_ref *)ptr; | |
106 | type = btrfs_extent_inline_ref_type(eb, iref); | |
107 | offset = btrfs_extent_inline_ref_offset(eb, iref); | |
64ecdb64 | 108 | pr_info("\t\tref#%d: ", ref_index++); |
5d4f98a2 YZ |
109 | switch (type) { |
110 | case BTRFS_TREE_BLOCK_REF_KEY: | |
64ecdb64 | 111 | pr_cont("tree block backref root %llu\n", offset); |
5d4f98a2 YZ |
112 | break; |
113 | case BTRFS_SHARED_BLOCK_REF_KEY: | |
64ecdb64 LB |
114 | pr_cont("shared block backref parent %llu\n", offset); |
115 | /* | |
116 | * offset is supposed to be a tree block which | |
117 | * must be aligned to nodesize. | |
118 | */ | |
119 | if (!IS_ALIGNED(offset, eb->fs_info->nodesize)) | |
120 | pr_info("\t\t\t(parent %llu is NOT ALIGNED to nodesize %llu)\n", | |
121 | offset, (unsigned long long)eb->fs_info->nodesize); | |
5d4f98a2 YZ |
122 | break; |
123 | case BTRFS_EXTENT_DATA_REF_KEY: | |
124 | dref = (struct btrfs_extent_data_ref *)(&iref->offset); | |
125 | print_extent_data_ref(eb, dref); | |
126 | break; | |
127 | case BTRFS_SHARED_DATA_REF_KEY: | |
128 | sref = (struct btrfs_shared_data_ref *)(iref + 1); | |
64ecdb64 | 129 | pr_cont("shared data backref parent %llu count %u\n", |
c1c9ff7c | 130 | offset, btrfs_shared_data_ref_count(eb, sref)); |
64ecdb64 LB |
131 | /* |
132 | * offset is supposed to be a tree block which | |
133 | * must be aligned to nodesize. | |
134 | */ | |
135 | if (!IS_ALIGNED(offset, eb->fs_info->nodesize)) | |
136 | pr_info("\t\t\t(parent %llu is NOT ALIGNED to nodesize %llu)\n", | |
137 | offset, (unsigned long long)eb->fs_info->nodesize); | |
5d4f98a2 YZ |
138 | break; |
139 | default: | |
64ecdb64 | 140 | pr_cont("(extent %llu has INVALID ref type %d)\n", |
07638ea5 LB |
141 | eb->start, type); |
142 | return; | |
5d4f98a2 YZ |
143 | } |
144 | ptr += btrfs_extent_inline_ref_size(type); | |
145 | } | |
146 | WARN_ON(ptr > end); | |
147 | } | |
148 | ||
149 | #ifdef BTRFS_COMPAT_EXTENT_TREE_V0 | |
150 | static void print_extent_ref_v0(struct extent_buffer *eb, int slot) | |
151 | { | |
152 | struct btrfs_extent_ref_v0 *ref0; | |
153 | ||
154 | ref0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_ref_v0); | |
5d163e0e | 155 | printk("\t\textent back ref root %llu gen %llu owner %llu num_refs %lu\n", |
c1c9ff7c GU |
156 | btrfs_ref_root_v0(eb, ref0), |
157 | btrfs_ref_generation_v0(eb, ref0), | |
158 | btrfs_ref_objectid_v0(eb, ref0), | |
5d4f98a2 YZ |
159 | (unsigned long)btrfs_ref_count_v0(eb, ref0)); |
160 | } | |
161 | #endif | |
162 | ||
8f8ae8e2 SB |
163 | static void print_uuid_item(struct extent_buffer *l, unsigned long offset, |
164 | u32 item_size) | |
165 | { | |
166 | if (!IS_ALIGNED(item_size, sizeof(u64))) { | |
efe120a0 | 167 | pr_warn("BTRFS: uuid item with illegal size %lu!\n", |
8f8ae8e2 SB |
168 | (unsigned long)item_size); |
169 | return; | |
170 | } | |
171 | while (item_size) { | |
172 | __le64 subvol_id; | |
173 | ||
174 | read_extent_buffer(l, &subvol_id, offset, sizeof(subvol_id)); | |
62e85577 | 175 | pr_info("\t\tsubvol_id %llu\n", |
8f8ae8e2 SB |
176 | (unsigned long long)le64_to_cpu(subvol_id)); |
177 | item_size -= sizeof(u64); | |
178 | offset += sizeof(u64); | |
179 | } | |
180 | } | |
181 | ||
a4f78750 | 182 | void btrfs_print_leaf(struct extent_buffer *l) |
5de08d7d | 183 | { |
a4f78750 | 184 | struct btrfs_fs_info *fs_info; |
5de08d7d | 185 | int i; |
068132ba | 186 | u32 type, nr; |
0783fcfc | 187 | struct btrfs_item *item; |
3768f368 | 188 | struct btrfs_root_item *ri; |
1d4f6404 | 189 | struct btrfs_dir_item *di; |
293ffd5f | 190 | struct btrfs_inode_item *ii; |
9078a3e1 | 191 | struct btrfs_block_group_item *bi; |
8c2383c3 | 192 | struct btrfs_file_extent_item *fi; |
5d4f98a2 YZ |
193 | struct btrfs_extent_data_ref *dref; |
194 | struct btrfs_shared_data_ref *sref; | |
195 | struct btrfs_dev_extent *dev_extent; | |
5f39d397 CM |
196 | struct btrfs_key key; |
197 | struct btrfs_key found_key; | |
1d4f6404 | 198 | |
068132ba DB |
199 | if (!l) |
200 | return; | |
201 | ||
a4f78750 | 202 | fs_info = l->fs_info; |
068132ba DB |
203 | nr = btrfs_header_nritems(l); |
204 | ||
0b246afa | 205 | btrfs_info(fs_info, "leaf %llu total ptrs %d free space %d", |
2ff7e61e JM |
206 | btrfs_header_bytenr(l), nr, |
207 | btrfs_leaf_free_space(fs_info, l)); | |
5de08d7d | 208 | for (i = 0 ; i < nr ; i++) { |
dd3cc16b | 209 | item = btrfs_item_nr(i); |
5f39d397 | 210 | btrfs_item_key_to_cpu(l, &key, i); |
962a298f | 211 | type = key.type; |
62e85577 | 212 | pr_info("\titem %d key (%llu %u %llu) itemoff %d itemsize %d\n", |
c1c9ff7c | 213 | i, key.objectid, type, key.offset, |
5f39d397 | 214 | btrfs_item_offset(l, item), btrfs_item_size(l, item)); |
62e2749e CM |
215 | switch (type) { |
216 | case BTRFS_INODE_ITEM_KEY: | |
293ffd5f | 217 | ii = btrfs_item_ptr(l, i, struct btrfs_inode_item); |
62e85577 | 218 | pr_info("\t\tinode generation %llu size %llu mode %o\n", |
d397712b | 219 | btrfs_inode_generation(l, ii), |
c1c9ff7c | 220 | btrfs_inode_size(l, ii), |
5f39d397 | 221 | btrfs_inode_mode(l, ii)); |
62e2749e CM |
222 | break; |
223 | case BTRFS_DIR_ITEM_KEY: | |
1d4f6404 | 224 | di = btrfs_item_ptr(l, i, struct btrfs_dir_item); |
5f39d397 | 225 | btrfs_dir_item_key_to_cpu(l, di, &found_key); |
62e85577 | 226 | pr_info("\t\tdir oid %llu type %u\n", |
c1c9ff7c | 227 | found_key.objectid, |
5f39d397 | 228 | btrfs_dir_type(l, di)); |
62e2749e CM |
229 | break; |
230 | case BTRFS_ROOT_ITEM_KEY: | |
231 | ri = btrfs_item_ptr(l, i, struct btrfs_root_item); | |
62e85577 | 232 | pr_info("\t\troot data bytenr %llu refs %u\n", |
d397712b | 233 | btrfs_disk_root_bytenr(l, ri), |
5f39d397 | 234 | btrfs_disk_root_refs(l, ri)); |
62e2749e CM |
235 | break; |
236 | case BTRFS_EXTENT_ITEM_KEY: | |
be2c765d JB |
237 | case BTRFS_METADATA_ITEM_KEY: |
238 | print_extent_item(l, i, type); | |
62e2749e | 239 | break; |
5d4f98a2 | 240 | case BTRFS_TREE_BLOCK_REF_KEY: |
62e85577 | 241 | pr_info("\t\ttree block backref\n"); |
5d4f98a2 YZ |
242 | break; |
243 | case BTRFS_SHARED_BLOCK_REF_KEY: | |
62e85577 | 244 | pr_info("\t\tshared block backref\n"); |
5d4f98a2 YZ |
245 | break; |
246 | case BTRFS_EXTENT_DATA_REF_KEY: | |
247 | dref = btrfs_item_ptr(l, i, | |
248 | struct btrfs_extent_data_ref); | |
249 | print_extent_data_ref(l, dref); | |
250 | break; | |
251 | case BTRFS_SHARED_DATA_REF_KEY: | |
252 | sref = btrfs_item_ptr(l, i, | |
253 | struct btrfs_shared_data_ref); | |
62e85577 | 254 | pr_info("\t\tshared data backref count %u\n", |
5d4f98a2 | 255 | btrfs_shared_data_ref_count(l, sref)); |
7bb86316 | 256 | break; |
8c2383c3 CM |
257 | case BTRFS_EXTENT_DATA_KEY: |
258 | fi = btrfs_item_ptr(l, i, | |
259 | struct btrfs_file_extent_item); | |
5f39d397 | 260 | if (btrfs_file_extent_type(l, fi) == |
8c2383c3 | 261 | BTRFS_FILE_EXTENT_INLINE) { |
62e85577 | 262 | pr_info("\t\tinline extent data size %u\n", |
514ac8ad | 263 | btrfs_file_extent_inline_len(l, i, fi)); |
8c2383c3 CM |
264 | break; |
265 | } | |
62e85577 | 266 | pr_info("\t\textent data disk bytenr %llu nr %llu\n", |
d397712b | 267 | btrfs_file_extent_disk_bytenr(l, fi), |
d397712b | 268 | btrfs_file_extent_disk_num_bytes(l, fi)); |
62e85577 | 269 | pr_info("\t\textent data offset %llu nr %llu ram %llu\n", |
d397712b | 270 | btrfs_file_extent_offset(l, fi), |
d397712b | 271 | btrfs_file_extent_num_bytes(l, fi), |
d397712b | 272 | btrfs_file_extent_ram_bytes(l, fi)); |
8c2383c3 | 273 | break; |
5d4f98a2 YZ |
274 | case BTRFS_EXTENT_REF_V0_KEY: |
275 | #ifdef BTRFS_COMPAT_EXTENT_TREE_V0 | |
276 | print_extent_ref_v0(l, i); | |
277 | #else | |
278 | BUG(); | |
279 | #endif | |
333e8105 | 280 | break; |
9078a3e1 CM |
281 | case BTRFS_BLOCK_GROUP_ITEM_KEY: |
282 | bi = btrfs_item_ptr(l, i, | |
283 | struct btrfs_block_group_item); | |
555ba411 LB |
284 | pr_info( |
285 | "\t\tblock group used %llu chunk_objectid %llu flags %llu\n", | |
286 | btrfs_disk_block_group_used(l, bi), | |
287 | btrfs_disk_block_group_chunk_objectid(l, bi), | |
288 | btrfs_disk_block_group_flags(l, bi)); | |
62e2749e | 289 | break; |
0b86a832 | 290 | case BTRFS_CHUNK_ITEM_KEY: |
d397712b CM |
291 | print_chunk(l, btrfs_item_ptr(l, i, |
292 | struct btrfs_chunk)); | |
0b86a832 CM |
293 | break; |
294 | case BTRFS_DEV_ITEM_KEY: | |
295 | print_dev_item(l, btrfs_item_ptr(l, i, | |
296 | struct btrfs_dev_item)); | |
297 | break; | |
298 | case BTRFS_DEV_EXTENT_KEY: | |
299 | dev_extent = btrfs_item_ptr(l, i, | |
300 | struct btrfs_dev_extent); | |
62e85577 | 301 | pr_info("\t\tdev extent chunk_tree %llu\n\t\tchunk objectid %llu chunk offset %llu length %llu\n", |
e17cade2 | 302 | btrfs_dev_extent_chunk_tree(l, dev_extent), |
e17cade2 | 303 | btrfs_dev_extent_chunk_objectid(l, dev_extent), |
e17cade2 | 304 | btrfs_dev_extent_chunk_offset(l, dev_extent), |
e17cade2 | 305 | btrfs_dev_extent_length(l, dev_extent)); |
0e636027 | 306 | break; |
585a3d0d | 307 | case BTRFS_PERSISTENT_ITEM_KEY: |
62e85577 | 308 | pr_info("\t\tpersistent item objectid %llu offset %llu\n", |
585a3d0d DS |
309 | key.objectid, key.offset); |
310 | switch (key.objectid) { | |
311 | case BTRFS_DEV_STATS_OBJECTID: | |
62e85577 | 312 | pr_info("\t\tdevice stats\n"); |
585a3d0d DS |
313 | break; |
314 | default: | |
62e85577 | 315 | pr_info("\t\tunknown persistent item\n"); |
585a3d0d | 316 | } |
733f4fbb | 317 | break; |
9f07e1d7 | 318 | case BTRFS_TEMPORARY_ITEM_KEY: |
62e85577 | 319 | pr_info("\t\ttemporary item objectid %llu offset %llu\n", |
9f07e1d7 DS |
320 | key.objectid, key.offset); |
321 | switch (key.objectid) { | |
322 | case BTRFS_BALANCE_OBJECTID: | |
62e85577 | 323 | pr_info("\t\tbalance status\n"); |
9f07e1d7 DS |
324 | break; |
325 | default: | |
62e85577 | 326 | pr_info("\t\tunknown temporary item\n"); |
9f07e1d7 DS |
327 | } |
328 | break; | |
a2bff640 | 329 | case BTRFS_DEV_REPLACE_KEY: |
62e85577 | 330 | pr_info("\t\tdev replace\n"); |
a2bff640 | 331 | break; |
8f8ae8e2 SB |
332 | case BTRFS_UUID_KEY_SUBVOL: |
333 | case BTRFS_UUID_KEY_RECEIVED_SUBVOL: | |
334 | print_uuid_item(l, btrfs_item_ptr_offset(l, i), | |
335 | btrfs_item_size_nr(l, i)); | |
336 | break; | |
62e2749e | 337 | }; |
5de08d7d CM |
338 | } |
339 | } | |
e20d96d6 | 340 | |
abe60ba4 | 341 | void btrfs_print_tree(struct extent_buffer *c) |
5de08d7d | 342 | { |
abe60ba4 | 343 | struct btrfs_fs_info *fs_info; |
e17cade2 | 344 | int i; u32 nr; |
5f39d397 | 345 | struct btrfs_key key; |
db94535d | 346 | int level; |
5de08d7d | 347 | |
5f39d397 | 348 | if (!c) |
5de08d7d | 349 | return; |
abe60ba4 | 350 | fs_info = c->fs_info; |
5f39d397 | 351 | nr = btrfs_header_nritems(c); |
db94535d CM |
352 | level = btrfs_header_level(c); |
353 | if (level == 0) { | |
a4f78750 | 354 | btrfs_print_leaf(c); |
5de08d7d CM |
355 | return; |
356 | } | |
0b246afa | 357 | btrfs_info(fs_info, |
5d163e0e JM |
358 | "node %llu level %d total ptrs %d free spc %u", |
359 | btrfs_header_bytenr(c), level, nr, | |
0b246afa | 360 | (u32)BTRFS_NODEPTRS_PER_BLOCK(fs_info) - nr); |
5de08d7d | 361 | for (i = 0; i < nr; i++) { |
5f39d397 | 362 | btrfs_node_key_to_cpu(c, &key, i); |
62e85577 | 363 | pr_info("\tkey %d (%llu %u %llu) block %llu\n", |
c1c9ff7c GU |
364 | i, key.objectid, key.type, key.offset, |
365 | btrfs_node_blockptr(c, i)); | |
5de08d7d CM |
366 | } |
367 | for (i = 0; i < nr; i++) { | |
2ff7e61e | 368 | struct extent_buffer *next = read_tree_block(fs_info, |
db94535d | 369 | btrfs_node_blockptr(c, i), |
ca7a79ad | 370 | btrfs_node_ptr_generation(c, i)); |
a42cbec9 LB |
371 | if (IS_ERR(next)) { |
372 | continue; | |
373 | } else if (!extent_buffer_uptodate(next)) { | |
374 | free_extent_buffer(next); | |
375 | continue; | |
376 | } | |
377 | ||
7518a238 | 378 | if (btrfs_is_leaf(next) && |
c271b492 | 379 | level != 1) |
5de08d7d | 380 | BUG(); |
5f39d397 | 381 | if (btrfs_header_level(next) != |
c271b492 | 382 | level - 1) |
5de08d7d | 383 | BUG(); |
abe60ba4 | 384 | btrfs_print_tree(next); |
5f39d397 | 385 | free_extent_buffer(next); |
5de08d7d | 386 | } |
5de08d7d | 387 | } |