print-tree.c 12 KB

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