print-tree.c 12 KB

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