PageRenderTime 26ms CodeModel.GetById 14ms RepoModel.GetById 1ms app.codeStats 0ms

/fs/btrfs/print-tree.c

https://github.com/mstsirkin/linux
C | 338 lines | 307 code | 14 blank | 17 comment | 18 complexity | d3e2f8ed1eb65c9fd8a039ee35f63260 MD5 | raw file
    

  1. /*
    2. 

  2.  * Copyright (C) 2007 Oracle.  All rights reserved.
    3. 

  3.  *
    4. 

  4.  * This program is free software; you can redistribute it and/or
    5. 

  5.  * modify it under the terms of the GNU General Public
    6. 

  6.  * License v2 as published by the Free Software Foundation.
    7. 

  7.  *
    8. 

  8.  * This program is distributed in the hope that it will be useful,
    9. 

  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    10. 

  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    11. 

  11.  * General Public License for more details.
    12. 

  12.  *
    13. 

  13.  * You should have received a copy of the GNU General Public
    14. 

  14.  * License along with this program; if not, write to the
    15. 

  15.  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    16. 

  16.  * Boston, MA 021110-1307, USA.
    17. 

  17.  */
    18. 

  18. 

  19. #include "ctree.h"
    20. 

  20. #include "disk-io.h"
    21. 

  21. #include "print-tree.h"
    22. 

  22. 

  23. static void print_chunk(struct extent_buffer *eb, struct btrfs_chunk *chunk)
    24. 

  24. {
    25. 

  25. 	int num_stripes = btrfs_chunk_num_stripes(eb, chunk);
    26. 

  26. 	int i;
    27. 

  27. 	printk(KERN_INFO "\t\tchunk length %llu owner %llu type %llu "
    28. 

  28. 	       "num_stripes %d\n",
    29. 

  29. 	       (unsigned long long)btrfs_chunk_length(eb, chunk),
    30. 

  30. 	       (unsigned long long)btrfs_chunk_owner(eb, chunk),
    31. 

  31. 	       (unsigned long long)btrfs_chunk_type(eb, chunk),
    32. 

  32. 	       num_stripes);
    33. 

  33. 	for (i = 0 ; i < num_stripes ; i++) {
    34. 

  34. 		printk(KERN_INFO "\t\t\tstripe %d devid %llu offset %llu\n", i,
    35. 

  35. 		      (unsigned long long)btrfs_stripe_devid_nr(eb, chunk, i),
    36. 

  36. 		      (unsigned long long)btrfs_stripe_offset_nr(eb, chunk, i));
    37. 

  37. 	}
    38. 

  38. }
    39. 

  39. static void print_dev_item(struct extent_buffer *eb,
    40. 

  40. 			   struct btrfs_dev_item *dev_item)
    41. 

  41. {
    42. 

  42. 	printk(KERN_INFO "\t\tdev item devid %llu "
    43. 

  43. 	       "total_bytes %llu bytes used %llu\n",
    44. 

  44. 	       (unsigned long long)btrfs_device_id(eb, dev_item),
    45. 

  45. 	       (unsigned long long)btrfs_device_total_bytes(eb, dev_item),
    46. 

  46. 	       (unsigned long long)btrfs_device_bytes_used(eb, dev_item));
    47. 

  47. }
    48. 

  48. static void print_extent_data_ref(struct extent_buffer *eb,
    49. 

  49. 				  struct btrfs_extent_data_ref *ref)
    50. 

  50. {
    51. 

  51. 	printk(KERN_INFO "\t\textent data backref root %llu "
    52. 

  52. 	       "objectid %llu offset %llu count %u\n",
    53. 

  53. 	       (unsigned long long)btrfs_extent_data_ref_root(eb, ref),
    54. 

  54. 	       (unsigned long long)btrfs_extent_data_ref_objectid(eb, ref),
    55. 

  55. 	       (unsigned long long)btrfs_extent_data_ref_offset(eb, ref),
    56. 

  56. 	       btrfs_extent_data_ref_count(eb, ref));
    57. 

  57. }
    58. 

  58. 

  59. static void print_extent_item(struct extent_buffer *eb, int slot)
    60. 

  60. {
    61. 

  61. 	struct btrfs_extent_item *ei;
    62. 

  62. 	struct btrfs_extent_inline_ref *iref;
    63. 

  63. 	struct btrfs_extent_data_ref *dref;
    64. 

  64. 	struct btrfs_shared_data_ref *sref;
    65. 

  65. 	struct btrfs_disk_key key;
    66. 

  66. 	unsigned long end;
    67. 

  67. 	unsigned long ptr;
    68. 

  68. 	int type;
    69. 

  69. 	u32 item_size = btrfs_item_size_nr(eb, slot);
    70. 

  70. 	u64 flags;
    71. 

  71. 	u64 offset;
    72. 

  72. 

  73. 	if (item_size < sizeof(*ei)) {
    74. 

  74. #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
    75. 

  75. 		struct btrfs_extent_item_v0 *ei0;
    76. 

  76. 		BUG_ON(item_size != sizeof(*ei0));
    77. 

  77. 		ei0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_item_v0);
    78. 

  78. 		printk(KERN_INFO "\t\textent refs %u\n",
    79. 

  79. 		       btrfs_extent_refs_v0(eb, ei0));
    80. 

  80. 		return;
    81. 

  81. #else
    82. 

  82. 		BUG();
    83. 

  83. #endif
    84. 

  84. 	}
    85. 

  85. 

  86. 	ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
    87. 

  87. 	flags = btrfs_extent_flags(eb, ei);
    88. 

  88. 

  89. 	printk(KERN_INFO "\t\textent refs %llu gen %llu flags %llu\n",
    90. 

  90. 	       (unsigned long long)btrfs_extent_refs(eb, ei),
    91. 

  91. 	       (unsigned long long)btrfs_extent_generation(eb, ei),
    92. 

  92. 	       (unsigned long long)flags);
    93. 

  93. 

  94. 	if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
    95. 

  95. 		struct btrfs_tree_block_info *info;
    96. 

  96. 		info = (struct btrfs_tree_block_info *)(ei + 1);
    97. 

  97. 		btrfs_tree_block_key(eb, info, &key);
    98. 

  98. 		printk(KERN_INFO "\t\ttree block key (%llu %x %llu) "
    99. 

  99. 		       "level %d\n",
    100. 

  100. 		       (unsigned long long)btrfs_disk_key_objectid(&key),
    101. 

  101. 		       key.type,
    102. 

  102. 		       (unsigned long long)btrfs_disk_key_offset(&key),
    103. 

  103. 		       btrfs_tree_block_level(eb, info));
    104. 

  104. 		iref = (struct btrfs_extent_inline_ref *)(info + 1);
    105. 

  105. 	} else {
    106. 

  106. 		iref = (struct btrfs_extent_inline_ref *)(ei + 1);
    107. 

  107. 	}
    108. 

  108. 

  109. 	ptr = (unsigned long)iref;
    110. 

  110. 	end = (unsigned long)ei + item_size;
    111. 

  111. 	while (ptr < end) {
    112. 

  112. 		iref = (struct btrfs_extent_inline_ref *)ptr;
    113. 

  113. 		type = btrfs_extent_inline_ref_type(eb, iref);
    114. 

  114. 		offset = btrfs_extent_inline_ref_offset(eb, iref);
    115. 

  115. 		switch (type) {
    116. 

  116. 		case BTRFS_TREE_BLOCK_REF_KEY:
    117. 

  117. 			printk(KERN_INFO "\t\ttree block backref "
    118. 

  118. 				"root %llu\n", (unsigned long long)offset);
    119. 

  119. 			break;
    120. 

  120. 		case BTRFS_SHARED_BLOCK_REF_KEY:
    121. 

  121. 			printk(KERN_INFO "\t\tshared block backref "
    122. 

  122. 				"parent %llu\n", (unsigned long long)offset);
    123. 

  123. 			break;
    124. 

  124. 		case BTRFS_EXTENT_DATA_REF_KEY:
    125. 

  125. 			dref = (struct btrfs_extent_data_ref *)(&iref->offset);
    126. 

  126. 			print_extent_data_ref(eb, dref);
    127. 

  127. 			break;
    128. 

  128. 		case BTRFS_SHARED_DATA_REF_KEY:
    129. 

  129. 			sref = (struct btrfs_shared_data_ref *)(iref + 1);
    130. 

  130. 			printk(KERN_INFO "\t\tshared data backref "
    131. 

  131. 			       "parent %llu count %u\n",
    132. 

  132. 			       (unsigned long long)offset,
    133. 

  133. 			       btrfs_shared_data_ref_count(eb, sref));
    134. 

  134. 			break;
    135. 

  135. 		default:
    136. 

  136. 			BUG();
    137. 

  137. 		}
    138. 

  138. 		ptr += btrfs_extent_inline_ref_size(type);
    139. 

  139. 	}
    140. 

  140. 	WARN_ON(ptr > end);
    141. 

  141. }
    142. 

  142. 

  143. #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
    144. 

  144. static void print_extent_ref_v0(struct extent_buffer *eb, int slot)
    145. 

  145. {
    146. 

  146. 	struct btrfs_extent_ref_v0 *ref0;
    147. 

  147. 

  148. 	ref0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_ref_v0);
    149. 

  149. 	printk("\t\textent back ref root %llu gen %llu "
    150. 

  150. 		"owner %llu num_refs %lu\n",
    151. 

  151. 		(unsigned long long)btrfs_ref_root_v0(eb, ref0),
    152. 

  152. 		(unsigned long long)btrfs_ref_generation_v0(eb, ref0),
    153. 

  153. 		(unsigned long long)btrfs_ref_objectid_v0(eb, ref0),
    154. 

  154. 		(unsigned long)btrfs_ref_count_v0(eb, ref0));
    155. 

  155. }
    156. 

  156. #endif
    157. 

  157. 

  158. void btrfs_print_leaf(struct btrfs_root *root, struct extent_buffer *l)
    159. 

  159. {
    160. 

  160. 	int i;
    161. 

  161. 	u32 type;
    162. 

  162. 	u32 nr = btrfs_header_nritems(l);
    163. 

  163. 	struct btrfs_item *item;
    164. 

  164. 	struct btrfs_root_item *ri;
    165. 

  165. 	struct btrfs_dir_item *di;
    166. 

  166. 	struct btrfs_inode_item *ii;
    167. 

  167. 	struct btrfs_block_group_item *bi;
    168. 

  168. 	struct btrfs_file_extent_item *fi;
    169. 

  169. 	struct btrfs_extent_data_ref *dref;
    170. 

  170. 	struct btrfs_shared_data_ref *sref;
    171. 

  171. 	struct btrfs_dev_extent *dev_extent;
    172. 

  172. 	struct btrfs_key key;
    173. 

  173. 	struct btrfs_key found_key;
    174. 

  174. 

  175. 	printk(KERN_INFO "leaf %llu total ptrs %d free space %d\n",
    176. 

  176. 		(unsigned long long)btrfs_header_bytenr(l), nr,
    177. 

  177. 		btrfs_leaf_free_space(root, l));
    178. 

  178. 	for (i = 0 ; i < nr ; i++) {
    179. 

  179. 		item = btrfs_item_nr(l, i);
    180. 

  180. 		btrfs_item_key_to_cpu(l, &key, i);
    181. 

  181. 		type = btrfs_key_type(&key);
    182. 

  182. 		printk(KERN_INFO "\titem %d key (%llu %x %llu) itemoff %d "
    183. 

  183. 		       "itemsize %d\n",
    184. 

  184. 			i,
    185. 

  185. 			(unsigned long long)key.objectid, type,
    186. 

  186. 			(unsigned long long)key.offset,
    187. 

  187. 			btrfs_item_offset(l, item), btrfs_item_size(l, item));
    188. 

  188. 		switch (type) {
    189. 

  189. 		case BTRFS_INODE_ITEM_KEY:
    190. 

  190. 			ii = btrfs_item_ptr(l, i, struct btrfs_inode_item);
    191. 

  191. 			printk(KERN_INFO "\t\tinode generation %llu size %llu "
    192. 

  192. 			       "mode %o\n",
    193. 

  193. 			       (unsigned long long)
    194. 

  194. 			       btrfs_inode_generation(l, ii),
    195. 

  195. 			      (unsigned long long)btrfs_inode_size(l, ii),
    196. 

  196. 			       btrfs_inode_mode(l, ii));
    197. 

  197. 			break;
    198. 

  198. 		case BTRFS_DIR_ITEM_KEY:
    199. 

  199. 			di = btrfs_item_ptr(l, i, struct btrfs_dir_item);
    200. 

  200. 			btrfs_dir_item_key_to_cpu(l, di, &found_key);
    201. 

  201. 			printk(KERN_INFO "\t\tdir oid %llu type %u\n",
    202. 

  202. 				(unsigned long long)found_key.objectid,
    203. 

  203. 				btrfs_dir_type(l, di));
    204. 

  204. 			break;
    205. 

  205. 		case BTRFS_ROOT_ITEM_KEY:
    206. 

  206. 			ri = btrfs_item_ptr(l, i, struct btrfs_root_item);
    207. 

  207. 			printk(KERN_INFO "\t\troot data bytenr %llu refs %u\n",
    208. 

  208. 				(unsigned long long)
    209. 

  209. 				btrfs_disk_root_bytenr(l, ri),
    210. 

  210. 				btrfs_disk_root_refs(l, ri));
    211. 

  211. 			break;
    212. 

  212. 		case BTRFS_EXTENT_ITEM_KEY:
    213. 

  213. 			print_extent_item(l, i);
    214. 

  214. 			break;
    215. 

  215. 		case BTRFS_TREE_BLOCK_REF_KEY:
    216. 

  216. 			printk(KERN_INFO "\t\ttree block backref\n");
    217. 

  217. 			break;
    218. 

  218. 		case BTRFS_SHARED_BLOCK_REF_KEY:
    219. 

  219. 			printk(KERN_INFO "\t\tshared block backref\n");
    220. 

  220. 			break;
    221. 

  221. 		case BTRFS_EXTENT_DATA_REF_KEY:
    222. 

  222. 			dref = btrfs_item_ptr(l, i,
    223. 

  223. 					      struct btrfs_extent_data_ref);
    224. 

  224. 			print_extent_data_ref(l, dref);
    225. 

  225. 			break;
    226. 

  226. 		case BTRFS_SHARED_DATA_REF_KEY:
    227. 

  227. 			sref = btrfs_item_ptr(l, i,
    228. 

  228. 					      struct btrfs_shared_data_ref);
    229. 

  229. 			printk(KERN_INFO "\t\tshared data backref count %u\n",
    230. 

  230. 			       btrfs_shared_data_ref_count(l, sref));
    231. 

  231. 			break;
    232. 

  232. 		case BTRFS_EXTENT_DATA_KEY:
    233. 

  233. 			fi = btrfs_item_ptr(l, i,
    234. 

  234. 					    struct btrfs_file_extent_item);
    235. 

  235. 			if (btrfs_file_extent_type(l, fi) ==
    236. 

  236. 			    BTRFS_FILE_EXTENT_INLINE) {
    237. 

  237. 				printk(KERN_INFO "\t\tinline extent data "
    238. 

  238. 				       "size %u\n",
    239. 

  239. 				       btrfs_file_extent_inline_len(l, fi));
    240. 

  240. 				break;
    241. 

  241. 			}
    242. 

  242. 			printk(KERN_INFO "\t\textent data disk bytenr %llu "
    243. 

  243. 			       "nr %llu\n",
    244. 

  244. 			       (unsigned long long)
    245. 

  245. 			       btrfs_file_extent_disk_bytenr(l, fi),
    246. 

  246. 			       (unsigned long long)
    247. 

  247. 			       btrfs_file_extent_disk_num_bytes(l, fi));
    248. 

  248. 			printk(KERN_INFO "\t\textent data offset %llu "
    249. 

  249. 			       "nr %llu ram %llu\n",
    250. 

  250. 			       (unsigned long long)
    251. 

  251. 			       btrfs_file_extent_offset(l, fi),
    252. 

  252. 			       (unsigned long long)
    253. 

  253. 			       btrfs_file_extent_num_bytes(l, fi),
    254. 

  254. 			       (unsigned long long)
    255. 

  255. 			       btrfs_file_extent_ram_bytes(l, fi));
    256. 

  256. 			break;
    257. 

  257. 		case BTRFS_EXTENT_REF_V0_KEY:
    258. 

  258. #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
    259. 

  259. 			print_extent_ref_v0(l, i);
    260. 

  260. #else
    261. 

  261. 			BUG();
    262. 

  262. #endif
    263. 

  263. 			break;
    264. 

  264. 		case BTRFS_BLOCK_GROUP_ITEM_KEY:
    265. 

  265. 			bi = btrfs_item_ptr(l, i,
    266. 

  266. 					    struct btrfs_block_group_item);
    267. 

  267. 			printk(KERN_INFO "\t\tblock group used %llu\n",
    268. 

  268. 			       (unsigned long long)
    269. 

  269. 			       btrfs_disk_block_group_used(l, bi));
    270. 

  270. 			break;
    271. 

  271. 		case BTRFS_CHUNK_ITEM_KEY:
    272. 

  272. 			print_chunk(l, btrfs_item_ptr(l, i,
    273. 

  273. 						      struct btrfs_chunk));
    274. 

  274. 			break;
    275. 

  275. 		case BTRFS_DEV_ITEM_KEY:
    276. 

  276. 			print_dev_item(l, btrfs_item_ptr(l, i,
    277. 

  277. 					struct btrfs_dev_item));
    278. 

  278. 			break;
    279. 

  279. 		case BTRFS_DEV_EXTENT_KEY:
    280. 

  280. 			dev_extent = btrfs_item_ptr(l, i,
    281. 

  281. 						    struct btrfs_dev_extent);
    282. 

  282. 			printk(KERN_INFO "\t\tdev extent chunk_tree %llu\n"
    283. 

  283. 			       "\t\tchunk objectid %llu chunk offset %llu "
    284. 

  284. 			       "length %llu\n",
    285. 

  285. 			       (unsigned long long)
    286. 

  286. 			       btrfs_dev_extent_chunk_tree(l, dev_extent),
    287. 

  287. 			       (unsigned long long)
    288. 

  288. 			       btrfs_dev_extent_chunk_objectid(l, dev_extent),
    289. 

  289. 			       (unsigned long long)
    290. 

  290. 			       btrfs_dev_extent_chunk_offset(l, dev_extent),
    291. 

  291. 			       (unsigned long long)
    292. 

  292. 			       btrfs_dev_extent_length(l, dev_extent));
    293. 

  293. 		};
    294. 

  294. 	}
    295. 

  295. }
    296. 

  296. 

  297. void btrfs_print_tree(struct btrfs_root *root, struct extent_buffer *c)
    298. 

  298. {
    299. 

  299. 	int i; u32 nr;
    300. 

  300. 	struct btrfs_key key;
    301. 

  301. 	int level;
    302. 

  302. 

  303. 	if (!c)
    304. 

  304. 		return;
    305. 

  305. 	nr = btrfs_header_nritems(c);
    306. 

  306. 	level = btrfs_header_level(c);
    307. 

  307. 	if (level == 0) {
    308. 

  308. 		btrfs_print_leaf(root, c);
    309. 

  309. 		return;
    310. 

  310. 	}
    311. 

  311. 	printk(KERN_INFO "node %llu level %d total ptrs %d free spc %u\n",
    312. 

  312. 	       (unsigned long long)btrfs_header_bytenr(c),
    313. 

  313. 	      level, nr,
    314. 

  314. 	       (u32)BTRFS_NODEPTRS_PER_BLOCK(root) - nr);
    315. 

  315. 	for (i = 0; i < nr; i++) {
    316. 

  316. 		btrfs_node_key_to_cpu(c, &key, i);
    317. 

  317. 		printk(KERN_INFO "\tkey %d (%llu %u %llu) block %llu\n",
    318. 

  318. 		       i,
    319. 

  319. 		       (unsigned long long)key.objectid,
    320. 

  320. 		       key.type,
    321. 

  321. 		       (unsigned long long)key.offset,
    322. 

  322. 		       (unsigned long long)btrfs_node_blockptr(c, i));
    323. 

  323. 	}
    324. 

  324. 	for (i = 0; i < nr; i++) {
    325. 

  325. 		struct extent_buffer *next = read_tree_block(root,
    326. 

  326. 					btrfs_node_blockptr(c, i),
    327. 

  327. 					btrfs_level_size(root, level - 1),
    328. 

  328. 					btrfs_node_ptr_generation(c, i));
    329. 

  329. 		if (btrfs_is_leaf(next) &&
    330. 

  330. 		   level != 1)
    331. 

  331. 			BUG();
    332. 

  332. 		if (btrfs_header_level(next) !=
    333. 

  333. 		       level - 1)
    334. 

  334. 			BUG();
    335. 

  335. 		btrfs_print_tree(root, next);
    336. 

  336. 		free_extent_buffer(next);
    337. 

  337. 	}
    338. 

  338. }
    339. 

  339.