debug-tree output tree/key type instead of id
[platform/upstream/btrfs-progs.git] / 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 <stdio.h>
20 #include <stdlib.h>
21 #include <uuid/uuid.h>
22 #include "kerncompat.h"
23 #include "radix-tree.h"
24 #include "ctree.h"
25 #include "disk-io.h"
26
27 static int print_dir_item(struct extent_buffer *eb, struct btrfs_item *item,
28                           struct btrfs_dir_item *di)
29 {
30         u32 total;
31         u32 cur = 0;
32         u32 len;
33         u32 name_len;
34         u32 data_len;
35         char namebuf[BTRFS_NAME_LEN];
36         struct btrfs_disk_key location;
37
38         total = btrfs_item_size(eb, item);
39         while(cur < total) {
40                 btrfs_dir_item_key(eb, di, &location);
41                 printf("\t\tdir index %llu type %u\n",
42                        (unsigned long long)btrfs_disk_key_objectid(&location),
43                        btrfs_dir_type(eb, di));
44                 name_len = btrfs_dir_name_len(eb, di);
45                 data_len = btrfs_dir_data_len(eb, di);
46                 len = (name_len <= sizeof(namebuf))? name_len: sizeof(namebuf);
47                 read_extent_buffer(eb, namebuf, (unsigned long)(di + 1), len);
48                 printf("\t\tnamelen %u datalen %u name: %.*s\n",
49                        name_len, data_len, len, namebuf);
50                 len = sizeof(*di) + name_len + data_len;
51                 di = (struct btrfs_dir_item *)((char *)di + len);
52                 cur += len;
53         }
54         return 0;
55 }
56
57 static int print_inode_ref_item(struct extent_buffer *eb, struct btrfs_item *item,
58                                 struct btrfs_inode_ref *ref)
59 {
60         u32 total;
61         u32 cur = 0;
62         u32 len;
63         u32 name_len;
64         u64 index;
65         char namebuf[BTRFS_NAME_LEN];
66         total = btrfs_item_size(eb, item);
67         while(cur < total) {
68                 name_len = btrfs_inode_ref_name_len(eb, ref);
69                 index = btrfs_inode_ref_index(eb, ref);
70                 len = (name_len <= sizeof(namebuf))? name_len: sizeof(namebuf);
71                 read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
72                 printf("\t\tinode ref index %llu namelen %u name: %.*s\n",
73                        index, name_len, len, namebuf);
74                 len = sizeof(*ref) + name_len;
75                 ref = (struct btrfs_inode_ref *)((char *)ref + len);
76                 cur += len;
77         }
78         return 0;
79 }
80
81 static void print_chunk(struct extent_buffer *eb, struct btrfs_chunk *chunk)
82 {
83         int num_stripes = btrfs_chunk_num_stripes(eb, chunk);
84         int i;
85         printf("\t\tchunk length %llu owner %llu type %llu num_stripes %d\n",
86                (unsigned long long)btrfs_chunk_length(eb, chunk),
87                (unsigned long long)btrfs_chunk_owner(eb, chunk),
88                (unsigned long long)btrfs_chunk_type(eb, chunk),
89                num_stripes);
90         for (i = 0 ; i < num_stripes ; i++) {
91                 printf("\t\t\tstripe %d devid %llu offset %llu\n", i,
92                       (unsigned long long)btrfs_stripe_devid_nr(eb, chunk, i),
93                       (unsigned long long)btrfs_stripe_offset_nr(eb, chunk, i));
94         }
95 }
96 static void print_dev_item(struct extent_buffer *eb,
97                            struct btrfs_dev_item *dev_item)
98 {
99         printf("\t\tdev item devid %llu "
100                "total_bytes %llu bytes used %Lu\n",
101                (unsigned long long)btrfs_device_id(eb, dev_item),
102                (unsigned long long)btrfs_device_total_bytes(eb, dev_item),
103                (unsigned long long)btrfs_device_bytes_used(eb, dev_item));
104 }
105
106 static void print_uuids(struct extent_buffer *eb)
107 {
108         char fs_uuid[37];
109         char chunk_uuid[37];
110         u8 disk_uuid[BTRFS_UUID_SIZE];
111
112         read_extent_buffer(eb, disk_uuid, (unsigned long)btrfs_header_fsid(eb),
113                            BTRFS_FSID_SIZE);
114
115         fs_uuid[36] = '\0';
116         uuid_unparse(disk_uuid, fs_uuid);
117
118         read_extent_buffer(eb, disk_uuid,
119                            (unsigned long)btrfs_header_chunk_tree_uuid(eb),
120                            BTRFS_UUID_SIZE);
121
122         chunk_uuid[36] = '\0';
123         uuid_unparse(disk_uuid, chunk_uuid);
124         printf("fs uuid %s\nchunk uuid %s\n", fs_uuid, chunk_uuid);
125 }
126
127 static void print_file_extent_item(struct extent_buffer *eb,
128                                    struct btrfs_item *item,
129                                    struct btrfs_file_extent_item *fi)
130 {
131         int extent_type = btrfs_file_extent_type(eb, fi);
132
133         if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
134                 printf("\t\tinline extent data size %u "
135                        "ram %u compress %d\n",
136                   btrfs_file_extent_inline_item_len(eb, item),
137                   btrfs_file_extent_inline_len(eb, fi),
138                   btrfs_file_extent_compression(eb, fi));
139                 return;
140         }
141         if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
142                 printf("\t\tprealloc data disk byte %llu nr %llu\n",
143                   (unsigned long long)btrfs_file_extent_disk_bytenr(eb, fi),
144                   (unsigned long long)btrfs_file_extent_disk_num_bytes(eb, fi));
145                 printf("\t\tprealloc data offset %llu nr %llu\n",
146                   (unsigned long long)btrfs_file_extent_offset(eb, fi),
147                   (unsigned long long)btrfs_file_extent_num_bytes(eb, fi));
148                 return;
149         }
150         printf("\t\textent data disk byte %llu nr %llu\n",
151                 (unsigned long long)btrfs_file_extent_disk_bytenr(eb, fi),
152                 (unsigned long long)btrfs_file_extent_disk_num_bytes(eb, fi));
153         printf("\t\textent data offset %llu nr %llu ram %llu\n",
154                 (unsigned long long)btrfs_file_extent_offset(eb, fi),
155                 (unsigned long long)btrfs_file_extent_num_bytes(eb, fi),
156                 (unsigned long long)btrfs_file_extent_ram_bytes(eb, fi));
157         printf("\t\textent compression %d\n",
158                btrfs_file_extent_compression(eb, fi));
159 }
160
161
162 static void print_root_ref(struct extent_buffer *leaf, int slot, char *tag)
163 {
164         struct btrfs_root_ref *ref;
165         char namebuf[BTRFS_NAME_LEN];
166         int namelen;
167
168         ref = btrfs_item_ptr(leaf, slot, struct btrfs_root_ref);
169         namelen = btrfs_root_ref_name_len(leaf, ref);
170         read_extent_buffer(leaf, namebuf, (unsigned long)(ref + 1), namelen);
171         printf("\t\troot %s key dirid %llu sequence %llu name %.*s\n", tag,
172                (unsigned long long)btrfs_root_ref_dirid(leaf, ref),
173                (unsigned long long)btrfs_root_ref_sequence(leaf, ref),
174                namelen, namebuf);
175 }
176
177 static void print_key_type(u8 type)
178 {
179         switch (type) {
180         case BTRFS_INODE_ITEM_KEY:
181                 printf("INODE_ITEM");
182                 break;
183         case BTRFS_INODE_REF_KEY:
184                 printf("INODE_REF");
185                 break;
186         case BTRFS_DIR_ITEM_KEY:
187                 printf("DIR_ITEM");
188                 break;
189         case BTRFS_DIR_INDEX_KEY:
190                 printf("DIR_INDEX");
191                 break;
192         case BTRFS_XATTR_ITEM_KEY:
193                 printf("XATTR_ITEM");
194                 break;
195         case BTRFS_ORPHAN_ITEM_KEY:
196                 printf("ORPHAN_ITEM");
197                 break;
198         case BTRFS_ROOT_ITEM_KEY:
199                 printf("ROOT_ITEM");
200                 break;
201         case BTRFS_ROOT_REF_KEY:
202                 printf("ROOT_REF");
203                 break;
204         case BTRFS_ROOT_BACKREF_KEY:
205                 printf("ROOT_BACKREF");
206                 break;
207         case BTRFS_EXTENT_ITEM_KEY:
208                 printf("EXTENT_ITEM");
209                 break;
210         case BTRFS_EXTENT_REF_KEY:
211                 printf("EXTENT_REF");
212                 break;
213         case BTRFS_CSUM_ITEM_KEY:
214                 printf("CSUM_ITEM");
215                 break;
216         case BTRFS_EXTENT_CSUM_KEY:
217                 printf("EXTENT_CSUM");
218                 break;
219         case BTRFS_EXTENT_DATA_KEY:
220                 printf("EXTENT_DATA");
221                 break;
222         case BTRFS_BLOCK_GROUP_ITEM_KEY:
223                 printf("GROUP_ITEM");
224                 break;
225         case BTRFS_CHUNK_ITEM_KEY:
226                 printf("CHUNK_ITEM");
227                 break;
228         case BTRFS_DEV_ITEM_KEY:
229                 printf("DEV_ITEM");
230                 break;
231         case BTRFS_DEV_EXTENT_KEY:
232                 printf("DEV_EXTENT");
233                 break;
234         case BTRFS_STRING_ITEM_KEY:
235                 printf("STRING_ITEM");
236                 break;
237         default:
238                 printf("UNKNOWN");
239         };
240 }
241
242 void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
243 {
244         int i;
245         char *str;
246         struct btrfs_item *item;
247         struct btrfs_extent_item *ei;
248         struct btrfs_root_item *ri;
249         struct btrfs_dir_item *di;
250         struct btrfs_inode_item *ii;
251         struct btrfs_file_extent_item *fi;
252         struct btrfs_csum_item *ci;
253         struct btrfs_block_group_item *bi;
254         struct btrfs_extent_ref *ref;
255         struct btrfs_inode_ref *iref;
256         struct btrfs_dev_extent *dev_extent;
257         struct btrfs_disk_key disk_key;
258         struct btrfs_root_item root_item;
259         struct btrfs_block_group_item bg_item;
260         u32 nr = btrfs_header_nritems(l);
261         u32 type;
262
263         printf("leaf %llu ptrs %d free space %d generation %llu owner %llu\n",
264                 (unsigned long long)btrfs_header_bytenr(l), nr,
265                 btrfs_leaf_free_space(root, l),
266                 (unsigned long long)btrfs_header_generation(l),
267                 (unsigned long long)btrfs_header_owner(l));
268         print_uuids(l);
269         fflush(stdout);
270         for (i = 0 ; i < nr ; i++) {
271                 item = btrfs_item_nr(l, i);
272                 btrfs_item_key(l, &disk_key, i);
273                 type = btrfs_disk_key_type(&disk_key);
274                 printf("\titem %d key (%llu ",
275                         i,
276                         (unsigned long long)btrfs_disk_key_objectid(&disk_key));
277                 print_key_type(type);
278                 printf(" %llu) itemoff %d itemsize %d\n",
279                         (unsigned long long)btrfs_disk_key_offset(&disk_key),
280                         btrfs_item_offset(l, item),
281                         btrfs_item_size(l, item));
282                 switch (type) {
283                 case BTRFS_INODE_ITEM_KEY:
284                         ii = btrfs_item_ptr(l, i, struct btrfs_inode_item);
285                         printf("\t\tinode generation %llu size %llu block group %llu mode %o links %u\n",
286                                (unsigned long long)btrfs_inode_generation(l, ii),
287                                (unsigned long long)btrfs_inode_size(l, ii),
288                                (unsigned long long)btrfs_inode_block_group(l,ii),
289                                btrfs_inode_mode(l, ii),
290                                btrfs_inode_nlink(l, ii));
291                         break;
292                 case BTRFS_INODE_REF_KEY:
293                         iref = btrfs_item_ptr(l, i, struct btrfs_inode_ref);
294                         print_inode_ref_item(l, item, iref);
295                         break;
296                 case BTRFS_DIR_ITEM_KEY:
297                 case BTRFS_DIR_INDEX_KEY:
298                 case BTRFS_XATTR_ITEM_KEY:
299                         di = btrfs_item_ptr(l, i, struct btrfs_dir_item);
300                         print_dir_item(l, item, di);
301                         break;
302                 case BTRFS_ORPHAN_ITEM_KEY:
303                         printf("\t\torphan item\n");
304                         break;
305                 case BTRFS_ROOT_ITEM_KEY:
306                         ri = btrfs_item_ptr(l, i, struct btrfs_root_item);
307                         read_extent_buffer(l, &root_item, (unsigned long)ri, sizeof(root_item));
308                         printf("\t\troot data bytenr %llu level %d dirid %llu refs %u\n",
309                                 (unsigned long long)btrfs_root_bytenr(&root_item),
310                                 btrfs_root_level(&root_item),
311                                 (unsigned long long)btrfs_root_dirid(&root_item),
312                                 btrfs_root_refs(&root_item));
313                         if (1 || btrfs_root_refs(&root_item) == 0) {
314                                 struct btrfs_key drop_key;
315                                 btrfs_disk_key_to_cpu(&drop_key,
316                                                       &root_item.drop_progress);
317                                 printf("\t\tdrop key %Lu %x %Lu level %d\n",
318                                        (unsigned long long)drop_key.objectid,
319                                        drop_key.type,
320                                        (unsigned long long)drop_key.offset,
321                                        root_item.drop_level);
322                         }
323                         break;
324                 case BTRFS_ROOT_REF_KEY:
325                         print_root_ref(l, i, "ref");
326                         break;
327                 case BTRFS_ROOT_BACKREF_KEY:
328                         print_root_ref(l, i, "backref");
329                         break;
330                 case BTRFS_EXTENT_ITEM_KEY:
331                         ei = btrfs_item_ptr(l, i, struct btrfs_extent_item);
332                         printf("\t\textent data refs %u\n",
333                                 btrfs_extent_refs(l, ei));
334                         break;
335                 case BTRFS_EXTENT_REF_KEY:
336                         ref = btrfs_item_ptr(l, i, struct btrfs_extent_ref);
337                         printf("\t\textent back ref root %llu gen %llu "
338                                "owner %llu num_refs %lu\n",
339                                (unsigned long long)btrfs_ref_root(l, ref),
340                                (unsigned long long)btrfs_ref_generation(l, ref),
341                                (unsigned long long)btrfs_ref_objectid(l, ref),
342                                (unsigned long)btrfs_ref_num_refs(l, ref));
343                         break;
344                 case BTRFS_CSUM_ITEM_KEY:
345                         ci = btrfs_item_ptr(l, i, struct btrfs_csum_item);
346                         printf("\t\tcsum item\n");
347                         break;
348                 case BTRFS_EXTENT_CSUM_KEY:
349                         ci = btrfs_item_ptr(l, i, struct btrfs_csum_item);
350                         printf("\t\textent csum item\n");
351                         break;
352                 case BTRFS_EXTENT_DATA_KEY:
353                         fi = btrfs_item_ptr(l, i,
354                                             struct btrfs_file_extent_item);
355                         print_file_extent_item(l, item, fi);
356                         break;
357                 case BTRFS_BLOCK_GROUP_ITEM_KEY:
358                         bi = btrfs_item_ptr(l, i,
359                                             struct btrfs_block_group_item);
360                         read_extent_buffer(l, &bg_item, (unsigned long)bi,
361                                            sizeof(bg_item));
362                         printf("\t\tblock group used %llu flags %llu\n",
363                                (unsigned long long)btrfs_block_group_used(&bg_item),
364                                (unsigned long long)btrfs_block_group_flags(&bg_item));
365                         break;
366                 case BTRFS_CHUNK_ITEM_KEY:
367                         print_chunk(l, btrfs_item_ptr(l, i, struct btrfs_chunk));
368                         break;
369                 case BTRFS_DEV_ITEM_KEY:
370                         print_dev_item(l, btrfs_item_ptr(l, i,
371                                         struct btrfs_dev_item));
372                         break;
373                 case BTRFS_DEV_EXTENT_KEY:
374                         dev_extent = btrfs_item_ptr(l, i,
375                                                     struct btrfs_dev_extent);
376                         printf("\t\tdev extent chunk_tree %llu\n"
377                                "\t\tchunk objectid %llu chunk offset %llu "
378                                "length %llu\n",
379                                (unsigned long long)
380                                btrfs_dev_extent_chunk_tree(l, dev_extent),
381                                (unsigned long long)
382                                btrfs_dev_extent_chunk_objectid(l, dev_extent),
383                                (unsigned long long)
384                                btrfs_dev_extent_chunk_offset(l, dev_extent),
385                                (unsigned long long)
386                                btrfs_dev_extent_length(l, dev_extent));
387                         break;
388                 case BTRFS_STRING_ITEM_KEY:
389                         /* dirty, but it's simple */
390                         str = l->data + btrfs_item_ptr_offset(l, i);
391                         printf("\t\titem data %.*s\n", btrfs_item_size(l, item), str);
392                         break;
393                 };
394                 fflush(stdout);
395         }
396 }
397
398 void btrfs_print_tree(struct btrfs_root *root, struct extent_buffer *eb)
399 {
400         int i;
401         u32 nr;
402         u32 size;
403         struct btrfs_key key;
404
405         if (!eb)
406                 return;
407         nr = btrfs_header_nritems(eb);
408         if (btrfs_is_leaf(eb)) {
409                 btrfs_print_leaf(root, eb);
410                 return;
411         }
412         printf("node %llu level %d ptrs %d free %u generation %llu owner %llu\n",
413                (unsigned long long)eb->start,
414                 btrfs_header_level(eb), nr,
415                 (u32)BTRFS_NODEPTRS_PER_BLOCK(root) - nr,
416                 (unsigned long long)btrfs_header_generation(eb),
417                 (unsigned long long)btrfs_header_owner(eb));
418         print_uuids(eb);
419         fflush(stdout);
420         size = btrfs_level_size(root, btrfs_header_level(eb) - 1);
421         for (i = 0; i < nr; i++) {
422                 u64 blocknr = btrfs_node_blockptr(eb, i);
423                 btrfs_node_key_to_cpu(eb, &key, i);
424                 printf("\tkey %d (%llu ",
425                        i,
426                        (unsigned long long)key.objectid);
427                 print_key_type(key.type);
428                 printf(" %llu) block %llu (%llu) gen %llu\n",
429                        (unsigned long long)key.offset,
430                        (unsigned long long)blocknr,
431                        (unsigned long long)blocknr / size,
432                        (unsigned long long)btrfs_node_ptr_generation(eb, i));
433                 fflush(stdout);
434         }
435         for (i = 0; i < nr; i++) {
436                 struct extent_buffer *next = read_tree_block(root,
437                                              btrfs_node_blockptr(eb, i),
438                                              size,
439                                              btrfs_node_ptr_generation(eb, i));
440                 if (btrfs_is_leaf(next) &&
441                     btrfs_header_level(eb) != 1)
442                         BUG();
443                 if (btrfs_header_level(next) !=
444                         btrfs_header_level(eb) - 1)
445                         BUG();
446                 btrfs_print_tree(root, next);
447                 free_extent_buffer(next);
448         }
449 }
450