print-tree.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387
  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. #include "ctree.h"
  19. #include "disk-io.h"
  20. #include "print-tree.h"
  21. static void print_chunk(struct extent_buffer *eb, struct btrfs_chunk *chunk)
  22. {
  23. int num_stripes = btrfs_chunk_num_stripes(eb, chunk);
  24. int i;
  25. pr_info("\t\tchunk length %llu owner %llu type %llu num_stripes %d\n",
  26. btrfs_chunk_length(eb, chunk), btrfs_chunk_owner(eb, chunk),
  27. btrfs_chunk_type(eb, chunk), num_stripes);
  28. for (i = 0 ; i < num_stripes ; i++) {
  29. pr_info("\t\t\tstripe %d devid %llu offset %llu\n", i,
  30. btrfs_stripe_devid_nr(eb, chunk, i),
  31. btrfs_stripe_offset_nr(eb, chunk, i));
  32. }
  33. }
  34. static void print_dev_item(struct extent_buffer *eb,
  35. struct btrfs_dev_item *dev_item)
  36. {
  37. pr_info("\t\tdev item devid %llu total_bytes %llu bytes used %llu\n",
  38. btrfs_device_id(eb, dev_item),
  39. btrfs_device_total_bytes(eb, dev_item),
  40. btrfs_device_bytes_used(eb, dev_item));
  41. }
  42. static void print_extent_data_ref(struct extent_buffer *eb,
  43. struct btrfs_extent_data_ref *ref)
  44. {
  45. pr_cont("extent data backref root %llu objectid %llu offset %llu count %u\n",
  46. btrfs_extent_data_ref_root(eb, ref),
  47. btrfs_extent_data_ref_objectid(eb, ref),
  48. btrfs_extent_data_ref_offset(eb, ref),
  49. btrfs_extent_data_ref_count(eb, ref));
  50. }
  51. static void print_extent_item(struct extent_buffer *eb, int slot, int type)
  52. {
  53. struct btrfs_extent_item *ei;
  54. struct btrfs_extent_inline_ref *iref;
  55. struct btrfs_extent_data_ref *dref;
  56. struct btrfs_shared_data_ref *sref;
  57. struct btrfs_disk_key key;
  58. unsigned long end;
  59. unsigned long ptr;
  60. u32 item_size = btrfs_item_size_nr(eb, slot);
  61. u64 flags;
  62. u64 offset;
  63. int ref_index = 0;
  64. if (item_size < sizeof(*ei)) {
  65. #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
  66. struct btrfs_extent_item_v0 *ei0;
  67. BUG_ON(item_size != sizeof(*ei0));
  68. ei0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_item_v0);
  69. pr_info("\t\textent refs %u\n",
  70. btrfs_extent_refs_v0(eb, ei0));
  71. return;
  72. #else
  73. BUG();
  74. #endif
  75. }
  76. ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
  77. flags = btrfs_extent_flags(eb, ei);
  78. pr_info("\t\textent refs %llu gen %llu flags %llu\n",
  79. btrfs_extent_refs(eb, ei), btrfs_extent_generation(eb, ei),
  80. flags);
  81. if ((type == BTRFS_EXTENT_ITEM_KEY) &&
  82. flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
  83. struct btrfs_tree_block_info *info;
  84. info = (struct btrfs_tree_block_info *)(ei + 1);
  85. btrfs_tree_block_key(eb, info, &key);
  86. pr_info("\t\ttree block key (%llu %u %llu) level %d\n",
  87. btrfs_disk_key_objectid(&key), key.type,
  88. btrfs_disk_key_offset(&key),
  89. btrfs_tree_block_level(eb, info));
  90. iref = (struct btrfs_extent_inline_ref *)(info + 1);
  91. } else {
  92. iref = (struct btrfs_extent_inline_ref *)(ei + 1);
  93. }
  94. ptr = (unsigned long)iref;
  95. end = (unsigned long)ei + item_size;
  96. while (ptr < end) {
  97. iref = (struct btrfs_extent_inline_ref *)ptr;
  98. type = btrfs_extent_inline_ref_type(eb, iref);
  99. offset = btrfs_extent_inline_ref_offset(eb, iref);
  100. pr_info("\t\tref#%d: ", ref_index++);
  101. switch (type) {
  102. case BTRFS_TREE_BLOCK_REF_KEY:
  103. pr_cont("tree block backref root %llu\n", offset);
  104. break;
  105. case BTRFS_SHARED_BLOCK_REF_KEY:
  106. pr_cont("shared block backref parent %llu\n", offset);
  107. /*
  108. * offset is supposed to be a tree block which
  109. * must be aligned to nodesize.
  110. */
  111. if (!IS_ALIGNED(offset, eb->fs_info->nodesize))
  112. pr_info("\t\t\t(parent %llu is NOT ALIGNED to nodesize %llu)\n",
  113. offset, (unsigned long long)eb->fs_info->nodesize);
  114. break;
  115. case BTRFS_EXTENT_DATA_REF_KEY:
  116. dref = (struct btrfs_extent_data_ref *)(&iref->offset);
  117. print_extent_data_ref(eb, dref);
  118. break;
  119. case BTRFS_SHARED_DATA_REF_KEY:
  120. sref = (struct btrfs_shared_data_ref *)(iref + 1);
  121. pr_cont("shared data backref parent %llu count %u\n",
  122. offset, btrfs_shared_data_ref_count(eb, sref));
  123. /*
  124. * offset is supposed to be a tree block which
  125. * must be aligned to nodesize.
  126. */
  127. if (!IS_ALIGNED(offset, eb->fs_info->nodesize))
  128. pr_info("\t\t\t(parent %llu is NOT ALIGNED to nodesize %llu)\n",
  129. offset, (unsigned long long)eb->fs_info->nodesize);
  130. break;
  131. default:
  132. pr_cont("(extent %llu has INVALID ref type %d)\n",
  133. eb->start, type);
  134. return;
  135. }
  136. ptr += btrfs_extent_inline_ref_size(type);
  137. }
  138. WARN_ON(ptr > end);
  139. }
  140. #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
  141. static void print_extent_ref_v0(struct extent_buffer *eb, int slot)
  142. {
  143. struct btrfs_extent_ref_v0 *ref0;
  144. ref0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_ref_v0);
  145. printk("\t\textent back ref root %llu gen %llu owner %llu num_refs %lu\n",
  146. btrfs_ref_root_v0(eb, ref0),
  147. btrfs_ref_generation_v0(eb, ref0),
  148. btrfs_ref_objectid_v0(eb, ref0),
  149. (unsigned long)btrfs_ref_count_v0(eb, ref0));
  150. }
  151. #endif
  152. static void print_uuid_item(struct extent_buffer *l, unsigned long offset,
  153. u32 item_size)
  154. {
  155. if (!IS_ALIGNED(item_size, sizeof(u64))) {
  156. pr_warn("BTRFS: uuid item with illegal size %lu!\n",
  157. (unsigned long)item_size);
  158. return;
  159. }
  160. while (item_size) {
  161. __le64 subvol_id;
  162. read_extent_buffer(l, &subvol_id, offset, sizeof(subvol_id));
  163. pr_info("\t\tsubvol_id %llu\n",
  164. (unsigned long long)le64_to_cpu(subvol_id));
  165. item_size -= sizeof(u64);
  166. offset += sizeof(u64);
  167. }
  168. }
  169. void btrfs_print_leaf(struct extent_buffer *l)
  170. {
  171. struct btrfs_fs_info *fs_info;
  172. int i;
  173. u32 type, nr;
  174. struct btrfs_item *item;
  175. struct btrfs_root_item *ri;
  176. struct btrfs_dir_item *di;
  177. struct btrfs_inode_item *ii;
  178. struct btrfs_block_group_item *bi;
  179. struct btrfs_file_extent_item *fi;
  180. struct btrfs_extent_data_ref *dref;
  181. struct btrfs_shared_data_ref *sref;
  182. struct btrfs_dev_extent *dev_extent;
  183. struct btrfs_key key;
  184. struct btrfs_key found_key;
  185. if (!l)
  186. return;
  187. fs_info = l->fs_info;
  188. nr = btrfs_header_nritems(l);
  189. btrfs_info(fs_info, "leaf %llu total ptrs %d free space %d",
  190. btrfs_header_bytenr(l), nr,
  191. btrfs_leaf_free_space(fs_info, l));
  192. for (i = 0 ; i < nr ; i++) {
  193. item = btrfs_item_nr(i);
  194. btrfs_item_key_to_cpu(l, &key, i);
  195. type = key.type;
  196. pr_info("\titem %d key (%llu %u %llu) itemoff %d itemsize %d\n",
  197. i, key.objectid, type, key.offset,
  198. btrfs_item_offset(l, item), btrfs_item_size(l, item));
  199. switch (type) {
  200. case BTRFS_INODE_ITEM_KEY:
  201. ii = btrfs_item_ptr(l, i, struct btrfs_inode_item);
  202. pr_info("\t\tinode generation %llu size %llu mode %o\n",
  203. btrfs_inode_generation(l, ii),
  204. btrfs_inode_size(l, ii),
  205. btrfs_inode_mode(l, ii));
  206. break;
  207. case BTRFS_DIR_ITEM_KEY:
  208. di = btrfs_item_ptr(l, i, struct btrfs_dir_item);
  209. btrfs_dir_item_key_to_cpu(l, di, &found_key);
  210. pr_info("\t\tdir oid %llu type %u\n",
  211. found_key.objectid,
  212. btrfs_dir_type(l, di));
  213. break;
  214. case BTRFS_ROOT_ITEM_KEY:
  215. ri = btrfs_item_ptr(l, i, struct btrfs_root_item);
  216. pr_info("\t\troot data bytenr %llu refs %u\n",
  217. btrfs_disk_root_bytenr(l, ri),
  218. btrfs_disk_root_refs(l, ri));
  219. break;
  220. case BTRFS_EXTENT_ITEM_KEY:
  221. case BTRFS_METADATA_ITEM_KEY:
  222. print_extent_item(l, i, type);
  223. break;
  224. case BTRFS_TREE_BLOCK_REF_KEY:
  225. pr_info("\t\ttree block backref\n");
  226. break;
  227. case BTRFS_SHARED_BLOCK_REF_KEY:
  228. pr_info("\t\tshared block backref\n");
  229. break;
  230. case BTRFS_EXTENT_DATA_REF_KEY:
  231. dref = btrfs_item_ptr(l, i,
  232. struct btrfs_extent_data_ref);
  233. print_extent_data_ref(l, dref);
  234. break;
  235. case BTRFS_SHARED_DATA_REF_KEY:
  236. sref = btrfs_item_ptr(l, i,
  237. struct btrfs_shared_data_ref);
  238. pr_info("\t\tshared data backref count %u\n",
  239. btrfs_shared_data_ref_count(l, sref));
  240. break;
  241. case BTRFS_EXTENT_DATA_KEY:
  242. fi = btrfs_item_ptr(l, i,
  243. struct btrfs_file_extent_item);
  244. if (btrfs_file_extent_type(l, fi) ==
  245. BTRFS_FILE_EXTENT_INLINE) {
  246. pr_info("\t\tinline extent data size %u\n",
  247. btrfs_file_extent_inline_len(l, i, fi));
  248. break;
  249. }
  250. pr_info("\t\textent data disk bytenr %llu nr %llu\n",
  251. btrfs_file_extent_disk_bytenr(l, fi),
  252. btrfs_file_extent_disk_num_bytes(l, fi));
  253. pr_info("\t\textent data offset %llu nr %llu ram %llu\n",
  254. btrfs_file_extent_offset(l, fi),
  255. btrfs_file_extent_num_bytes(l, fi),
  256. btrfs_file_extent_ram_bytes(l, fi));
  257. break;
  258. case BTRFS_EXTENT_REF_V0_KEY:
  259. #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
  260. print_extent_ref_v0(l, i);
  261. #else
  262. BUG();
  263. #endif
  264. break;
  265. case BTRFS_BLOCK_GROUP_ITEM_KEY:
  266. bi = btrfs_item_ptr(l, i,
  267. struct btrfs_block_group_item);
  268. pr_info(
  269. "\t\tblock group used %llu chunk_objectid %llu flags %llu\n",
  270. btrfs_disk_block_group_used(l, bi),
  271. btrfs_disk_block_group_chunk_objectid(l, bi),
  272. btrfs_disk_block_group_flags(l, bi));
  273. break;
  274. case BTRFS_CHUNK_ITEM_KEY:
  275. print_chunk(l, btrfs_item_ptr(l, i,
  276. struct btrfs_chunk));
  277. break;
  278. case BTRFS_DEV_ITEM_KEY:
  279. print_dev_item(l, btrfs_item_ptr(l, i,
  280. struct btrfs_dev_item));
  281. break;
  282. case BTRFS_DEV_EXTENT_KEY:
  283. dev_extent = btrfs_item_ptr(l, i,
  284. struct btrfs_dev_extent);
  285. pr_info("\t\tdev extent chunk_tree %llu\n\t\tchunk objectid %llu chunk offset %llu length %llu\n",
  286. btrfs_dev_extent_chunk_tree(l, dev_extent),
  287. btrfs_dev_extent_chunk_objectid(l, dev_extent),
  288. btrfs_dev_extent_chunk_offset(l, dev_extent),
  289. btrfs_dev_extent_length(l, dev_extent));
  290. break;
  291. case BTRFS_PERSISTENT_ITEM_KEY:
  292. pr_info("\t\tpersistent item objectid %llu offset %llu\n",
  293. key.objectid, key.offset);
  294. switch (key.objectid) {
  295. case BTRFS_DEV_STATS_OBJECTID:
  296. pr_info("\t\tdevice stats\n");
  297. break;
  298. default:
  299. pr_info("\t\tunknown persistent item\n");
  300. }
  301. break;
  302. case BTRFS_TEMPORARY_ITEM_KEY:
  303. pr_info("\t\ttemporary item objectid %llu offset %llu\n",
  304. key.objectid, key.offset);
  305. switch (key.objectid) {
  306. case BTRFS_BALANCE_OBJECTID:
  307. pr_info("\t\tbalance status\n");
  308. break;
  309. default:
  310. pr_info("\t\tunknown temporary item\n");
  311. }
  312. break;
  313. case BTRFS_DEV_REPLACE_KEY:
  314. pr_info("\t\tdev replace\n");
  315. break;
  316. case BTRFS_UUID_KEY_SUBVOL:
  317. case BTRFS_UUID_KEY_RECEIVED_SUBVOL:
  318. print_uuid_item(l, btrfs_item_ptr_offset(l, i),
  319. btrfs_item_size_nr(l, i));
  320. break;
  321. };
  322. }
  323. }
  324. void btrfs_print_tree(struct extent_buffer *c)
  325. {
  326. struct btrfs_fs_info *fs_info;
  327. int i; u32 nr;
  328. struct btrfs_key key;
  329. int level;
  330. if (!c)
  331. return;
  332. fs_info = c->fs_info;
  333. nr = btrfs_header_nritems(c);
  334. level = btrfs_header_level(c);
  335. if (level == 0) {
  336. btrfs_print_leaf(c);
  337. return;
  338. }
  339. btrfs_info(fs_info,
  340. "node %llu level %d total ptrs %d free spc %u",
  341. btrfs_header_bytenr(c), level, nr,
  342. (u32)BTRFS_NODEPTRS_PER_BLOCK(fs_info) - nr);
  343. for (i = 0; i < nr; i++) {
  344. btrfs_node_key_to_cpu(c, &key, i);
  345. pr_info("\tkey %d (%llu %u %llu) block %llu\n",
  346. i, key.objectid, key.type, key.offset,
  347. btrfs_node_blockptr(c, i));
  348. }
  349. for (i = 0; i < nr; i++) {
  350. struct extent_buffer *next = read_tree_block(fs_info,
  351. btrfs_node_blockptr(c, i),
  352. btrfs_node_ptr_generation(c, i));
  353. if (IS_ERR(next)) {
  354. continue;
  355. } else if (!extent_buffer_uptodate(next)) {
  356. free_extent_buffer(next);
  357. continue;
  358. }
  359. if (btrfs_is_leaf(next) &&
  360. level != 1)
  361. BUG();
  362. if (btrfs_header_level(next) !=
  363. level - 1)
  364. BUG();
  365. btrfs_print_tree(next);
  366. free_extent_buffer(next);
  367. }
  368. }