Btrfs: Start btree concurrency work.
[linux-2.6] / fs / btrfs / print-tree.c
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
19 #include "ctree.h"
20 #include "disk-io.h"
21 #include "print-tree.h"
22
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;
27         printk("\t\tchunk length %llu owner %llu type %llu num_stripes %d\n",
28                (unsigned long long)btrfs_chunk_length(eb, chunk),
29                (unsigned long long)btrfs_chunk_owner(eb, chunk),
30                (unsigned long long)btrfs_chunk_type(eb, chunk),
31                num_stripes);
32         for (i = 0 ; i < num_stripes ; i++) {
33                 printk("\t\t\tstripe %d devid %llu offset %llu\n", i,
34                       (unsigned long long)btrfs_stripe_devid_nr(eb, chunk, i),
35                       (unsigned long long)btrfs_stripe_offset_nr(eb, chunk, i));
36         }
37 }
38 static void print_dev_item(struct extent_buffer *eb,
39                            struct btrfs_dev_item *dev_item)
40 {
41         printk("\t\tdev item devid %llu "
42                "total_bytes %llu bytes used %Lu\n",
43                (unsigned long long)btrfs_device_id(eb, dev_item),
44                (unsigned long long)btrfs_device_total_bytes(eb, dev_item),
45                (unsigned long long)btrfs_device_bytes_used(eb, dev_item));
46 }
47 void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
48 {
49         int i;
50         u32 nr = btrfs_header_nritems(l);
51         struct btrfs_item *item;
52         struct btrfs_extent_item *ei;
53         struct btrfs_root_item *ri;
54         struct btrfs_dir_item *di;
55         struct btrfs_inode_item *ii;
56         struct btrfs_block_group_item *bi;
57         struct btrfs_file_extent_item *fi;
58         struct btrfs_key key;
59         struct btrfs_key found_key;
60         struct btrfs_extent_ref *ref;
61         struct btrfs_dev_extent *dev_extent;
62         u32 type;
63
64         printk("leaf %llu total ptrs %d free space %d\n",
65                 (unsigned long long)btrfs_header_bytenr(l), nr,
66                 btrfs_leaf_free_space(root, l));
67         for (i = 0 ; i < nr ; i++) {
68                 item = btrfs_item_nr(l, i);
69                 btrfs_item_key_to_cpu(l, &key, i);
70                 type = btrfs_key_type(&key);
71                 printk("\titem %d key (%llu %x %llu) itemoff %d itemsize %d\n",
72                         i,
73                         (unsigned long long)key.objectid, type,
74                         (unsigned long long)key.offset,
75                         btrfs_item_offset(l, item), btrfs_item_size(l, item));
76                 switch (type) {
77                 case BTRFS_INODE_ITEM_KEY:
78                         ii = btrfs_item_ptr(l, i, struct btrfs_inode_item);
79                         printk("\t\tinode generation %llu size %llu mode %o\n",
80                               (unsigned long long)btrfs_inode_generation(l, ii),
81                               (unsigned long long)btrfs_inode_size(l, ii),
82                                btrfs_inode_mode(l, ii));
83                         break;
84                 case BTRFS_DIR_ITEM_KEY:
85                         di = btrfs_item_ptr(l, i, struct btrfs_dir_item);
86                         btrfs_dir_item_key_to_cpu(l, di, &found_key);
87                         printk("\t\tdir oid %llu type %u\n",
88                                 (unsigned long long)found_key.objectid,
89                                 btrfs_dir_type(l, di));
90                         break;
91                 case BTRFS_ROOT_ITEM_KEY:
92                         ri = btrfs_item_ptr(l, i, struct btrfs_root_item);
93                         printk("\t\troot data bytenr %llu refs %u\n",
94                                 (unsigned long long)btrfs_disk_root_bytenr(l, ri),
95                                 btrfs_disk_root_refs(l, ri));
96                         break;
97                 case BTRFS_EXTENT_ITEM_KEY:
98                         ei = btrfs_item_ptr(l, i, struct btrfs_extent_item);
99                         printk("\t\textent data refs %u\n",
100                                 btrfs_extent_refs(l, ei));
101                         break;
102                 case BTRFS_EXTENT_REF_KEY:
103                         ref = btrfs_item_ptr(l, i, struct btrfs_extent_ref);
104                         printk("\t\textent back ref root %llu gen %llu "
105                                "owner %llu offset %llu\n",
106                                (unsigned long long)btrfs_ref_root(l, ref),
107                                (unsigned long long)btrfs_ref_generation(l, ref),
108                                (unsigned long long)btrfs_ref_objectid(l, ref),
109                                (unsigned long long)btrfs_ref_offset(l, ref));
110                         break;
111
112                 case BTRFS_EXTENT_DATA_KEY:
113                         fi = btrfs_item_ptr(l, i,
114                                             struct btrfs_file_extent_item);
115                         if (btrfs_file_extent_type(l, fi) ==
116                             BTRFS_FILE_EXTENT_INLINE) {
117                                 printk("\t\tinline extent data size %u\n",
118                                    btrfs_file_extent_inline_len(l, item));
119                                 break;
120                         }
121                         printk("\t\textent data disk bytenr %llu nr %llu\n",
122                                (unsigned long long)btrfs_file_extent_disk_bytenr(l, fi),
123                                (unsigned long long)btrfs_file_extent_disk_num_bytes(l, fi));
124                         printk("\t\textent data offset %llu nr %llu\n",
125                           (unsigned long long)btrfs_file_extent_offset(l, fi),
126                           (unsigned long long)btrfs_file_extent_num_bytes(l, fi));
127                         break;
128                 case BTRFS_BLOCK_GROUP_ITEM_KEY:
129                         bi = btrfs_item_ptr(l, i,
130                                             struct btrfs_block_group_item);
131                         printk("\t\tblock group used %llu\n",
132                                (unsigned long long)btrfs_disk_block_group_used(l, bi));
133                         break;
134                 case BTRFS_CHUNK_ITEM_KEY:
135                         print_chunk(l, btrfs_item_ptr(l, i, struct btrfs_chunk));
136                         break;
137                 case BTRFS_DEV_ITEM_KEY:
138                         print_dev_item(l, btrfs_item_ptr(l, i,
139                                         struct btrfs_dev_item));
140                         break;
141                 case BTRFS_DEV_EXTENT_KEY:
142                         dev_extent = btrfs_item_ptr(l, i,
143                                                     struct btrfs_dev_extent);
144                         printk("\t\tdev extent chunk_tree %llu\n"
145                                "\t\tchunk objectid %llu chunk offset %llu "
146                                "length %llu\n",
147                                (unsigned long long)
148                                btrfs_dev_extent_chunk_tree(l, dev_extent),
149                                (unsigned long long)
150                                btrfs_dev_extent_chunk_objectid(l, dev_extent),
151                                (unsigned long long)
152                                btrfs_dev_extent_chunk_offset(l, dev_extent),
153                                (unsigned long long)
154                                btrfs_dev_extent_length(l, dev_extent));
155                 };
156         }
157 }
158
159 void btrfs_print_tree(struct btrfs_root *root, struct extent_buffer *c)
160 {
161         int i; u32 nr;
162         struct btrfs_key key;
163         int level;
164
165         if (!c)
166                 return;
167         nr = btrfs_header_nritems(c);
168         level = btrfs_header_level(c);
169         if (level == 0) {
170                 btrfs_print_leaf(root, c);
171                 return;
172         }
173         printk("node %llu level %d total ptrs %d free spc %u\n",
174                (unsigned long long)btrfs_header_bytenr(c),
175                btrfs_header_level(c), nr,
176                (u32)BTRFS_NODEPTRS_PER_BLOCK(root) - nr);
177         for (i = 0; i < nr; i++) {
178                 btrfs_node_key_to_cpu(c, &key, i);
179                 printk("\tkey %d (%llu %u %llu) block %llu\n",
180                        i,
181                        (unsigned long long)key.objectid,
182                        key.type,
183                        (unsigned long long)key.offset,
184                        (unsigned long long)btrfs_node_blockptr(c, i));
185         }
186         for (i = 0; i < nr; i++) {
187                 struct extent_buffer *next = read_tree_block(root,
188                                         btrfs_node_blockptr(c, i),
189                                         btrfs_level_size(root, level - 1),
190                                         btrfs_node_ptr_generation(c, i));
191                 if (btrfs_is_leaf(next) &&
192                     btrfs_header_level(c) != 1)
193                         BUG();
194                 if (btrfs_header_level(next) !=
195                         btrfs_header_level(c) - 1)
196                         BUG();
197                 btrfs_print_tree(root, next);
198                 free_extent_buffer(next);
199         }
200 }
201