Chris Mason | 6cbd557 | 2007-06-12 09:07:21 -0400 | [diff] [blame] | 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 | |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 19 | #include "ctree.h" |
| 20 | #include "disk-io.h" |
Chris Mason | 35b7e47 | 2007-05-02 15:53:43 -0400 | [diff] [blame] | 21 | #include "print-tree.h" |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 22 | |
Chris Mason | 0b86a83 | 2008-03-24 15:01:56 -0400 | [diff] [blame] | 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; |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 27 | printk(KERN_INFO "\t\tchunk length %llu owner %llu type %llu " |
| 28 | "num_stripes %d\n", |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 29 | btrfs_chunk_length(eb, chunk), btrfs_chunk_owner(eb, chunk), |
| 30 | btrfs_chunk_type(eb, chunk), num_stripes); |
Chris Mason | 0b86a83 | 2008-03-24 15:01:56 -0400 | [diff] [blame] | 31 | for (i = 0 ; i < num_stripes ; i++) { |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 32 | printk(KERN_INFO "\t\t\tstripe %d devid %llu offset %llu\n", i, |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 33 | btrfs_stripe_devid_nr(eb, chunk, i), |
| 34 | btrfs_stripe_offset_nr(eb, chunk, i)); |
Chris Mason | 0b86a83 | 2008-03-24 15:01:56 -0400 | [diff] [blame] | 35 | } |
| 36 | } |
| 37 | static void print_dev_item(struct extent_buffer *eb, |
| 38 | struct btrfs_dev_item *dev_item) |
| 39 | { |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 40 | printk(KERN_INFO "\t\tdev item devid %llu " |
| 41 | "total_bytes %llu bytes used %llu\n", |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 42 | btrfs_device_id(eb, dev_item), |
| 43 | btrfs_device_total_bytes(eb, dev_item), |
| 44 | btrfs_device_bytes_used(eb, dev_item)); |
Chris Mason | 0b86a83 | 2008-03-24 15:01:56 -0400 | [diff] [blame] | 45 | } |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 46 | static void print_extent_data_ref(struct extent_buffer *eb, |
| 47 | struct btrfs_extent_data_ref *ref) |
| 48 | { |
| 49 | printk(KERN_INFO "\t\textent data backref root %llu " |
| 50 | "objectid %llu offset %llu count %u\n", |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 51 | btrfs_extent_data_ref_root(eb, ref), |
| 52 | btrfs_extent_data_ref_objectid(eb, ref), |
| 53 | btrfs_extent_data_ref_offset(eb, ref), |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 54 | btrfs_extent_data_ref_count(eb, ref)); |
| 55 | } |
| 56 | |
Josef Bacik | be2c765 | 2014-07-02 10:20:48 -0700 | [diff] [blame] | 57 | static void print_extent_item(struct extent_buffer *eb, int slot, int type) |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 58 | { |
| 59 | struct btrfs_extent_item *ei; |
| 60 | struct btrfs_extent_inline_ref *iref; |
| 61 | struct btrfs_extent_data_ref *dref; |
| 62 | struct btrfs_shared_data_ref *sref; |
| 63 | struct btrfs_disk_key key; |
| 64 | unsigned long end; |
| 65 | unsigned long ptr; |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 66 | u32 item_size = btrfs_item_size_nr(eb, slot); |
| 67 | u64 flags; |
| 68 | u64 offset; |
| 69 | |
| 70 | if (item_size < sizeof(*ei)) { |
| 71 | #ifdef BTRFS_COMPAT_EXTENT_TREE_V0 |
| 72 | struct btrfs_extent_item_v0 *ei0; |
| 73 | BUG_ON(item_size != sizeof(*ei0)); |
| 74 | ei0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_item_v0); |
| 75 | printk(KERN_INFO "\t\textent refs %u\n", |
| 76 | btrfs_extent_refs_v0(eb, ei0)); |
| 77 | return; |
| 78 | #else |
| 79 | BUG(); |
| 80 | #endif |
| 81 | } |
| 82 | |
| 83 | ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item); |
| 84 | flags = btrfs_extent_flags(eb, ei); |
| 85 | |
| 86 | printk(KERN_INFO "\t\textent refs %llu gen %llu flags %llu\n", |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 87 | btrfs_extent_refs(eb, ei), btrfs_extent_generation(eb, ei), |
| 88 | flags); |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 89 | |
Josef Bacik | be2c765 | 2014-07-02 10:20:48 -0700 | [diff] [blame] | 90 | if ((type == BTRFS_EXTENT_ITEM_KEY) && |
| 91 | flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) { |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 92 | struct btrfs_tree_block_info *info; |
| 93 | info = (struct btrfs_tree_block_info *)(ei + 1); |
| 94 | btrfs_tree_block_key(eb, info, &key); |
Stefan Behrens | d4c34f6 | 2013-07-16 15:38:33 +0200 | [diff] [blame] | 95 | printk(KERN_INFO "\t\ttree block key (%llu %u %llu) " |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 96 | "level %d\n", |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 97 | btrfs_disk_key_objectid(&key), key.type, |
| 98 | btrfs_disk_key_offset(&key), |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 99 | btrfs_tree_block_level(eb, info)); |
| 100 | iref = (struct btrfs_extent_inline_ref *)(info + 1); |
| 101 | } else { |
| 102 | iref = (struct btrfs_extent_inline_ref *)(ei + 1); |
| 103 | } |
| 104 | |
| 105 | ptr = (unsigned long)iref; |
| 106 | end = (unsigned long)ei + item_size; |
| 107 | while (ptr < end) { |
| 108 | iref = (struct btrfs_extent_inline_ref *)ptr; |
| 109 | type = btrfs_extent_inline_ref_type(eb, iref); |
| 110 | offset = btrfs_extent_inline_ref_offset(eb, iref); |
| 111 | switch (type) { |
| 112 | case BTRFS_TREE_BLOCK_REF_KEY: |
| 113 | printk(KERN_INFO "\t\ttree block backref " |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 114 | "root %llu\n", offset); |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 115 | break; |
| 116 | case BTRFS_SHARED_BLOCK_REF_KEY: |
| 117 | printk(KERN_INFO "\t\tshared block backref " |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 118 | "parent %llu\n", offset); |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 119 | break; |
| 120 | case BTRFS_EXTENT_DATA_REF_KEY: |
| 121 | dref = (struct btrfs_extent_data_ref *)(&iref->offset); |
| 122 | print_extent_data_ref(eb, dref); |
| 123 | break; |
| 124 | case BTRFS_SHARED_DATA_REF_KEY: |
| 125 | sref = (struct btrfs_shared_data_ref *)(iref + 1); |
| 126 | printk(KERN_INFO "\t\tshared data backref " |
| 127 | "parent %llu count %u\n", |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 128 | offset, btrfs_shared_data_ref_count(eb, sref)); |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 129 | break; |
| 130 | default: |
| 131 | BUG(); |
| 132 | } |
| 133 | ptr += btrfs_extent_inline_ref_size(type); |
| 134 | } |
| 135 | WARN_ON(ptr > end); |
| 136 | } |
| 137 | |
| 138 | #ifdef BTRFS_COMPAT_EXTENT_TREE_V0 |
| 139 | static void print_extent_ref_v0(struct extent_buffer *eb, int slot) |
| 140 | { |
| 141 | struct btrfs_extent_ref_v0 *ref0; |
| 142 | |
| 143 | ref0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_ref_v0); |
| 144 | printk("\t\textent back ref root %llu gen %llu " |
| 145 | "owner %llu num_refs %lu\n", |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 146 | btrfs_ref_root_v0(eb, ref0), |
| 147 | btrfs_ref_generation_v0(eb, ref0), |
| 148 | btrfs_ref_objectid_v0(eb, ref0), |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 149 | (unsigned long)btrfs_ref_count_v0(eb, ref0)); |
| 150 | } |
| 151 | #endif |
| 152 | |
Stefan Behrens | 8f8ae8e | 2013-08-15 17:11:18 +0200 | [diff] [blame] | 153 | static void print_uuid_item(struct extent_buffer *l, unsigned long offset, |
| 154 | u32 item_size) |
| 155 | { |
| 156 | if (!IS_ALIGNED(item_size, sizeof(u64))) { |
Frank Holton | efe120a | 2013-12-20 11:37:06 -0500 | [diff] [blame] | 157 | pr_warn("BTRFS: uuid item with illegal size %lu!\n", |
Stefan Behrens | 8f8ae8e | 2013-08-15 17:11:18 +0200 | [diff] [blame] | 158 | (unsigned long)item_size); |
| 159 | return; |
| 160 | } |
| 161 | while (item_size) { |
| 162 | __le64 subvol_id; |
| 163 | |
| 164 | read_extent_buffer(l, &subvol_id, offset, sizeof(subvol_id)); |
| 165 | printk(KERN_INFO "\t\tsubvol_id %llu\n", |
| 166 | (unsigned long long)le64_to_cpu(subvol_id)); |
| 167 | item_size -= sizeof(u64); |
| 168 | offset += sizeof(u64); |
| 169 | } |
| 170 | } |
| 171 | |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 172 | void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l) |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 173 | { |
| 174 | int i; |
Daniel J Blueman | 068132b | 2011-06-23 23:01:01 +0800 | [diff] [blame] | 175 | u32 type, nr; |
Chris Mason | 0783fcf | 2007-03-12 20:12:07 -0400 | [diff] [blame] | 176 | struct btrfs_item *item; |
Chris Mason | 3768f36 | 2007-03-13 16:47:54 -0400 | [diff] [blame] | 177 | struct btrfs_root_item *ri; |
Chris Mason | 1d4f640 | 2007-03-15 15:18:43 -0400 | [diff] [blame] | 178 | struct btrfs_dir_item *di; |
Chris Mason | 293ffd5 | 2007-03-20 15:57:25 -0400 | [diff] [blame] | 179 | struct btrfs_inode_item *ii; |
Chris Mason | 9078a3e | 2007-04-26 16:46:15 -0400 | [diff] [blame] | 180 | struct btrfs_block_group_item *bi; |
Chris Mason | 8c2383c | 2007-06-18 09:57:58 -0400 | [diff] [blame] | 181 | struct btrfs_file_extent_item *fi; |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 182 | struct btrfs_extent_data_ref *dref; |
| 183 | struct btrfs_shared_data_ref *sref; |
| 184 | struct btrfs_dev_extent *dev_extent; |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 185 | struct btrfs_key key; |
| 186 | struct btrfs_key found_key; |
Chris Mason | 1d4f640 | 2007-03-15 15:18:43 -0400 | [diff] [blame] | 187 | |
Daniel J Blueman | 068132b | 2011-06-23 23:01:01 +0800 | [diff] [blame] | 188 | if (!l) |
| 189 | return; |
| 190 | |
| 191 | nr = btrfs_header_nritems(l); |
| 192 | |
Simon Kirby | c2cf52e | 2013-03-19 22:41:23 +0000 | [diff] [blame] | 193 | btrfs_info(root->fs_info, "leaf %llu total ptrs %d free space %d", |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 194 | btrfs_header_bytenr(l), nr, btrfs_leaf_free_space(root, l)); |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 195 | for (i = 0 ; i < nr ; i++) { |
Ross Kirk | dd3cc16 | 2013-09-16 15:58:09 +0100 | [diff] [blame] | 196 | item = btrfs_item_nr(i); |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 197 | btrfs_item_key_to_cpu(l, &key, i); |
| 198 | type = btrfs_key_type(&key); |
Stefan Behrens | d4c34f6 | 2013-07-16 15:38:33 +0200 | [diff] [blame] | 199 | printk(KERN_INFO "\titem %d key (%llu %u %llu) itemoff %d " |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 200 | "itemsize %d\n", |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 201 | i, key.objectid, type, key.offset, |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 202 | btrfs_item_offset(l, item), btrfs_item_size(l, item)); |
Chris Mason | 62e2749 | 2007-03-15 12:56:47 -0400 | [diff] [blame] | 203 | switch (type) { |
| 204 | case BTRFS_INODE_ITEM_KEY: |
Chris Mason | 293ffd5 | 2007-03-20 15:57:25 -0400 | [diff] [blame] | 205 | ii = btrfs_item_ptr(l, i, struct btrfs_inode_item); |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 206 | printk(KERN_INFO "\t\tinode generation %llu size %llu " |
| 207 | "mode %o\n", |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 208 | btrfs_inode_generation(l, ii), |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 209 | btrfs_inode_size(l, ii), |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 210 | btrfs_inode_mode(l, ii)); |
Chris Mason | 62e2749 | 2007-03-15 12:56:47 -0400 | [diff] [blame] | 211 | break; |
| 212 | case BTRFS_DIR_ITEM_KEY: |
Chris Mason | 1d4f640 | 2007-03-15 15:18:43 -0400 | [diff] [blame] | 213 | di = btrfs_item_ptr(l, i, struct btrfs_dir_item); |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 214 | btrfs_dir_item_key_to_cpu(l, di, &found_key); |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 215 | printk(KERN_INFO "\t\tdir oid %llu type %u\n", |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 216 | found_key.objectid, |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 217 | btrfs_dir_type(l, di)); |
Chris Mason | 62e2749 | 2007-03-15 12:56:47 -0400 | [diff] [blame] | 218 | break; |
| 219 | case BTRFS_ROOT_ITEM_KEY: |
| 220 | ri = btrfs_item_ptr(l, i, struct btrfs_root_item); |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 221 | printk(KERN_INFO "\t\troot data bytenr %llu refs %u\n", |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 222 | btrfs_disk_root_bytenr(l, ri), |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 223 | btrfs_disk_root_refs(l, ri)); |
Chris Mason | 62e2749 | 2007-03-15 12:56:47 -0400 | [diff] [blame] | 224 | break; |
| 225 | case BTRFS_EXTENT_ITEM_KEY: |
Josef Bacik | be2c765 | 2014-07-02 10:20:48 -0700 | [diff] [blame] | 226 | case BTRFS_METADATA_ITEM_KEY: |
| 227 | print_extent_item(l, i, type); |
Chris Mason | 62e2749 | 2007-03-15 12:56:47 -0400 | [diff] [blame] | 228 | break; |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 229 | case BTRFS_TREE_BLOCK_REF_KEY: |
| 230 | printk(KERN_INFO "\t\ttree block backref\n"); |
Chris Mason | 7bb8631 | 2007-12-11 09:25:06 -0500 | [diff] [blame] | 231 | break; |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 232 | case BTRFS_SHARED_BLOCK_REF_KEY: |
| 233 | printk(KERN_INFO "\t\tshared block backref\n"); |
| 234 | break; |
| 235 | case BTRFS_EXTENT_DATA_REF_KEY: |
| 236 | dref = btrfs_item_ptr(l, i, |
| 237 | struct btrfs_extent_data_ref); |
| 238 | print_extent_data_ref(l, dref); |
| 239 | break; |
| 240 | case BTRFS_SHARED_DATA_REF_KEY: |
| 241 | sref = btrfs_item_ptr(l, i, |
| 242 | struct btrfs_shared_data_ref); |
| 243 | printk(KERN_INFO "\t\tshared data backref count %u\n", |
| 244 | btrfs_shared_data_ref_count(l, sref)); |
| 245 | break; |
Chris Mason | 8c2383c | 2007-06-18 09:57:58 -0400 | [diff] [blame] | 246 | case BTRFS_EXTENT_DATA_KEY: |
| 247 | fi = btrfs_item_ptr(l, i, |
| 248 | struct btrfs_file_extent_item); |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 249 | if (btrfs_file_extent_type(l, fi) == |
Chris Mason | 8c2383c | 2007-06-18 09:57:58 -0400 | [diff] [blame] | 250 | BTRFS_FILE_EXTENT_INLINE) { |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 251 | printk(KERN_INFO "\t\tinline extent data " |
| 252 | "size %u\n", |
Chris Mason | 514ac8a | 2014-01-03 21:07:00 -0800 | [diff] [blame] | 253 | btrfs_file_extent_inline_len(l, i, fi)); |
Chris Mason | 8c2383c | 2007-06-18 09:57:58 -0400 | [diff] [blame] | 254 | break; |
| 255 | } |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 256 | printk(KERN_INFO "\t\textent data disk bytenr %llu " |
| 257 | "nr %llu\n", |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 258 | btrfs_file_extent_disk_bytenr(l, fi), |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 259 | btrfs_file_extent_disk_num_bytes(l, fi)); |
| 260 | printk(KERN_INFO "\t\textent data offset %llu " |
| 261 | "nr %llu ram %llu\n", |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 262 | btrfs_file_extent_offset(l, fi), |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 263 | btrfs_file_extent_num_bytes(l, fi), |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 264 | btrfs_file_extent_ram_bytes(l, fi)); |
Chris Mason | 8c2383c | 2007-06-18 09:57:58 -0400 | [diff] [blame] | 265 | break; |
Yan Zheng | 5d4f98a | 2009-06-10 10:45:14 -0400 | [diff] [blame] | 266 | case BTRFS_EXTENT_REF_V0_KEY: |
| 267 | #ifdef BTRFS_COMPAT_EXTENT_TREE_V0 |
| 268 | print_extent_ref_v0(l, i); |
| 269 | #else |
| 270 | BUG(); |
| 271 | #endif |
liubo | 333e810 | 2011-01-26 06:22:33 +0000 | [diff] [blame] | 272 | break; |
Chris Mason | 9078a3e | 2007-04-26 16:46:15 -0400 | [diff] [blame] | 273 | case BTRFS_BLOCK_GROUP_ITEM_KEY: |
| 274 | bi = btrfs_item_ptr(l, i, |
| 275 | struct btrfs_block_group_item); |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 276 | printk(KERN_INFO "\t\tblock group used %llu\n", |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 277 | btrfs_disk_block_group_used(l, bi)); |
Chris Mason | 62e2749 | 2007-03-15 12:56:47 -0400 | [diff] [blame] | 278 | break; |
Chris Mason | 0b86a83 | 2008-03-24 15:01:56 -0400 | [diff] [blame] | 279 | case BTRFS_CHUNK_ITEM_KEY: |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 280 | print_chunk(l, btrfs_item_ptr(l, i, |
| 281 | struct btrfs_chunk)); |
Chris Mason | 0b86a83 | 2008-03-24 15:01:56 -0400 | [diff] [blame] | 282 | break; |
| 283 | case BTRFS_DEV_ITEM_KEY: |
| 284 | print_dev_item(l, btrfs_item_ptr(l, i, |
| 285 | struct btrfs_dev_item)); |
| 286 | break; |
| 287 | case BTRFS_DEV_EXTENT_KEY: |
| 288 | dev_extent = btrfs_item_ptr(l, i, |
| 289 | struct btrfs_dev_extent); |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 290 | printk(KERN_INFO "\t\tdev extent chunk_tree %llu\n" |
Chris Mason | e17cade | 2008-04-15 15:41:47 -0400 | [diff] [blame] | 291 | "\t\tchunk objectid %llu chunk offset %llu " |
| 292 | "length %llu\n", |
Chris Mason | e17cade | 2008-04-15 15:41:47 -0400 | [diff] [blame] | 293 | btrfs_dev_extent_chunk_tree(l, dev_extent), |
Chris Mason | e17cade | 2008-04-15 15:41:47 -0400 | [diff] [blame] | 294 | btrfs_dev_extent_chunk_objectid(l, dev_extent), |
Chris Mason | e17cade | 2008-04-15 15:41:47 -0400 | [diff] [blame] | 295 | btrfs_dev_extent_chunk_offset(l, dev_extent), |
Chris Mason | e17cade | 2008-04-15 15:41:47 -0400 | [diff] [blame] | 296 | btrfs_dev_extent_length(l, dev_extent)); |
Eric Sandeen | 0e63602 | 2013-01-31 00:54:57 +0000 | [diff] [blame] | 297 | break; |
Stefan Behrens | 733f4fb | 2012-05-25 16:06:10 +0200 | [diff] [blame] | 298 | case BTRFS_DEV_STATS_KEY: |
| 299 | printk(KERN_INFO "\t\tdevice stats\n"); |
| 300 | break; |
Stefan Behrens | a2bff64 | 2012-11-05 17:32:20 +0100 | [diff] [blame] | 301 | case BTRFS_DEV_REPLACE_KEY: |
| 302 | printk(KERN_INFO "\t\tdev replace\n"); |
| 303 | break; |
Stefan Behrens | 8f8ae8e | 2013-08-15 17:11:18 +0200 | [diff] [blame] | 304 | case BTRFS_UUID_KEY_SUBVOL: |
| 305 | case BTRFS_UUID_KEY_RECEIVED_SUBVOL: |
| 306 | print_uuid_item(l, btrfs_item_ptr_offset(l, i), |
| 307 | btrfs_item_size_nr(l, i)); |
| 308 | break; |
Chris Mason | 62e2749 | 2007-03-15 12:56:47 -0400 | [diff] [blame] | 309 | }; |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 310 | } |
| 311 | } |
Chris Mason | e20d96d | 2007-03-22 12:13:20 -0400 | [diff] [blame] | 312 | |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 313 | void btrfs_print_tree(struct btrfs_root *root, struct extent_buffer *c) |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 314 | { |
Chris Mason | e17cade | 2008-04-15 15:41:47 -0400 | [diff] [blame] | 315 | int i; u32 nr; |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 316 | struct btrfs_key key; |
Chris Mason | db94535 | 2007-10-15 16:15:53 -0400 | [diff] [blame] | 317 | int level; |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 318 | |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 319 | if (!c) |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 320 | return; |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 321 | nr = btrfs_header_nritems(c); |
Chris Mason | db94535 | 2007-10-15 16:15:53 -0400 | [diff] [blame] | 322 | level = btrfs_header_level(c); |
| 323 | if (level == 0) { |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 324 | btrfs_print_leaf(root, c); |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 325 | return; |
| 326 | } |
Simon Kirby | c2cf52e | 2013-03-19 22:41:23 +0000 | [diff] [blame] | 327 | btrfs_info(root->fs_info, "node %llu level %d total ptrs %d free spc %u", |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 328 | btrfs_header_bytenr(c), level, nr, |
| 329 | (u32)BTRFS_NODEPTRS_PER_BLOCK(root) - nr); |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 330 | for (i = 0; i < nr; i++) { |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 331 | btrfs_node_key_to_cpu(c, &key, i); |
Chris Mason | d397712 | 2009-01-05 21:25:51 -0500 | [diff] [blame] | 332 | printk(KERN_INFO "\tkey %d (%llu %u %llu) block %llu\n", |
Geert Uytterhoeven | c1c9ff7 | 2013-08-20 13:20:07 +0200 | [diff] [blame] | 333 | i, key.objectid, key.type, key.offset, |
| 334 | btrfs_node_blockptr(c, i)); |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 335 | } |
| 336 | for (i = 0; i < nr; i++) { |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 337 | struct extent_buffer *next = read_tree_block(root, |
Chris Mason | db94535 | 2007-10-15 16:15:53 -0400 | [diff] [blame] | 338 | btrfs_node_blockptr(c, i), |
Chris Mason | ca7a79a | 2008-05-12 12:59:19 -0400 | [diff] [blame] | 339 | btrfs_level_size(root, level - 1), |
| 340 | btrfs_node_ptr_generation(c, i)); |
Chris Mason | 7518a23 | 2007-03-12 12:01:18 -0400 | [diff] [blame] | 341 | if (btrfs_is_leaf(next) && |
Daniel Cadete | c271b49 | 2009-07-22 16:52:13 -0400 | [diff] [blame] | 342 | level != 1) |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 343 | BUG(); |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 344 | if (btrfs_header_level(next) != |
Daniel Cadete | c271b49 | 2009-07-22 16:52:13 -0400 | [diff] [blame] | 345 | level - 1) |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 346 | BUG(); |
Chris Mason | 5f39d39 | 2007-10-15 16:14:19 -0400 | [diff] [blame] | 347 | btrfs_print_tree(root, next); |
| 348 | free_extent_buffer(next); |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 349 | } |
Chris Mason | 5de08d7 | 2007-02-24 06:24:44 -0500 | [diff] [blame] | 350 | } |