forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-05-10 ee930fffee469d076998274a2ca55e13dc1efb67 
 kernel/fs/btrfs/tree-checker.c
....@@ -15,11 +15,15 @@
1515  * carefully reviewed otherwise so it does not prevent mount of valid images.
1616  */
1717 
18
+#include <linux/types.h>
19
+#include <linux/stddef.h>
20
+#include <linux/error-injection.h>
1821 #include "ctree.h"
1922 #include "tree-checker.h"
2023 #include "disk-io.h"
2124 #include "compression.h"
2225 #include "volumes.h"
26
+#include "misc.h"
2327 
2428 /*
2529  * Error message should follow the following format:
....@@ -27,10 +31,10 @@
2731  *
2832  * @type:	leaf or node
2933  * @identifier:	the necessary info to locate the leaf/node.
30
- * 		It's recommened to decode key.objecitd/offset if it's
34
+ * 		It's recommended to decode key.objecitd/offset if it's
3135  * 		meaningful.
3236  * @reason:	describe the error
33
- * @bad_value:	optional, it's recommened to output bad value and its
37
+ * @bad_value:	optional, it's recommended to output bad value and its
3438  *		expected value (range).
3539  *
3640  * Since comma is used to separate the components, only space is allowed
....@@ -41,12 +45,12 @@
4145  * Append generic "corrupt leaf/node root=%llu block=%llu slot=%d: " to @fmt.
4246  * Allows callers to customize the output.
4347  */
44
-__printf(4, 5)
48
+__printf(3, 4)
4549 __cold
46
-static void generic_err(const struct btrfs_fs_info *fs_info,
47
-			const struct extent_buffer *eb, int slot,
50
+static void generic_err(const struct extent_buffer *eb, int slot,
4851 			const char *fmt, ...)
4952 {
53
+	const struct btrfs_fs_info *fs_info = eb->fs_info;
5054 	struct va_format vaf;
5155 	va_list args;
5256 
....@@ -66,12 +70,12 @@
6670  * Customized reporter for extent data item, since its key objectid and
6771  * offset has its own meaning.
6872  */
69
-__printf(4, 5)
73
+__printf(3, 4)
7074 __cold
71
-static void file_extent_err(const struct btrfs_fs_info *fs_info,
72
-			    const struct extent_buffer *eb, int slot,
75
+static void file_extent_err(const struct extent_buffer *eb, int slot,
7376 			    const char *fmt, ...)
7477 {
78
+	const struct btrfs_fs_info *fs_info = eb->fs_info;
7579 	struct btrfs_key key;
7680 	struct va_format vaf;
7781 	va_list args;
....@@ -94,54 +98,161 @@
9498  * Return 0 if the btrfs_file_extent_##name is aligned to @alignment
9599  * Else return 1
96100  */
97
-#define CHECK_FE_ALIGNED(fs_info, leaf, slot, fi, name, alignment)	      \
101
+#define CHECK_FE_ALIGNED(leaf, slot, fi, name, alignment)		      \
98102 ({									      \
99103 	if (!IS_ALIGNED(btrfs_file_extent_##name((leaf), (fi)), (alignment))) \
100
-		file_extent_err((fs_info), (leaf), (slot),		      \
104
+		file_extent_err((leaf), (slot),				      \
101105 	"invalid %s for file extent, have %llu, should be aligned to %u",     \
102106 			(#name), btrfs_file_extent_##name((leaf), (fi)),      \
103107 			(alignment));					      \
104108 	(!IS_ALIGNED(btrfs_file_extent_##name((leaf), (fi)), (alignment)));   \
105109 })
106110 
107
-static int check_extent_data_item(struct btrfs_fs_info *fs_info,
108
-				  struct extent_buffer *leaf,
109
-				  struct btrfs_key *key, int slot)
111
+static u64 file_extent_end(struct extent_buffer *leaf,
112
+			   struct btrfs_key *key,
113
+			   struct btrfs_file_extent_item *extent)
110114 {
115
+	u64 end;
116
+	u64 len;
117
+
118
+	if (btrfs_file_extent_type(leaf, extent) == BTRFS_FILE_EXTENT_INLINE) {
119
+		len = btrfs_file_extent_ram_bytes(leaf, extent);
120
+		end = ALIGN(key->offset + len, leaf->fs_info->sectorsize);
121
+	} else {
122
+		len = btrfs_file_extent_num_bytes(leaf, extent);
123
+		end = key->offset + len;
124
+	}
125
+	return end;
126
+}
127
+
128
+/*
129
+ * Customized report for dir_item, the only new important information is
130
+ * key->objectid, which represents inode number
131
+ */
132
+__printf(3, 4)
133
+__cold
134
+static void dir_item_err(const struct extent_buffer *eb, int slot,
135
+			 const char *fmt, ...)
136
+{
137
+	const struct btrfs_fs_info *fs_info = eb->fs_info;
138
+	struct btrfs_key key;
139
+	struct va_format vaf;
140
+	va_list args;
141
+
142
+	btrfs_item_key_to_cpu(eb, &key, slot);
143
+	va_start(args, fmt);
144
+
145
+	vaf.fmt = fmt;
146
+	vaf.va = &args;
147
+
148
+	btrfs_crit(fs_info,
149
+		"corrupt %s: root=%llu block=%llu slot=%d ino=%llu, %pV",
150
+		btrfs_header_level(eb) == 0 ? "leaf" : "node",
151
+		btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot,
152
+		key.objectid, &vaf);
153
+	va_end(args);
154
+}
155
+
156
+/*
157
+ * This functions checks prev_key->objectid, to ensure current key and prev_key
158
+ * share the same objectid as inode number.
159
+ *
160
+ * This is to detect missing INODE_ITEM in subvolume trees.
161
+ *
162
+ * Return true if everything is OK or we don't need to check.
163
+ * Return false if anything is wrong.
164
+ */
165
+static bool check_prev_ino(struct extent_buffer *leaf,
166
+			   struct btrfs_key *key, int slot,
167
+			   struct btrfs_key *prev_key)
168
+{
169
+	/* No prev key, skip check */
170
+	if (slot == 0)
171
+		return true;
172
+
173
+	/* Only these key->types needs to be checked */
174
+	ASSERT(key->type == BTRFS_XATTR_ITEM_KEY ||
175
+	       key->type == BTRFS_INODE_REF_KEY ||
176
+	       key->type == BTRFS_DIR_INDEX_KEY ||
177
+	       key->type == BTRFS_DIR_ITEM_KEY ||
178
+	       key->type == BTRFS_EXTENT_DATA_KEY);
179
+
180
+	/*
181
+	 * Only subvolume trees along with their reloc trees need this check.
182
+	 * Things like log tree doesn't follow this ino requirement.
183
+	 */
184
+	if (!is_fstree(btrfs_header_owner(leaf)))
185
+		return true;
186
+
187
+	if (key->objectid == prev_key->objectid)
188
+		return true;
189
+
190
+	/* Error found */
191
+	dir_item_err(leaf, slot,
192
+		"invalid previous key objectid, have %llu expect %llu",
193
+		prev_key->objectid, key->objectid);
194
+	return false;
195
+}
196
+static int check_extent_data_item(struct extent_buffer *leaf,
197
+				  struct btrfs_key *key, int slot,
198
+				  struct btrfs_key *prev_key)
199
+{
200
+	struct btrfs_fs_info *fs_info = leaf->fs_info;
111201 	struct btrfs_file_extent_item *fi;
112202 	u32 sectorsize = fs_info->sectorsize;
113203 	u32 item_size = btrfs_item_size_nr(leaf, slot);
204
+	u64 extent_end;
114205 
115206 	if (!IS_ALIGNED(key->offset, sectorsize)) {
116
-		file_extent_err(fs_info, leaf, slot,
207
+		file_extent_err(leaf, slot,
117208 "unaligned file_offset for file extent, have %llu should be aligned to %u",
118209 			key->offset, sectorsize);
119210 		return -EUCLEAN;
120211 	}
121212 
213
+	/*
214
+	 * Previous key must have the same key->objectid (ino).
215
+	 * It can be XATTR_ITEM, INODE_ITEM or just another EXTENT_DATA.
216
+	 * But if objectids mismatch, it means we have a missing
217
+	 * INODE_ITEM.
218
+	 */
219
+	if (!check_prev_ino(leaf, key, slot, prev_key))
220
+		return -EUCLEAN;
221
+
122222 	fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
123223 
124
-	if (btrfs_file_extent_type(leaf, fi) > BTRFS_FILE_EXTENT_TYPES) {
125
-		file_extent_err(fs_info, leaf, slot,
224
+	/*
225
+	 * Make sure the item contains at least inline header, so the file
226
+	 * extent type is not some garbage.
227
+	 */
228
+	if (item_size < BTRFS_FILE_EXTENT_INLINE_DATA_START) {
229
+		file_extent_err(leaf, slot,
230
+				"invalid item size, have %u expect [%zu, %u)",
231
+				item_size, BTRFS_FILE_EXTENT_INLINE_DATA_START,
232
+				SZ_4K);
233
+		return -EUCLEAN;
234
+	}
235
+	if (btrfs_file_extent_type(leaf, fi) >= BTRFS_NR_FILE_EXTENT_TYPES) {
236
+		file_extent_err(leaf, slot,
126237 		"invalid type for file extent, have %u expect range [0, %u]",
127238 			btrfs_file_extent_type(leaf, fi),
128
-			BTRFS_FILE_EXTENT_TYPES);
239
+			BTRFS_NR_FILE_EXTENT_TYPES - 1);
129240 		return -EUCLEAN;
130241 	}
131242 
132243 	/*
133
-	 * Support for new compression/encrption must introduce incompat flag,
244
+	 * Support for new compression/encryption must introduce incompat flag,
134245 	 * and must be caught in open_ctree().
135246 	 */
136
-	if (btrfs_file_extent_compression(leaf, fi) > BTRFS_COMPRESS_TYPES) {
137
-		file_extent_err(fs_info, leaf, slot,
247
+	if (btrfs_file_extent_compression(leaf, fi) >= BTRFS_NR_COMPRESS_TYPES) {
248
+		file_extent_err(leaf, slot,
138249 	"invalid compression for file extent, have %u expect range [0, %u]",
139250 			btrfs_file_extent_compression(leaf, fi),
140
-			BTRFS_COMPRESS_TYPES);
251
+			BTRFS_NR_COMPRESS_TYPES - 1);
141252 		return -EUCLEAN;
142253 	}
143254 	if (btrfs_file_extent_encryption(leaf, fi)) {
144
-		file_extent_err(fs_info, leaf, slot,
255
+		file_extent_err(leaf, slot,
145256 			"invalid encryption for file extent, have %u expect 0",
146257 			btrfs_file_extent_encryption(leaf, fi));
147258 		return -EUCLEAN;
....@@ -149,7 +260,7 @@
149260 	if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE) {
150261 		/* Inline extent must have 0 as key offset */
151262 		if (key->offset) {
152
-			file_extent_err(fs_info, leaf, slot,
263
+			file_extent_err(leaf, slot,
153264 		"invalid file_offset for inline file extent, have %llu expect 0",
154265 				key->offset);
155266 			return -EUCLEAN;
....@@ -163,7 +274,7 @@
163274 		/* Uncompressed inline extent size must match item size */
164275 		if (item_size != BTRFS_FILE_EXTENT_INLINE_DATA_START +
165276 		    btrfs_file_extent_ram_bytes(leaf, fi)) {
166
-			file_extent_err(fs_info, leaf, slot,
277
+			file_extent_err(leaf, slot,
167278 	"invalid ram_bytes for uncompressed inline extent, have %u expect %llu",
168279 				item_size, BTRFS_FILE_EXTENT_INLINE_DATA_START +
169280 				btrfs_file_extent_ram_bytes(leaf, fi));
....@@ -174,105 +285,245 @@
174285 
175286 	/* Regular or preallocated extent has fixed item size */
176287 	if (item_size != sizeof(*fi)) {
177
-		file_extent_err(fs_info, leaf, slot,
288
+		file_extent_err(leaf, slot,
178289 	"invalid item size for reg/prealloc file extent, have %u expect %zu",
179290 			item_size, sizeof(*fi));
180291 		return -EUCLEAN;
181292 	}
182
-	if (CHECK_FE_ALIGNED(fs_info, leaf, slot, fi, ram_bytes, sectorsize) ||
183
-	    CHECK_FE_ALIGNED(fs_info, leaf, slot, fi, disk_bytenr, sectorsize) ||
184
-	    CHECK_FE_ALIGNED(fs_info, leaf, slot, fi, disk_num_bytes, sectorsize) ||
185
-	    CHECK_FE_ALIGNED(fs_info, leaf, slot, fi, offset, sectorsize) ||
186
-	    CHECK_FE_ALIGNED(fs_info, leaf, slot, fi, num_bytes, sectorsize))
293
+	if (CHECK_FE_ALIGNED(leaf, slot, fi, ram_bytes, sectorsize) ||
294
+	    CHECK_FE_ALIGNED(leaf, slot, fi, disk_bytenr, sectorsize) ||
295
+	    CHECK_FE_ALIGNED(leaf, slot, fi, disk_num_bytes, sectorsize) ||
296
+	    CHECK_FE_ALIGNED(leaf, slot, fi, offset, sectorsize) ||
297
+	    CHECK_FE_ALIGNED(leaf, slot, fi, num_bytes, sectorsize))
187298 		return -EUCLEAN;
299
+
300
+	/* Catch extent end overflow */
301
+	if (check_add_overflow(btrfs_file_extent_num_bytes(leaf, fi),
302
+			       key->offset, &extent_end)) {
303
+		file_extent_err(leaf, slot,
304
+	"extent end overflow, have file offset %llu extent num bytes %llu",
305
+				key->offset,
306
+				btrfs_file_extent_num_bytes(leaf, fi));
307
+		return -EUCLEAN;
308
+	}
309
+
310
+	/*
311
+	 * Check that no two consecutive file extent items, in the same leaf,
312
+	 * present ranges that overlap each other.
313
+	 */
314
+	if (slot > 0 &&
315
+	    prev_key->objectid == key->objectid &&
316
+	    prev_key->type == BTRFS_EXTENT_DATA_KEY) {
317
+		struct btrfs_file_extent_item *prev_fi;
318
+		u64 prev_end;
319
+
320
+		prev_fi = btrfs_item_ptr(leaf, slot - 1,
321
+					 struct btrfs_file_extent_item);
322
+		prev_end = file_extent_end(leaf, prev_key, prev_fi);
323
+		if (prev_end > key->offset) {
324
+			file_extent_err(leaf, slot - 1,
325
+"file extent end range (%llu) goes beyond start offset (%llu) of the next file extent",
326
+					prev_end, key->offset);
327
+			return -EUCLEAN;
328
+		}
329
+	}
330
+
188331 	return 0;
189332 }
190333 
191
-static int check_csum_item(struct btrfs_fs_info *fs_info,
192
-			   struct extent_buffer *leaf, struct btrfs_key *key,
193
-			   int slot)
334
+static int check_csum_item(struct extent_buffer *leaf, struct btrfs_key *key,
335
+			   int slot, struct btrfs_key *prev_key)
194336 {
337
+	struct btrfs_fs_info *fs_info = leaf->fs_info;
195338 	u32 sectorsize = fs_info->sectorsize;
196339 	u32 csumsize = btrfs_super_csum_size(fs_info->super_copy);
197340 
198341 	if (key->objectid != BTRFS_EXTENT_CSUM_OBJECTID) {
199
-		generic_err(fs_info, leaf, slot,
342
+		generic_err(leaf, slot,
200343 		"invalid key objectid for csum item, have %llu expect %llu",
201344 			key->objectid, BTRFS_EXTENT_CSUM_OBJECTID);
202345 		return -EUCLEAN;
203346 	}
204347 	if (!IS_ALIGNED(key->offset, sectorsize)) {
205
-		generic_err(fs_info, leaf, slot,
348
+		generic_err(leaf, slot,
206349 	"unaligned key offset for csum item, have %llu should be aligned to %u",
207350 			key->offset, sectorsize);
208351 		return -EUCLEAN;
209352 	}
210353 	if (!IS_ALIGNED(btrfs_item_size_nr(leaf, slot), csumsize)) {
211
-		generic_err(fs_info, leaf, slot,
354
+		generic_err(leaf, slot,
212355 	"unaligned item size for csum item, have %u should be aligned to %u",
213356 			btrfs_item_size_nr(leaf, slot), csumsize);
357
+		return -EUCLEAN;
358
+	}
359
+	if (slot > 0 && prev_key->type == BTRFS_EXTENT_CSUM_KEY) {
360
+		u64 prev_csum_end;
361
+		u32 prev_item_size;
362
+
363
+		prev_item_size = btrfs_item_size_nr(leaf, slot - 1);
364
+		prev_csum_end = (prev_item_size / csumsize) * sectorsize;
365
+		prev_csum_end += prev_key->offset;
366
+		if (prev_csum_end > key->offset) {
367
+			generic_err(leaf, slot - 1,
368
+"csum end range (%llu) goes beyond the start range (%llu) of the next csum item",
369
+				    prev_csum_end, key->offset);
370
+			return -EUCLEAN;
371
+		}
372
+	}
373
+	return 0;
374
+}
375
+
376
+/* Inode item error output has the same format as dir_item_err() */
377
+#define inode_item_err(eb, slot, fmt, ...)			\
378
+	dir_item_err(eb, slot, fmt, __VA_ARGS__)
379
+
380
+static int check_inode_key(struct extent_buffer *leaf, struct btrfs_key *key,
381
+			   int slot)
382
+{
383
+	struct btrfs_key item_key;
384
+	bool is_inode_item;
385
+
386
+	btrfs_item_key_to_cpu(leaf, &item_key, slot);
387
+	is_inode_item = (item_key.type == BTRFS_INODE_ITEM_KEY);
388
+
389
+	/* For XATTR_ITEM, location key should be all 0 */
390
+	if (item_key.type == BTRFS_XATTR_ITEM_KEY) {
391
+		if (key->type != 0 || key->objectid != 0 || key->offset != 0)
392
+			return -EUCLEAN;
393
+		return 0;
394
+	}
395
+
396
+	if ((key->objectid < BTRFS_FIRST_FREE_OBJECTID ||
397
+	     key->objectid > BTRFS_LAST_FREE_OBJECTID) &&
398
+	    key->objectid != BTRFS_ROOT_TREE_DIR_OBJECTID &&
399
+	    key->objectid != BTRFS_FREE_INO_OBJECTID) {
400
+		if (is_inode_item) {
401
+			generic_err(leaf, slot,
402
+	"invalid key objectid: has %llu expect %llu or [%llu, %llu] or %llu",
403
+				key->objectid, BTRFS_ROOT_TREE_DIR_OBJECTID,
404
+				BTRFS_FIRST_FREE_OBJECTID,
405
+				BTRFS_LAST_FREE_OBJECTID,
406
+				BTRFS_FREE_INO_OBJECTID);
407
+		} else {
408
+			dir_item_err(leaf, slot,
409
+"invalid location key objectid: has %llu expect %llu or [%llu, %llu] or %llu",
410
+				key->objectid, BTRFS_ROOT_TREE_DIR_OBJECTID,
411
+				BTRFS_FIRST_FREE_OBJECTID,
412
+				BTRFS_LAST_FREE_OBJECTID,
413
+				BTRFS_FREE_INO_OBJECTID);
414
+		}
415
+		return -EUCLEAN;
416
+	}
417
+	if (key->offset != 0) {
418
+		if (is_inode_item)
419
+			inode_item_err(leaf, slot,
420
+				       "invalid key offset: has %llu expect 0",
421
+				       key->offset);
422
+		else
423
+			dir_item_err(leaf, slot,
424
+				"invalid location key offset:has %llu expect 0",
425
+				key->offset);
214426 		return -EUCLEAN;
215427 	}
216428 	return 0;
217429 }
218430 
219
-/*
220
- * Customized reported for dir_item, only important new info is key->objectid,
221
- * which represents inode number
222
- */
223
-__printf(4, 5)
224
-__cold
225
-static void dir_item_err(const struct btrfs_fs_info *fs_info,
226
-			 const struct extent_buffer *eb, int slot,
227
-			 const char *fmt, ...)
431
+static int check_root_key(struct extent_buffer *leaf, struct btrfs_key *key,
432
+			  int slot)
228433 {
229
-	struct btrfs_key key;
230
-	struct va_format vaf;
231
-	va_list args;
434
+	struct btrfs_key item_key;
435
+	bool is_root_item;
232436 
233
-	btrfs_item_key_to_cpu(eb, &key, slot);
234
-	va_start(args, fmt);
437
+	btrfs_item_key_to_cpu(leaf, &item_key, slot);
438
+	is_root_item = (item_key.type == BTRFS_ROOT_ITEM_KEY);
235439 
236
-	vaf.fmt = fmt;
237
-	vaf.va = &args;
440
+	/* No such tree id */
441
+	if (key->objectid == 0) {
442
+		if (is_root_item)
443
+			generic_err(leaf, slot, "invalid root id 0");
444
+		else
445
+			dir_item_err(leaf, slot,
446
+				     "invalid location key root id 0");
447
+		return -EUCLEAN;
448
+	}
238449 
239
-	btrfs_crit(fs_info,
240
-	"corrupt %s: root=%llu block=%llu slot=%d ino=%llu, %pV",
241
-		btrfs_header_level(eb) == 0 ? "leaf" : "node",
242
-		btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot,
243
-		key.objectid, &vaf);
244
-	va_end(args);
450
+	/* DIR_ITEM/INDEX/INODE_REF is not allowed to point to non-fs trees */
451
+	if (!is_fstree(key->objectid) && !is_root_item) {
452
+		dir_item_err(leaf, slot,
453
+		"invalid location key objectid, have %llu expect [%llu, %llu]",
454
+				key->objectid, BTRFS_FIRST_FREE_OBJECTID,
455
+				BTRFS_LAST_FREE_OBJECTID);
456
+		return -EUCLEAN;
457
+	}
458
+
459
+	/*
460
+	 * ROOT_ITEM with non-zero offset means this is a snapshot, created at
461
+	 * @offset transid.
462
+	 * Furthermore, for location key in DIR_ITEM, its offset is always -1.
463
+	 *
464
+	 * So here we only check offset for reloc tree whose key->offset must
465
+	 * be a valid tree.
466
+	 */
467
+	if (key->objectid == BTRFS_TREE_RELOC_OBJECTID && key->offset == 0) {
468
+		generic_err(leaf, slot, "invalid root id 0 for reloc tree");
469
+		return -EUCLEAN;
470
+	}
471
+	return 0;
245472 }
246473 
247
-static int check_dir_item(struct btrfs_fs_info *fs_info,
248
-			  struct extent_buffer *leaf,
249
-			  struct btrfs_key *key, int slot)
474
+static int check_dir_item(struct extent_buffer *leaf,
475
+			  struct btrfs_key *key, struct btrfs_key *prev_key,
476
+			  int slot)
250477 {
478
+	struct btrfs_fs_info *fs_info = leaf->fs_info;
251479 	struct btrfs_dir_item *di;
252480 	u32 item_size = btrfs_item_size_nr(leaf, slot);
253481 	u32 cur = 0;
254482 
483
+	if (!check_prev_ino(leaf, key, slot, prev_key))
484
+		return -EUCLEAN;
255485 	di = btrfs_item_ptr(leaf, slot, struct btrfs_dir_item);
256486 	while (cur < item_size) {
487
+		struct btrfs_key location_key;
257488 		u32 name_len;
258489 		u32 data_len;
259490 		u32 max_name_len;
260491 		u32 total_size;
261492 		u32 name_hash;
262493 		u8 dir_type;
494
+		int ret;
263495 
264496 		/* header itself should not cross item boundary */
265497 		if (cur + sizeof(*di) > item_size) {
266
-			dir_item_err(fs_info, leaf, slot,
498
+			dir_item_err(leaf, slot,
267499 		"dir item header crosses item boundary, have %zu boundary %u",
268500 				cur + sizeof(*di), item_size);
501
+			return -EUCLEAN;
502
+		}
503
+
504
+		/* Location key check */
505
+		btrfs_dir_item_key_to_cpu(leaf, di, &location_key);
506
+		if (location_key.type == BTRFS_ROOT_ITEM_KEY) {
507
+			ret = check_root_key(leaf, &location_key, slot);
508
+			if (ret < 0)
509
+				return ret;
510
+		} else if (location_key.type == BTRFS_INODE_ITEM_KEY ||
511
+			   location_key.type == 0) {
512
+			ret = check_inode_key(leaf, &location_key, slot);
513
+			if (ret < 0)
514
+				return ret;
515
+		} else {
516
+			dir_item_err(leaf, slot,
517
+			"invalid location key type, have %u, expect %u or %u",
518
+				     location_key.type, BTRFS_ROOT_ITEM_KEY,
519
+				     BTRFS_INODE_ITEM_KEY);
269520 			return -EUCLEAN;
270521 		}
271522 
272523 		/* dir type check */
273524 		dir_type = btrfs_dir_type(leaf, di);
274525 		if (dir_type >= BTRFS_FT_MAX) {
275
-			dir_item_err(fs_info, leaf, slot,
526
+			dir_item_err(leaf, slot,
276527 			"invalid dir item type, have %u expect [0, %u)",
277528 				dir_type, BTRFS_FT_MAX);
278529 			return -EUCLEAN;
....@@ -280,14 +531,14 @@
280531 
281532 		if (key->type == BTRFS_XATTR_ITEM_KEY &&
282533 		    dir_type != BTRFS_FT_XATTR) {
283
-			dir_item_err(fs_info, leaf, slot,
534
+			dir_item_err(leaf, slot,
284535 		"invalid dir item type for XATTR key, have %u expect %u",
285536 				dir_type, BTRFS_FT_XATTR);
286537 			return -EUCLEAN;
287538 		}
288539 		if (dir_type == BTRFS_FT_XATTR &&
289540 		    key->type != BTRFS_XATTR_ITEM_KEY) {
290
-			dir_item_err(fs_info, leaf, slot,
541
+			dir_item_err(leaf, slot,
291542 			"xattr dir type found for non-XATTR key");
292543 			return -EUCLEAN;
293544 		}
....@@ -300,13 +551,13 @@
300551 		name_len = btrfs_dir_name_len(leaf, di);
301552 		data_len = btrfs_dir_data_len(leaf, di);
302553 		if (name_len > max_name_len) {
303
-			dir_item_err(fs_info, leaf, slot,
554
+			dir_item_err(leaf, slot,
304555 			"dir item name len too long, have %u max %u",
305556 				name_len, max_name_len);
306557 			return -EUCLEAN;
307558 		}
308559 		if (name_len + data_len > BTRFS_MAX_XATTR_SIZE(fs_info)) {
309
-			dir_item_err(fs_info, leaf, slot,
560
+			dir_item_err(leaf, slot,
310561 			"dir item name and data len too long, have %u max %u",
311562 				name_len + data_len,
312563 				BTRFS_MAX_XATTR_SIZE(fs_info));
....@@ -314,7 +565,7 @@
314565 		}
315566 
316567 		if (data_len && dir_type != BTRFS_FT_XATTR) {
317
-			dir_item_err(fs_info, leaf, slot,
568
+			dir_item_err(leaf, slot,
318569 			"dir item with invalid data len, have %u expect 0",
319570 				data_len);
320571 			return -EUCLEAN;
....@@ -324,7 +575,7 @@
324575 
325576 		/* header and name/data should not cross item boundary */
326577 		if (cur + total_size > item_size) {
327
-			dir_item_err(fs_info, leaf, slot,
578
+			dir_item_err(leaf, slot,
328579 		"dir item data crosses item boundary, have %u boundary %u",
329580 				cur + total_size, item_size);
330581 			return -EUCLEAN;
....@@ -342,7 +593,7 @@
342593 					(unsigned long)(di + 1), name_len);
343594 			name_hash = btrfs_name_hash(namebuf, name_len);
344595 			if (key->offset != name_hash) {
345
-				dir_item_err(fs_info, leaf, slot,
596
+				dir_item_err(leaf, slot,
346597 		"name hash mismatch with key, have 0x%016x expect 0x%016llx",
347598 					name_hash, key->offset);
348599 				return -EUCLEAN;
....@@ -354,12 +605,12 @@
354605 	return 0;
355606 }
356607 
357
-__printf(4, 5)
608
+__printf(3, 4)
358609 __cold
359
-static void block_group_err(const struct btrfs_fs_info *fs_info,
360
-			    const struct extent_buffer *eb, int slot,
610
+static void block_group_err(const struct extent_buffer *eb, int slot,
361611 			    const char *fmt, ...)
362612 {
613
+	const struct btrfs_fs_info *fs_info = eb->fs_info;
363614 	struct btrfs_key key;
364615 	struct va_format vaf;
365616 	va_list args;
....@@ -378,8 +629,7 @@
378629 	va_end(args);
379630 }
380631 
381
-static int check_block_group_item(struct btrfs_fs_info *fs_info,
382
-				  struct extent_buffer *leaf,
632
+static int check_block_group_item(struct extent_buffer *leaf,
383633 				  struct btrfs_key *key, int slot)
384634 {
385635 	struct btrfs_block_group_item bgi;
....@@ -392,13 +642,13 @@
392642 	 * handle it.  We care more about the size.
393643 	 */
394644 	if (key->offset == 0) {
395
-		block_group_err(fs_info, leaf, slot,
645
+		block_group_err(leaf, slot,
396646 				"invalid block group size 0");
397647 		return -EUCLEAN;
398648 	}
399649 
400650 	if (item_size != sizeof(bgi)) {
401
-		block_group_err(fs_info, leaf, slot,
651
+		block_group_err(leaf, slot,
402652 			"invalid item size, have %u expect %zu",
403653 				item_size, sizeof(bgi));
404654 		return -EUCLEAN;
....@@ -406,25 +656,25 @@
406656 
407657 	read_extent_buffer(leaf, &bgi, btrfs_item_ptr_offset(leaf, slot),
408658 			   sizeof(bgi));
409
-	if (btrfs_block_group_chunk_objectid(&bgi) !=
659
+	if (btrfs_stack_block_group_chunk_objectid(&bgi) !=
410660 	    BTRFS_FIRST_CHUNK_TREE_OBJECTID) {
411
-		block_group_err(fs_info, leaf, slot,
661
+		block_group_err(leaf, slot,
412662 		"invalid block group chunk objectid, have %llu expect %llu",
413
-				btrfs_block_group_chunk_objectid(&bgi),
663
+				btrfs_stack_block_group_chunk_objectid(&bgi),
414664 				BTRFS_FIRST_CHUNK_TREE_OBJECTID);
415665 		return -EUCLEAN;
416666 	}
417667 
418
-	if (btrfs_block_group_used(&bgi) > key->offset) {
419
-		block_group_err(fs_info, leaf, slot,
668
+	if (btrfs_stack_block_group_used(&bgi) > key->offset) {
669
+		block_group_err(leaf, slot,
420670 			"invalid block group used, have %llu expect [0, %llu)",
421
-				btrfs_block_group_used(&bgi), key->offset);
671
+				btrfs_stack_block_group_used(&bgi), key->offset);
422672 		return -EUCLEAN;
423673 	}
424674 
425
-	flags = btrfs_block_group_flags(&bgi);
675
+	flags = btrfs_stack_block_group_flags(&bgi);
426676 	if (hweight64(flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) > 1) {
427
-		block_group_err(fs_info, leaf, slot,
677
+		block_group_err(leaf, slot,
428678 "invalid profile flags, have 0x%llx (%lu bits set) expect no more than 1 bit set",
429679 			flags & BTRFS_BLOCK_GROUP_PROFILE_MASK,
430680 			hweight64(flags & BTRFS_BLOCK_GROUP_PROFILE_MASK));
....@@ -437,7 +687,7 @@
437687 	    type != BTRFS_BLOCK_GROUP_SYSTEM &&
438688 	    type != (BTRFS_BLOCK_GROUP_METADATA |
439689 			   BTRFS_BLOCK_GROUP_DATA)) {
440
-		block_group_err(fs_info, leaf, slot,
690
+		block_group_err(leaf, slot,
441691 "invalid type, have 0x%llx (%lu bits set) expect either 0x%llx, 0x%llx, 0x%llx or 0x%llx",
442692 			type, hweight64(type),
443693 			BTRFS_BLOCK_GROUP_DATA, BTRFS_BLOCK_GROUP_METADATA,
....@@ -448,13 +698,13 @@
448698 	return 0;
449699 }
450700 
451
-__printf(5, 6)
701
+__printf(4, 5)
452702 __cold
453
-static void chunk_err(const struct btrfs_fs_info *fs_info,
454
-		      const struct extent_buffer *leaf,
703
+static void chunk_err(const struct extent_buffer *leaf,
455704 		      const struct btrfs_chunk *chunk, u64 logical,
456705 		      const char *fmt, ...)
457706 {
707
+	const struct btrfs_fs_info *fs_info = leaf->fs_info;
458708 	bool is_sb;
459709 	struct va_format vaf;
460710 	va_list args;
....@@ -499,56 +749,81 @@
499749  * Return -EUCLEAN if anything is corrupted.
500750  * Return 0 if everything is OK.
501751  */
502
-int btrfs_check_chunk_valid(struct btrfs_fs_info *fs_info,
503
-			    struct extent_buffer *leaf,
752
+int btrfs_check_chunk_valid(struct extent_buffer *leaf,
504753 			    struct btrfs_chunk *chunk, u64 logical)
505754 {
755
+	struct btrfs_fs_info *fs_info = leaf->fs_info;
506756 	u64 length;
757
+	u64 chunk_end;
507758 	u64 stripe_len;
508759 	u16 num_stripes;
509760 	u16 sub_stripes;
510761 	u64 type;
511762 	u64 features;
512763 	bool mixed = false;
764
+	int raid_index;
765
+	int nparity;
766
+	int ncopies;
513767 
514768 	length = btrfs_chunk_length(leaf, chunk);
515769 	stripe_len = btrfs_chunk_stripe_len(leaf, chunk);
516770 	num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
517771 	sub_stripes = btrfs_chunk_sub_stripes(leaf, chunk);
518772 	type = btrfs_chunk_type(leaf, chunk);
773
+	raid_index = btrfs_bg_flags_to_raid_index(type);
774
+	ncopies = btrfs_raid_array[raid_index].ncopies;
775
+	nparity = btrfs_raid_array[raid_index].nparity;
519776 
520777 	if (!num_stripes) {
521
-		chunk_err(fs_info, leaf, chunk, logical,
778
+		chunk_err(leaf, chunk, logical,
522779 			  "invalid chunk num_stripes, have %u", num_stripes);
523780 		return -EUCLEAN;
524781 	}
782
+	if (num_stripes < ncopies) {
783
+		chunk_err(leaf, chunk, logical,
784
+			  "invalid chunk num_stripes < ncopies, have %u < %d",
785
+			  num_stripes, ncopies);
786
+		return -EUCLEAN;
787
+	}
788
+	if (nparity && num_stripes == nparity) {
789
+		chunk_err(leaf, chunk, logical,
790
+			  "invalid chunk num_stripes == nparity, have %u == %d",
791
+			  num_stripes, nparity);
792
+		return -EUCLEAN;
793
+	}
525794 	if (!IS_ALIGNED(logical, fs_info->sectorsize)) {
526
-		chunk_err(fs_info, leaf, chunk, logical,
795
+		chunk_err(leaf, chunk, logical,
527796 		"invalid chunk logical, have %llu should aligned to %u",
528797 			  logical, fs_info->sectorsize);
529798 		return -EUCLEAN;
530799 	}
531800 	if (btrfs_chunk_sector_size(leaf, chunk) != fs_info->sectorsize) {
532
-		chunk_err(fs_info, leaf, chunk, logical,
801
+		chunk_err(leaf, chunk, logical,
533802 			  "invalid chunk sectorsize, have %u expect %u",
534803 			  btrfs_chunk_sector_size(leaf, chunk),
535804 			  fs_info->sectorsize);
536805 		return -EUCLEAN;
537806 	}
538807 	if (!length || !IS_ALIGNED(length, fs_info->sectorsize)) {
539
-		chunk_err(fs_info, leaf, chunk, logical,
808
+		chunk_err(leaf, chunk, logical,
540809 			  "invalid chunk length, have %llu", length);
541810 		return -EUCLEAN;
542811 	}
812
+	if (unlikely(check_add_overflow(logical, length, &chunk_end))) {
813
+		chunk_err(leaf, chunk, logical,
814
+"invalid chunk logical start and length, have logical start %llu length %llu",
815
+			  logical, length);
816
+		return -EUCLEAN;
817
+	}
543818 	if (!is_power_of_2(stripe_len) || stripe_len != BTRFS_STRIPE_LEN) {
544
-		chunk_err(fs_info, leaf, chunk, logical,
819
+		chunk_err(leaf, chunk, logical,
545820 			  "invalid chunk stripe length: %llu",
546821 			  stripe_len);
547822 		return -EUCLEAN;
548823 	}
549824 	if (~(BTRFS_BLOCK_GROUP_TYPE_MASK | BTRFS_BLOCK_GROUP_PROFILE_MASK) &
550825 	    type) {
551
-		chunk_err(fs_info, leaf, chunk, logical,
826
+		chunk_err(leaf, chunk, logical,
552827 			  "unrecognized chunk type: 0x%llx",
553828 			  ~(BTRFS_BLOCK_GROUP_TYPE_MASK |
554829 			    BTRFS_BLOCK_GROUP_PROFILE_MASK) &
....@@ -556,15 +831,15 @@
556831 		return -EUCLEAN;
557832 	}
558833 
559
-	if (!is_power_of_2(type & BTRFS_BLOCK_GROUP_PROFILE_MASK) &&
834
+	if (!has_single_bit_set(type & BTRFS_BLOCK_GROUP_PROFILE_MASK) &&
560835 	    (type & BTRFS_BLOCK_GROUP_PROFILE_MASK) != 0) {
561
-		chunk_err(fs_info, leaf, chunk, logical,
836
+		chunk_err(leaf, chunk, logical,
562837 		"invalid chunk profile flag: 0x%llx, expect 0 or 1 bit set",
563838 			  type & BTRFS_BLOCK_GROUP_PROFILE_MASK);
564839 		return -EUCLEAN;
565840 	}
566841 	if ((type & BTRFS_BLOCK_GROUP_TYPE_MASK) == 0) {
567
-		chunk_err(fs_info, leaf, chunk, logical,
842
+		chunk_err(leaf, chunk, logical,
568843 	"missing chunk type flag, have 0x%llx one bit must be set in 0x%llx",
569844 			  type, BTRFS_BLOCK_GROUP_TYPE_MASK);
570845 		return -EUCLEAN;
....@@ -572,7 +847,7 @@
572847 
573848 	if ((type & BTRFS_BLOCK_GROUP_SYSTEM) &&
574849 	    (type & (BTRFS_BLOCK_GROUP_METADATA | BTRFS_BLOCK_GROUP_DATA))) {
575
-		chunk_err(fs_info, leaf, chunk, logical,
850
+		chunk_err(leaf, chunk, logical,
576851 			  "system chunk with data or metadata type: 0x%llx",
577852 			  type);
578853 		return -EUCLEAN;
....@@ -585,7 +860,7 @@
585860 	if (!mixed) {
586861 		if ((type & BTRFS_BLOCK_GROUP_METADATA) &&
587862 		    (type & BTRFS_BLOCK_GROUP_DATA)) {
588
-			chunk_err(fs_info, leaf, chunk, logical,
863
+			chunk_err(leaf, chunk, logical,
589864 			"mixed chunk type in non-mixed mode: 0x%llx", type);
590865 			return -EUCLEAN;
591866 		}
....@@ -597,7 +872,7 @@
597872 	    (type & BTRFS_BLOCK_GROUP_RAID6 && num_stripes < 3) ||
598873 	    (type & BTRFS_BLOCK_GROUP_DUP && num_stripes != 2) ||
599874 	    ((type & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0 && num_stripes != 1)) {
600
-		chunk_err(fs_info, leaf, chunk, logical,
875
+		chunk_err(leaf, chunk, logical,
601876 			"invalid num_stripes:sub_stripes %u:%u for profile %llu",
602877 			num_stripes, sub_stripes,
603878 			type & BTRFS_BLOCK_GROUP_PROFILE_MASK);
....@@ -607,10 +882,47 @@
607882 	return 0;
608883 }
609884 
610
-__printf(4, 5)
885
+/*
886
+ * Enhanced version of chunk item checker.
887
+ *
888
+ * The common btrfs_check_chunk_valid() doesn't check item size since it needs
889
+ * to work on super block sys_chunk_array which doesn't have full item ptr.
890
+ */
891
+static int check_leaf_chunk_item(struct extent_buffer *leaf,
892
+				 struct btrfs_chunk *chunk,
893
+				 struct btrfs_key *key, int slot)
894
+{
895
+	int num_stripes;
896
+
897
+	if (btrfs_item_size_nr(leaf, slot) < sizeof(struct btrfs_chunk)) {
898
+		chunk_err(leaf, chunk, key->offset,
899
+			"invalid chunk item size: have %u expect [%zu, %u)",
900
+			btrfs_item_size_nr(leaf, slot),
901
+			sizeof(struct btrfs_chunk),
902
+			BTRFS_LEAF_DATA_SIZE(leaf->fs_info));
903
+		return -EUCLEAN;
904
+	}
905
+
906
+	num_stripes = btrfs_chunk_num_stripes(leaf, chunk);
907
+	/* Let btrfs_check_chunk_valid() handle this error type */
908
+	if (num_stripes == 0)
909
+		goto out;
910
+
911
+	if (btrfs_chunk_item_size(num_stripes) !=
912
+	    btrfs_item_size_nr(leaf, slot)) {
913
+		chunk_err(leaf, chunk, key->offset,
914
+			"invalid chunk item size: have %u expect %lu",
915
+			btrfs_item_size_nr(leaf, slot),
916
+			btrfs_chunk_item_size(num_stripes));
917
+		return -EUCLEAN;
918
+	}
919
+out:
920
+	return btrfs_check_chunk_valid(leaf, chunk, key->offset);
921
+}
922
+
923
+__printf(3, 4)
611924 __cold
612
-static void dev_item_err(const struct btrfs_fs_info *fs_info,
613
-			 const struct extent_buffer *eb, int slot,
925
+static void dev_item_err(const struct extent_buffer *eb, int slot,
614926 			 const char *fmt, ...)
615927 {
616928 	struct btrfs_key key;
....@@ -623,7 +935,7 @@
623935 	vaf.fmt = fmt;
624936 	vaf.va = &args;
625937 
626
-	btrfs_crit(fs_info,
938
+	btrfs_crit(eb->fs_info,
627939 	"corrupt %s: root=%llu block=%llu slot=%d devid=%llu %pV",
628940 		btrfs_header_level(eb) == 0 ? "leaf" : "node",
629941 		btrfs_header_owner(eb), btrfs_header_bytenr(eb), slot,
....@@ -631,21 +943,28 @@
631943 	va_end(args);
632944 }
633945 
634
-static int check_dev_item(struct btrfs_fs_info *fs_info,
635
-			  struct extent_buffer *leaf,
946
+static int check_dev_item(struct extent_buffer *leaf,
636947 			  struct btrfs_key *key, int slot)
637948 {
638949 	struct btrfs_dev_item *ditem;
950
+	const u32 item_size = btrfs_item_size_nr(leaf, slot);
639951 
640952 	if (key->objectid != BTRFS_DEV_ITEMS_OBJECTID) {
641
-		dev_item_err(fs_info, leaf, slot,
953
+		dev_item_err(leaf, slot,
642954 			     "invalid objectid: has=%llu expect=%llu",
643955 			     key->objectid, BTRFS_DEV_ITEMS_OBJECTID);
644956 		return -EUCLEAN;
645957 	}
958
+
959
+	if (unlikely(item_size != sizeof(*ditem))) {
960
+		dev_item_err(leaf, slot, "invalid item size: has %u expect %zu",
961
+			     item_size, sizeof(*ditem));
962
+		return -EUCLEAN;
963
+	}
964
+
646965 	ditem = btrfs_item_ptr(leaf, slot, struct btrfs_dev_item);
647966 	if (btrfs_device_id(leaf, ditem) != key->offset) {
648
-		dev_item_err(fs_info, leaf, slot,
967
+		dev_item_err(leaf, slot,
649968 			     "devid mismatch: key has=%llu item has=%llu",
650969 			     key->offset, btrfs_device_id(leaf, ditem));
651970 		return -EUCLEAN;
....@@ -658,7 +977,7 @@
658977 	 */
659978 	if (btrfs_device_bytes_used(leaf, ditem) >
660979 	    btrfs_device_total_bytes(leaf, ditem)) {
661
-		dev_item_err(fs_info, leaf, slot,
980
+		dev_item_err(leaf, slot,
662981 			     "invalid bytes used: have %llu expect [0, %llu]",
663982 			     btrfs_device_bytes_used(leaf, ditem),
664983 			     btrfs_device_total_bytes(leaf, ditem));
....@@ -671,42 +990,32 @@
671990 	return 0;
672991 }
673992 
674
-/* Inode item error output has the same format as dir_item_err() */
675
-#define inode_item_err(fs_info, eb, slot, fmt, ...)			\
676
-	dir_item_err(fs_info, eb, slot, fmt, __VA_ARGS__)
677
-
678
-static int check_inode_item(struct btrfs_fs_info *fs_info,
679
-			    struct extent_buffer *leaf,
993
+static int check_inode_item(struct extent_buffer *leaf,
680994 			    struct btrfs_key *key, int slot)
681995 {
996
+	struct btrfs_fs_info *fs_info = leaf->fs_info;
682997 	struct btrfs_inode_item *iitem;
683998 	u64 super_gen = btrfs_super_generation(fs_info->super_copy);
684999 	u32 valid_mask = (S_IFMT | S_ISUID | S_ISGID | S_ISVTX | 0777);
1000
+	const u32 item_size = btrfs_item_size_nr(leaf, slot);
6851001 	u32 mode;
1002
+	int ret;
6861003 
687
-	if ((key->objectid < BTRFS_FIRST_FREE_OBJECTID ||
688
-	     key->objectid > BTRFS_LAST_FREE_OBJECTID) &&
689
-	    key->objectid != BTRFS_ROOT_TREE_DIR_OBJECTID &&
690
-	    key->objectid != BTRFS_FREE_INO_OBJECTID) {
691
-		generic_err(fs_info, leaf, slot,
692
-	"invalid key objectid: has %llu expect %llu or [%llu, %llu] or %llu",
693
-			    key->objectid, BTRFS_ROOT_TREE_DIR_OBJECTID,
694
-			    BTRFS_FIRST_FREE_OBJECTID,
695
-			    BTRFS_LAST_FREE_OBJECTID,
696
-			    BTRFS_FREE_INO_OBJECTID);
1004
+	ret = check_inode_key(leaf, key, slot);
1005
+	if (ret < 0)
1006
+		return ret;
1007
+
1008
+	if (unlikely(item_size != sizeof(*iitem))) {
1009
+		generic_err(leaf, slot, "invalid item size: has %u expect %zu",
1010
+			    item_size, sizeof(*iitem));
6971011 		return -EUCLEAN;
6981012 	}
699
-	if (key->offset != 0) {
700
-		inode_item_err(fs_info, leaf, slot,
701
-			"invalid key offset: has %llu expect 0",
702
-			key->offset);
703
-		return -EUCLEAN;
704
-	}
1013
+
7051014 	iitem = btrfs_item_ptr(leaf, slot, struct btrfs_inode_item);
7061015 
7071016 	/* Here we use super block generation + 1 to handle log tree */
7081017 	if (btrfs_inode_generation(leaf, iitem) > super_gen + 1) {
709
-		inode_item_err(fs_info, leaf, slot,
1018
+		inode_item_err(leaf, slot,
7101019 			"invalid inode generation: has %llu expect (0, %llu]",
7111020 			       btrfs_inode_generation(leaf, iitem),
7121021 			       super_gen + 1);
....@@ -714,7 +1023,7 @@
7141023 	}
7151024 	/* Note for ROOT_TREE_DIR_ITEM, mkfs could set its transid 0 */
7161025 	if (btrfs_inode_transid(leaf, iitem) > super_gen + 1) {
717
-		inode_item_err(fs_info, leaf, slot,
1026
+		inode_item_err(leaf, slot,
7181027 			"invalid inode transid: has %llu expect [0, %llu]",
7191028 			       btrfs_inode_transid(leaf, iitem), super_gen + 1);
7201029 		return -EUCLEAN;
....@@ -727,33 +1036,33 @@
7271036 	 */
7281037 	mode = btrfs_inode_mode(leaf, iitem);
7291038 	if (mode & ~valid_mask) {
730
-		inode_item_err(fs_info, leaf, slot,
1039
+		inode_item_err(leaf, slot,
7311040 			       "unknown mode bit detected: 0x%x",
7321041 			       mode & ~valid_mask);
7331042 		return -EUCLEAN;
7341043 	}
7351044 
7361045 	/*
737
-	 * S_IFMT is not bit mapped so we can't completely rely on is_power_of_2,
738
-	 * but is_power_of_2() can save us from checking FIFO/CHR/DIR/REG.
739
-	 * Only needs to check BLK, LNK and SOCKS
1046
+	 * S_IFMT is not bit mapped so we can't completely rely on
1047
+	 * is_power_of_2/has_single_bit_set, but it can save us from checking
1048
+	 * FIFO/CHR/DIR/REG.  Only needs to check BLK, LNK and SOCKS
7401049 	 */
741
-	if (!is_power_of_2(mode & S_IFMT)) {
1050
+	if (!has_single_bit_set(mode & S_IFMT)) {
7421051 		if (!S_ISLNK(mode) && !S_ISBLK(mode) && !S_ISSOCK(mode)) {
743
-			inode_item_err(fs_info, leaf, slot,
1052
+			inode_item_err(leaf, slot,
7441053 			"invalid mode: has 0%o expect valid S_IF* bit(s)",
7451054 				       mode & S_IFMT);
7461055 			return -EUCLEAN;
7471056 		}
7481057 	}
7491058 	if (S_ISDIR(mode) && btrfs_inode_nlink(leaf, iitem) > 1) {
750
-		inode_item_err(fs_info, leaf, slot,
1059
+		inode_item_err(leaf, slot,
7511060 		       "invalid nlink: has %u expect no more than 1 for dir",
7521061 			btrfs_inode_nlink(leaf, iitem));
7531062 		return -EUCLEAN;
7541063 	}
7551064 	if (btrfs_inode_flags(leaf, iitem) & ~BTRFS_INODE_FLAG_MASK) {
756
-		inode_item_err(fs_info, leaf, slot,
1065
+		inode_item_err(leaf, slot,
7571066 			       "unknown flags detected: 0x%llx",
7581067 			       btrfs_inode_flags(leaf, iitem) &
7591068 			       ~BTRFS_INODE_FLAG_MASK);
....@@ -762,49 +1071,520 @@
7621071 	return 0;
7631072 }
7641073 
1074
+static int check_root_item(struct extent_buffer *leaf, struct btrfs_key *key,
1075
+			   int slot)
1076
+{
1077
+	struct btrfs_fs_info *fs_info = leaf->fs_info;
1078
+	struct btrfs_root_item ri = { 0 };
1079
+	const u64 valid_root_flags = BTRFS_ROOT_SUBVOL_RDONLY |
1080
+				     BTRFS_ROOT_SUBVOL_DEAD;
1081
+	int ret;
1082
+
1083
+	ret = check_root_key(leaf, key, slot);
1084
+	if (ret < 0)
1085
+		return ret;
1086
+
1087
+	if (btrfs_item_size_nr(leaf, slot) != sizeof(ri) &&
1088
+	    btrfs_item_size_nr(leaf, slot) != btrfs_legacy_root_item_size()) {
1089
+		generic_err(leaf, slot,
1090
+			    "invalid root item size, have %u expect %zu or %u",
1091
+			    btrfs_item_size_nr(leaf, slot), sizeof(ri),
1092
+			    btrfs_legacy_root_item_size());
1093
+		return -EUCLEAN;
1094
+	}
1095
+
1096
+	/*
1097
+	 * For legacy root item, the members starting at generation_v2 will be
1098
+	 * all filled with 0.
1099
+	 * And since we allow geneartion_v2 as 0, it will still pass the check.
1100
+	 */
1101
+	read_extent_buffer(leaf, &ri, btrfs_item_ptr_offset(leaf, slot),
1102
+			   btrfs_item_size_nr(leaf, slot));
1103
+
1104
+	/* Generation related */
1105
+	if (btrfs_root_generation(&ri) >
1106
+	    btrfs_super_generation(fs_info->super_copy) + 1) {
1107
+		generic_err(leaf, slot,
1108
+			"invalid root generation, have %llu expect (0, %llu]",
1109
+			    btrfs_root_generation(&ri),
1110
+			    btrfs_super_generation(fs_info->super_copy) + 1);
1111
+		return -EUCLEAN;
1112
+	}
1113
+	if (btrfs_root_generation_v2(&ri) >
1114
+	    btrfs_super_generation(fs_info->super_copy) + 1) {
1115
+		generic_err(leaf, slot,
1116
+		"invalid root v2 generation, have %llu expect (0, %llu]",
1117
+			    btrfs_root_generation_v2(&ri),
1118
+			    btrfs_super_generation(fs_info->super_copy) + 1);
1119
+		return -EUCLEAN;
1120
+	}
1121
+	if (btrfs_root_last_snapshot(&ri) >
1122
+	    btrfs_super_generation(fs_info->super_copy) + 1) {
1123
+		generic_err(leaf, slot,
1124
+		"invalid root last_snapshot, have %llu expect (0, %llu]",
1125
+			    btrfs_root_last_snapshot(&ri),
1126
+			    btrfs_super_generation(fs_info->super_copy) + 1);
1127
+		return -EUCLEAN;
1128
+	}
1129
+
1130
+	/* Alignment and level check */
1131
+	if (!IS_ALIGNED(btrfs_root_bytenr(&ri), fs_info->sectorsize)) {
1132
+		generic_err(leaf, slot,
1133
+		"invalid root bytenr, have %llu expect to be aligned to %u",
1134
+			    btrfs_root_bytenr(&ri), fs_info->sectorsize);
1135
+		return -EUCLEAN;
1136
+	}
1137
+	if (btrfs_root_level(&ri) >= BTRFS_MAX_LEVEL) {
1138
+		generic_err(leaf, slot,
1139
+			    "invalid root level, have %u expect [0, %u]",
1140
+			    btrfs_root_level(&ri), BTRFS_MAX_LEVEL - 1);
1141
+		return -EUCLEAN;
1142
+	}
1143
+	if (ri.drop_level >= BTRFS_MAX_LEVEL) {
1144
+		generic_err(leaf, slot,
1145
+			    "invalid root level, have %u expect [0, %u]",
1146
+			    ri.drop_level, BTRFS_MAX_LEVEL - 1);
1147
+		return -EUCLEAN;
1148
+	}
1149
+
1150
+	/* Flags check */
1151
+	if (btrfs_root_flags(&ri) & ~valid_root_flags) {
1152
+		generic_err(leaf, slot,
1153
+			    "invalid root flags, have 0x%llx expect mask 0x%llx",
1154
+			    btrfs_root_flags(&ri), valid_root_flags);
1155
+		return -EUCLEAN;
1156
+	}
1157
+	return 0;
1158
+}
1159
+
1160
+__printf(3,4)
1161
+__cold
1162
+static void extent_err(const struct extent_buffer *eb, int slot,
1163
+		       const char *fmt, ...)
1164
+{
1165
+	struct btrfs_key key;
1166
+	struct va_format vaf;
1167
+	va_list args;
1168
+	u64 bytenr;
1169
+	u64 len;
1170
+
1171
+	btrfs_item_key_to_cpu(eb, &key, slot);
1172
+	bytenr = key.objectid;
1173
+	if (key.type == BTRFS_METADATA_ITEM_KEY ||
1174
+	    key.type == BTRFS_TREE_BLOCK_REF_KEY ||
1175
+	    key.type == BTRFS_SHARED_BLOCK_REF_KEY)
1176
+		len = eb->fs_info->nodesize;
1177
+	else
1178
+		len = key.offset;
1179
+	va_start(args, fmt);
1180
+
1181
+	vaf.fmt = fmt;
1182
+	vaf.va = &args;
1183
+
1184
+	btrfs_crit(eb->fs_info,
1185
+	"corrupt %s: block=%llu slot=%d extent bytenr=%llu len=%llu %pV",
1186
+		btrfs_header_level(eb) == 0 ? "leaf" : "node",
1187
+		eb->start, slot, bytenr, len, &vaf);
1188
+	va_end(args);
1189
+}
1190
+
1191
+static int check_extent_item(struct extent_buffer *leaf,
1192
+			     struct btrfs_key *key, int slot)
1193
+{
1194
+	struct btrfs_fs_info *fs_info = leaf->fs_info;
1195
+	struct btrfs_extent_item *ei;
1196
+	bool is_tree_block = false;
1197
+	unsigned long ptr;	/* Current pointer inside inline refs */
1198
+	unsigned long end;	/* Extent item end */
1199
+	const u32 item_size = btrfs_item_size_nr(leaf, slot);
1200
+	u64 flags;
1201
+	u64 generation;
1202
+	u64 total_refs;		/* Total refs in btrfs_extent_item */
1203
+	u64 inline_refs = 0;	/* found total inline refs */
1204
+
1205
+	if (key->type == BTRFS_METADATA_ITEM_KEY &&
1206
+	    !btrfs_fs_incompat(fs_info, SKINNY_METADATA)) {
1207
+		generic_err(leaf, slot,
1208
+"invalid key type, METADATA_ITEM type invalid when SKINNY_METADATA feature disabled");
1209
+		return -EUCLEAN;
1210
+	}
1211
+	/* key->objectid is the bytenr for both key types */
1212
+	if (!IS_ALIGNED(key->objectid, fs_info->sectorsize)) {
1213
+		generic_err(leaf, slot,
1214
+		"invalid key objectid, have %llu expect to be aligned to %u",
1215
+			   key->objectid, fs_info->sectorsize);
1216
+		return -EUCLEAN;
1217
+	}
1218
+
1219
+	/* key->offset is tree level for METADATA_ITEM_KEY */
1220
+	if (key->type == BTRFS_METADATA_ITEM_KEY &&
1221
+	    key->offset >= BTRFS_MAX_LEVEL) {
1222
+		extent_err(leaf, slot,
1223
+			   "invalid tree level, have %llu expect [0, %u]",
1224
+			   key->offset, BTRFS_MAX_LEVEL - 1);
1225
+		return -EUCLEAN;
1226
+	}
1227
+
1228
+	/*
1229
+	 * EXTENT/METADATA_ITEM consists of:
1230
+	 * 1) One btrfs_extent_item
1231
+	 *    Records the total refs, type and generation of the extent.
1232
+	 *
1233
+	 * 2) One btrfs_tree_block_info (for EXTENT_ITEM and tree backref only)
1234
+	 *    Records the first key and level of the tree block.
1235
+	 *
1236
+	 * 2) Zero or more btrfs_extent_inline_ref(s)
1237
+	 *    Each inline ref has one btrfs_extent_inline_ref shows:
1238
+	 *    2.1) The ref type, one of the 4
1239
+	 *         TREE_BLOCK_REF	Tree block only
1240
+	 *         SHARED_BLOCK_REF	Tree block only
1241
+	 *         EXTENT_DATA_REF	Data only
1242
+	 *         SHARED_DATA_REF	Data only
1243
+	 *    2.2) Ref type specific data
1244
+	 *         Either using btrfs_extent_inline_ref::offset, or specific
1245
+	 *         data structure.
1246
+	 */
1247
+	if (item_size < sizeof(*ei)) {
1248
+		extent_err(leaf, slot,
1249
+			   "invalid item size, have %u expect [%zu, %u)",
1250
+			   item_size, sizeof(*ei),
1251
+			   BTRFS_LEAF_DATA_SIZE(fs_info));
1252
+		return -EUCLEAN;
1253
+	}
1254
+	end = item_size + btrfs_item_ptr_offset(leaf, slot);
1255
+
1256
+	/* Checks against extent_item */
1257
+	ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
1258
+	flags = btrfs_extent_flags(leaf, ei);
1259
+	total_refs = btrfs_extent_refs(leaf, ei);
1260
+	generation = btrfs_extent_generation(leaf, ei);
1261
+	if (generation > btrfs_super_generation(fs_info->super_copy) + 1) {
1262
+		extent_err(leaf, slot,
1263
+			   "invalid generation, have %llu expect (0, %llu]",
1264
+			   generation,
1265
+			   btrfs_super_generation(fs_info->super_copy) + 1);
1266
+		return -EUCLEAN;
1267
+	}
1268
+	if (!has_single_bit_set(flags & (BTRFS_EXTENT_FLAG_DATA |
1269
+					 BTRFS_EXTENT_FLAG_TREE_BLOCK))) {
1270
+		extent_err(leaf, slot,
1271
+		"invalid extent flag, have 0x%llx expect 1 bit set in 0x%llx",
1272
+			flags, BTRFS_EXTENT_FLAG_DATA |
1273
+			BTRFS_EXTENT_FLAG_TREE_BLOCK);
1274
+		return -EUCLEAN;
1275
+	}
1276
+	is_tree_block = !!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK);
1277
+	if (is_tree_block) {
1278
+		if (key->type == BTRFS_EXTENT_ITEM_KEY &&
1279
+		    key->offset != fs_info->nodesize) {
1280
+			extent_err(leaf, slot,
1281
+				   "invalid extent length, have %llu expect %u",
1282
+				   key->offset, fs_info->nodesize);
1283
+			return -EUCLEAN;
1284
+		}
1285
+	} else {
1286
+		if (key->type != BTRFS_EXTENT_ITEM_KEY) {
1287
+			extent_err(leaf, slot,
1288
+			"invalid key type, have %u expect %u for data backref",
1289
+				   key->type, BTRFS_EXTENT_ITEM_KEY);
1290
+			return -EUCLEAN;
1291
+		}
1292
+		if (!IS_ALIGNED(key->offset, fs_info->sectorsize)) {
1293
+			extent_err(leaf, slot,
1294
+			"invalid extent length, have %llu expect aligned to %u",
1295
+				   key->offset, fs_info->sectorsize);
1296
+			return -EUCLEAN;
1297
+		}
1298
+	}
1299
+	ptr = (unsigned long)(struct btrfs_extent_item *)(ei + 1);
1300
+
1301
+	/* Check the special case of btrfs_tree_block_info */
1302
+	if (is_tree_block && key->type != BTRFS_METADATA_ITEM_KEY) {
1303
+		struct btrfs_tree_block_info *info;
1304
+
1305
+		info = (struct btrfs_tree_block_info *)ptr;
1306
+		if (btrfs_tree_block_level(leaf, info) >= BTRFS_MAX_LEVEL) {
1307
+			extent_err(leaf, slot,
1308
+			"invalid tree block info level, have %u expect [0, %u]",
1309
+				   btrfs_tree_block_level(leaf, info),
1310
+				   BTRFS_MAX_LEVEL - 1);
1311
+			return -EUCLEAN;
1312
+		}
1313
+		ptr = (unsigned long)(struct btrfs_tree_block_info *)(info + 1);
1314
+	}
1315
+
1316
+	/* Check inline refs */
1317
+	while (ptr < end) {
1318
+		struct btrfs_extent_inline_ref *iref;
1319
+		struct btrfs_extent_data_ref *dref;
1320
+		struct btrfs_shared_data_ref *sref;
1321
+		u64 dref_offset;
1322
+		u64 inline_offset;
1323
+		u8 inline_type;
1324
+
1325
+		if (ptr + sizeof(*iref) > end) {
1326
+			extent_err(leaf, slot,
1327
+"inline ref item overflows extent item, ptr %lu iref size %zu end %lu",
1328
+				   ptr, sizeof(*iref), end);
1329
+			return -EUCLEAN;
1330
+		}
1331
+		iref = (struct btrfs_extent_inline_ref *)ptr;
1332
+		inline_type = btrfs_extent_inline_ref_type(leaf, iref);
1333
+		inline_offset = btrfs_extent_inline_ref_offset(leaf, iref);
1334
+		if (ptr + btrfs_extent_inline_ref_size(inline_type) > end) {
1335
+			extent_err(leaf, slot,
1336
+"inline ref item overflows extent item, ptr %lu iref size %u end %lu",
1337
+				   ptr, inline_type, end);
1338
+			return -EUCLEAN;
1339
+		}
1340
+
1341
+		switch (inline_type) {
1342
+		/* inline_offset is subvolid of the owner, no need to check */
1343
+		case BTRFS_TREE_BLOCK_REF_KEY:
1344
+			inline_refs++;
1345
+			break;
1346
+		/* Contains parent bytenr */
1347
+		case BTRFS_SHARED_BLOCK_REF_KEY:
1348
+			if (!IS_ALIGNED(inline_offset, fs_info->sectorsize)) {
1349
+				extent_err(leaf, slot,
1350
+		"invalid tree parent bytenr, have %llu expect aligned to %u",
1351
+					   inline_offset, fs_info->sectorsize);
1352
+				return -EUCLEAN;
1353
+			}
1354
+			inline_refs++;
1355
+			break;
1356
+		/*
1357
+		 * Contains owner subvolid, owner key objectid, adjusted offset.
1358
+		 * The only obvious corruption can happen in that offset.
1359
+		 */
1360
+		case BTRFS_EXTENT_DATA_REF_KEY:
1361
+			dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1362
+			dref_offset = btrfs_extent_data_ref_offset(leaf, dref);
1363
+			if (!IS_ALIGNED(dref_offset, fs_info->sectorsize)) {
1364
+				extent_err(leaf, slot,
1365
+		"invalid data ref offset, have %llu expect aligned to %u",
1366
+					   dref_offset, fs_info->sectorsize);
1367
+				return -EUCLEAN;
1368
+			}
1369
+			inline_refs += btrfs_extent_data_ref_count(leaf, dref);
1370
+			break;
1371
+		/* Contains parent bytenr and ref count */
1372
+		case BTRFS_SHARED_DATA_REF_KEY:
1373
+			sref = (struct btrfs_shared_data_ref *)(iref + 1);
1374
+			if (!IS_ALIGNED(inline_offset, fs_info->sectorsize)) {
1375
+				extent_err(leaf, slot,
1376
+		"invalid data parent bytenr, have %llu expect aligned to %u",
1377
+					   inline_offset, fs_info->sectorsize);
1378
+				return -EUCLEAN;
1379
+			}
1380
+			inline_refs += btrfs_shared_data_ref_count(leaf, sref);
1381
+			break;
1382
+		default:
1383
+			extent_err(leaf, slot, "unknown inline ref type: %u",
1384
+				   inline_type);
1385
+			return -EUCLEAN;
1386
+		}
1387
+		ptr += btrfs_extent_inline_ref_size(inline_type);
1388
+	}
1389
+	/* No padding is allowed */
1390
+	if (ptr != end) {
1391
+		extent_err(leaf, slot,
1392
+			   "invalid extent item size, padding bytes found");
1393
+		return -EUCLEAN;
1394
+	}
1395
+
1396
+	/* Finally, check the inline refs against total refs */
1397
+	if (inline_refs > total_refs) {
1398
+		extent_err(leaf, slot,
1399
+			"invalid extent refs, have %llu expect >= inline %llu",
1400
+			   total_refs, inline_refs);
1401
+		return -EUCLEAN;
1402
+	}
1403
+	return 0;
1404
+}
1405
+
1406
+static int check_simple_keyed_refs(struct extent_buffer *leaf,
1407
+				   struct btrfs_key *key, int slot)
1408
+{
1409
+	u32 expect_item_size = 0;
1410
+
1411
+	if (key->type == BTRFS_SHARED_DATA_REF_KEY)
1412
+		expect_item_size = sizeof(struct btrfs_shared_data_ref);
1413
+
1414
+	if (btrfs_item_size_nr(leaf, slot) != expect_item_size) {
1415
+		generic_err(leaf, slot,
1416
+		"invalid item size, have %u expect %u for key type %u",
1417
+			    btrfs_item_size_nr(leaf, slot),
1418
+			    expect_item_size, key->type);
1419
+		return -EUCLEAN;
1420
+	}
1421
+	if (!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize)) {
1422
+		generic_err(leaf, slot,
1423
+"invalid key objectid for shared block ref, have %llu expect aligned to %u",
1424
+			    key->objectid, leaf->fs_info->sectorsize);
1425
+		return -EUCLEAN;
1426
+	}
1427
+	if (key->type != BTRFS_TREE_BLOCK_REF_KEY &&
1428
+	    !IS_ALIGNED(key->offset, leaf->fs_info->sectorsize)) {
1429
+		extent_err(leaf, slot,
1430
+		"invalid tree parent bytenr, have %llu expect aligned to %u",
1431
+			   key->offset, leaf->fs_info->sectorsize);
1432
+		return -EUCLEAN;
1433
+	}
1434
+	return 0;
1435
+}
1436
+
1437
+static int check_extent_data_ref(struct extent_buffer *leaf,
1438
+				 struct btrfs_key *key, int slot)
1439
+{
1440
+	struct btrfs_extent_data_ref *dref;
1441
+	unsigned long ptr = btrfs_item_ptr_offset(leaf, slot);
1442
+	const unsigned long end = ptr + btrfs_item_size_nr(leaf, slot);
1443
+
1444
+	if (btrfs_item_size_nr(leaf, slot) % sizeof(*dref) != 0) {
1445
+		generic_err(leaf, slot,
1446
+	"invalid item size, have %u expect aligned to %zu for key type %u",
1447
+			    btrfs_item_size_nr(leaf, slot),
1448
+			    sizeof(*dref), key->type);
1449
+		return -EUCLEAN;
1450
+	}
1451
+	if (!IS_ALIGNED(key->objectid, leaf->fs_info->sectorsize)) {
1452
+		generic_err(leaf, slot,
1453
+"invalid key objectid for shared block ref, have %llu expect aligned to %u",
1454
+			    key->objectid, leaf->fs_info->sectorsize);
1455
+		return -EUCLEAN;
1456
+	}
1457
+	for (; ptr < end; ptr += sizeof(*dref)) {
1458
+		u64 offset;
1459
+
1460
+		/*
1461
+		 * We cannot check the extent_data_ref hash due to possible
1462
+		 * overflow from the leaf due to hash collisions.
1463
+		 */
1464
+		dref = (struct btrfs_extent_data_ref *)ptr;
1465
+		offset = btrfs_extent_data_ref_offset(leaf, dref);
1466
+		if (!IS_ALIGNED(offset, leaf->fs_info->sectorsize)) {
1467
+			extent_err(leaf, slot,
1468
+	"invalid extent data backref offset, have %llu expect aligned to %u",
1469
+				   offset, leaf->fs_info->sectorsize);
1470
+			return -EUCLEAN;
1471
+		}
1472
+	}
1473
+	return 0;
1474
+}
1475
+
1476
+#define inode_ref_err(eb, slot, fmt, args...)			\
1477
+	inode_item_err(eb, slot, fmt, ##args)
1478
+static int check_inode_ref(struct extent_buffer *leaf,
1479
+			   struct btrfs_key *key, struct btrfs_key *prev_key,
1480
+			   int slot)
1481
+{
1482
+	struct btrfs_inode_ref *iref;
1483
+	unsigned long ptr;
1484
+	unsigned long end;
1485
+
1486
+	if (!check_prev_ino(leaf, key, slot, prev_key))
1487
+		return -EUCLEAN;
1488
+	/* namelen can't be 0, so item_size == sizeof() is also invalid */
1489
+	if (btrfs_item_size_nr(leaf, slot) <= sizeof(*iref)) {
1490
+		inode_ref_err(leaf, slot,
1491
+			"invalid item size, have %u expect (%zu, %u)",
1492
+			btrfs_item_size_nr(leaf, slot),
1493
+			sizeof(*iref), BTRFS_LEAF_DATA_SIZE(leaf->fs_info));
1494
+		return -EUCLEAN;
1495
+	}
1496
+
1497
+	ptr = btrfs_item_ptr_offset(leaf, slot);
1498
+	end = ptr + btrfs_item_size_nr(leaf, slot);
1499
+	while (ptr < end) {
1500
+		u16 namelen;
1501
+
1502
+		if (ptr + sizeof(iref) > end) {
1503
+			inode_ref_err(leaf, slot,
1504
+			"inode ref overflow, ptr %lu end %lu inode_ref_size %zu",
1505
+				ptr, end, sizeof(iref));
1506
+			return -EUCLEAN;
1507
+		}
1508
+
1509
+		iref = (struct btrfs_inode_ref *)ptr;
1510
+		namelen = btrfs_inode_ref_name_len(leaf, iref);
1511
+		if (ptr + sizeof(*iref) + namelen > end) {
1512
+			inode_ref_err(leaf, slot,
1513
+				"inode ref overflow, ptr %lu end %lu namelen %u",
1514
+				ptr, end, namelen);
1515
+			return -EUCLEAN;
1516
+		}
1517
+
1518
+		/*
1519
+		 * NOTE: In theory we should record all found index numbers
1520
+		 * to find any duplicated indexes, but that will be too time
1521
+		 * consuming for inodes with too many hard links.
1522
+		 */
1523
+		ptr += sizeof(*iref) + namelen;
1524
+	}
1525
+	return 0;
1526
+}
1527
+
7651528 /*
7661529  * Common point to switch the item-specific validation.
7671530  */
768
-static int check_leaf_item(struct btrfs_fs_info *fs_info,
769
-			   struct extent_buffer *leaf,
770
-			   struct btrfs_key *key, int slot)
1531
+static int check_leaf_item(struct extent_buffer *leaf,
1532
+			   struct btrfs_key *key, int slot,
1533
+			   struct btrfs_key *prev_key)
7711534 {
7721535 	int ret = 0;
7731536 	struct btrfs_chunk *chunk;
7741537 
7751538 	switch (key->type) {
7761539 	case BTRFS_EXTENT_DATA_KEY:
777
-		ret = check_extent_data_item(fs_info, leaf, key, slot);
1540
+		ret = check_extent_data_item(leaf, key, slot, prev_key);
7781541 		break;
7791542 	case BTRFS_EXTENT_CSUM_KEY:
780
-		ret = check_csum_item(fs_info, leaf, key, slot);
1543
+		ret = check_csum_item(leaf, key, slot, prev_key);
7811544 		break;
7821545 	case BTRFS_DIR_ITEM_KEY:
7831546 	case BTRFS_DIR_INDEX_KEY:
7841547 	case BTRFS_XATTR_ITEM_KEY:
785
-		ret = check_dir_item(fs_info, leaf, key, slot);
1548
+		ret = check_dir_item(leaf, key, prev_key, slot);
1549
+		break;
1550
+	case BTRFS_INODE_REF_KEY:
1551
+		ret = check_inode_ref(leaf, key, prev_key, slot);
7861552 		break;
7871553 	case BTRFS_BLOCK_GROUP_ITEM_KEY:
788
-		ret = check_block_group_item(fs_info, leaf, key, slot);
1554
+		ret = check_block_group_item(leaf, key, slot);
7891555 		break;
7901556 	case BTRFS_CHUNK_ITEM_KEY:
7911557 		chunk = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
792
-		ret = btrfs_check_chunk_valid(fs_info, leaf, chunk,
793
-					      key->offset);
1558
+		ret = check_leaf_chunk_item(leaf, chunk, key, slot);
7941559 		break;
7951560 	case BTRFS_DEV_ITEM_KEY:
796
-		ret = check_dev_item(fs_info, leaf, key, slot);
1561
+		ret = check_dev_item(leaf, key, slot);
7971562 		break;
7981563 	case BTRFS_INODE_ITEM_KEY:
799
-		ret = check_inode_item(fs_info, leaf, key, slot);
1564
+		ret = check_inode_item(leaf, key, slot);
1565
+		break;
1566
+	case BTRFS_ROOT_ITEM_KEY:
1567
+		ret = check_root_item(leaf, key, slot);
1568
+		break;
1569
+	case BTRFS_EXTENT_ITEM_KEY:
1570
+	case BTRFS_METADATA_ITEM_KEY:
1571
+		ret = check_extent_item(leaf, key, slot);
1572
+		break;
1573
+	case BTRFS_TREE_BLOCK_REF_KEY:
1574
+	case BTRFS_SHARED_DATA_REF_KEY:
1575
+	case BTRFS_SHARED_BLOCK_REF_KEY:
1576
+		ret = check_simple_keyed_refs(leaf, key, slot);
1577
+		break;
1578
+	case BTRFS_EXTENT_DATA_REF_KEY:
1579
+		ret = check_extent_data_ref(leaf, key, slot);
8001580 		break;
8011581 	}
8021582 	return ret;
8031583 }
8041584 
805
-static int check_leaf(struct btrfs_fs_info *fs_info, struct extent_buffer *leaf,
806
-		      bool check_item_data)
1585
+static int check_leaf(struct extent_buffer *leaf, bool check_item_data)
8071586 {
1587
+	struct btrfs_fs_info *fs_info = leaf->fs_info;
8081588 	/* No valid key type is 0, so all key should be larger than this key */
8091589 	struct btrfs_key prev_key = {0, 0, 0};
8101590 	struct btrfs_key key;
....@@ -812,7 +1592,7 @@
8121592 	int slot;
8131593 
8141594 	if (btrfs_header_level(leaf) != 0) {
815
-		generic_err(fs_info, leaf, 0,
1595
+		generic_err(leaf, 0,
8161596 			"invalid level for leaf, have %d expect 0",
8171597 			btrfs_header_level(leaf));
8181598 		return -EUCLEAN;
....@@ -828,7 +1608,6 @@
8281608 	 */
8291609 	if (nritems == 0 && !btrfs_header_flag(leaf, BTRFS_HEADER_FLAG_RELOC)) {
8301610 		u64 owner = btrfs_header_owner(leaf);
831
-		struct btrfs_root *check_root;
8321611 
8331612 		/* These trees must never be empty */
8341613 		if (owner == BTRFS_ROOT_TREE_OBJECTID ||
....@@ -837,39 +1616,16 @@
8371616 		    owner == BTRFS_DEV_TREE_OBJECTID ||
8381617 		    owner == BTRFS_FS_TREE_OBJECTID ||
8391618 		    owner == BTRFS_DATA_RELOC_TREE_OBJECTID) {
840
-			generic_err(fs_info, leaf, 0,
1619
+			generic_err(leaf, 0,
8411620 			"invalid root, root %llu must never be empty",
8421621 				    owner);
8431622 			return -EUCLEAN;
8441623 		}
8451624 		/* Unknown tree */
8461625 		if (owner == 0) {
847
-			generic_err(fs_info, leaf, 0,
1626
+			generic_err(leaf, 0,
8481627 				"invalid owner, root 0 is not defined");
8491628 			return -EUCLEAN;
850
-		}
851
-		key.objectid = owner;
852
-		key.type = BTRFS_ROOT_ITEM_KEY;
853
-		key.offset = (u64)-1;
854
-
855
-		check_root = btrfs_get_fs_root(fs_info, &key, false);
856
-		/*
857
-		 * The only reason we also check NULL here is that during
858
-		 * open_ctree() some roots has not yet been set up.
859
-		 */
860
-		if (!IS_ERR_OR_NULL(check_root)) {
861
-			struct extent_buffer *eb;
862
-
863
-			eb = btrfs_root_node(check_root);
864
-			/* if leaf is the root, then it's fine */
865
-			if (leaf != eb) {
866
-				generic_err(fs_info, leaf, 0,
867
-		"invalid nritems, have %u should not be 0 for non-root leaf",
868
-					nritems);
869
-				free_extent_buffer(eb);
870
-				return -EUCLEAN;
871
-			}
872
-			free_extent_buffer(eb);
8731629 		}
8741630 		return 0;
8751631 	}
....@@ -896,7 +1652,7 @@
8961652 
8971653 		/* Make sure the keys are in the right order */
8981654 		if (btrfs_comp_cpu_keys(&prev_key, &key) >= 0) {
899
-			generic_err(fs_info, leaf, slot,
1655
+			generic_err(leaf, slot,
9001656 	"bad key order, prev (%llu %u %llu) current (%llu %u %llu)",
9011657 				prev_key.objectid, prev_key.type,
9021658 				prev_key.offset, key.objectid, key.type,
....@@ -915,7 +1671,7 @@
9151671 			item_end_expected = btrfs_item_offset_nr(leaf,
9161672 								 slot - 1);
9171673 		if (btrfs_item_end_nr(leaf, slot) != item_end_expected) {
918
-			generic_err(fs_info, leaf, slot,
1674
+			generic_err(leaf, slot,
9191675 				"unexpected item end, have %u expect %u",
9201676 				btrfs_item_end_nr(leaf, slot),
9211677 				item_end_expected);
....@@ -929,7 +1685,7 @@
9291685 		 */
9301686 		if (btrfs_item_end_nr(leaf, slot) >
9311687 		    BTRFS_LEAF_DATA_SIZE(fs_info)) {
932
-			generic_err(fs_info, leaf, slot,
1688
+			generic_err(leaf, slot,
9331689 			"slot end outside of leaf, have %u expect range [0, %u]",
9341690 				btrfs_item_end_nr(leaf, slot),
9351691 				BTRFS_LEAF_DATA_SIZE(fs_info));
....@@ -939,7 +1695,7 @@
9391695 		/* Also check if the item pointer overlaps with btrfs item. */
9401696 		if (btrfs_item_nr_offset(slot) + sizeof(struct btrfs_item) >
9411697 		    btrfs_item_ptr_offset(leaf, slot)) {
942
-			generic_err(fs_info, leaf, slot,
1698
+			generic_err(leaf, slot,
9431699 		"slot overlaps with its data, item end %lu data start %lu",
9441700 				btrfs_item_nr_offset(slot) +
9451701 				sizeof(struct btrfs_item),
....@@ -952,7 +1708,7 @@
9521708 			 * Check if the item size and content meet other
9531709 			 * criteria
9541710 			 */
955
-			ret = check_leaf_item(fs_info, leaf, &key, slot);
1711
+			ret = check_leaf_item(leaf, &key, slot, &prev_key);
9561712 			if (ret < 0)
9571713 				return ret;
9581714 		}
....@@ -965,20 +1721,20 @@
9651721 	return 0;
9661722 }
9671723 
968
-int btrfs_check_leaf_full(struct btrfs_fs_info *fs_info,
969
-			  struct extent_buffer *leaf)
1724
+int btrfs_check_leaf_full(struct extent_buffer *leaf)
9701725 {
971
-	return check_leaf(fs_info, leaf, true);
1726
+	return check_leaf(leaf, true);
1727
+}
1728
+ALLOW_ERROR_INJECTION(btrfs_check_leaf_full, ERRNO);
1729
+
1730
+int btrfs_check_leaf_relaxed(struct extent_buffer *leaf)
1731
+{
1732
+	return check_leaf(leaf, false);
9721733 }
9731734 
974
-int btrfs_check_leaf_relaxed(struct btrfs_fs_info *fs_info,
975
-			     struct extent_buffer *leaf)
1735
+int btrfs_check_node(struct extent_buffer *node)
9761736 {
977
-	return check_leaf(fs_info, leaf, false);
978
-}
979
-
980
-int btrfs_check_node(struct btrfs_fs_info *fs_info, struct extent_buffer *node)
981
-{
1737
+	struct btrfs_fs_info *fs_info = node->fs_info;
9821738 	unsigned long nr = btrfs_header_nritems(node);
9831739 	struct btrfs_key key, next_key;
9841740 	int slot;
....@@ -987,7 +1743,7 @@
9871743 	int ret = 0;
9881744 
9891745 	if (level <= 0 || level >= BTRFS_MAX_LEVEL) {
990
-		generic_err(fs_info, node, 0,
1746
+		generic_err(node, 0,
9911747 			"invalid level for node, have %d expect [1, %d]",
9921748 			level, BTRFS_MAX_LEVEL - 1);
9931749 		return -EUCLEAN;
....@@ -1007,13 +1763,13 @@
10071763 		btrfs_node_key_to_cpu(node, &next_key, slot + 1);
10081764 
10091765 		if (!bytenr) {
1010
-			generic_err(fs_info, node, slot,
1766
+			generic_err(node, slot,
10111767 				"invalid NULL node pointer");
10121768 			ret = -EUCLEAN;
10131769 			goto out;
10141770 		}
10151771 		if (!IS_ALIGNED(bytenr, fs_info->sectorsize)) {
1016
-			generic_err(fs_info, node, slot,
1772
+			generic_err(node, slot,
10171773 			"unaligned pointer, have %llu should be aligned to %u",
10181774 				bytenr, fs_info->sectorsize);
10191775 			ret = -EUCLEAN;
....@@ -1021,7 +1777,7 @@
10211777 		}
10221778 
10231779 		if (btrfs_comp_cpu_keys(&key, &next_key) >= 0) {
1024
-			generic_err(fs_info, node, slot,
1780
+			generic_err(node, slot,
10251781 	"bad key order, current (%llu %u %llu) next (%llu %u %llu)",
10261782 				key.objectid, key.type, key.offset,
10271783 				next_key.objectid, next_key.type,
....@@ -1033,3 +1789,4 @@
10331789 out:
10341790 	return ret;
10351791 }
1792
+ALLOW_ERROR_INJECTION(btrfs_check_node, ERRNO);