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