?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
btrfs-progs: docs: add missing short option for qroup-report
[btrfs-progs-unstable/devel.git] / cmds-check.c
blobf6320b21665263dd42a52cd7196c415fd369d228
1 /*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <unistd.h>
22 #include <fcntl.h>
23 #include <sys/types.h>
24 #include <sys/stat.h>
25 #include <unistd.h>
26 #include <getopt.h>
27 #include <uuid/uuid.h>
28 #include "ctree.h"
29 #include "volumes.h"
30 #include "repair.h"
31 #include "disk-io.h"
32 #include "print-tree.h"
33 #include "task-utils.h"
34 #include "transaction.h"
35 #include "utils.h"
36 #include "commands.h"
37 #include "free-space-cache.h"
38 #include "free-space-tree.h"
39 #include "btrfsck.h"
40 #include "qgroup-verify.h"
41 #include "rbtree-utils.h"
42 #include "backref.h"
43 #include "kernel-shared/ulist.h"
44 #include "hash.h"
45 #include "help.h"
46
47 enum task_position {
48 TASK_EXTENTS,
49 TASK_FREE_SPACE,
50 TASK_FS_ROOTS,
51 TASK_NOTHING, /* have to be the last element */
52 };
53
54 struct task_ctx {
55 int progress_enabled;
56 enum task_position tp;
57
58 struct task_info *info;
59 };
60
61 static u64 bytes_used = 0;
62 static u64 total_csum_bytes = 0;
63 static u64 total_btree_bytes = 0;
64 static u64 total_fs_tree_bytes = 0;
65 static u64 total_extent_tree_bytes = 0;
66 static u64 btree_space_waste = 0;
67 static u64 data_bytes_allocated = 0;
68 static u64 data_bytes_referenced = 0;
69 static int found_old_backref = 0;
70 static LIST_HEAD(duplicate_extents);
71 static LIST_HEAD(delete_items);
72 static int no_holes = 0;
73 static int init_extent_tree = 0;
74 static int check_data_csum = 0;
75 static struct btrfs_fs_info *global_info;
76 static struct task_ctx ctx = { 0 };
77 static struct cache_tree *roots_info_cache = NULL;
78
79 enum btrfs_check_mode {
80 CHECK_MODE_ORIGINAL,
81 CHECK_MODE_LOWMEM,
82 CHECK_MODE_UNKNOWN,
83 CHECK_MODE_DEFAULT = CHECK_MODE_ORIGINAL
84 };
85
86 static enum btrfs_check_mode check_mode = CHECK_MODE_DEFAULT;
87
88 struct extent_backref {
89 struct list_head list;
90 unsigned int is_data:1;
91 unsigned int found_extent_tree:1;
92 unsigned int full_backref:1;
93 unsigned int found_ref:1;
94 unsigned int broken:1;
95 };
96
97 static inline struct extent_backref* to_extent_backref(struct list_head *entry)
98 {
99 return list_entry(entry, struct extent_backref, list);
100 }
101
102 struct data_backref {
103 struct extent_backref node;
104 union {
105 u64 parent;
106 u64 root;
107 };
108 u64 owner;
109 u64 offset;
110 u64 disk_bytenr;
111 u64 bytes;
112 u64 ram_bytes;
113 u32 num_refs;
114 u32 found_ref;
115 };
116
117 #define ROOT_DIR_ERROR (1<<1) /* bad ROOT_DIR */
118 #define DIR_ITEM_MISSING (1<<2) /* DIR_ITEM not found */
119 #define DIR_ITEM_MISMATCH (1<<3) /* DIR_ITEM found but not match */
120 #define INODE_REF_MISSING (1<<4) /* INODE_REF/INODE_EXTREF not found */
121 #define INODE_ITEM_MISSING (1<<5) /* INODE_ITEM not found */
122 #define INODE_ITEM_MISMATCH (1<<6) /* INODE_ITEM found but not match */
123 #define FILE_EXTENT_ERROR (1<<7) /* bad FILE_EXTENT */
124 #define ODD_CSUM_ITEM (1<<8) /* CSUM_ITEM error */
125 #define CSUM_ITEM_MISSING (1<<9) /* CSUM_ITEM not found */
126 #define LINK_COUNT_ERROR (1<<10) /* INODE_ITEM nlink count error */
127 #define NBYTES_ERROR (1<<11) /* INODE_ITEM nbytes count error */
128 #define ISIZE_ERROR (1<<12) /* INODE_ITEM size count error */
129 #define ORPHAN_ITEM (1<<13) /* INODE_ITEM no reference */
130 #define NO_INODE_ITEM (1<<14) /* no inode_item */
131 #define LAST_ITEM (1<<15) /* Complete this tree traversal */
132 #define ROOT_REF_MISSING (1<<16) /* ROOT_REF not found */
133 #define ROOT_REF_MISMATCH (1<<17) /* ROOT_REF found but not match */
134
135 static inline struct data_backref* to_data_backref(struct extent_backref *back)
136 {
137 return container_of(back, struct data_backref, node);
138 }
139
140 /*
141 * Much like data_backref, just removed the undetermined members
142 * and change it to use list_head.
143 * During extent scan, it is stored in root->orphan_data_extent.
144 * During fs tree scan, it is then moved to inode_rec->orphan_data_extents.
145 */
146 struct orphan_data_extent {
147 struct list_head list;
148 u64 root;
149 u64 objectid;
150 u64 offset;
151 u64 disk_bytenr;
152 u64 disk_len;
153 };
154
155 struct tree_backref {
156 struct extent_backref node;
157 union {
158 u64 parent;
159 u64 root;
160 };
161 };
162
163 static inline struct tree_backref* to_tree_backref(struct extent_backref *back)
164 {
165 return container_of(back, struct tree_backref, node);
166 }
167
168 /* Explicit initialization for extent_record::flag_block_full_backref */
169 enum { FLAG_UNSET = 2 };
170
171 struct extent_record {
172 struct list_head backrefs;
173 struct list_head dups;
174 struct list_head list;
175 struct cache_extent cache;
176 struct btrfs_disk_key parent_key;
177 u64 start;
178 u64 max_size;
179 u64 nr;
180 u64 refs;
181 u64 extent_item_refs;
182 u64 generation;
183 u64 parent_generation;
184 u64 info_objectid;
185 u32 num_duplicates;
186 u8 info_level;
187 unsigned int flag_block_full_backref:2;
188 unsigned int found_rec:1;
189 unsigned int content_checked:1;
190 unsigned int owner_ref_checked:1;
191 unsigned int is_root:1;
192 unsigned int metadata:1;
193 unsigned int bad_full_backref:1;
194 unsigned int crossing_stripes:1;
195 unsigned int wrong_chunk_type:1;
196 };
197
198 static inline struct extent_record* to_extent_record(struct list_head *entry)
199 {
200 return container_of(entry, struct extent_record, list);
201 }
202
203 struct inode_backref {
204 struct list_head list;
205 unsigned int found_dir_item:1;
206 unsigned int found_dir_index:1;
207 unsigned int found_inode_ref:1;
208 u8 filetype;
209 u8 ref_type;
210 int errors;
211 u64 dir;
212 u64 index;
213 u16 namelen;
214 char name[0];
215 };
216
217 static inline struct inode_backref* to_inode_backref(struct list_head *entry)
218 {
219 return list_entry(entry, struct inode_backref, list);
220 }
221
222 struct root_item_record {
223 struct list_head list;
224 u64 objectid;
225 u64 bytenr;
226 u64 last_snapshot;
227 u8 level;
228 u8 drop_level;
229 int level_size;
230 struct btrfs_key drop_key;
231 };
232
233 #define REF_ERR_NO_DIR_ITEM (1 << 0)
234 #define REF_ERR_NO_DIR_INDEX (1 << 1)
235 #define REF_ERR_NO_INODE_REF (1 << 2)
236 #define REF_ERR_DUP_DIR_ITEM (1 << 3)
237 #define REF_ERR_DUP_DIR_INDEX (1 << 4)
238 #define REF_ERR_DUP_INODE_REF (1 << 5)
239 #define REF_ERR_INDEX_UNMATCH (1 << 6)
240 #define REF_ERR_FILETYPE_UNMATCH (1 << 7)
241 #define REF_ERR_NAME_TOO_LONG (1 << 8) // 100
242 #define REF_ERR_NO_ROOT_REF (1 << 9)
243 #define REF_ERR_NO_ROOT_BACKREF (1 << 10)
244 #define REF_ERR_DUP_ROOT_REF (1 << 11)
245 #define REF_ERR_DUP_ROOT_BACKREF (1 << 12)
246
247 struct file_extent_hole {
248 struct rb_node node;
249 u64 start;
250 u64 len;
251 };
252
253 struct inode_record {
254 struct list_head backrefs;
255 unsigned int checked:1;
256 unsigned int merging:1;
257 unsigned int found_inode_item:1;
258 unsigned int found_dir_item:1;
259 unsigned int found_file_extent:1;
260 unsigned int found_csum_item:1;
261 unsigned int some_csum_missing:1;
262 unsigned int nodatasum:1;
263 int errors;
264
265 u64 ino;
266 u32 nlink;
267 u32 imode;
268 u64 isize;
269 u64 nbytes;
270
271 u32 found_link;
272 u64 found_size;
273 u64 extent_start;
274 u64 extent_end;
275 struct rb_root holes;
276 struct list_head orphan_extents;
277
278 u32 refs;
279 };
280
281 #define I_ERR_NO_INODE_ITEM (1 << 0)
282 #define I_ERR_NO_ORPHAN_ITEM (1 << 1)
283 #define I_ERR_DUP_INODE_ITEM (1 << 2)
284 #define I_ERR_DUP_DIR_INDEX (1 << 3)
285 #define I_ERR_ODD_DIR_ITEM (1 << 4)
286 #define I_ERR_ODD_FILE_EXTENT (1 << 5)
287 #define I_ERR_BAD_FILE_EXTENT (1 << 6)
288 #define I_ERR_FILE_EXTENT_OVERLAP (1 << 7)
289 #define I_ERR_FILE_EXTENT_DISCOUNT (1 << 8) // 100
290 #define I_ERR_DIR_ISIZE_WRONG (1 << 9)
291 #define I_ERR_FILE_NBYTES_WRONG (1 << 10) // 400
292 #define I_ERR_ODD_CSUM_ITEM (1 << 11)
293 #define I_ERR_SOME_CSUM_MISSING (1 << 12)
294 #define I_ERR_LINK_COUNT_WRONG (1 << 13)
295 #define I_ERR_FILE_EXTENT_ORPHAN (1 << 14)
296
297 struct root_backref {
298 struct list_head list;
299 unsigned int found_dir_item:1;
300 unsigned int found_dir_index:1;
301 unsigned int found_back_ref:1;
302 unsigned int found_forward_ref:1;
303 unsigned int reachable:1;
304 int errors;
305 u64 ref_root;
306 u64 dir;
307 u64 index;
308 u16 namelen;
309 char name[0];
310 };
311
312 static inline struct root_backref* to_root_backref(struct list_head *entry)
313 {
314 return list_entry(entry, struct root_backref, list);
315 }
316
317 struct root_record {
318 struct list_head backrefs;
319 struct cache_extent cache;
320 unsigned int found_root_item:1;
321 u64 objectid;
322 u32 found_ref;
323 };
324
325 struct ptr_node {
326 struct cache_extent cache;
327 void *data;
328 };
329
330 struct shared_node {
331 struct cache_extent cache;
332 struct cache_tree root_cache;
333 struct cache_tree inode_cache;
334 struct inode_record *current;
335 u32 refs;
336 };
337
338 struct block_info {
339 u64 start;
340 u32 size;
341 };
342
343 struct walk_control {
344 struct cache_tree shared;
345 struct shared_node *nodes[BTRFS_MAX_LEVEL];
346 int active_node;
347 int root_level;
348 };
349
350 struct bad_item {
351 struct btrfs_key key;
352 u64 root_id;
353 struct list_head list;
354 };
355
356 struct extent_entry {
357 u64 bytenr;
358 u64 bytes;
359 int count;
360 int broken;
361 struct list_head list;
362 };
363
364 struct root_item_info {
365 /* level of the root */
366 u8 level;
367 /* number of nodes at this level, must be 1 for a root */
368 int node_count;
369 u64 bytenr;
370 u64 gen;
371 struct cache_extent cache_extent;
372 };
373
374 /*
375 * Error bit for low memory mode check.
376 *
377 * Currently no caller cares about it yet. Just internal use for error
378 * classification.
379 */
380 #define BACKREF_MISSING (1 << 0) /* Backref missing in extent tree */
381 #define BACKREF_MISMATCH (1 << 1) /* Backref exists but does not match */
382 #define BYTES_UNALIGNED (1 << 2) /* Some bytes are not aligned */
383 #define REFERENCER_MISSING (1 << 3) /* Referencer not found */
384 #define REFERENCER_MISMATCH (1 << 4) /* Referenceer found but does not match */
385 #define CROSSING_STRIPE_BOUNDARY (1 << 4) /* For kernel scrub workaround */
386 #define ITEM_SIZE_MISMATCH (1 << 5) /* Bad item size */
387 #define UNKNOWN_TYPE (1 << 6) /* Unknown type */
388 #define ACCOUNTING_MISMATCH (1 << 7) /* Used space accounting error */
389 #define CHUNK_TYPE_MISMATCH (1 << 8)
390
391 static void *print_status_check(void *p)
392 {
393 struct task_ctx *priv = p;
394 const char work_indicator[] = { '.', 'o', 'O', 'o' };
395 uint32_t count = 0;
396 static char *task_position_string[] = {
397 "checking extents",
398 "checking free space cache",
399 "checking fs roots",
400 };
401
402 task_period_start(priv->info, 1000 /* 1s */);
403
404 if (priv->tp == TASK_NOTHING)
405 return NULL;
406
407 while (1) {
408 printf("%s [%c]\r", task_position_string[priv->tp],
409 work_indicator[count % 4]);
410 count++;
411 fflush(stdout);
412 task_period_wait(priv->info);
413 }
414 return NULL;
415 }
416
417 static int print_status_return(void *p)
418 {
419 printf("\n");
420 fflush(stdout);
421
422 return 0;
423 }
424
425 static enum btrfs_check_mode parse_check_mode(const char *str)
426 {
427 if (strcmp(str, "lowmem") == 0)
428 return CHECK_MODE_LOWMEM;
429 if (strcmp(str, "orig") == 0)
430 return CHECK_MODE_ORIGINAL;
431 if (strcmp(str, "original") == 0)
432 return CHECK_MODE_ORIGINAL;
433
434 return CHECK_MODE_UNKNOWN;
435 }
436
437 /* Compatible function to allow reuse of old codes */
438 static u64 first_extent_gap(struct rb_root *holes)
439 {
440 struct file_extent_hole *hole;
441
442 if (RB_EMPTY_ROOT(holes))
443 return (u64)-1;
444
445 hole = rb_entry(rb_first(holes), struct file_extent_hole, node);
446 return hole->start;
447 }
448
449 static int compare_hole(struct rb_node *node1, struct rb_node *node2)
450 {
451 struct file_extent_hole *hole1;
452 struct file_extent_hole *hole2;
453
454 hole1 = rb_entry(node1, struct file_extent_hole, node);
455 hole2 = rb_entry(node2, struct file_extent_hole, node);
456
457 if (hole1->start > hole2->start)
458 return -1;
459 if (hole1->start < hole2->start)
460 return 1;
461 /* Now hole1->start == hole2->start */
462 if (hole1->len >= hole2->len)
463 /*
464 * Hole 1 will be merge center
465 * Same hole will be merged later
466 */
467 return -1;
468 /* Hole 2 will be merge center */
469 return 1;
470 }
471
472 /*
473 * Add a hole to the record
474 *
475 * This will do hole merge for copy_file_extent_holes(),
476 * which will ensure there won't be continuous holes.
477 */
478 static int add_file_extent_hole(struct rb_root *holes,
479 u64 start, u64 len)
480 {
481 struct file_extent_hole *hole;
482 struct file_extent_hole *prev = NULL;
483 struct file_extent_hole *next = NULL;
484
485 hole = malloc(sizeof(*hole));
486 if (!hole)
487 return -ENOMEM;
488 hole->start = start;
489 hole->len = len;
490 /* Since compare will not return 0, no -EEXIST will happen */
491 rb_insert(holes, &hole->node, compare_hole);
492
493 /* simple merge with previous hole */
494 if (rb_prev(&hole->node))
495 prev = rb_entry(rb_prev(&hole->node), struct file_extent_hole,
496 node);
497 if (prev && prev->start + prev->len >= hole->start) {
498 hole->len = hole->start + hole->len - prev->start;
499 hole->start = prev->start;
500 rb_erase(&prev->node, holes);
501 free(prev);
502 prev = NULL;
503 }
504
505 /* iterate merge with next holes */
506 while (1) {
507 if (!rb_next(&hole->node))
508 break;
509 next = rb_entry(rb_next(&hole->node), struct file_extent_hole,
510 node);
511 if (hole->start + hole->len >= next->start) {
512 if (hole->start + hole->len <= next->start + next->len)
513 hole->len = next->start + next->len -
514 hole->start;
515 rb_erase(&next->node, holes);
516 free(next);
517 next = NULL;
518 } else
519 break;
520 }
521 return 0;
522 }
523
524 static int compare_hole_range(struct rb_node *node, void *data)
525 {
526 struct file_extent_hole *hole;
527 u64 start;
528
529 hole = (struct file_extent_hole *)data;
530 start = hole->start;
531
532 hole = rb_entry(node, struct file_extent_hole, node);
533 if (start < hole->start)
534 return -1;
535 if (start >= hole->start && start < hole->start + hole->len)
536 return 0;
537 return 1;
538 }
539
540 /*
541 * Delete a hole in the record
542 *
543 * This will do the hole split and is much restrict than add.
544 */
545 static int del_file_extent_hole(struct rb_root *holes,
546 u64 start, u64 len)
547 {
548 struct file_extent_hole *hole;
549 struct file_extent_hole tmp;
550 u64 prev_start = 0;
551 u64 prev_len = 0;
552 u64 next_start = 0;
553 u64 next_len = 0;
554 struct rb_node *node;
555 int have_prev = 0;
556 int have_next = 0;
557 int ret = 0;
558
559 tmp.start = start;
560 tmp.len = len;
561 node = rb_search(holes, &tmp, compare_hole_range, NULL);
562 if (!node)
563 return -EEXIST;
564 hole = rb_entry(node, struct file_extent_hole, node);
565 if (start + len > hole->start + hole->len)
566 return -EEXIST;
567
568 /*
569 * Now there will be no overlap, delete the hole and re-add the
570 * split(s) if they exists.
571 */
572 if (start > hole->start) {
573 prev_start = hole->start;
574 prev_len = start - hole->start;
575 have_prev = 1;
576 }
577 if (hole->start + hole->len > start + len) {
578 next_start = start + len;
579 next_len = hole->start + hole->len - start - len;
580 have_next = 1;
581 }
582 rb_erase(node, holes);
583 free(hole);
584 if (have_prev) {
585 ret = add_file_extent_hole(holes, prev_start, prev_len);
586 if (ret < 0)
587 return ret;
588 }
589 if (have_next) {
590 ret = add_file_extent_hole(holes, next_start, next_len);
591 if (ret < 0)
592 return ret;
593 }
594 return 0;
595 }
596
597 static int copy_file_extent_holes(struct rb_root *dst,
598 struct rb_root *src)
599 {
600 struct file_extent_hole *hole;
601 struct rb_node *node;
602 int ret = 0;
603
604 node = rb_first(src);
605 while (node) {
606 hole = rb_entry(node, struct file_extent_hole, node);
607 ret = add_file_extent_hole(dst, hole->start, hole->len);
608 if (ret)
609 break;
610 node = rb_next(node);
611 }
612 return ret;
613 }
614
615 static void free_file_extent_holes(struct rb_root *holes)
616 {
617 struct rb_node *node;
618 struct file_extent_hole *hole;
619
620 node = rb_first(holes);
621 while (node) {
622 hole = rb_entry(node, struct file_extent_hole, node);
623 rb_erase(node, holes);
624 free(hole);
625 node = rb_first(holes);
626 }
627 }
628
629 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info);
630
631 static void record_root_in_trans(struct btrfs_trans_handle *trans,
632 struct btrfs_root *root)
633 {
634 if (root->last_trans != trans->transid) {
635 root->track_dirty = 1;
636 root->last_trans = trans->transid;
637 root->commit_root = root->node;
638 extent_buffer_get(root->node);
639 }
640 }
641
642 static u8 imode_to_type(u32 imode)
643 {
644 #define S_SHIFT 12
645 static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
646 [S_IFREG >> S_SHIFT] = BTRFS_FT_REG_FILE,
647 [S_IFDIR >> S_SHIFT] = BTRFS_FT_DIR,
648 [S_IFCHR >> S_SHIFT] = BTRFS_FT_CHRDEV,
649 [S_IFBLK >> S_SHIFT] = BTRFS_FT_BLKDEV,
650 [S_IFIFO >> S_SHIFT] = BTRFS_FT_FIFO,
651 [S_IFSOCK >> S_SHIFT] = BTRFS_FT_SOCK,
652 [S_IFLNK >> S_SHIFT] = BTRFS_FT_SYMLINK,
653 };
654
655 return btrfs_type_by_mode[(imode & S_IFMT) >> S_SHIFT];
656 #undef S_SHIFT
657 }
658
659 static int device_record_compare(struct rb_node *node1, struct rb_node *node2)
660 {
661 struct device_record *rec1;
662 struct device_record *rec2;
663
664 rec1 = rb_entry(node1, struct device_record, node);
665 rec2 = rb_entry(node2, struct device_record, node);
666 if (rec1->devid > rec2->devid)
667 return -1;
668 else if (rec1->devid < rec2->devid)
669 return 1;
670 else
671 return 0;
672 }
673
674 static struct inode_record *clone_inode_rec(struct inode_record *orig_rec)
675 {
676 struct inode_record *rec;
677 struct inode_backref *backref;
678 struct inode_backref *orig;
679 struct inode_backref *tmp;
680 struct orphan_data_extent *src_orphan;
681 struct orphan_data_extent *dst_orphan;
682 struct rb_node *rb;
683 size_t size;
684 int ret;
685
686 rec = malloc(sizeof(*rec));
687 if (!rec)
688 return ERR_PTR(-ENOMEM);
689 memcpy(rec, orig_rec, sizeof(*rec));
690 rec->refs = 1;
691 INIT_LIST_HEAD(&rec->backrefs);
692 INIT_LIST_HEAD(&rec->orphan_extents);
693 rec->holes = RB_ROOT;
694
695 list_for_each_entry(orig, &orig_rec->backrefs, list) {
696 size = sizeof(*orig) + orig->namelen + 1;
697 backref = malloc(size);
698 if (!backref) {
699 ret = -ENOMEM;
700 goto cleanup;
701 }
702 memcpy(backref, orig, size);
703 list_add_tail(&backref->list, &rec->backrefs);
704 }
705 list_for_each_entry(src_orphan, &orig_rec->orphan_extents, list) {
706 dst_orphan = malloc(sizeof(*dst_orphan));
707 if (!dst_orphan) {
708 ret = -ENOMEM;
709 goto cleanup;
710 }
711 memcpy(dst_orphan, src_orphan, sizeof(*src_orphan));
712 list_add_tail(&dst_orphan->list, &rec->orphan_extents);
713 }
714 ret = copy_file_extent_holes(&rec->holes, &orig_rec->holes);
715 if (ret < 0)
716 goto cleanup_rb;
717
718 return rec;
719
720 cleanup_rb:
721 rb = rb_first(&rec->holes);
722 while (rb) {
723 struct file_extent_hole *hole;
724
725 hole = rb_entry(rb, struct file_extent_hole, node);
726 rb = rb_next(rb);
727 free(hole);
728 }
729
730 cleanup:
731 if (!list_empty(&rec->backrefs))
732 list_for_each_entry_safe(orig, tmp, &rec->backrefs, list) {
733 list_del(&orig->list);
734 free(orig);
735 }
736
737 if (!list_empty(&rec->orphan_extents))
738 list_for_each_entry_safe(orig, tmp, &rec->orphan_extents, list) {
739 list_del(&orig->list);
740 free(orig);
741 }
742
743 free(rec);
744
745 return ERR_PTR(ret);
746 }
747
748 static void print_orphan_data_extents(struct list_head *orphan_extents,
749 u64 objectid)
750 {
751 struct orphan_data_extent *orphan;
752
753 if (list_empty(orphan_extents))
754 return;
755 printf("The following data extent is lost in tree %llu:\n",
756 objectid);
757 list_for_each_entry(orphan, orphan_extents, list) {
758 printf("\tinode: %llu, offset:%llu, disk_bytenr: %llu, disk_len: %llu\n",
759 orphan->objectid, orphan->offset, orphan->disk_bytenr,
760 orphan->disk_len);
761 }
762 }
763
764 static void print_inode_error(struct btrfs_root *root, struct inode_record *rec)
765 {
766 u64 root_objectid = root->root_key.objectid;
767 int errors = rec->errors;
768
769 if (!errors)
770 return;
771 /* reloc root errors, we print its corresponding fs root objectid*/
772 if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) {
773 root_objectid = root->root_key.offset;
774 fprintf(stderr, "reloc");
775 }
776 fprintf(stderr, "root %llu inode %llu errors %x",
777 (unsigned long long) root_objectid,
778 (unsigned long long) rec->ino, rec->errors);
779
780 if (errors & I_ERR_NO_INODE_ITEM)
781 fprintf(stderr, ", no inode item");
782 if (errors & I_ERR_NO_ORPHAN_ITEM)
783 fprintf(stderr, ", no orphan item");
784 if (errors & I_ERR_DUP_INODE_ITEM)
785 fprintf(stderr, ", dup inode item");
786 if (errors & I_ERR_DUP_DIR_INDEX)
787 fprintf(stderr, ", dup dir index");
788 if (errors & I_ERR_ODD_DIR_ITEM)
789 fprintf(stderr, ", odd dir item");
790 if (errors & I_ERR_ODD_FILE_EXTENT)
791 fprintf(stderr, ", odd file extent");
792 if (errors & I_ERR_BAD_FILE_EXTENT)
793 fprintf(stderr, ", bad file extent");
794 if (errors & I_ERR_FILE_EXTENT_OVERLAP)
795 fprintf(stderr, ", file extent overlap");
796 if (errors & I_ERR_FILE_EXTENT_DISCOUNT)
797 fprintf(stderr, ", file extent discount");
798 if (errors & I_ERR_DIR_ISIZE_WRONG)
799 fprintf(stderr, ", dir isize wrong");
800 if (errors & I_ERR_FILE_NBYTES_WRONG)
801 fprintf(stderr, ", nbytes wrong");
802 if (errors & I_ERR_ODD_CSUM_ITEM)
803 fprintf(stderr, ", odd csum item");
804 if (errors & I_ERR_SOME_CSUM_MISSING)
805 fprintf(stderr, ", some csum missing");
806 if (errors & I_ERR_LINK_COUNT_WRONG)
807 fprintf(stderr, ", link count wrong");
808 if (errors & I_ERR_FILE_EXTENT_ORPHAN)
809 fprintf(stderr, ", orphan file extent");
810 fprintf(stderr, "\n");
811 /* Print the orphan extents if needed */
812 if (errors & I_ERR_FILE_EXTENT_ORPHAN)
813 print_orphan_data_extents(&rec->orphan_extents, root->objectid);
814
815 /* Print the holes if needed */
816 if (errors & I_ERR_FILE_EXTENT_DISCOUNT) {
817 struct file_extent_hole *hole;
818 struct rb_node *node;
819 int found = 0;
820
821 node = rb_first(&rec->holes);
822 fprintf(stderr, "Found file extent holes:\n");
823 while (node) {
824 found = 1;
825 hole = rb_entry(node, struct file_extent_hole, node);
826 fprintf(stderr, "\tstart: %llu, len: %llu\n",
827 hole->start, hole->len);
828 node = rb_next(node);
829 }
830 if (!found)
831 fprintf(stderr, "\tstart: 0, len: %llu\n",
832 round_up(rec->isize,
833 root->fs_info->sectorsize));
834 }
835 }
836
837 static void print_ref_error(int errors)
838 {
839 if (errors & REF_ERR_NO_DIR_ITEM)
840 fprintf(stderr, ", no dir item");
841 if (errors & REF_ERR_NO_DIR_INDEX)
842 fprintf(stderr, ", no dir index");
843 if (errors & REF_ERR_NO_INODE_REF)
844 fprintf(stderr, ", no inode ref");
845 if (errors & REF_ERR_DUP_DIR_ITEM)
846 fprintf(stderr, ", dup dir item");
847 if (errors & REF_ERR_DUP_DIR_INDEX)
848 fprintf(stderr, ", dup dir index");
849 if (errors & REF_ERR_DUP_INODE_REF)
850 fprintf(stderr, ", dup inode ref");
851 if (errors & REF_ERR_INDEX_UNMATCH)
852 fprintf(stderr, ", index mismatch");
853 if (errors & REF_ERR_FILETYPE_UNMATCH)
854 fprintf(stderr, ", filetype mismatch");
855 if (errors & REF_ERR_NAME_TOO_LONG)
856 fprintf(stderr, ", name too long");
857 if (errors & REF_ERR_NO_ROOT_REF)
858 fprintf(stderr, ", no root ref");
859 if (errors & REF_ERR_NO_ROOT_BACKREF)
860 fprintf(stderr, ", no root backref");
861 if (errors & REF_ERR_DUP_ROOT_REF)
862 fprintf(stderr, ", dup root ref");
863 if (errors & REF_ERR_DUP_ROOT_BACKREF)
864 fprintf(stderr, ", dup root backref");
865 fprintf(stderr, "\n");
866 }
867
868 static struct inode_record *get_inode_rec(struct cache_tree *inode_cache,
869 u64 ino, int mod)
870 {
871 struct ptr_node *node;
872 struct cache_extent *cache;
873 struct inode_record *rec = NULL;
874 int ret;
875
876 cache = lookup_cache_extent(inode_cache, ino, 1);
877 if (cache) {
878 node = container_of(cache, struct ptr_node, cache);
879 rec = node->data;
880 if (mod && rec->refs > 1) {
881 node->data = clone_inode_rec(rec);
882 if (IS_ERR(node->data))
883 return node->data;
884 rec->refs--;
885 rec = node->data;
886 }
887 } else if (mod) {
888 rec = calloc(1, sizeof(*rec));
889 if (!rec)
890 return ERR_PTR(-ENOMEM);
891 rec->ino = ino;
892 rec->extent_start = (u64)-1;
893 rec->refs = 1;
894 INIT_LIST_HEAD(&rec->backrefs);
895 INIT_LIST_HEAD(&rec->orphan_extents);
896 rec->holes = RB_ROOT;
897
898 node = malloc(sizeof(*node));
899 if (!node) {
900 free(rec);
901 return ERR_PTR(-ENOMEM);
902 }
903 node->cache.start = ino;
904 node->cache.size = 1;
905 node->data = rec;
906
907 if (ino == BTRFS_FREE_INO_OBJECTID)
908 rec->found_link = 1;
909
910 ret = insert_cache_extent(inode_cache, &node->cache);
911 if (ret)
912 return ERR_PTR(-EEXIST);
913 }
914 return rec;
915 }
916
917 static void free_orphan_data_extents(struct list_head *orphan_extents)
918 {
919 struct orphan_data_extent *orphan;
920
921 while (!list_empty(orphan_extents)) {
922 orphan = list_entry(orphan_extents->next,
923 struct orphan_data_extent, list);
924 list_del(&orphan->list);
925 free(orphan);
926 }
927 }
928
929 static void free_inode_rec(struct inode_record *rec)
930 {
931 struct inode_backref *backref;
932
933 if (--rec->refs > 0)
934 return;
935
936 while (!list_empty(&rec->backrefs)) {
937 backref = to_inode_backref(rec->backrefs.next);
938 list_del(&backref->list);
939 free(backref);
940 }
941 free_orphan_data_extents(&rec->orphan_extents);
942 free_file_extent_holes(&rec->holes);
943 free(rec);
944 }
945
946 static int can_free_inode_rec(struct inode_record *rec)
947 {
948 if (!rec->errors && rec->checked && rec->found_inode_item &&
949 rec->nlink == rec->found_link && list_empty(&rec->backrefs))
950 return 1;
951 return 0;
952 }
953
954 static void maybe_free_inode_rec(struct cache_tree *inode_cache,
955 struct inode_record *rec)
956 {
957 struct cache_extent *cache;
958 struct inode_backref *tmp, *backref;
959 struct ptr_node *node;
960 u8 filetype;
961
962 if (!rec->found_inode_item)
963 return;
964
965 filetype = imode_to_type(rec->imode);
966 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
967 if (backref->found_dir_item && backref->found_dir_index) {
968 if (backref->filetype != filetype)
969 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
970 if (!backref->errors && backref->found_inode_ref &&
971 rec->nlink == rec->found_link) {
972 list_del(&backref->list);
973 free(backref);
974 }
975 }
976 }
977
978 if (!rec->checked || rec->merging)
979 return;
980
981 if (S_ISDIR(rec->imode)) {
982 if (rec->found_size != rec->isize)
983 rec->errors |= I_ERR_DIR_ISIZE_WRONG;
984 if (rec->found_file_extent)
985 rec->errors |= I_ERR_ODD_FILE_EXTENT;
986 } else if (S_ISREG(rec->imode) || S_ISLNK(rec->imode)) {
987 if (rec->found_dir_item)
988 rec->errors |= I_ERR_ODD_DIR_ITEM;
989 if (rec->found_size != rec->nbytes)
990 rec->errors |= I_ERR_FILE_NBYTES_WRONG;
991 if (rec->nlink > 0 && !no_holes &&
992 (rec->extent_end < rec->isize ||
993 first_extent_gap(&rec->holes) < rec->isize))
994 rec->errors |= I_ERR_FILE_EXTENT_DISCOUNT;
995 }
996
997 if (S_ISREG(rec->imode) || S_ISLNK(rec->imode)) {
998 if (rec->found_csum_item && rec->nodatasum)
999 rec->errors |= I_ERR_ODD_CSUM_ITEM;
1000 if (rec->some_csum_missing && !rec->nodatasum)
1001 rec->errors |= I_ERR_SOME_CSUM_MISSING;
1002 }
1003
1004 BUG_ON(rec->refs != 1);
1005 if (can_free_inode_rec(rec)) {
1006 cache = lookup_cache_extent(inode_cache, rec->ino, 1);
1007 node = container_of(cache, struct ptr_node, cache);
1008 BUG_ON(node->data != rec);
1009 remove_cache_extent(inode_cache, &node->cache);
1010 free(node);
1011 free_inode_rec(rec);
1012 }
1013 }
1014
1015 static int check_orphan_item(struct btrfs_root *root, u64 ino)
1016 {
1017 struct btrfs_path path;
1018 struct btrfs_key key;
1019 int ret;
1020
1021 key.objectid = BTRFS_ORPHAN_OBJECTID;
1022 key.type = BTRFS_ORPHAN_ITEM_KEY;
1023 key.offset = ino;
1024
1025 btrfs_init_path(&path);
1026 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
1027 btrfs_release_path(&path);
1028 if (ret > 0)
1029 ret = -ENOENT;
1030 return ret;
1031 }
1032
1033 static int process_inode_item(struct extent_buffer *eb,
1034 int slot, struct btrfs_key *key,
1035 struct shared_node *active_node)
1036 {
1037 struct inode_record *rec;
1038 struct btrfs_inode_item *item;
1039
1040 rec = active_node->current;
1041 BUG_ON(rec->ino != key->objectid || rec->refs > 1);
1042 if (rec->found_inode_item) {
1043 rec->errors |= I_ERR_DUP_INODE_ITEM;
1044 return 1;
1045 }
1046 item = btrfs_item_ptr(eb, slot, struct btrfs_inode_item);
1047 rec->nlink = btrfs_inode_nlink(eb, item);
1048 rec->isize = btrfs_inode_size(eb, item);
1049 rec->nbytes = btrfs_inode_nbytes(eb, item);
1050 rec->imode = btrfs_inode_mode(eb, item);
1051 if (btrfs_inode_flags(eb, item) & BTRFS_INODE_NODATASUM)
1052 rec->nodatasum = 1;
1053 rec->found_inode_item = 1;
1054 if (rec->nlink == 0)
1055 rec->errors |= I_ERR_NO_ORPHAN_ITEM;
1056 maybe_free_inode_rec(&active_node->inode_cache, rec);
1057 return 0;
1058 }
1059
1060 static struct inode_backref *get_inode_backref(struct inode_record *rec,
1061 const char *name,
1062 int namelen, u64 dir)
1063 {
1064 struct inode_backref *backref;
1065
1066 list_for_each_entry(backref, &rec->backrefs, list) {
1067 if (rec->ino == BTRFS_MULTIPLE_OBJECTIDS)
1068 break;
1069 if (backref->dir != dir || backref->namelen != namelen)
1070 continue;
1071 if (memcmp(name, backref->name, namelen))
1072 continue;
1073 return backref;
1074 }
1075
1076 backref = malloc(sizeof(*backref) + namelen + 1);
1077 if (!backref)
1078 return NULL;
1079 memset(backref, 0, sizeof(*backref));
1080 backref->dir = dir;
1081 backref->namelen = namelen;
1082 memcpy(backref->name, name, namelen);
1083 backref->name[namelen] = '\0';
1084 list_add_tail(&backref->list, &rec->backrefs);
1085 return backref;
1086 }
1087
1088 static int add_inode_backref(struct cache_tree *inode_cache,
1089 u64 ino, u64 dir, u64 index,
1090 const char *name, int namelen,
1091 u8 filetype, u8 itemtype, int errors)
1092 {
1093 struct inode_record *rec;
1094 struct inode_backref *backref;
1095
1096 rec = get_inode_rec(inode_cache, ino, 1);
1097 BUG_ON(IS_ERR(rec));
1098 backref = get_inode_backref(rec, name, namelen, dir);
1099 BUG_ON(!backref);
1100 if (errors)
1101 backref->errors |= errors;
1102 if (itemtype == BTRFS_DIR_INDEX_KEY) {
1103 if (backref->found_dir_index)
1104 backref->errors |= REF_ERR_DUP_DIR_INDEX;
1105 if (backref->found_inode_ref && backref->index != index)
1106 backref->errors |= REF_ERR_INDEX_UNMATCH;
1107 if (backref->found_dir_item && backref->filetype != filetype)
1108 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
1109
1110 backref->index = index;
1111 backref->filetype = filetype;
1112 backref->found_dir_index = 1;
1113 } else if (itemtype == BTRFS_DIR_ITEM_KEY) {
1114 rec->found_link++;
1115 if (backref->found_dir_item)
1116 backref->errors |= REF_ERR_DUP_DIR_ITEM;
1117 if (backref->found_dir_index && backref->filetype != filetype)
1118 backref->errors |= REF_ERR_FILETYPE_UNMATCH;
1119
1120 backref->filetype = filetype;
1121 backref->found_dir_item = 1;
1122 } else if ((itemtype == BTRFS_INODE_REF_KEY) ||
1123 (itemtype == BTRFS_INODE_EXTREF_KEY)) {
1124 if (backref->found_inode_ref)
1125 backref->errors |= REF_ERR_DUP_INODE_REF;
1126 if (backref->found_dir_index && backref->index != index)
1127 backref->errors |= REF_ERR_INDEX_UNMATCH;
1128 else
1129 backref->index = index;
1130
1131 backref->ref_type = itemtype;
1132 backref->found_inode_ref = 1;
1133 } else {
1134 BUG_ON(1);
1135 }
1136
1137 maybe_free_inode_rec(inode_cache, rec);
1138 return 0;
1139 }
1140
1141 static int merge_inode_recs(struct inode_record *src, struct inode_record *dst,
1142 struct cache_tree *dst_cache)
1143 {
1144 struct inode_backref *backref;
1145 u32 dir_count = 0;
1146 int ret = 0;
1147
1148 dst->merging = 1;
1149 list_for_each_entry(backref, &src->backrefs, list) {
1150 if (backref->found_dir_index) {
1151 add_inode_backref(dst_cache, dst->ino, backref->dir,
1152 backref->index, backref->name,
1153 backref->namelen, backref->filetype,
1154 BTRFS_DIR_INDEX_KEY, backref->errors);
1155 }
1156 if (backref->found_dir_item) {
1157 dir_count++;
1158 add_inode_backref(dst_cache, dst->ino,
1159 backref->dir, 0, backref->name,
1160 backref->namelen, backref->filetype,
1161 BTRFS_DIR_ITEM_KEY, backref->errors);
1162 }
1163 if (backref->found_inode_ref) {
1164 add_inode_backref(dst_cache, dst->ino,
1165 backref->dir, backref->index,
1166 backref->name, backref->namelen, 0,
1167 backref->ref_type, backref->errors);
1168 }
1169 }
1170
1171 if (src->found_dir_item)
1172 dst->found_dir_item = 1;
1173 if (src->found_file_extent)
1174 dst->found_file_extent = 1;
1175 if (src->found_csum_item)
1176 dst->found_csum_item = 1;
1177 if (src->some_csum_missing)
1178 dst->some_csum_missing = 1;
1179 if (first_extent_gap(&dst->holes) > first_extent_gap(&src->holes)) {
1180 ret = copy_file_extent_holes(&dst->holes, &src->holes);
1181 if (ret < 0)
1182 return ret;
1183 }
1184
1185 BUG_ON(src->found_link < dir_count);
1186 dst->found_link += src->found_link - dir_count;
1187 dst->found_size += src->found_size;
1188 if (src->extent_start != (u64)-1) {
1189 if (dst->extent_start == (u64)-1) {
1190 dst->extent_start = src->extent_start;
1191 dst->extent_end = src->extent_end;
1192 } else {
1193 if (dst->extent_end > src->extent_start)
1194 dst->errors |= I_ERR_FILE_EXTENT_OVERLAP;
1195 else if (dst->extent_end < src->extent_start) {
1196 ret = add_file_extent_hole(&dst->holes,
1197 dst->extent_end,
1198 src->extent_start - dst->extent_end);
1199 }
1200 if (dst->extent_end < src->extent_end)
1201 dst->extent_end = src->extent_end;
1202 }
1203 }
1204
1205 dst->errors |= src->errors;
1206 if (src->found_inode_item) {
1207 if (!dst->found_inode_item) {
1208 dst->nlink = src->nlink;
1209 dst->isize = src->isize;
1210 dst->nbytes = src->nbytes;
1211 dst->imode = src->imode;
1212 dst->nodatasum = src->nodatasum;
1213 dst->found_inode_item = 1;
1214 } else {
1215 dst->errors |= I_ERR_DUP_INODE_ITEM;
1216 }
1217 }
1218 dst->merging = 0;
1219
1220 return 0;
1221 }
1222
1223 static int splice_shared_node(struct shared_node *src_node,
1224 struct shared_node *dst_node)
1225 {
1226 struct cache_extent *cache;
1227 struct ptr_node *node, *ins;
1228 struct cache_tree *src, *dst;
1229 struct inode_record *rec, *conflict;
1230 u64 current_ino = 0;
1231 int splice = 0;
1232 int ret;
1233
1234 if (--src_node->refs == 0)
1235 splice = 1;
1236 if (src_node->current)
1237 current_ino = src_node->current->ino;
1238
1239 src = &src_node->root_cache;
1240 dst = &dst_node->root_cache;
1241 again:
1242 cache = search_cache_extent(src, 0);
1243 while (cache) {
1244 node = container_of(cache, struct ptr_node, cache);
1245 rec = node->data;
1246 cache = next_cache_extent(cache);
1247
1248 if (splice) {
1249 remove_cache_extent(src, &node->cache);
1250 ins = node;
1251 } else {
1252 ins = malloc(sizeof(*ins));
1253 BUG_ON(!ins);
1254 ins->cache.start = node->cache.start;
1255 ins->cache.size = node->cache.size;
1256 ins->data = rec;
1257 rec->refs++;
1258 }
1259 ret = insert_cache_extent(dst, &ins->cache);
1260 if (ret == -EEXIST) {
1261 conflict = get_inode_rec(dst, rec->ino, 1);
1262 BUG_ON(IS_ERR(conflict));
1263 merge_inode_recs(rec, conflict, dst);
1264 if (rec->checked) {
1265 conflict->checked = 1;
1266 if (dst_node->current == conflict)
1267 dst_node->current = NULL;
1268 }
1269 maybe_free_inode_rec(dst, conflict);
1270 free_inode_rec(rec);
1271 free(ins);
1272 } else {
1273 BUG_ON(ret);
1274 }
1275 }
1276
1277 if (src == &src_node->root_cache) {
1278 src = &src_node->inode_cache;
1279 dst = &dst_node->inode_cache;
1280 goto again;
1281 }
1282
1283 if (current_ino > 0 && (!dst_node->current ||
1284 current_ino > dst_node->current->ino)) {
1285 if (dst_node->current) {
1286 dst_node->current->checked = 1;
1287 maybe_free_inode_rec(dst, dst_node->current);
1288 }
1289 dst_node->current = get_inode_rec(dst, current_ino, 1);
1290 BUG_ON(IS_ERR(dst_node->current));
1291 }
1292 return 0;
1293 }
1294
1295 static void free_inode_ptr(struct cache_extent *cache)
1296 {
1297 struct ptr_node *node;
1298 struct inode_record *rec;
1299
1300 node = container_of(cache, struct ptr_node, cache);
1301 rec = node->data;
1302 free_inode_rec(rec);
1303 free(node);
1304 }
1305
1306 FREE_EXTENT_CACHE_BASED_TREE(inode_recs, free_inode_ptr);
1307
1308 static struct shared_node *find_shared_node(struct cache_tree *shared,
1309 u64 bytenr)
1310 {
1311 struct cache_extent *cache;
1312 struct shared_node *node;
1313
1314 cache = lookup_cache_extent(shared, bytenr, 1);
1315 if (cache) {
1316 node = container_of(cache, struct shared_node, cache);
1317 return node;
1318 }
1319 return NULL;
1320 }
1321
1322 static int add_shared_node(struct cache_tree *shared, u64 bytenr, u32 refs)
1323 {
1324 int ret;
1325 struct shared_node *node;
1326
1327 node = calloc(1, sizeof(*node));
1328 if (!node)
1329 return -ENOMEM;
1330 node->cache.start = bytenr;
1331 node->cache.size = 1;
1332 cache_tree_init(&node->root_cache);
1333 cache_tree_init(&node->inode_cache);
1334 node->refs = refs;
1335
1336 ret = insert_cache_extent(shared, &node->cache);
1337
1338 return ret;
1339 }
1340
1341 static int enter_shared_node(struct btrfs_root *root, u64 bytenr, u32 refs,
1342 struct walk_control *wc, int level)
1343 {
1344 struct shared_node *node;
1345 struct shared_node *dest;
1346 int ret;
1347
1348 if (level == wc->active_node)
1349 return 0;
1350
1351 BUG_ON(wc->active_node <= level);
1352 node = find_shared_node(&wc->shared, bytenr);
1353 if (!node) {
1354 ret = add_shared_node(&wc->shared, bytenr, refs);
1355 BUG_ON(ret);
1356 node = find_shared_node(&wc->shared, bytenr);
1357 wc->nodes[level] = node;
1358 wc->active_node = level;
1359 return 0;
1360 }
1361
1362 if (wc->root_level == wc->active_node &&
1363 btrfs_root_refs(&root->root_item) == 0) {
1364 if (--node->refs == 0) {
1365 free_inode_recs_tree(&node->root_cache);
1366 free_inode_recs_tree(&node->inode_cache);
1367 remove_cache_extent(&wc->shared, &node->cache);
1368 free(node);
1369 }
1370 return 1;
1371 }
1372
1373 dest = wc->nodes[wc->active_node];
1374 splice_shared_node(node, dest);
1375 if (node->refs == 0) {
1376 remove_cache_extent(&wc->shared, &node->cache);
1377 free(node);
1378 }
1379 return 1;
1380 }
1381
1382 static int leave_shared_node(struct btrfs_root *root,
1383 struct walk_control *wc, int level)
1384 {
1385 struct shared_node *node;
1386 struct shared_node *dest;
1387 int i;
1388
1389 if (level == wc->root_level)
1390 return 0;
1391
1392 for (i = level + 1; i < BTRFS_MAX_LEVEL; i++) {
1393 if (wc->nodes[i])
1394 break;
1395 }
1396 BUG_ON(i >= BTRFS_MAX_LEVEL);
1397
1398 node = wc->nodes[wc->active_node];
1399 wc->nodes[wc->active_node] = NULL;
1400 wc->active_node = i;
1401
1402 dest = wc->nodes[wc->active_node];
1403 if (wc->active_node < wc->root_level ||
1404 btrfs_root_refs(&root->root_item) > 0) {
1405 BUG_ON(node->refs <= 1);
1406 splice_shared_node(node, dest);
1407 } else {
1408 BUG_ON(node->refs < 2);
1409 node->refs--;
1410 }
1411 return 0;
1412 }
1413
1414 /*
1415 * Returns:
1416 * < 0 - on error
1417 * 1 - if the root with id child_root_id is a child of root parent_root_id
1418 * 0 - if the root child_root_id isn't a child of the root parent_root_id but
1419 * has other root(s) as parent(s)
1420 * 2 - if the root child_root_id doesn't have any parent roots
1421 */
1422 static int is_child_root(struct btrfs_root *root, u64 parent_root_id,
1423 u64 child_root_id)
1424 {
1425 struct btrfs_path path;
1426 struct btrfs_key key;
1427 struct extent_buffer *leaf;
1428 int has_parent = 0;
1429 int ret;
1430
1431 btrfs_init_path(&path);
1432
1433 key.objectid = parent_root_id;
1434 key.type = BTRFS_ROOT_REF_KEY;
1435 key.offset = child_root_id;
1436 ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, &path,
1437 0, 0);
1438 if (ret < 0)
1439 return ret;
1440 btrfs_release_path(&path);
1441 if (!ret)
1442 return 1;
1443
1444 key.objectid = child_root_id;
1445 key.type = BTRFS_ROOT_BACKREF_KEY;
1446 key.offset = 0;
1447 ret = btrfs_search_slot(NULL, root->fs_info->tree_root, &key, &path,
1448 0, 0);
1449 if (ret < 0)
1450 goto out;
1451
1452 while (1) {
1453 leaf = path.nodes[0];
1454 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1455 ret = btrfs_next_leaf(root->fs_info->tree_root, &path);
1456 if (ret)
1457 break;
1458 leaf = path.nodes[0];
1459 }
1460
1461 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1462 if (key.objectid != child_root_id ||
1463 key.type != BTRFS_ROOT_BACKREF_KEY)
1464 break;
1465
1466 has_parent = 1;
1467
1468 if (key.offset == parent_root_id) {
1469 btrfs_release_path(&path);
1470 return 1;
1471 }
1472
1473 path.slots[0]++;
1474 }
1475 out:
1476 btrfs_release_path(&path);
1477 if (ret < 0)
1478 return ret;
1479 return has_parent ? 0 : 2;
1480 }
1481
1482 static int process_dir_item(struct extent_buffer *eb,
1483 int slot, struct btrfs_key *key,
1484 struct shared_node *active_node)
1485 {
1486 u32 total;
1487 u32 cur = 0;
1488 u32 len;
1489 u32 name_len;
1490 u32 data_len;
1491 int error;
1492 int nritems = 0;
1493 u8 filetype;
1494 struct btrfs_dir_item *di;
1495 struct inode_record *rec;
1496 struct cache_tree *root_cache;
1497 struct cache_tree *inode_cache;
1498 struct btrfs_key location;
1499 char namebuf[BTRFS_NAME_LEN];
1500
1501 root_cache = &active_node->root_cache;
1502 inode_cache = &active_node->inode_cache;
1503 rec = active_node->current;
1504 rec->found_dir_item = 1;
1505
1506 di = btrfs_item_ptr(eb, slot, struct btrfs_dir_item);
1507 total = btrfs_item_size_nr(eb, slot);
1508 while (cur < total) {
1509 nritems++;
1510 btrfs_dir_item_key_to_cpu(eb, di, &location);
1511 name_len = btrfs_dir_name_len(eb, di);
1512 data_len = btrfs_dir_data_len(eb, di);
1513 filetype = btrfs_dir_type(eb, di);
1514
1515 rec->found_size += name_len;
1516 if (cur + sizeof(*di) + name_len > total ||
1517 name_len > BTRFS_NAME_LEN) {
1518 error = REF_ERR_NAME_TOO_LONG;
1519
1520 if (cur + sizeof(*di) > total)
1521 break;
1522 len = min_t(u32, total - cur - sizeof(*di),
1523 BTRFS_NAME_LEN);
1524 } else {
1525 len = name_len;
1526 error = 0;
1527 }
1528
1529 read_extent_buffer(eb, namebuf, (unsigned long)(di + 1), len);
1530
1531 if (key->type == BTRFS_DIR_ITEM_KEY &&
1532 key->offset != btrfs_name_hash(namebuf, len)) {
1533 rec->errors |= I_ERR_ODD_DIR_ITEM;
1534 error("DIR_ITEM[%llu %llu] name %s namelen %u filetype %u mismatch with its hash, wanted %llu have %llu",
1535 key->objectid, key->offset, namebuf, len, filetype,
1536 key->offset, btrfs_name_hash(namebuf, len));
1537 }
1538
1539 if (location.type == BTRFS_INODE_ITEM_KEY) {
1540 add_inode_backref(inode_cache, location.objectid,
1541 key->objectid, key->offset, namebuf,
1542 len, filetype, key->type, error);
1543 } else if (location.type == BTRFS_ROOT_ITEM_KEY) {
1544 add_inode_backref(root_cache, location.objectid,
1545 key->objectid, key->offset,
1546 namebuf, len, filetype,
1547 key->type, error);
1548 } else {
1549 fprintf(stderr, "invalid location in dir item %u\n",
1550 location.type);
1551 add_inode_backref(inode_cache, BTRFS_MULTIPLE_OBJECTIDS,
1552 key->objectid, key->offset, namebuf,
1553 len, filetype, key->type, error);
1554 }
1555
1556 len = sizeof(*di) + name_len + data_len;
1557 di = (struct btrfs_dir_item *)((char *)di + len);
1558 cur += len;
1559 }
1560 if (key->type == BTRFS_DIR_INDEX_KEY && nritems > 1)
1561 rec->errors |= I_ERR_DUP_DIR_INDEX;
1562
1563 return 0;
1564 }
1565
1566 static int process_inode_ref(struct extent_buffer *eb,
1567 int slot, struct btrfs_key *key,
1568 struct shared_node *active_node)
1569 {
1570 u32 total;
1571 u32 cur = 0;
1572 u32 len;
1573 u32 name_len;
1574 u64 index;
1575 int error;
1576 struct cache_tree *inode_cache;
1577 struct btrfs_inode_ref *ref;
1578 char namebuf[BTRFS_NAME_LEN];
1579
1580 inode_cache = &active_node->inode_cache;
1581
1582 ref = btrfs_item_ptr(eb, slot, struct btrfs_inode_ref);
1583 total = btrfs_item_size_nr(eb, slot);
1584 while (cur < total) {
1585 name_len = btrfs_inode_ref_name_len(eb, ref);
1586 index = btrfs_inode_ref_index(eb, ref);
1587
1588 /* inode_ref + namelen should not cross item boundary */
1589 if (cur + sizeof(*ref) + name_len > total ||
1590 name_len > BTRFS_NAME_LEN) {
1591 if (total < cur + sizeof(*ref))
1592 break;
1593
1594 /* Still try to read out the remaining part */
1595 len = min_t(u32, total - cur - sizeof(*ref),
1596 BTRFS_NAME_LEN);
1597 error = REF_ERR_NAME_TOO_LONG;
1598 } else {
1599 len = name_len;
1600 error = 0;
1601 }
1602
1603 read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
1604 add_inode_backref(inode_cache, key->objectid, key->offset,
1605 index, namebuf, len, 0, key->type, error);
1606
1607 len = sizeof(*ref) + name_len;
1608 ref = (struct btrfs_inode_ref *)((char *)ref + len);
1609 cur += len;
1610 }
1611 return 0;
1612 }
1613
1614 static int process_inode_extref(struct extent_buffer *eb,
1615 int slot, struct btrfs_key *key,
1616 struct shared_node *active_node)
1617 {
1618 u32 total;
1619 u32 cur = 0;
1620 u32 len;
1621 u32 name_len;
1622 u64 index;
1623 u64 parent;
1624 int error;
1625 struct cache_tree *inode_cache;
1626 struct btrfs_inode_extref *extref;
1627 char namebuf[BTRFS_NAME_LEN];
1628
1629 inode_cache = &active_node->inode_cache;
1630
1631 extref = btrfs_item_ptr(eb, slot, struct btrfs_inode_extref);
1632 total = btrfs_item_size_nr(eb, slot);
1633 while (cur < total) {
1634 name_len = btrfs_inode_extref_name_len(eb, extref);
1635 index = btrfs_inode_extref_index(eb, extref);
1636 parent = btrfs_inode_extref_parent(eb, extref);
1637 if (name_len <= BTRFS_NAME_LEN) {
1638 len = name_len;
1639 error = 0;
1640 } else {
1641 len = BTRFS_NAME_LEN;
1642 error = REF_ERR_NAME_TOO_LONG;
1643 }
1644 read_extent_buffer(eb, namebuf,
1645 (unsigned long)(extref + 1), len);
1646 add_inode_backref(inode_cache, key->objectid, parent,
1647 index, namebuf, len, 0, key->type, error);
1648
1649 len = sizeof(*extref) + name_len;
1650 extref = (struct btrfs_inode_extref *)((char *)extref + len);
1651 cur += len;
1652 }
1653 return 0;
1654
1655 }
1656
1657 static int count_csum_range(struct btrfs_root *root, u64 start,
1658 u64 len, u64 *found)
1659 {
1660 struct btrfs_key key;
1661 struct btrfs_path path;
1662 struct extent_buffer *leaf;
1663 int ret;
1664 size_t size;
1665 *found = 0;
1666 u64 csum_end;
1667 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
1668
1669 btrfs_init_path(&path);
1670
1671 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
1672 key.offset = start;
1673 key.type = BTRFS_EXTENT_CSUM_KEY;
1674
1675 ret = btrfs_search_slot(NULL, root->fs_info->csum_root,
1676 &key, &path, 0, 0);
1677 if (ret < 0)
1678 goto out;
1679 if (ret > 0 && path.slots[0] > 0) {
1680 leaf = path.nodes[0];
1681 btrfs_item_key_to_cpu(leaf, &key, path.slots[0] - 1);
1682 if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID &&
1683 key.type == BTRFS_EXTENT_CSUM_KEY)
1684 path.slots[0]--;
1685 }
1686
1687 while (len > 0) {
1688 leaf = path.nodes[0];
1689 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
1690 ret = btrfs_next_leaf(root->fs_info->csum_root, &path);
1691 if (ret > 0)
1692 break;
1693 else if (ret < 0)
1694 goto out;
1695 leaf = path.nodes[0];
1696 }
1697
1698 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1699 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
1700 key.type != BTRFS_EXTENT_CSUM_KEY)
1701 break;
1702
1703 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
1704 if (key.offset >= start + len)
1705 break;
1706
1707 if (key.offset > start)
1708 start = key.offset;
1709
1710 size = btrfs_item_size_nr(leaf, path.slots[0]);
1711 csum_end = key.offset + (size / csum_size) *
1712 root->fs_info->sectorsize;
1713 if (csum_end > start) {
1714 size = min(csum_end - start, len);
1715 len -= size;
1716 start += size;
1717 *found += size;
1718 }
1719
1720 path.slots[0]++;
1721 }
1722 out:
1723 btrfs_release_path(&path);
1724 if (ret < 0)
1725 return ret;
1726 return 0;
1727 }
1728
1729 static int process_file_extent(struct btrfs_root *root,
1730 struct extent_buffer *eb,
1731 int slot, struct btrfs_key *key,
1732 struct shared_node *active_node)
1733 {
1734 struct inode_record *rec;
1735 struct btrfs_file_extent_item *fi;
1736 u64 num_bytes = 0;
1737 u64 disk_bytenr = 0;
1738 u64 extent_offset = 0;
1739 u64 mask = root->fs_info->sectorsize - 1;
1740 int extent_type;
1741 int ret;
1742
1743 rec = active_node->current;
1744 BUG_ON(rec->ino != key->objectid || rec->refs > 1);
1745 rec->found_file_extent = 1;
1746
1747 if (rec->extent_start == (u64)-1) {
1748 rec->extent_start = key->offset;
1749 rec->extent_end = key->offset;
1750 }
1751
1752 if (rec->extent_end > key->offset)
1753 rec->errors |= I_ERR_FILE_EXTENT_OVERLAP;
1754 else if (rec->extent_end < key->offset) {
1755 ret = add_file_extent_hole(&rec->holes, rec->extent_end,
1756 key->offset - rec->extent_end);
1757 if (ret < 0)
1758 return ret;
1759 }
1760
1761 fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
1762 extent_type = btrfs_file_extent_type(eb, fi);
1763
1764 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
1765 num_bytes = btrfs_file_extent_inline_len(eb, slot, fi);
1766 if (num_bytes == 0)
1767 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1768 rec->found_size += num_bytes;
1769 num_bytes = (num_bytes + mask) & ~mask;
1770 } else if (extent_type == BTRFS_FILE_EXTENT_REG ||
1771 extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1772 num_bytes = btrfs_file_extent_num_bytes(eb, fi);
1773 disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
1774 extent_offset = btrfs_file_extent_offset(eb, fi);
1775 if (num_bytes == 0 || (num_bytes & mask))
1776 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1777 if (num_bytes + extent_offset >
1778 btrfs_file_extent_ram_bytes(eb, fi))
1779 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1780 if (extent_type == BTRFS_FILE_EXTENT_PREALLOC &&
1781 (btrfs_file_extent_compression(eb, fi) ||
1782 btrfs_file_extent_encryption(eb, fi) ||
1783 btrfs_file_extent_other_encoding(eb, fi)))
1784 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1785 if (disk_bytenr > 0)
1786 rec->found_size += num_bytes;
1787 } else {
1788 rec->errors |= I_ERR_BAD_FILE_EXTENT;
1789 }
1790 rec->extent_end = key->offset + num_bytes;
1791
1792 /*
1793 * The data reloc tree will copy full extents into its inode and then
1794 * copy the corresponding csums. Because the extent it copied could be
1795 * a preallocated extent that hasn't been written to yet there may be no
1796 * csums to copy, ergo we won't have csums for our file extent. This is
1797 * ok so just don't bother checking csums if the inode belongs to the
1798 * data reloc tree.
1799 */
1800 if (disk_bytenr > 0 &&
1801 btrfs_header_owner(eb) != BTRFS_DATA_RELOC_TREE_OBJECTID) {
1802 u64 found;
1803 if (btrfs_file_extent_compression(eb, fi))
1804 num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
1805 else
1806 disk_bytenr += extent_offset;
1807
1808 ret = count_csum_range(root, disk_bytenr, num_bytes, &found);
1809 if (ret < 0)
1810 return ret;
1811 if (extent_type == BTRFS_FILE_EXTENT_REG) {
1812 if (found > 0)
1813 rec->found_csum_item = 1;
1814 if (found < num_bytes)
1815 rec->some_csum_missing = 1;
1816 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
1817 if (found > 0)
1818 rec->errors |= I_ERR_ODD_CSUM_ITEM;
1819 }
1820 }
1821 return 0;
1822 }
1823
1824 static int process_one_leaf(struct btrfs_root *root, struct extent_buffer *eb,
1825 struct walk_control *wc)
1826 {
1827 struct btrfs_key key;
1828 u32 nritems;
1829 int i;
1830 int ret = 0;
1831 struct cache_tree *inode_cache;
1832 struct shared_node *active_node;
1833
1834 if (wc->root_level == wc->active_node &&
1835 btrfs_root_refs(&root->root_item) == 0)
1836 return 0;
1837
1838 active_node = wc->nodes[wc->active_node];
1839 inode_cache = &active_node->inode_cache;
1840 nritems = btrfs_header_nritems(eb);
1841 for (i = 0; i < nritems; i++) {
1842 btrfs_item_key_to_cpu(eb, &key, i);
1843
1844 if (key.objectid == BTRFS_FREE_SPACE_OBJECTID)
1845 continue;
1846 if (key.type == BTRFS_ORPHAN_ITEM_KEY)
1847 continue;
1848
1849 if (active_node->current == NULL ||
1850 active_node->current->ino < key.objectid) {
1851 if (active_node->current) {
1852 active_node->current->checked = 1;
1853 maybe_free_inode_rec(inode_cache,
1854 active_node->current);
1855 }
1856 active_node->current = get_inode_rec(inode_cache,
1857 key.objectid, 1);
1858 BUG_ON(IS_ERR(active_node->current));
1859 }
1860 switch (key.type) {
1861 case BTRFS_DIR_ITEM_KEY:
1862 case BTRFS_DIR_INDEX_KEY:
1863 ret = process_dir_item(eb, i, &key, active_node);
1864 break;
1865 case BTRFS_INODE_REF_KEY:
1866 ret = process_inode_ref(eb, i, &key, active_node);
1867 break;
1868 case BTRFS_INODE_EXTREF_KEY:
1869 ret = process_inode_extref(eb, i, &key, active_node);
1870 break;
1871 case BTRFS_INODE_ITEM_KEY:
1872 ret = process_inode_item(eb, i, &key, active_node);
1873 break;
1874 case BTRFS_EXTENT_DATA_KEY:
1875 ret = process_file_extent(root, eb, i, &key,
1876 active_node);
1877 break;
1878 default:
1879 break;
1880 };
1881 }
1882 return ret;
1883 }
1884
1885 struct node_refs {
1886 u64 bytenr[BTRFS_MAX_LEVEL];
1887 u64 refs[BTRFS_MAX_LEVEL];
1888 int need_check[BTRFS_MAX_LEVEL];
1889 };
1890
1891 static int update_nodes_refs(struct btrfs_root *root, u64 bytenr,
1892 struct node_refs *nrefs, u64 level);
1893 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
1894 unsigned int ext_ref);
1895
1896 /*
1897 * Returns >0 Found error, not fatal, should continue
1898 * Returns <0 Fatal error, must exit the whole check
1899 * Returns 0 No errors found
1900 */
1901 static int process_one_leaf_v2(struct btrfs_root *root, struct btrfs_path *path,
1902 struct node_refs *nrefs, int *level, int ext_ref)
1903 {
1904 struct extent_buffer *cur = path->nodes[0];
1905 struct btrfs_key key;
1906 u64 cur_bytenr;
1907 u32 nritems;
1908 u64 first_ino = 0;
1909 int root_level = btrfs_header_level(root->node);
1910 int i;
1911 int ret = 0; /* Final return value */
1912 int err = 0; /* Positive error bitmap */
1913
1914 cur_bytenr = cur->start;
1915
1916 /* skip to first inode item or the first inode number change */
1917 nritems = btrfs_header_nritems(cur);
1918 for (i = 0; i < nritems; i++) {
1919 btrfs_item_key_to_cpu(cur, &key, i);
1920 if (i == 0)
1921 first_ino = key.objectid;
1922 if (key.type == BTRFS_INODE_ITEM_KEY ||
1923 (first_ino && first_ino != key.objectid))
1924 break;
1925 }
1926 if (i == nritems) {
1927 path->slots[0] = nritems;
1928 return 0;
1929 }
1930 path->slots[0] = i;
1931
1932 again:
1933 err |= check_inode_item(root, path, ext_ref);
1934
1935 if (err & LAST_ITEM)
1936 goto out;
1937
1938 /* still have inode items in thie leaf */
1939 if (cur->start == cur_bytenr)
1940 goto again;
1941
1942 /*
1943 * we have switched to another leaf, above nodes may
1944 * have changed, here walk down the path, if a node
1945 * or leaf is shared, check whether we can skip this
1946 * node or leaf.
1947 */
1948 for (i = root_level; i >= 0; i--) {
1949 if (path->nodes[i]->start == nrefs->bytenr[i])
1950 continue;
1951
1952 ret = update_nodes_refs(root,
1953 path->nodes[i]->start,
1954 nrefs, i);
1955 if (ret)
1956 goto out;
1957
1958 if (!nrefs->need_check[i]) {
1959 *level += 1;
1960 break;
1961 }
1962 }
1963
1964 for (i = 0; i < *level; i++) {
1965 free_extent_buffer(path->nodes[i]);
1966 path->nodes[i] = NULL;
1967 }
1968 out:
1969 err &= ~LAST_ITEM;
1970 if (err && !ret)
1971 ret = err;
1972 return ret;
1973 }
1974
1975 static void reada_walk_down(struct btrfs_root *root,
1976 struct extent_buffer *node, int slot)
1977 {
1978 struct btrfs_fs_info *fs_info = root->fs_info;
1979 u64 bytenr;
1980 u64 ptr_gen;
1981 u32 nritems;
1982 u32 blocksize;
1983 int i;
1984 int level;
1985
1986 level = btrfs_header_level(node);
1987 if (level != 1)
1988 return;
1989
1990 nritems = btrfs_header_nritems(node);
1991 blocksize = fs_info->nodesize;
1992 for (i = slot; i < nritems; i++) {
1993 bytenr = btrfs_node_blockptr(node, i);
1994 ptr_gen = btrfs_node_ptr_generation(node, i);
1995 readahead_tree_block(fs_info, bytenr, blocksize, ptr_gen);
1996 }
1997 }
1998
1999 /*
2000 * Check the child node/leaf by the following condition:
2001 * 1. the first item key of the node/leaf should be the same with the one
2002 * in parent.
2003 * 2. block in parent node should match the child node/leaf.
2004 * 3. generation of parent node and child's header should be consistent.
2005 *
2006 * Or the child node/leaf pointed by the key in parent is not valid.
2007 *
2008 * We hope to check leaf owner too, but since subvol may share leaves,
2009 * which makes leaf owner check not so strong, key check should be
2010 * sufficient enough for that case.
2011 */
2012 static int check_child_node(struct extent_buffer *parent, int slot,
2013 struct extent_buffer *child)
2014 {
2015 struct btrfs_key parent_key;
2016 struct btrfs_key child_key;
2017 int ret = 0;
2018
2019 btrfs_node_key_to_cpu(parent, &parent_key, slot);
2020 if (btrfs_header_level(child) == 0)
2021 btrfs_item_key_to_cpu(child, &child_key, 0);
2022 else
2023 btrfs_node_key_to_cpu(child, &child_key, 0);
2024
2025 if (memcmp(&parent_key, &child_key, sizeof(parent_key))) {
2026 ret = -EINVAL;
2027 fprintf(stderr,
2028 "Wrong key of child node/leaf, wanted: (%llu, %u, %llu), have: (%llu, %u, %llu)\n",
2029 parent_key.objectid, parent_key.type, parent_key.offset,
2030 child_key.objectid, child_key.type, child_key.offset);
2031 }
2032 if (btrfs_header_bytenr(child) != btrfs_node_blockptr(parent, slot)) {
2033 ret = -EINVAL;
2034 fprintf(stderr, "Wrong block of child node/leaf, wanted: %llu, have: %llu\n",
2035 btrfs_node_blockptr(parent, slot),
2036 btrfs_header_bytenr(child));
2037 }
2038 if (btrfs_node_ptr_generation(parent, slot) !=
2039 btrfs_header_generation(child)) {
2040 ret = -EINVAL;
2041 fprintf(stderr, "Wrong generation of child node/leaf, wanted: %llu, have: %llu\n",
2042 btrfs_header_generation(child),
2043 btrfs_node_ptr_generation(parent, slot));
2044 }
2045 return ret;
2046 }
2047
2048 /*
2049 * for a tree node or leaf, if it's shared, indeed we don't need to iterate it
2050 * in every fs or file tree check. Here we find its all root ids, and only check
2051 * it in the fs or file tree which has the smallest root id.
2052 */
2053 static int need_check(struct btrfs_root *root, struct ulist *roots)
2054 {
2055 struct rb_node *node;
2056 struct ulist_node *u;
2057
2058 if (roots->nnodes == 1)
2059 return 1;
2060
2061 node = rb_first(&roots->root);
2062 u = rb_entry(node, struct ulist_node, rb_node);
2063 /*
2064 * current root id is not smallest, we skip it and let it be checked
2065 * in the fs or file tree who hash the smallest root id.
2066 */
2067 if (root->objectid != u->val)
2068 return 0;
2069
2070 return 1;
2071 }
2072
2073 /*
2074 * for a tree node or leaf, we record its reference count, so later if we still
2075 * process this node or leaf, don't need to compute its reference count again.
2076 */
2077 static int update_nodes_refs(struct btrfs_root *root, u64 bytenr,
2078 struct node_refs *nrefs, u64 level)
2079 {
2080 int check, ret;
2081 u64 refs;
2082 struct ulist *roots;
2083
2084 if (nrefs->bytenr[level] != bytenr) {
2085 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
2086 level, 1, &refs, NULL);
2087 if (ret < 0)
2088 return ret;
2089
2090 nrefs->bytenr[level] = bytenr;
2091 nrefs->refs[level] = refs;
2092 if (refs > 1) {
2093 ret = btrfs_find_all_roots(NULL, root->fs_info, bytenr,
2094 0, &roots);
2095 if (ret)
2096 return -EIO;
2097
2098 check = need_check(root, roots);
2099 ulist_free(roots);
2100 nrefs->need_check[level] = check;
2101 } else {
2102 nrefs->need_check[level] = 1;
2103 }
2104 }
2105
2106 return 0;
2107 }
2108
2109 static int walk_down_tree(struct btrfs_root *root, struct btrfs_path *path,
2110 struct walk_control *wc, int *level,
2111 struct node_refs *nrefs)
2112 {
2113 enum btrfs_tree_block_status status;
2114 u64 bytenr;
2115 u64 ptr_gen;
2116 struct btrfs_fs_info *fs_info = root->fs_info;
2117 struct extent_buffer *next;
2118 struct extent_buffer *cur;
2119 u32 blocksize;
2120 int ret, err = 0;
2121 u64 refs;
2122
2123 WARN_ON(*level < 0);
2124 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2125
2126 if (path->nodes[*level]->start == nrefs->bytenr[*level]) {
2127 refs = nrefs->refs[*level];
2128 ret = 0;
2129 } else {
2130 ret = btrfs_lookup_extent_info(NULL, root,
2131 path->nodes[*level]->start,
2132 *level, 1, &refs, NULL);
2133 if (ret < 0) {
2134 err = ret;
2135 goto out;
2136 }
2137 nrefs->bytenr[*level] = path->nodes[*level]->start;
2138 nrefs->refs[*level] = refs;
2139 }
2140
2141 if (refs > 1) {
2142 ret = enter_shared_node(root, path->nodes[*level]->start,
2143 refs, wc, *level);
2144 if (ret > 0) {
2145 err = ret;
2146 goto out;
2147 }
2148 }
2149
2150 while (*level >= 0) {
2151 WARN_ON(*level < 0);
2152 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2153 cur = path->nodes[*level];
2154
2155 if (btrfs_header_level(cur) != *level)
2156 WARN_ON(1);
2157
2158 if (path->slots[*level] >= btrfs_header_nritems(cur))
2159 break;
2160 if (*level == 0) {
2161 ret = process_one_leaf(root, cur, wc);
2162 if (ret < 0)
2163 err = ret;
2164 break;
2165 }
2166 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2167 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2168 blocksize = fs_info->nodesize;
2169
2170 if (bytenr == nrefs->bytenr[*level - 1]) {
2171 refs = nrefs->refs[*level - 1];
2172 } else {
2173 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
2174 *level - 1, 1, &refs, NULL);
2175 if (ret < 0) {
2176 refs = 0;
2177 } else {
2178 nrefs->bytenr[*level - 1] = bytenr;
2179 nrefs->refs[*level - 1] = refs;
2180 }
2181 }
2182
2183 if (refs > 1) {
2184 ret = enter_shared_node(root, bytenr, refs,
2185 wc, *level - 1);
2186 if (ret > 0) {
2187 path->slots[*level]++;
2188 continue;
2189 }
2190 }
2191
2192 next = btrfs_find_tree_block(fs_info, bytenr, blocksize);
2193 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
2194 free_extent_buffer(next);
2195 reada_walk_down(root, cur, path->slots[*level]);
2196 next = read_tree_block(root->fs_info, bytenr, blocksize,
2197 ptr_gen);
2198 if (!extent_buffer_uptodate(next)) {
2199 struct btrfs_key node_key;
2200
2201 btrfs_node_key_to_cpu(path->nodes[*level],
2202 &node_key,
2203 path->slots[*level]);
2204 btrfs_add_corrupt_extent_record(root->fs_info,
2205 &node_key,
2206 path->nodes[*level]->start,
2207 root->fs_info->nodesize,
2208 *level);
2209 err = -EIO;
2210 goto out;
2211 }
2212 }
2213
2214 ret = check_child_node(cur, path->slots[*level], next);
2215 if (ret) {
2216 free_extent_buffer(next);
2217 err = ret;
2218 goto out;
2219 }
2220
2221 if (btrfs_is_leaf(next))
2222 status = btrfs_check_leaf(root, NULL, next);
2223 else
2224 status = btrfs_check_node(root, NULL, next);
2225 if (status != BTRFS_TREE_BLOCK_CLEAN) {
2226 free_extent_buffer(next);
2227 err = -EIO;
2228 goto out;
2229 }
2230
2231 *level = *level - 1;
2232 free_extent_buffer(path->nodes[*level]);
2233 path->nodes[*level] = next;
2234 path->slots[*level] = 0;
2235 }
2236 out:
2237 path->slots[*level] = btrfs_header_nritems(path->nodes[*level]);
2238 return err;
2239 }
2240
2241 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
2242 unsigned int ext_ref);
2243
2244 /*
2245 * Returns >0 Found error, should continue
2246 * Returns <0 Fatal error, must exit the whole check
2247 * Returns 0 No errors found
2248 */
2249 static int walk_down_tree_v2(struct btrfs_root *root, struct btrfs_path *path,
2250 int *level, struct node_refs *nrefs, int ext_ref)
2251 {
2252 enum btrfs_tree_block_status status;
2253 u64 bytenr;
2254 u64 ptr_gen;
2255 struct btrfs_fs_info *fs_info = root->fs_info;
2256 struct extent_buffer *next;
2257 struct extent_buffer *cur;
2258 u32 blocksize;
2259 int ret;
2260
2261 WARN_ON(*level < 0);
2262 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2263
2264 ret = update_nodes_refs(root, path->nodes[*level]->start,
2265 nrefs, *level);
2266 if (ret < 0)
2267 return ret;
2268
2269 while (*level >= 0) {
2270 WARN_ON(*level < 0);
2271 WARN_ON(*level >= BTRFS_MAX_LEVEL);
2272 cur = path->nodes[*level];
2273
2274 if (btrfs_header_level(cur) != *level)
2275 WARN_ON(1);
2276
2277 if (path->slots[*level] >= btrfs_header_nritems(cur))
2278 break;
2279 /* Don't forgot to check leaf/node validation */
2280 if (*level == 0) {
2281 ret = btrfs_check_leaf(root, NULL, cur);
2282 if (ret != BTRFS_TREE_BLOCK_CLEAN) {
2283 ret = -EIO;
2284 break;
2285 }
2286 ret = process_one_leaf_v2(root, path, nrefs,
2287 level, ext_ref);
2288 break;
2289 } else {
2290 ret = btrfs_check_node(root, NULL, cur);
2291 if (ret != BTRFS_TREE_BLOCK_CLEAN) {
2292 ret = -EIO;
2293 break;
2294 }
2295 }
2296 bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
2297 ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
2298 blocksize = fs_info->nodesize;
2299
2300 ret = update_nodes_refs(root, bytenr, nrefs, *level - 1);
2301 if (ret)
2302 break;
2303 if (!nrefs->need_check[*level - 1]) {
2304 path->slots[*level]++;
2305 continue;
2306 }
2307
2308 next = btrfs_find_tree_block(fs_info, bytenr, blocksize);
2309 if (!next || !btrfs_buffer_uptodate(next, ptr_gen)) {
2310 free_extent_buffer(next);
2311 reada_walk_down(root, cur, path->slots[*level]);
2312 next = read_tree_block(fs_info, bytenr, blocksize,
2313 ptr_gen);
2314 if (!extent_buffer_uptodate(next)) {
2315 struct btrfs_key node_key;
2316
2317 btrfs_node_key_to_cpu(path->nodes[*level],
2318 &node_key,
2319 path->slots[*level]);
2320 btrfs_add_corrupt_extent_record(fs_info,
2321 &node_key,
2322 path->nodes[*level]->start,
2323 fs_info->nodesize,
2324 *level);
2325 ret = -EIO;
2326 break;
2327 }
2328 }
2329
2330 ret = check_child_node(cur, path->slots[*level], next);
2331 if (ret < 0)
2332 break;
2333
2334 if (btrfs_is_leaf(next))
2335 status = btrfs_check_leaf(root, NULL, next);
2336 else
2337 status = btrfs_check_node(root, NULL, next);
2338 if (status != BTRFS_TREE_BLOCK_CLEAN) {
2339 free_extent_buffer(next);
2340 ret = -EIO;
2341 break;
2342 }
2343
2344 *level = *level - 1;
2345 free_extent_buffer(path->nodes[*level]);
2346 path->nodes[*level] = next;
2347 path->slots[*level] = 0;
2348 }
2349 return ret;
2350 }
2351
2352 static int walk_up_tree(struct btrfs_root *root, struct btrfs_path *path,
2353 struct walk_control *wc, int *level)
2354 {
2355 int i;
2356 struct extent_buffer *leaf;
2357
2358 for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2359 leaf = path->nodes[i];
2360 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
2361 path->slots[i]++;
2362 *level = i;
2363 return 0;
2364 } else {
2365 free_extent_buffer(path->nodes[*level]);
2366 path->nodes[*level] = NULL;
2367 BUG_ON(*level > wc->active_node);
2368 if (*level == wc->active_node)
2369 leave_shared_node(root, wc, *level);
2370 *level = i + 1;
2371 }
2372 }
2373 return 1;
2374 }
2375
2376 static int walk_up_tree_v2(struct btrfs_root *root, struct btrfs_path *path,
2377 int *level)
2378 {
2379 int i;
2380 struct extent_buffer *leaf;
2381
2382 for (i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
2383 leaf = path->nodes[i];
2384 if (path->slots[i] + 1 < btrfs_header_nritems(leaf)) {
2385 path->slots[i]++;
2386 *level = i;
2387 return 0;
2388 } else {
2389 free_extent_buffer(path->nodes[*level]);
2390 path->nodes[*level] = NULL;
2391 *level = i + 1;
2392 }
2393 }
2394 return 1;
2395 }
2396
2397 static int check_root_dir(struct inode_record *rec)
2398 {
2399 struct inode_backref *backref;
2400 int ret = -1;
2401
2402 if (!rec->found_inode_item || rec->errors)
2403 goto out;
2404 if (rec->nlink != 1 || rec->found_link != 0)
2405 goto out;
2406 if (list_empty(&rec->backrefs))
2407 goto out;
2408 backref = to_inode_backref(rec->backrefs.next);
2409 if (!backref->found_inode_ref)
2410 goto out;
2411 if (backref->index != 0 || backref->namelen != 2 ||
2412 memcmp(backref->name, "..", 2))
2413 goto out;
2414 if (backref->found_dir_index || backref->found_dir_item)
2415 goto out;
2416 ret = 0;
2417 out:
2418 return ret;
2419 }
2420
2421 static int repair_inode_isize(struct btrfs_trans_handle *trans,
2422 struct btrfs_root *root, struct btrfs_path *path,
2423 struct inode_record *rec)
2424 {
2425 struct btrfs_inode_item *ei;
2426 struct btrfs_key key;
2427 int ret;
2428
2429 key.objectid = rec->ino;
2430 key.type = BTRFS_INODE_ITEM_KEY;
2431 key.offset = (u64)-1;
2432
2433 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2434 if (ret < 0)
2435 goto out;
2436 if (ret) {
2437 if (!path->slots[0]) {
2438 ret = -ENOENT;
2439 goto out;
2440 }
2441 path->slots[0]--;
2442 ret = 0;
2443 }
2444 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
2445 if (key.objectid != rec->ino) {
2446 ret = -ENOENT;
2447 goto out;
2448 }
2449
2450 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2451 struct btrfs_inode_item);
2452 btrfs_set_inode_size(path->nodes[0], ei, rec->found_size);
2453 btrfs_mark_buffer_dirty(path->nodes[0]);
2454 rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
2455 printf("reset isize for dir %Lu root %Lu\n", rec->ino,
2456 root->root_key.objectid);
2457 out:
2458 btrfs_release_path(path);
2459 return ret;
2460 }
2461
2462 static int repair_inode_orphan_item(struct btrfs_trans_handle *trans,
2463 struct btrfs_root *root,
2464 struct btrfs_path *path,
2465 struct inode_record *rec)
2466 {
2467 int ret;
2468
2469 ret = btrfs_add_orphan_item(trans, root, path, rec->ino);
2470 btrfs_release_path(path);
2471 if (!ret)
2472 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
2473 return ret;
2474 }
2475
2476 static int repair_inode_nbytes(struct btrfs_trans_handle *trans,
2477 struct btrfs_root *root,
2478 struct btrfs_path *path,
2479 struct inode_record *rec)
2480 {
2481 struct btrfs_inode_item *ei;
2482 struct btrfs_key key;
2483 int ret = 0;
2484
2485 key.objectid = rec->ino;
2486 key.type = BTRFS_INODE_ITEM_KEY;
2487 key.offset = 0;
2488
2489 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2490 if (ret) {
2491 if (ret > 0)
2492 ret = -ENOENT;
2493 goto out;
2494 }
2495
2496 /* Since ret == 0, no need to check anything */
2497 ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
2498 struct btrfs_inode_item);
2499 btrfs_set_inode_nbytes(path->nodes[0], ei, rec->found_size);
2500 btrfs_mark_buffer_dirty(path->nodes[0]);
2501 rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
2502 printf("reset nbytes for ino %llu root %llu\n",
2503 rec->ino, root->root_key.objectid);
2504 out:
2505 btrfs_release_path(path);
2506 return ret;
2507 }
2508
2509 static int add_missing_dir_index(struct btrfs_root *root,
2510 struct cache_tree *inode_cache,
2511 struct inode_record *rec,
2512 struct inode_backref *backref)
2513 {
2514 struct btrfs_path path;
2515 struct btrfs_trans_handle *trans;
2516 struct btrfs_dir_item *dir_item;
2517 struct extent_buffer *leaf;
2518 struct btrfs_key key;
2519 struct btrfs_disk_key disk_key;
2520 struct inode_record *dir_rec;
2521 unsigned long name_ptr;
2522 u32 data_size = sizeof(*dir_item) + backref->namelen;
2523 int ret;
2524
2525 trans = btrfs_start_transaction(root, 1);
2526 if (IS_ERR(trans))
2527 return PTR_ERR(trans);
2528
2529 fprintf(stderr, "repairing missing dir index item for inode %llu\n",
2530 (unsigned long long)rec->ino);
2531
2532 btrfs_init_path(&path);
2533 key.objectid = backref->dir;
2534 key.type = BTRFS_DIR_INDEX_KEY;
2535 key.offset = backref->index;
2536 ret = btrfs_insert_empty_item(trans, root, &path, &key, data_size);
2537 BUG_ON(ret);
2538
2539 leaf = path.nodes[0];
2540 dir_item = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_dir_item);
2541
2542 disk_key.objectid = cpu_to_le64(rec->ino);
2543 disk_key.type = BTRFS_INODE_ITEM_KEY;
2544 disk_key.offset = 0;
2545
2546 btrfs_set_dir_item_key(leaf, dir_item, &disk_key);
2547 btrfs_set_dir_type(leaf, dir_item, imode_to_type(rec->imode));
2548 btrfs_set_dir_data_len(leaf, dir_item, 0);
2549 btrfs_set_dir_name_len(leaf, dir_item, backref->namelen);
2550 name_ptr = (unsigned long)(dir_item + 1);
2551 write_extent_buffer(leaf, backref->name, name_ptr, backref->namelen);
2552 btrfs_mark_buffer_dirty(leaf);
2553 btrfs_release_path(&path);
2554 btrfs_commit_transaction(trans, root);
2555
2556 backref->found_dir_index = 1;
2557 dir_rec = get_inode_rec(inode_cache, backref->dir, 0);
2558 BUG_ON(IS_ERR(dir_rec));
2559 if (!dir_rec)
2560 return 0;
2561 dir_rec->found_size += backref->namelen;
2562 if (dir_rec->found_size == dir_rec->isize &&
2563 (dir_rec->errors & I_ERR_DIR_ISIZE_WRONG))
2564 dir_rec->errors &= ~I_ERR_DIR_ISIZE_WRONG;
2565 if (dir_rec->found_size != dir_rec->isize)
2566 dir_rec->errors |= I_ERR_DIR_ISIZE_WRONG;
2567
2568 return 0;
2569 }
2570
2571 static int delete_dir_index(struct btrfs_root *root,
2572 struct inode_backref *backref)
2573 {
2574 struct btrfs_trans_handle *trans;
2575 struct btrfs_dir_item *di;
2576 struct btrfs_path path;
2577 int ret = 0;
2578
2579 trans = btrfs_start_transaction(root, 1);
2580 if (IS_ERR(trans))
2581 return PTR_ERR(trans);
2582
2583 fprintf(stderr, "Deleting bad dir index [%llu,%u,%llu] root %llu\n",
2584 (unsigned long long)backref->dir,
2585 BTRFS_DIR_INDEX_KEY, (unsigned long long)backref->index,
2586 (unsigned long long)root->objectid);
2587
2588 btrfs_init_path(&path);
2589 di = btrfs_lookup_dir_index(trans, root, &path, backref->dir,
2590 backref->name, backref->namelen,
2591 backref->index, -1);
2592 if (IS_ERR(di)) {
2593 ret = PTR_ERR(di);
2594 btrfs_release_path(&path);
2595 btrfs_commit_transaction(trans, root);
2596 if (ret == -ENOENT)
2597 return 0;
2598 return ret;
2599 }
2600
2601 if (!di)
2602 ret = btrfs_del_item(trans, root, &path);
2603 else
2604 ret = btrfs_delete_one_dir_name(trans, root, &path, di);
2605 BUG_ON(ret);
2606 btrfs_release_path(&path);
2607 btrfs_commit_transaction(trans, root);
2608 return ret;
2609 }
2610
2611 static int create_inode_item(struct btrfs_root *root,
2612 struct inode_record *rec,
2613 int root_dir)
2614 {
2615 struct btrfs_trans_handle *trans;
2616 struct btrfs_inode_item inode_item;
2617 time_t now = time(NULL);
2618 int ret;
2619
2620 trans = btrfs_start_transaction(root, 1);
2621 if (IS_ERR(trans)) {
2622 ret = PTR_ERR(trans);
2623 return ret;
2624 }
2625
2626 fprintf(stderr, "root %llu inode %llu recreating inode item, this may "
2627 "be incomplete, please check permissions and content after "
2628 "the fsck completes.\n", (unsigned long long)root->objectid,
2629 (unsigned long long)rec->ino);
2630
2631 memset(&inode_item, 0, sizeof(inode_item));
2632 btrfs_set_stack_inode_generation(&inode_item, trans->transid);
2633 if (root_dir)
2634 btrfs_set_stack_inode_nlink(&inode_item, 1);
2635 else
2636 btrfs_set_stack_inode_nlink(&inode_item, rec->found_link);
2637 btrfs_set_stack_inode_nbytes(&inode_item, rec->found_size);
2638 if (rec->found_dir_item) {
2639 if (rec->found_file_extent)
2640 fprintf(stderr, "root %llu inode %llu has both a dir "
2641 "item and extents, unsure if it is a dir or a "
2642 "regular file so setting it as a directory\n",
2643 (unsigned long long)root->objectid,
2644 (unsigned long long)rec->ino);
2645 btrfs_set_stack_inode_mode(&inode_item, S_IFDIR | 0755);
2646 btrfs_set_stack_inode_size(&inode_item, rec->found_size);
2647 } else if (!rec->found_dir_item) {
2648 btrfs_set_stack_inode_size(&inode_item, rec->extent_end);
2649 btrfs_set_stack_inode_mode(&inode_item, S_IFREG | 0755);
2650 }
2651 btrfs_set_stack_timespec_sec(&inode_item.atime, now);
2652 btrfs_set_stack_timespec_nsec(&inode_item.atime, 0);
2653 btrfs_set_stack_timespec_sec(&inode_item.ctime, now);
2654 btrfs_set_stack_timespec_nsec(&inode_item.ctime, 0);
2655 btrfs_set_stack_timespec_sec(&inode_item.mtime, now);
2656 btrfs_set_stack_timespec_nsec(&inode_item.mtime, 0);
2657 btrfs_set_stack_timespec_sec(&inode_item.otime, 0);
2658 btrfs_set_stack_timespec_nsec(&inode_item.otime, 0);
2659
2660 ret = btrfs_insert_inode(trans, root, rec->ino, &inode_item);
2661 BUG_ON(ret);
2662 btrfs_commit_transaction(trans, root);
2663 return 0;
2664 }
2665
2666 static int repair_inode_backrefs(struct btrfs_root *root,
2667 struct inode_record *rec,
2668 struct cache_tree *inode_cache,
2669 int delete)
2670 {
2671 struct inode_backref *tmp, *backref;
2672 u64 root_dirid = btrfs_root_dirid(&root->root_item);
2673 int ret = 0;
2674 int repaired = 0;
2675
2676 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
2677 if (!delete && rec->ino == root_dirid) {
2678 if (!rec->found_inode_item) {
2679 ret = create_inode_item(root, rec, 1);
2680 if (ret)
2681 break;
2682 repaired++;
2683 }
2684 }
2685
2686 /* Index 0 for root dir's are special, don't mess with it */
2687 if (rec->ino == root_dirid && backref->index == 0)
2688 continue;
2689
2690 if (delete &&
2691 ((backref->found_dir_index && !backref->found_inode_ref) ||
2692 (backref->found_dir_index && backref->found_inode_ref &&
2693 (backref->errors & REF_ERR_INDEX_UNMATCH)))) {
2694 ret = delete_dir_index(root, backref);
2695 if (ret)
2696 break;
2697 repaired++;
2698 list_del(&backref->list);
2699 free(backref);
2700 continue;
2701 }
2702
2703 if (!delete && !backref->found_dir_index &&
2704 backref->found_dir_item && backref->found_inode_ref) {
2705 ret = add_missing_dir_index(root, inode_cache, rec,
2706 backref);
2707 if (ret)
2708 break;
2709 repaired++;
2710 if (backref->found_dir_item &&
2711 backref->found_dir_index) {
2712 if (!backref->errors &&
2713 backref->found_inode_ref) {
2714 list_del(&backref->list);
2715 free(backref);
2716 continue;
2717 }
2718 }
2719 }
2720
2721 if (!delete && (!backref->found_dir_index &&
2722 !backref->found_dir_item &&
2723 backref->found_inode_ref)) {
2724 struct btrfs_trans_handle *trans;
2725 struct btrfs_key location;
2726
2727 ret = check_dir_conflict(root, backref->name,
2728 backref->namelen,
2729 backref->dir,
2730 backref->index);
2731 if (ret) {
2732 /*
2733 * let nlink fixing routine to handle it,
2734 * which can do it better.
2735 */
2736 ret = 0;
2737 break;
2738 }
2739 location.objectid = rec->ino;
2740 location.type = BTRFS_INODE_ITEM_KEY;
2741 location.offset = 0;
2742
2743 trans = btrfs_start_transaction(root, 1);
2744 if (IS_ERR(trans)) {
2745 ret = PTR_ERR(trans);
2746 break;
2747 }
2748 fprintf(stderr, "adding missing dir index/item pair "
2749 "for inode %llu\n",
2750 (unsigned long long)rec->ino);
2751 ret = btrfs_insert_dir_item(trans, root, backref->name,
2752 backref->namelen,
2753 backref->dir, &location,
2754 imode_to_type(rec->imode),
2755 backref->index);
2756 BUG_ON(ret);
2757 btrfs_commit_transaction(trans, root);
2758 repaired++;
2759 }
2760
2761 if (!delete && (backref->found_inode_ref &&
2762 backref->found_dir_index &&
2763 backref->found_dir_item &&
2764 !(backref->errors & REF_ERR_INDEX_UNMATCH) &&
2765 !rec->found_inode_item)) {
2766 ret = create_inode_item(root, rec, 0);
2767 if (ret)
2768 break;
2769 repaired++;
2770 }
2771
2772 }
2773 return ret ? ret : repaired;
2774 }
2775
2776 /*
2777 * To determine the file type for nlink/inode_item repair
2778 *
2779 * Return 0 if file type is found and BTRFS_FT_* is stored into type.
2780 * Return -ENOENT if file type is not found.
2781 */
2782 static int find_file_type(struct inode_record *rec, u8 *type)
2783 {
2784 struct inode_backref *backref;
2785
2786 /* For inode item recovered case */
2787 if (rec->found_inode_item) {
2788 *type = imode_to_type(rec->imode);
2789 return 0;
2790 }
2791
2792 list_for_each_entry(backref, &rec->backrefs, list) {
2793 if (backref->found_dir_index || backref->found_dir_item) {
2794 *type = backref->filetype;
2795 return 0;
2796 }
2797 }
2798 return -ENOENT;
2799 }
2800
2801 /*
2802 * To determine the file name for nlink repair
2803 *
2804 * Return 0 if file name is found, set name and namelen.
2805 * Return -ENOENT if file name is not found.
2806 */
2807 static int find_file_name(struct inode_record *rec,
2808 char *name, int *namelen)
2809 {
2810 struct inode_backref *backref;
2811
2812 list_for_each_entry(backref, &rec->backrefs, list) {
2813 if (backref->found_dir_index || backref->found_dir_item ||
2814 backref->found_inode_ref) {
2815 memcpy(name, backref->name, backref->namelen);
2816 *namelen = backref->namelen;
2817 return 0;
2818 }
2819 }
2820 return -ENOENT;
2821 }
2822
2823 /* Reset the nlink of the inode to the correct one */
2824 static int reset_nlink(struct btrfs_trans_handle *trans,
2825 struct btrfs_root *root,
2826 struct btrfs_path *path,
2827 struct inode_record *rec)
2828 {
2829 struct inode_backref *backref;
2830 struct inode_backref *tmp;
2831 struct btrfs_key key;
2832 struct btrfs_inode_item *inode_item;
2833 int ret = 0;
2834
2835 /* We don't believe this either, reset it and iterate backref */
2836 rec->found_link = 0;
2837
2838 /* Remove all backref including the valid ones */
2839 list_for_each_entry_safe(backref, tmp, &rec->backrefs, list) {
2840 ret = btrfs_unlink(trans, root, rec->ino, backref->dir,
2841 backref->index, backref->name,
2842 backref->namelen, 0);
2843 if (ret < 0)
2844 goto out;
2845
2846 /* remove invalid backref, so it won't be added back */
2847 if (!(backref->found_dir_index &&
2848 backref->found_dir_item &&
2849 backref->found_inode_ref)) {
2850 list_del(&backref->list);
2851 free(backref);
2852 } else {
2853 rec->found_link++;
2854 }
2855 }
2856
2857 /* Set nlink to 0 */
2858 key.objectid = rec->ino;
2859 key.type = BTRFS_INODE_ITEM_KEY;
2860 key.offset = 0;
2861 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2862 if (ret < 0)
2863 goto out;
2864 if (ret > 0) {
2865 ret = -ENOENT;
2866 goto out;
2867 }
2868 inode_item = btrfs_item_ptr(path->nodes[0], path->slots[0],
2869 struct btrfs_inode_item);
2870 btrfs_set_inode_nlink(path->nodes[0], inode_item, 0);
2871 btrfs_mark_buffer_dirty(path->nodes[0]);
2872 btrfs_release_path(path);
2873
2874 /*
2875 * Add back valid inode_ref/dir_item/dir_index,
2876 * add_link() will handle the nlink inc, so new nlink must be correct
2877 */
2878 list_for_each_entry(backref, &rec->backrefs, list) {
2879 ret = btrfs_add_link(trans, root, rec->ino, backref->dir,
2880 backref->name, backref->namelen,
2881 backref->filetype, &backref->index, 1);
2882 if (ret < 0)
2883 goto out;
2884 }
2885 out:
2886 btrfs_release_path(path);
2887 return ret;
2888 }
2889
2890 static int get_highest_inode(struct btrfs_trans_handle *trans,
2891 struct btrfs_root *root,
2892 struct btrfs_path *path,
2893 u64 *highest_ino)
2894 {
2895 struct btrfs_key key, found_key;
2896 int ret;
2897
2898 btrfs_init_path(path);
2899 key.objectid = BTRFS_LAST_FREE_OBJECTID;
2900 key.offset = -1;
2901 key.type = BTRFS_INODE_ITEM_KEY;
2902 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
2903 if (ret == 1) {
2904 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
2905 path->slots[0] - 1);
2906 *highest_ino = found_key.objectid;
2907 ret = 0;
2908 }
2909 if (*highest_ino >= BTRFS_LAST_FREE_OBJECTID)
2910 ret = -EOVERFLOW;
2911 btrfs_release_path(path);
2912 return ret;
2913 }
2914
2915 static int repair_inode_nlinks(struct btrfs_trans_handle *trans,
2916 struct btrfs_root *root,
2917 struct btrfs_path *path,
2918 struct inode_record *rec)
2919 {
2920 char *dir_name = "lost+found";
2921 char namebuf[BTRFS_NAME_LEN] = {0};
2922 u64 lost_found_ino;
2923 u32 mode = 0700;
2924 u8 type = 0;
2925 int namelen = 0;
2926 int name_recovered = 0;
2927 int type_recovered = 0;
2928 int ret = 0;
2929
2930 /*
2931 * Get file name and type first before these invalid inode ref
2932 * are deleted by remove_all_invalid_backref()
2933 */
2934 name_recovered = !find_file_name(rec, namebuf, &namelen);
2935 type_recovered = !find_file_type(rec, &type);
2936
2937 if (!name_recovered) {
2938 printf("Can't get file name for inode %llu, using '%llu' as fallback\n",
2939 rec->ino, rec->ino);
2940 namelen = count_digits(rec->ino);
2941 sprintf(namebuf, "%llu", rec->ino);
2942 name_recovered = 1;
2943 }
2944 if (!type_recovered) {
2945 printf("Can't get file type for inode %llu, using FILE as fallback\n",
2946 rec->ino);
2947 type = BTRFS_FT_REG_FILE;
2948 type_recovered = 1;
2949 }
2950
2951 ret = reset_nlink(trans, root, path, rec);
2952 if (ret < 0) {
2953 fprintf(stderr,
2954 "Failed to reset nlink for inode %llu: %s\n",
2955 rec->ino, strerror(-ret));
2956 goto out;
2957 }
2958
2959 if (rec->found_link == 0) {
2960 ret = get_highest_inode(trans, root, path, &lost_found_ino);
2961 if (ret < 0)
2962 goto out;
2963 lost_found_ino++;
2964 ret = btrfs_mkdir(trans, root, dir_name, strlen(dir_name),
2965 BTRFS_FIRST_FREE_OBJECTID, &lost_found_ino,
2966 mode);
2967 if (ret < 0) {
2968 fprintf(stderr, "Failed to create '%s' dir: %s\n",
2969 dir_name, strerror(-ret));
2970 goto out;
2971 }
2972 ret = btrfs_add_link(trans, root, rec->ino, lost_found_ino,
2973 namebuf, namelen, type, NULL, 1);
2974 /*
2975 * Add ".INO" suffix several times to handle case where
2976 * "FILENAME.INO" is already taken by another file.
2977 */
2978 while (ret == -EEXIST) {
2979 /*
2980 * Conflicting file name, add ".INO" as suffix * +1 for '.'
2981 */
2982 if (namelen + count_digits(rec->ino) + 1 >
2983 BTRFS_NAME_LEN) {
2984 ret = -EFBIG;
2985 goto out;
2986 }
2987 snprintf(namebuf + namelen, BTRFS_NAME_LEN - namelen,
2988 ".%llu", rec->ino);
2989 namelen += count_digits(rec->ino) + 1;
2990 ret = btrfs_add_link(trans, root, rec->ino,
2991 lost_found_ino, namebuf,
2992 namelen, type, NULL, 1);
2993 }
2994 if (ret < 0) {
2995 fprintf(stderr,
2996 "Failed to link the inode %llu to %s dir: %s\n",
2997 rec->ino, dir_name, strerror(-ret));
2998 goto out;
2999 }
3000 /*
3001 * Just increase the found_link, don't actually add the
3002 * backref. This will make things easier and this inode
3003 * record will be freed after the repair is done.
3004 * So fsck will not report problem about this inode.
3005 */
3006 rec->found_link++;
3007 printf("Moving file '%.*s' to '%s' dir since it has no valid backref\n",
3008 namelen, namebuf, dir_name);
3009 }
3010 printf("Fixed the nlink of inode %llu\n", rec->ino);
3011 out:
3012 /*
3013 * Clear the flag anyway, or we will loop forever for the same inode
3014 * as it will not be removed from the bad inode list and the dead loop
3015 * happens.
3016 */
3017 rec->errors &= ~I_ERR_LINK_COUNT_WRONG;
3018 btrfs_release_path(path);
3019 return ret;
3020 }
3021
3022 /*
3023 * Check if there is any normal(reg or prealloc) file extent for given
3024 * ino.
3025 * This is used to determine the file type when neither its dir_index/item or
3026 * inode_item exists.
3027 *
3028 * This will *NOT* report error, if any error happens, just consider it does
3029 * not have any normal file extent.
3030 */
3031 static int find_normal_file_extent(struct btrfs_root *root, u64 ino)
3032 {
3033 struct btrfs_path path;
3034 struct btrfs_key key;
3035 struct btrfs_key found_key;
3036 struct btrfs_file_extent_item *fi;
3037 u8 type;
3038 int ret = 0;
3039
3040 btrfs_init_path(&path);
3041 key.objectid = ino;
3042 key.type = BTRFS_EXTENT_DATA_KEY;
3043 key.offset = 0;
3044
3045 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
3046 if (ret < 0) {
3047 ret = 0;
3048 goto out;
3049 }
3050 if (ret && path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
3051 ret = btrfs_next_leaf(root, &path);
3052 if (ret) {
3053 ret = 0;
3054 goto out;
3055 }
3056 }
3057 while (1) {
3058 btrfs_item_key_to_cpu(path.nodes[0], &found_key,
3059 path.slots[0]);
3060 if (found_key.objectid != ino ||
3061 found_key.type != BTRFS_EXTENT_DATA_KEY)
3062 break;
3063 fi = btrfs_item_ptr(path.nodes[0], path.slots[0],
3064 struct btrfs_file_extent_item);
3065 type = btrfs_file_extent_type(path.nodes[0], fi);
3066 if (type != BTRFS_FILE_EXTENT_INLINE) {
3067 ret = 1;
3068 goto out;
3069 }
3070 }
3071 out:
3072 btrfs_release_path(&path);
3073 return ret;
3074 }
3075
3076 static u32 btrfs_type_to_imode(u8 type)
3077 {
3078 static u32 imode_by_btrfs_type[] = {
3079 [BTRFS_FT_REG_FILE] = S_IFREG,
3080 [BTRFS_FT_DIR] = S_IFDIR,
3081 [BTRFS_FT_CHRDEV] = S_IFCHR,
3082 [BTRFS_FT_BLKDEV] = S_IFBLK,
3083 [BTRFS_FT_FIFO] = S_IFIFO,
3084 [BTRFS_FT_SOCK] = S_IFSOCK,
3085 [BTRFS_FT_SYMLINK] = S_IFLNK,
3086 };
3087
3088 return imode_by_btrfs_type[(type)];
3089 }
3090
3091 static int repair_inode_no_item(struct btrfs_trans_handle *trans,
3092 struct btrfs_root *root,
3093 struct btrfs_path *path,
3094 struct inode_record *rec)
3095 {
3096 u8 filetype;
3097 u32 mode = 0700;
3098 int type_recovered = 0;
3099 int ret = 0;
3100
3101 printf("Trying to rebuild inode:%llu\n", rec->ino);
3102
3103 type_recovered = !find_file_type(rec, &filetype);
3104
3105 /*
3106 * Try to determine inode type if type not found.
3107 *
3108 * For found regular file extent, it must be FILE.
3109 * For found dir_item/index, it must be DIR.
3110 *
3111 * For undetermined one, use FILE as fallback.
3112 *
3113 * TODO:
3114 * 1. If found backref(inode_index/item is already handled) to it,
3115 * it must be DIR.
3116 * Need new inode-inode ref structure to allow search for that.
3117 */
3118 if (!type_recovered) {
3119 if (rec->found_file_extent &&
3120 find_normal_file_extent(root, rec->ino)) {
3121 type_recovered = 1;
3122 filetype = BTRFS_FT_REG_FILE;
3123 } else if (rec->found_dir_item) {
3124 type_recovered = 1;
3125 filetype = BTRFS_FT_DIR;
3126 } else if (!list_empty(&rec->orphan_extents)) {
3127 type_recovered = 1;
3128 filetype = BTRFS_FT_REG_FILE;
3129 } else{
3130 printf("Can't determine the filetype for inode %llu, assume it is a normal file\n",
3131 rec->ino);
3132 type_recovered = 1;
3133 filetype = BTRFS_FT_REG_FILE;
3134 }
3135 }
3136
3137 ret = btrfs_new_inode(trans, root, rec->ino,
3138 mode | btrfs_type_to_imode(filetype));
3139 if (ret < 0)
3140 goto out;
3141
3142 /*
3143 * Here inode rebuild is done, we only rebuild the inode item,
3144 * don't repair the nlink(like move to lost+found).
3145 * That is the job of nlink repair.
3146 *
3147 * We just fill the record and return
3148 */
3149 rec->found_dir_item = 1;
3150 rec->imode = mode | btrfs_type_to_imode(filetype);
3151 rec->nlink = 0;
3152 rec->errors &= ~I_ERR_NO_INODE_ITEM;
3153 /* Ensure the inode_nlinks repair function will be called */
3154 rec->errors |= I_ERR_LINK_COUNT_WRONG;
3155 out:
3156 return ret;
3157 }
3158
3159 static int repair_inode_orphan_extent(struct btrfs_trans_handle *trans,
3160 struct btrfs_root *root,
3161 struct btrfs_path *path,
3162 struct inode_record *rec)
3163 {
3164 struct orphan_data_extent *orphan;
3165 struct orphan_data_extent *tmp;
3166 int ret = 0;
3167
3168 list_for_each_entry_safe(orphan, tmp, &rec->orphan_extents, list) {
3169 /*
3170 * Check for conflicting file extents
3171 *
3172 * Here we don't know whether the extents is compressed or not,
3173 * so we can only assume it not compressed nor data offset,
3174 * and use its disk_len as extent length.
3175 */
3176 ret = btrfs_get_extent(NULL, root, path, orphan->objectid,
3177 orphan->offset, orphan->disk_len, 0);
3178 btrfs_release_path(path);
3179 if (ret < 0)
3180 goto out;
3181 if (!ret) {
3182 fprintf(stderr,
3183 "orphan extent (%llu, %llu) conflicts, delete the orphan\n",
3184 orphan->disk_bytenr, orphan->disk_len);
3185 ret = btrfs_free_extent(trans,
3186 root->fs_info->extent_root,
3187 orphan->disk_bytenr, orphan->disk_len,
3188 0, root->objectid, orphan->objectid,
3189 orphan->offset);
3190 if (ret < 0)
3191 goto out;
3192 }
3193 ret = btrfs_insert_file_extent(trans, root, orphan->objectid,
3194 orphan->offset, orphan->disk_bytenr,
3195 orphan->disk_len, orphan->disk_len);
3196 if (ret < 0)
3197 goto out;
3198
3199 /* Update file size info */
3200 rec->found_size += orphan->disk_len;
3201 if (rec->found_size == rec->nbytes)
3202 rec->errors &= ~I_ERR_FILE_NBYTES_WRONG;
3203
3204 /* Update the file extent hole info too */
3205 ret = del_file_extent_hole(&rec->holes, orphan->offset,
3206 orphan->disk_len);
3207 if (ret < 0)
3208 goto out;
3209 if (RB_EMPTY_ROOT(&rec->holes))
3210 rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
3211
3212 list_del(&orphan->list);
3213 free(orphan);
3214 }
3215 rec->errors &= ~I_ERR_FILE_EXTENT_ORPHAN;
3216 out:
3217 return ret;
3218 }
3219
3220 static int repair_inode_discount_extent(struct btrfs_trans_handle *trans,
3221 struct btrfs_root *root,
3222 struct btrfs_path *path,
3223 struct inode_record *rec)
3224 {
3225 struct rb_node *node;
3226 struct file_extent_hole *hole;
3227 int found = 0;
3228 int ret = 0;
3229
3230 node = rb_first(&rec->holes);
3231
3232 while (node) {
3233 found = 1;
3234 hole = rb_entry(node, struct file_extent_hole, node);
3235 ret = btrfs_punch_hole(trans, root, rec->ino,
3236 hole->start, hole->len);
3237 if (ret < 0)
3238 goto out;
3239 ret = del_file_extent_hole(&rec->holes, hole->start,
3240 hole->len);
3241 if (ret < 0)
3242 goto out;
3243 if (RB_EMPTY_ROOT(&rec->holes))
3244 rec->errors &= ~I_ERR_FILE_EXTENT_DISCOUNT;
3245 node = rb_first(&rec->holes);
3246 }
3247 /* special case for a file losing all its file extent */
3248 if (!found) {
3249 ret = btrfs_punch_hole(trans, root, rec->ino, 0,
3250 round_up(rec->isize,
3251 root->fs_info->sectorsize));
3252 if (ret < 0)
3253 goto out;
3254 }
3255 printf("Fixed discount file extents for inode: %llu in root: %llu\n",
3256 rec->ino, root->objectid);
3257 out:
3258 return ret;
3259 }
3260
3261 static int try_repair_inode(struct btrfs_root *root, struct inode_record *rec)
3262 {
3263 struct btrfs_trans_handle *trans;
3264 struct btrfs_path path;
3265 int ret = 0;
3266
3267 if (!(rec->errors & (I_ERR_DIR_ISIZE_WRONG |
3268 I_ERR_NO_ORPHAN_ITEM |
3269 I_ERR_LINK_COUNT_WRONG |
3270 I_ERR_NO_INODE_ITEM |
3271 I_ERR_FILE_EXTENT_ORPHAN |
3272 I_ERR_FILE_EXTENT_DISCOUNT|
3273 I_ERR_FILE_NBYTES_WRONG)))
3274 return rec->errors;
3275
3276 /*
3277 * For nlink repair, it may create a dir and add link, so
3278 * 2 for parent(256)'s dir_index and dir_item
3279 * 2 for lost+found dir's inode_item and inode_ref
3280 * 1 for the new inode_ref of the file
3281 * 2 for lost+found dir's dir_index and dir_item for the file
3282 */
3283 trans = btrfs_start_transaction(root, 7);
3284 if (IS_ERR(trans))
3285 return PTR_ERR(trans);
3286
3287 btrfs_init_path(&path);
3288 if (rec->errors & I_ERR_NO_INODE_ITEM)
3289 ret = repair_inode_no_item(trans, root, &path, rec);
3290 if (!ret && rec->errors & I_ERR_FILE_EXTENT_ORPHAN)
3291 ret = repair_inode_orphan_extent(trans, root, &path, rec);
3292 if (!ret && rec->errors & I_ERR_FILE_EXTENT_DISCOUNT)
3293 ret = repair_inode_discount_extent(trans, root, &path, rec);
3294 if (!ret && rec->errors & I_ERR_DIR_ISIZE_WRONG)
3295 ret = repair_inode_isize(trans, root, &path, rec);
3296 if (!ret && rec->errors & I_ERR_NO_ORPHAN_ITEM)
3297 ret = repair_inode_orphan_item(trans, root, &path, rec);
3298 if (!ret && rec->errors & I_ERR_LINK_COUNT_WRONG)
3299 ret = repair_inode_nlinks(trans, root, &path, rec);
3300 if (!ret && rec->errors & I_ERR_FILE_NBYTES_WRONG)
3301 ret = repair_inode_nbytes(trans, root, &path, rec);
3302 btrfs_commit_transaction(trans, root);
3303 btrfs_release_path(&path);
3304 return ret;
3305 }
3306
3307 static int check_inode_recs(struct btrfs_root *root,
3308 struct cache_tree *inode_cache)
3309 {
3310 struct cache_extent *cache;
3311 struct ptr_node *node;
3312 struct inode_record *rec;
3313 struct inode_backref *backref;
3314 int stage = 0;
3315 int ret = 0;
3316 int err = 0;
3317 u64 error = 0;
3318 u64 root_dirid = btrfs_root_dirid(&root->root_item);
3319
3320 if (btrfs_root_refs(&root->root_item) == 0) {
3321 if (!cache_tree_empty(inode_cache))
3322 fprintf(stderr, "warning line %d\n", __LINE__);
3323 return 0;
3324 }
3325
3326 /*
3327 * We need to repair backrefs first because we could change some of the
3328 * errors in the inode recs.
3329 *
3330 * We also need to go through and delete invalid backrefs first and then
3331 * add the correct ones second. We do this because we may get EEXIST
3332 * when adding back the correct index because we hadn't yet deleted the
3333 * invalid index.
3334 *
3335 * For example, if we were missing a dir index then the directories
3336 * isize would be wrong, so if we fixed the isize to what we thought it
3337 * would be and then fixed the backref we'd still have a invalid fs, so
3338 * we need to add back the dir index and then check to see if the isize
3339 * is still wrong.
3340 */
3341 while (stage < 3) {
3342 stage++;
3343 if (stage == 3 && !err)
3344 break;
3345
3346 cache = search_cache_extent(inode_cache, 0);
3347 while (repair && cache) {
3348 node = container_of(cache, struct ptr_node, cache);
3349 rec = node->data;
3350 cache = next_cache_extent(cache);
3351
3352 /* Need to free everything up and rescan */
3353 if (stage == 3) {
3354 remove_cache_extent(inode_cache, &node->cache);
3355 free(node);
3356 free_inode_rec(rec);
3357 continue;
3358 }
3359
3360 if (list_empty(&rec->backrefs))
3361 continue;
3362
3363 ret = repair_inode_backrefs(root, rec, inode_cache,
3364 stage == 1);
3365 if (ret < 0) {
3366 err = ret;
3367 stage = 2;
3368 break;
3369 } if (ret > 0) {
3370 err = -EAGAIN;
3371 }
3372 }
3373 }
3374 if (err)
3375 return err;
3376
3377 rec = get_inode_rec(inode_cache, root_dirid, 0);
3378 BUG_ON(IS_ERR(rec));
3379 if (rec) {
3380 ret = check_root_dir(rec);
3381 if (ret) {
3382 fprintf(stderr, "root %llu root dir %llu error\n",
3383 (unsigned long long)root->root_key.objectid,
3384 (unsigned long long)root_dirid);
3385 print_inode_error(root, rec);
3386 error++;
3387 }
3388 } else {
3389 if (repair) {
3390 struct btrfs_trans_handle *trans;
3391
3392 trans = btrfs_start_transaction(root, 1);
3393 if (IS_ERR(trans)) {
3394 err = PTR_ERR(trans);
3395 return err;
3396 }
3397
3398 fprintf(stderr,
3399 "root %llu missing its root dir, recreating\n",
3400 (unsigned long long)root->objectid);
3401
3402 ret = btrfs_make_root_dir(trans, root, root_dirid);
3403 BUG_ON(ret);
3404
3405 btrfs_commit_transaction(trans, root);
3406 return -EAGAIN;
3407 }
3408
3409 fprintf(stderr, "root %llu root dir %llu not found\n",
3410 (unsigned long long)root->root_key.objectid,
3411 (unsigned long long)root_dirid);
3412 }
3413
3414 while (1) {
3415 cache = search_cache_extent(inode_cache, 0);
3416 if (!cache)
3417 break;
3418 node = container_of(cache, struct ptr_node, cache);
3419 rec = node->data;
3420 remove_cache_extent(inode_cache, &node->cache);
3421 free(node);
3422 if (rec->ino == root_dirid ||
3423 rec->ino == BTRFS_ORPHAN_OBJECTID) {
3424 free_inode_rec(rec);
3425 continue;
3426 }
3427
3428 if (rec->errors & I_ERR_NO_ORPHAN_ITEM) {
3429 ret = check_orphan_item(root, rec->ino);
3430 if (ret == 0)
3431 rec->errors &= ~I_ERR_NO_ORPHAN_ITEM;
3432 if (can_free_inode_rec(rec)) {
3433 free_inode_rec(rec);
3434 continue;
3435 }
3436 }
3437
3438 if (!rec->found_inode_item)
3439 rec->errors |= I_ERR_NO_INODE_ITEM;
3440 if (rec->found_link != rec->nlink)
3441 rec->errors |= I_ERR_LINK_COUNT_WRONG;
3442 if (repair) {
3443 ret = try_repair_inode(root, rec);
3444 if (ret == 0 && can_free_inode_rec(rec)) {
3445 free_inode_rec(rec);
3446 continue;
3447 }
3448 ret = 0;
3449 }
3450
3451 if (!(repair && ret == 0))
3452 error++;
3453 print_inode_error(root, rec);
3454 list_for_each_entry(backref, &rec->backrefs, list) {
3455 if (!backref->found_dir_item)
3456 backref->errors |= REF_ERR_NO_DIR_ITEM;
3457 if (!backref->found_dir_index)
3458 backref->errors |= REF_ERR_NO_DIR_INDEX;
3459 if (!backref->found_inode_ref)
3460 backref->errors |= REF_ERR_NO_INODE_REF;
3461 fprintf(stderr, "\tunresolved ref dir %llu index %llu"
3462 " namelen %u name %s filetype %d errors %x",
3463 (unsigned long long)backref->dir,
3464 (unsigned long long)backref->index,
3465 backref->namelen, backref->name,
3466 backref->filetype, backref->errors);
3467 print_ref_error(backref->errors);
3468 }
3469 free_inode_rec(rec);
3470 }
3471 return (error > 0) ? -1 : 0;
3472 }
3473
3474 static struct root_record *get_root_rec(struct cache_tree *root_cache,
3475 u64 objectid)
3476 {
3477 struct cache_extent *cache;
3478 struct root_record *rec = NULL;
3479 int ret;
3480
3481 cache = lookup_cache_extent(root_cache, objectid, 1);
3482 if (cache) {
3483 rec = container_of(cache, struct root_record, cache);
3484 } else {
3485 rec = calloc(1, sizeof(*rec));
3486 if (!rec)
3487 return ERR_PTR(-ENOMEM);
3488 rec->objectid = objectid;
3489 INIT_LIST_HEAD(&rec->backrefs);
3490 rec->cache.start = objectid;
3491 rec->cache.size = 1;
3492
3493 ret = insert_cache_extent(root_cache, &rec->cache);
3494 if (ret)
3495 return ERR_PTR(-EEXIST);
3496 }
3497 return rec;
3498 }
3499
3500 static struct root_backref *get_root_backref(struct root_record *rec,
3501 u64 ref_root, u64 dir, u64 index,
3502 const char *name, int namelen)
3503 {
3504 struct root_backref *backref;
3505
3506 list_for_each_entry(backref, &rec->backrefs, list) {
3507 if (backref->ref_root != ref_root || backref->dir != dir ||
3508 backref->namelen != namelen)
3509 continue;
3510 if (memcmp(name, backref->name, namelen))
3511 continue;
3512 return backref;
3513 }
3514
3515 backref = calloc(1, sizeof(*backref) + namelen + 1);
3516 if (!backref)
3517 return NULL;
3518 backref->ref_root = ref_root;
3519 backref->dir = dir;
3520 backref->index = index;
3521 backref->namelen = namelen;
3522 memcpy(backref->name, name, namelen);
3523 backref->name[namelen] = '\0';
3524 list_add_tail(&backref->list, &rec->backrefs);
3525 return backref;
3526 }
3527
3528 static void free_root_record(struct cache_extent *cache)
3529 {
3530 struct root_record *rec;
3531 struct root_backref *backref;
3532
3533 rec = container_of(cache, struct root_record, cache);
3534 while (!list_empty(&rec->backrefs)) {
3535 backref = to_root_backref(rec->backrefs.next);
3536 list_del(&backref->list);
3537 free(backref);
3538 }
3539
3540 free(rec);
3541 }
3542
3543 FREE_EXTENT_CACHE_BASED_TREE(root_recs, free_root_record);
3544
3545 static int add_root_backref(struct cache_tree *root_cache,
3546 u64 root_id, u64 ref_root, u64 dir, u64 index,
3547 const char *name, int namelen,
3548 int item_type, int errors)
3549 {
3550 struct root_record *rec;
3551 struct root_backref *backref;
3552
3553 rec = get_root_rec(root_cache, root_id);
3554 BUG_ON(IS_ERR(rec));
3555 backref = get_root_backref(rec, ref_root, dir, index, name, namelen);
3556 BUG_ON(!backref);
3557
3558 backref->errors |= errors;
3559
3560 if (item_type != BTRFS_DIR_ITEM_KEY) {
3561 if (backref->found_dir_index || backref->found_back_ref ||
3562 backref->found_forward_ref) {
3563 if (backref->index != index)
3564 backref->errors |= REF_ERR_INDEX_UNMATCH;
3565 } else {
3566 backref->index = index;
3567 }
3568 }
3569
3570 if (item_type == BTRFS_DIR_ITEM_KEY) {
3571 if (backref->found_forward_ref)
3572 rec->found_ref++;
3573 backref->found_dir_item = 1;
3574 } else if (item_type == BTRFS_DIR_INDEX_KEY) {
3575 backref->found_dir_index = 1;
3576 } else if (item_type == BTRFS_ROOT_REF_KEY) {
3577 if (backref->found_forward_ref)
3578 backref->errors |= REF_ERR_DUP_ROOT_REF;
3579 else if (backref->found_dir_item)
3580 rec->found_ref++;
3581 backref->found_forward_ref = 1;
3582 } else if (item_type == BTRFS_ROOT_BACKREF_KEY) {
3583 if (backref->found_back_ref)
3584 backref->errors |= REF_ERR_DUP_ROOT_BACKREF;
3585 backref->found_back_ref = 1;
3586 } else {
3587 BUG_ON(1);
3588 }
3589
3590 if (backref->found_forward_ref && backref->found_dir_item)
3591 backref->reachable = 1;
3592 return 0;
3593 }
3594
3595 static int merge_root_recs(struct btrfs_root *root,
3596 struct cache_tree *src_cache,
3597 struct cache_tree *dst_cache)
3598 {
3599 struct cache_extent *cache;
3600 struct ptr_node *node;
3601 struct inode_record *rec;
3602 struct inode_backref *backref;
3603 int ret = 0;
3604
3605 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
3606 free_inode_recs_tree(src_cache);
3607 return 0;
3608 }
3609
3610 while (1) {
3611 cache = search_cache_extent(src_cache, 0);
3612 if (!cache)
3613 break;
3614 node = container_of(cache, struct ptr_node, cache);
3615 rec = node->data;
3616 remove_cache_extent(src_cache, &node->cache);
3617 free(node);
3618
3619 ret = is_child_root(root, root->objectid, rec->ino);
3620 if (ret < 0)
3621 break;
3622 else if (ret == 0)
3623 goto skip;
3624
3625 list_for_each_entry(backref, &rec->backrefs, list) {
3626 BUG_ON(backref->found_inode_ref);
3627 if (backref->found_dir_item)
3628 add_root_backref(dst_cache, rec->ino,
3629 root->root_key.objectid, backref->dir,
3630 backref->index, backref->name,
3631 backref->namelen, BTRFS_DIR_ITEM_KEY,
3632 backref->errors);
3633 if (backref->found_dir_index)
3634 add_root_backref(dst_cache, rec->ino,
3635 root->root_key.objectid, backref->dir,
3636 backref->index, backref->name,
3637 backref->namelen, BTRFS_DIR_INDEX_KEY,
3638 backref->errors);
3639 }
3640 skip:
3641 free_inode_rec(rec);
3642 }
3643 if (ret < 0)
3644 return ret;
3645 return 0;
3646 }
3647
3648 static int check_root_refs(struct btrfs_root *root,
3649 struct cache_tree *root_cache)
3650 {
3651 struct root_record *rec;
3652 struct root_record *ref_root;
3653 struct root_backref *backref;
3654 struct cache_extent *cache;
3655 int loop = 1;
3656 int ret;
3657 int error;
3658 int errors = 0;
3659
3660 rec = get_root_rec(root_cache, BTRFS_FS_TREE_OBJECTID);
3661 BUG_ON(IS_ERR(rec));
3662 rec->found_ref = 1;
3663
3664 /* fixme: this can not detect circular references */
3665 while (loop) {
3666 loop = 0;
3667 cache = search_cache_extent(root_cache, 0);
3668 while (1) {
3669 if (!cache)
3670 break;
3671 rec = container_of(cache, struct root_record, cache);
3672 cache = next_cache_extent(cache);
3673
3674 if (rec->found_ref == 0)
3675 continue;
3676
3677 list_for_each_entry(backref, &rec->backrefs, list) {
3678 if (!backref->reachable)
3679 continue;
3680
3681 ref_root = get_root_rec(root_cache,
3682 backref->ref_root);
3683 BUG_ON(IS_ERR(ref_root));
3684 if (ref_root->found_ref > 0)
3685 continue;
3686
3687 backref->reachable = 0;
3688 rec->found_ref--;
3689 if (rec->found_ref == 0)
3690 loop = 1;
3691 }
3692 }
3693 }
3694
3695 cache = search_cache_extent(root_cache, 0);
3696 while (1) {
3697 if (!cache)
3698 break;
3699 rec = container_of(cache, struct root_record, cache);
3700 cache = next_cache_extent(cache);
3701
3702 if (rec->found_ref == 0 &&
3703 rec->objectid >= BTRFS_FIRST_FREE_OBJECTID &&
3704 rec->objectid <= BTRFS_LAST_FREE_OBJECTID) {
3705 ret = check_orphan_item(root->fs_info->tree_root,
3706 rec->objectid);
3707 if (ret == 0)
3708 continue;
3709
3710 /*
3711 * If we don't have a root item then we likely just have
3712 * a dir item in a snapshot for this root but no actual
3713 * ref key or anything so it's meaningless.
3714 */
3715 if (!rec->found_root_item)
3716 continue;
3717 errors++;
3718 fprintf(stderr, "fs tree %llu not referenced\n",
3719 (unsigned long long)rec->objectid);
3720 }
3721
3722 error = 0;
3723 if (rec->found_ref > 0 && !rec->found_root_item)
3724 error = 1;
3725 list_for_each_entry(backref, &rec->backrefs, list) {
3726 if (!backref->found_dir_item)
3727 backref->errors |= REF_ERR_NO_DIR_ITEM;
3728 if (!backref->found_dir_index)
3729 backref->errors |= REF_ERR_NO_DIR_INDEX;
3730 if (!backref->found_back_ref)
3731 backref->errors |= REF_ERR_NO_ROOT_BACKREF;
3732 if (!backref->found_forward_ref)
3733 backref->errors |= REF_ERR_NO_ROOT_REF;
3734 if (backref->reachable && backref->errors)
3735 error = 1;
3736 }
3737 if (!error)
3738 continue;
3739
3740 errors++;
3741 fprintf(stderr, "fs tree %llu refs %u %s\n",
3742 (unsigned long long)rec->objectid, rec->found_ref,
3743 rec->found_root_item ? "" : "not found");
3744
3745 list_for_each_entry(backref, &rec->backrefs, list) {
3746 if (!backref->reachable)
3747 continue;
3748 if (!backref->errors && rec->found_root_item)
3749 continue;
3750 fprintf(stderr, "\tunresolved ref root %llu dir %llu"
3751 " index %llu namelen %u name %s errors %x\n",
3752 (unsigned long long)backref->ref_root,
3753 (unsigned long long)backref->dir,
3754 (unsigned long long)backref->index,
3755 backref->namelen, backref->name,
3756 backref->errors);
3757 print_ref_error(backref->errors);
3758 }
3759 }
3760 return errors > 0 ? 1 : 0;
3761 }
3762
3763 static int process_root_ref(struct extent_buffer *eb, int slot,
3764 struct btrfs_key *key,
3765 struct cache_tree *root_cache)
3766 {
3767 u64 dirid;
3768 u64 index;
3769 u32 len;
3770 u32 name_len;
3771 struct btrfs_root_ref *ref;
3772 char namebuf[BTRFS_NAME_LEN];
3773 int error;
3774
3775 ref = btrfs_item_ptr(eb, slot, struct btrfs_root_ref);
3776
3777 dirid = btrfs_root_ref_dirid(eb, ref);
3778 index = btrfs_root_ref_sequence(eb, ref);
3779 name_len = btrfs_root_ref_name_len(eb, ref);
3780
3781 if (name_len <= BTRFS_NAME_LEN) {
3782 len = name_len;
3783 error = 0;
3784 } else {
3785 len = BTRFS_NAME_LEN;
3786 error = REF_ERR_NAME_TOO_LONG;
3787 }
3788 read_extent_buffer(eb, namebuf, (unsigned long)(ref + 1), len);
3789
3790 if (key->type == BTRFS_ROOT_REF_KEY) {
3791 add_root_backref(root_cache, key->offset, key->objectid, dirid,
3792 index, namebuf, len, key->type, error);
3793 } else {
3794 add_root_backref(root_cache, key->objectid, key->offset, dirid,
3795 index, namebuf, len, key->type, error);
3796 }
3797 return 0;
3798 }
3799
3800 static void free_corrupt_block(struct cache_extent *cache)
3801 {
3802 struct btrfs_corrupt_block *corrupt;
3803
3804 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
3805 free(corrupt);
3806 }
3807
3808 FREE_EXTENT_CACHE_BASED_TREE(corrupt_blocks, free_corrupt_block);
3809
3810 /*
3811 * Repair the btree of the given root.
3812 *
3813 * The fix is to remove the node key in corrupt_blocks cache_tree.
3814 * and rebalance the tree.
3815 * After the fix, the btree should be writeable.
3816 */
3817 static int repair_btree(struct btrfs_root *root,
3818 struct cache_tree *corrupt_blocks)
3819 {
3820 struct btrfs_trans_handle *trans;
3821 struct btrfs_path path;
3822 struct btrfs_corrupt_block *corrupt;
3823 struct cache_extent *cache;
3824 struct btrfs_key key;
3825 u64 offset;
3826 int level;
3827 int ret = 0;
3828
3829 if (cache_tree_empty(corrupt_blocks))
3830 return 0;
3831
3832 trans = btrfs_start_transaction(root, 1);
3833 if (IS_ERR(trans)) {
3834 ret = PTR_ERR(trans);
3835 fprintf(stderr, "Error starting transaction: %s\n",
3836 strerror(-ret));
3837 return ret;
3838 }
3839 btrfs_init_path(&path);
3840 cache = first_cache_extent(corrupt_blocks);
3841 while (cache) {
3842 corrupt = container_of(cache, struct btrfs_corrupt_block,
3843 cache);
3844 level = corrupt->level;
3845 path.lowest_level = level;
3846 key.objectid = corrupt->key.objectid;
3847 key.type = corrupt->key.type;
3848 key.offset = corrupt->key.offset;
3849
3850 /*
3851 * Here we don't want to do any tree balance, since it may
3852 * cause a balance with corrupted brother leaf/node,
3853 * so ins_len set to 0 here.
3854 * Balance will be done after all corrupt node/leaf is deleted.
3855 */
3856 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
3857 if (ret < 0)
3858 goto out;
3859 offset = btrfs_node_blockptr(path.nodes[level],
3860 path.slots[level]);
3861
3862 /* Remove the ptr */
3863 ret = btrfs_del_ptr(root, &path, level, path.slots[level]);
3864 if (ret < 0)
3865 goto out;
3866 /*
3867 * Remove the corresponding extent
3868 * return value is not concerned.
3869 */
3870 btrfs_release_path(&path);
3871 ret = btrfs_free_extent(trans, root, offset,
3872 root->fs_info->nodesize, 0,
3873 root->root_key.objectid, level - 1, 0);
3874 cache = next_cache_extent(cache);
3875 }
3876
3877 /* Balance the btree using btrfs_search_slot() */
3878 cache = first_cache_extent(corrupt_blocks);
3879 while (cache) {
3880 corrupt = container_of(cache, struct btrfs_corrupt_block,
3881 cache);
3882 memcpy(&key, &corrupt->key, sizeof(key));
3883 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
3884 if (ret < 0)
3885 goto out;
3886 /* return will always >0 since it won't find the item */
3887 ret = 0;
3888 btrfs_release_path(&path);
3889 cache = next_cache_extent(cache);
3890 }
3891 out:
3892 btrfs_commit_transaction(trans, root);
3893 btrfs_release_path(&path);
3894 return ret;
3895 }
3896
3897 static int check_fs_root(struct btrfs_root *root,
3898 struct cache_tree *root_cache,
3899 struct walk_control *wc)
3900 {
3901 int ret = 0;
3902 int err = 0;
3903 int wret;
3904 int level;
3905 struct btrfs_path path;
3906 struct shared_node root_node;
3907 struct root_record *rec;
3908 struct btrfs_root_item *root_item = &root->root_item;
3909 struct cache_tree corrupt_blocks;
3910 struct orphan_data_extent *orphan;
3911 struct orphan_data_extent *tmp;
3912 enum btrfs_tree_block_status status;
3913 struct node_refs nrefs;
3914
3915 /*
3916 * Reuse the corrupt_block cache tree to record corrupted tree block
3917 *
3918 * Unlike the usage in extent tree check, here we do it in a per
3919 * fs/subvol tree base.
3920 */
3921 cache_tree_init(&corrupt_blocks);
3922 root->fs_info->corrupt_blocks = &corrupt_blocks;
3923
3924 if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
3925 rec = get_root_rec(root_cache, root->root_key.objectid);
3926 BUG_ON(IS_ERR(rec));
3927 if (btrfs_root_refs(root_item) > 0)
3928 rec->found_root_item = 1;
3929 }
3930
3931 btrfs_init_path(&path);
3932 memset(&root_node, 0, sizeof(root_node));
3933 cache_tree_init(&root_node.root_cache);
3934 cache_tree_init(&root_node.inode_cache);
3935 memset(&nrefs, 0, sizeof(nrefs));
3936
3937 /* Move the orphan extent record to corresponding inode_record */
3938 list_for_each_entry_safe(orphan, tmp,
3939 &root->orphan_data_extents, list) {
3940 struct inode_record *inode;
3941
3942 inode = get_inode_rec(&root_node.inode_cache, orphan->objectid,
3943 1);
3944 BUG_ON(IS_ERR(inode));
3945 inode->errors |= I_ERR_FILE_EXTENT_ORPHAN;
3946 list_move(&orphan->list, &inode->orphan_extents);
3947 }
3948
3949 level = btrfs_header_level(root->node);
3950 memset(wc->nodes, 0, sizeof(wc->nodes));
3951 wc->nodes[level] = &root_node;
3952 wc->active_node = level;
3953 wc->root_level = level;
3954
3955 /* We may not have checked the root block, lets do that now */
3956 if (btrfs_is_leaf(root->node))
3957 status = btrfs_check_leaf(root, NULL, root->node);
3958 else
3959 status = btrfs_check_node(root, NULL, root->node);
3960 if (status != BTRFS_TREE_BLOCK_CLEAN)
3961 return -EIO;
3962
3963 if (btrfs_root_refs(root_item) > 0 ||
3964 btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
3965 path.nodes[level] = root->node;
3966 extent_buffer_get(root->node);
3967 path.slots[level] = 0;
3968 } else {
3969 struct btrfs_key key;
3970 struct btrfs_disk_key found_key;
3971
3972 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
3973 level = root_item->drop_level;
3974 path.lowest_level = level;
3975 if (level > btrfs_header_level(root->node) ||
3976 level >= BTRFS_MAX_LEVEL) {
3977 error("ignoring invalid drop level: %u", level);
3978 goto skip_walking;
3979 }
3980 wret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
3981 if (wret < 0)
3982 goto skip_walking;
3983 btrfs_node_key(path.nodes[level], &found_key,
3984 path.slots[level]);
3985 WARN_ON(memcmp(&found_key, &root_item->drop_progress,
3986 sizeof(found_key)));
3987 }
3988
3989 while (1) {
3990 wret = walk_down_tree(root, &path, wc, &level, &nrefs);
3991 if (wret < 0)
3992 ret = wret;
3993 if (wret != 0)
3994 break;
3995
3996 wret = walk_up_tree(root, &path, wc, &level);
3997 if (wret < 0)
3998 ret = wret;
3999 if (wret != 0)
4000 break;
4001 }
4002 skip_walking:
4003 btrfs_release_path(&path);
4004
4005 if (!cache_tree_empty(&corrupt_blocks)) {
4006 struct cache_extent *cache;
4007 struct btrfs_corrupt_block *corrupt;
4008
4009 printf("The following tree block(s) is corrupted in tree %llu:\n",
4010 root->root_key.objectid);
4011 cache = first_cache_extent(&corrupt_blocks);
4012 while (cache) {
4013 corrupt = container_of(cache,
4014 struct btrfs_corrupt_block,
4015 cache);
4016 printf("\ttree block bytenr: %llu, level: %d, node key: (%llu, %u, %llu)\n",
4017 cache->start, corrupt->level,
4018 corrupt->key.objectid, corrupt->key.type,
4019 corrupt->key.offset);
4020 cache = next_cache_extent(cache);
4021 }
4022 if (repair) {
4023 printf("Try to repair the btree for root %llu\n",
4024 root->root_key.objectid);
4025 ret = repair_btree(root, &corrupt_blocks);
4026 if (ret < 0)
4027 fprintf(stderr, "Failed to repair btree: %s\n",
4028 strerror(-ret));
4029 if (!ret)
4030 printf("Btree for root %llu is fixed\n",
4031 root->root_key.objectid);
4032 }
4033 }
4034
4035 err = merge_root_recs(root, &root_node.root_cache, root_cache);
4036 if (err < 0)
4037 ret = err;
4038
4039 if (root_node.current) {
4040 root_node.current->checked = 1;
4041 maybe_free_inode_rec(&root_node.inode_cache,
4042 root_node.current);
4043 }
4044
4045 err = check_inode_recs(root, &root_node.inode_cache);
4046 if (!ret)
4047 ret = err;
4048
4049 free_corrupt_blocks_tree(&corrupt_blocks);
4050 root->fs_info->corrupt_blocks = NULL;
4051 free_orphan_data_extents(&root->orphan_data_extents);
4052 return ret;
4053 }
4054
4055 static int fs_root_objectid(u64 objectid)
4056 {
4057 if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
4058 objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
4059 return 1;
4060 return is_fstree(objectid);
4061 }
4062
4063 static int check_fs_roots(struct btrfs_root *root,
4064 struct cache_tree *root_cache)
4065 {
4066 struct btrfs_path path;
4067 struct btrfs_key key;
4068 struct walk_control wc;
4069 struct extent_buffer *leaf, *tree_node;
4070 struct btrfs_root *tmp_root;
4071 struct btrfs_root *tree_root = root->fs_info->tree_root;
4072 int ret;
4073 int err = 0;
4074
4075 if (ctx.progress_enabled) {
4076 ctx.tp = TASK_FS_ROOTS;
4077 task_start(ctx.info);
4078 }
4079
4080 /*
4081 * Just in case we made any changes to the extent tree that weren't
4082 * reflected into the free space cache yet.
4083 */
4084 if (repair)
4085 reset_cached_block_groups(root->fs_info);
4086 memset(&wc, 0, sizeof(wc));
4087 cache_tree_init(&wc.shared);
4088 btrfs_init_path(&path);
4089
4090 again:
4091 key.offset = 0;
4092 key.objectid = 0;
4093 key.type = BTRFS_ROOT_ITEM_KEY;
4094 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
4095 if (ret < 0) {
4096 err = 1;
4097 goto out;
4098 }
4099 tree_node = tree_root->node;
4100 while (1) {
4101 if (tree_node != tree_root->node) {
4102 free_root_recs_tree(root_cache);
4103 btrfs_release_path(&path);
4104 goto again;
4105 }
4106 leaf = path.nodes[0];
4107 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
4108 ret = btrfs_next_leaf(tree_root, &path);
4109 if (ret) {
4110 if (ret < 0)
4111 err = 1;
4112 break;
4113 }
4114 leaf = path.nodes[0];
4115 }
4116 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
4117 if (key.type == BTRFS_ROOT_ITEM_KEY &&
4118 fs_root_objectid(key.objectid)) {
4119 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
4120 tmp_root = btrfs_read_fs_root_no_cache(
4121 root->fs_info, &key);
4122 } else {
4123 key.offset = (u64)-1;
4124 tmp_root = btrfs_read_fs_root(
4125 root->fs_info, &key);
4126 }
4127 if (IS_ERR(tmp_root)) {
4128 err = 1;
4129 goto next;
4130 }
4131 ret = check_fs_root(tmp_root, root_cache, &wc);
4132 if (ret == -EAGAIN) {
4133 free_root_recs_tree(root_cache);
4134 btrfs_release_path(&path);
4135 goto again;
4136 }
4137 if (ret)
4138 err = 1;
4139 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
4140 btrfs_free_fs_root(tmp_root);
4141 } else if (key.type == BTRFS_ROOT_REF_KEY ||
4142 key.type == BTRFS_ROOT_BACKREF_KEY) {
4143 process_root_ref(leaf, path.slots[0], &key,
4144 root_cache);
4145 }
4146 next:
4147 path.slots[0]++;
4148 }
4149 out:
4150 btrfs_release_path(&path);
4151 if (err)
4152 free_extent_cache_tree(&wc.shared);
4153 if (!cache_tree_empty(&wc.shared))
4154 fprintf(stderr, "warning line %d\n", __LINE__);
4155
4156 task_stop(ctx.info);
4157
4158 return err;
4159 }
4160
4161 /*
4162 * Find DIR_ITEM/DIR_INDEX for the given key and check it with the specified
4163 * INODE_REF/INODE_EXTREF match.
4164 *
4165 * @root: the root of the fs/file tree
4166 * @ref_key: the key of the INODE_REF/INODE_EXTREF
4167 * @key: the key of the DIR_ITEM/DIR_INDEX
4168 * @index: the index in the INODE_REF/INODE_EXTREF, be used to
4169 * distinguish root_dir between normal dir/file
4170 * @name: the name in the INODE_REF/INODE_EXTREF
4171 * @namelen: the length of name in the INODE_REF/INODE_EXTREF
4172 * @mode: the st_mode of INODE_ITEM
4173 *
4174 * Return 0 if no error occurred.
4175 * Return ROOT_DIR_ERROR if found DIR_ITEM/DIR_INDEX for root_dir.
4176 * Return DIR_ITEM_MISSING if couldn't find DIR_ITEM/DIR_INDEX for normal
4177 * dir/file.
4178 * Return DIR_ITEM_MISMATCH if INODE_REF/INODE_EXTREF and DIR_ITEM/DIR_INDEX
4179 * not match for normal dir/file.
4180 */
4181 static int find_dir_item(struct btrfs_root *root, struct btrfs_key *ref_key,
4182 struct btrfs_key *key, u64 index, char *name,
4183 u32 namelen, u32 mode)
4184 {
4185 struct btrfs_path path;
4186 struct extent_buffer *node;
4187 struct btrfs_dir_item *di;
4188 struct btrfs_key location;
4189 char namebuf[BTRFS_NAME_LEN] = {0};
4190 u32 total;
4191 u32 cur = 0;
4192 u32 len;
4193 u32 name_len;
4194 u32 data_len;
4195 u8 filetype;
4196 int slot;
4197 int ret;
4198
4199 btrfs_init_path(&path);
4200 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4201 if (ret < 0) {
4202 ret = DIR_ITEM_MISSING;
4203 goto out;
4204 }
4205
4206 /* Process root dir and goto out*/
4207 if (index == 0) {
4208 if (ret == 0) {
4209 ret = ROOT_DIR_ERROR;
4210 error(
4211 "root %llu INODE %s[%llu %llu] ROOT_DIR shouldn't have %s",
4212 root->objectid,
4213 ref_key->type == BTRFS_INODE_REF_KEY ?
4214 "REF" : "EXTREF",
4215 ref_key->objectid, ref_key->offset,
4216 key->type == BTRFS_DIR_ITEM_KEY ?
4217 "DIR_ITEM" : "DIR_INDEX");
4218 } else {
4219 ret = 0;
4220 }
4221
4222 goto out;
4223 }
4224
4225 /* Process normal file/dir */
4226 if (ret > 0) {
4227 ret = DIR_ITEM_MISSING;
4228 error(
4229 "root %llu INODE %s[%llu %llu] doesn't have related %s[%llu %llu] namelen %u filename %s filetype %d",
4230 root->objectid,
4231 ref_key->type == BTRFS_INODE_REF_KEY ? "REF" : "EXTREF",
4232 ref_key->objectid, ref_key->offset,
4233 key->type == BTRFS_DIR_ITEM_KEY ?
4234 "DIR_ITEM" : "DIR_INDEX",
4235 key->objectid, key->offset, namelen, name,
4236 imode_to_type(mode));
4237 goto out;
4238 }
4239
4240 /* Check whether inode_id/filetype/name match */
4241 node = path.nodes[0];
4242 slot = path.slots[0];
4243 di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
4244 total = btrfs_item_size_nr(node, slot);
4245 while (cur < total) {
4246 ret = DIR_ITEM_MISMATCH;
4247 name_len = btrfs_dir_name_len(node, di);
4248 data_len = btrfs_dir_data_len(node, di);
4249
4250 btrfs_dir_item_key_to_cpu(node, di, &location);
4251 if (location.objectid != ref_key->objectid ||
4252 location.type != BTRFS_INODE_ITEM_KEY ||
4253 location.offset != 0)
4254 goto next;
4255
4256 filetype = btrfs_dir_type(node, di);
4257 if (imode_to_type(mode) != filetype)
4258 goto next;
4259
4260 if (cur + sizeof(*di) + name_len > total ||
4261 name_len > BTRFS_NAME_LEN) {
4262 warning("root %llu %s[%llu %llu] name too long %u, trimmed",
4263 root->objectid,
4264 key->type == BTRFS_DIR_ITEM_KEY ?
4265 "DIR_ITEM" : "DIR_INDEX",
4266 key->objectid, key->offset, name_len);
4267
4268 if (cur + sizeof(*di) > total)
4269 break;
4270 len = min_t(u32, total - cur - sizeof(*di),
4271 BTRFS_NAME_LEN);
4272 } else {
4273 len = name_len;
4274 }
4275
4276 read_extent_buffer(node, namebuf, (unsigned long)(di + 1), len);
4277 if (len != namelen || strncmp(namebuf, name, len))
4278 goto next;
4279
4280 ret = 0;
4281 goto out;
4282 next:
4283 len = sizeof(*di) + name_len + data_len;
4284 di = (struct btrfs_dir_item *)((char *)di + len);
4285 cur += len;
4286 }
4287 if (ret == DIR_ITEM_MISMATCH)
4288 error(
4289 "root %llu INODE %s[%llu %llu] and %s[%llu %llu] mismatch namelen %u filename %s filetype %d",
4290 root->objectid,
4291 ref_key->type == BTRFS_INODE_REF_KEY ? "REF" : "EXTREF",
4292 ref_key->objectid, ref_key->offset,
4293 key->type == BTRFS_DIR_ITEM_KEY ?
4294 "DIR_ITEM" : "DIR_INDEX",
4295 key->objectid, key->offset, namelen, name,
4296 imode_to_type(mode));
4297 out:
4298 btrfs_release_path(&path);
4299 return ret;
4300 }
4301
4302 /*
4303 * Traverse the given INODE_REF and call find_dir_item() to find related
4304 * DIR_ITEM/DIR_INDEX.
4305 *
4306 * @root: the root of the fs/file tree
4307 * @ref_key: the key of the INODE_REF
4308 * @refs: the count of INODE_REF
4309 * @mode: the st_mode of INODE_ITEM
4310 *
4311 * Return 0 if no error occurred.
4312 */
4313 static int check_inode_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
4314 struct extent_buffer *node, int slot, u64 *refs,
4315 int mode)
4316 {
4317 struct btrfs_key key;
4318 struct btrfs_inode_ref *ref;
4319 char namebuf[BTRFS_NAME_LEN] = {0};
4320 u32 total;
4321 u32 cur = 0;
4322 u32 len;
4323 u32 name_len;
4324 u64 index;
4325 int ret, err = 0;
4326
4327 ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
4328 total = btrfs_item_size_nr(node, slot);
4329
4330 next:
4331 /* Update inode ref count */
4332 (*refs)++;
4333
4334 index = btrfs_inode_ref_index(node, ref);
4335 name_len = btrfs_inode_ref_name_len(node, ref);
4336 if (cur + sizeof(*ref) + name_len > total ||
4337 name_len > BTRFS_NAME_LEN) {
4338 warning("root %llu INODE_REF[%llu %llu] name too long",
4339 root->objectid, ref_key->objectid, ref_key->offset);
4340
4341 if (total < cur + sizeof(*ref))
4342 goto out;
4343 len = min_t(u32, total - cur - sizeof(*ref), BTRFS_NAME_LEN);
4344 } else {
4345 len = name_len;
4346 }
4347
4348 read_extent_buffer(node, namebuf, (unsigned long)(ref + 1), len);
4349
4350 /* Check root dir ref name */
4351 if (index == 0 && strncmp(namebuf, "..", name_len)) {
4352 error("root %llu INODE_REF[%llu %llu] ROOT_DIR name shouldn't be %s",
4353 root->objectid, ref_key->objectid, ref_key->offset,
4354 namebuf);
4355 err |= ROOT_DIR_ERROR;
4356 }
4357
4358 /* Find related DIR_INDEX */
4359 key.objectid = ref_key->offset;
4360 key.type = BTRFS_DIR_INDEX_KEY;
4361 key.offset = index;
4362 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4363 err |= ret;
4364
4365 /* Find related dir_item */
4366 key.objectid = ref_key->offset;
4367 key.type = BTRFS_DIR_ITEM_KEY;
4368 key.offset = btrfs_name_hash(namebuf, len);
4369 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4370 err |= ret;
4371
4372 len = sizeof(*ref) + name_len;
4373 ref = (struct btrfs_inode_ref *)((char *)ref + len);
4374 cur += len;
4375 if (cur < total)
4376 goto next;
4377
4378 out:
4379 return err;
4380 }
4381
4382 /*
4383 * Traverse the given INODE_EXTREF and call find_dir_item() to find related
4384 * DIR_ITEM/DIR_INDEX.
4385 *
4386 * @root: the root of the fs/file tree
4387 * @ref_key: the key of the INODE_EXTREF
4388 * @refs: the count of INODE_EXTREF
4389 * @mode: the st_mode of INODE_ITEM
4390 *
4391 * Return 0 if no error occurred.
4392 */
4393 static int check_inode_extref(struct btrfs_root *root,
4394 struct btrfs_key *ref_key,
4395 struct extent_buffer *node, int slot, u64 *refs,
4396 int mode)
4397 {
4398 struct btrfs_key key;
4399 struct btrfs_inode_extref *extref;
4400 char namebuf[BTRFS_NAME_LEN] = {0};
4401 u32 total;
4402 u32 cur = 0;
4403 u32 len;
4404 u32 name_len;
4405 u64 index;
4406 u64 parent;
4407 int ret;
4408 int err = 0;
4409
4410 extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
4411 total = btrfs_item_size_nr(node, slot);
4412
4413 next:
4414 /* update inode ref count */
4415 (*refs)++;
4416 name_len = btrfs_inode_extref_name_len(node, extref);
4417 index = btrfs_inode_extref_index(node, extref);
4418 parent = btrfs_inode_extref_parent(node, extref);
4419 if (name_len <= BTRFS_NAME_LEN) {
4420 len = name_len;
4421 } else {
4422 len = BTRFS_NAME_LEN;
4423 warning("root %llu INODE_EXTREF[%llu %llu] name too long",
4424 root->objectid, ref_key->objectid, ref_key->offset);
4425 }
4426 read_extent_buffer(node, namebuf, (unsigned long)(extref + 1), len);
4427
4428 /* Check root dir ref name */
4429 if (index == 0 && strncmp(namebuf, "..", name_len)) {
4430 error("root %llu INODE_EXTREF[%llu %llu] ROOT_DIR name shouldn't be %s",
4431 root->objectid, ref_key->objectid, ref_key->offset,
4432 namebuf);
4433 err |= ROOT_DIR_ERROR;
4434 }
4435
4436 /* find related dir_index */
4437 key.objectid = parent;
4438 key.type = BTRFS_DIR_INDEX_KEY;
4439 key.offset = index;
4440 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4441 err |= ret;
4442
4443 /* find related dir_item */
4444 key.objectid = parent;
4445 key.type = BTRFS_DIR_ITEM_KEY;
4446 key.offset = btrfs_name_hash(namebuf, len);
4447 ret = find_dir_item(root, ref_key, &key, index, namebuf, len, mode);
4448 err |= ret;
4449
4450 len = sizeof(*extref) + name_len;
4451 extref = (struct btrfs_inode_extref *)((char *)extref + len);
4452 cur += len;
4453
4454 if (cur < total)
4455 goto next;
4456
4457 return err;
4458 }
4459
4460 /*
4461 * Find INODE_REF/INODE_EXTREF for the given key and check it with the specified
4462 * DIR_ITEM/DIR_INDEX match.
4463 *
4464 * @root: the root of the fs/file tree
4465 * @key: the key of the INODE_REF/INODE_EXTREF
4466 * @name: the name in the INODE_REF/INODE_EXTREF
4467 * @namelen: the length of name in the INODE_REF/INODE_EXTREF
4468 * @index: the index in the INODE_REF/INODE_EXTREF, for DIR_ITEM set index
4469 * to (u64)-1
4470 * @ext_ref: the EXTENDED_IREF feature
4471 *
4472 * Return 0 if no error occurred.
4473 * Return >0 for error bitmap
4474 */
4475 static int find_inode_ref(struct btrfs_root *root, struct btrfs_key *key,
4476 char *name, int namelen, u64 index,
4477 unsigned int ext_ref)
4478 {
4479 struct btrfs_path path;
4480 struct btrfs_inode_ref *ref;
4481 struct btrfs_inode_extref *extref;
4482 struct extent_buffer *node;
4483 char ref_namebuf[BTRFS_NAME_LEN] = {0};
4484 u32 total;
4485 u32 cur = 0;
4486 u32 len;
4487 u32 ref_namelen;
4488 u64 ref_index;
4489 u64 parent;
4490 u64 dir_id;
4491 int slot;
4492 int ret;
4493
4494 btrfs_init_path(&path);
4495 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4496 if (ret) {
4497 ret = INODE_REF_MISSING;
4498 goto extref;
4499 }
4500
4501 node = path.nodes[0];
4502 slot = path.slots[0];
4503
4504 ref = btrfs_item_ptr(node, slot, struct btrfs_inode_ref);
4505 total = btrfs_item_size_nr(node, slot);
4506
4507 /* Iterate all entry of INODE_REF */
4508 while (cur < total) {
4509 ret = INODE_REF_MISSING;
4510
4511 ref_namelen = btrfs_inode_ref_name_len(node, ref);
4512 ref_index = btrfs_inode_ref_index(node, ref);
4513 if (index != (u64)-1 && index != ref_index)
4514 goto next_ref;
4515
4516 if (cur + sizeof(*ref) + ref_namelen > total ||
4517 ref_namelen > BTRFS_NAME_LEN) {
4518 warning("root %llu INODE %s[%llu %llu] name too long",
4519 root->objectid,
4520 key->type == BTRFS_INODE_REF_KEY ?
4521 "REF" : "EXTREF",
4522 key->objectid, key->offset);
4523
4524 if (cur + sizeof(*ref) > total)
4525 break;
4526 len = min_t(u32, total - cur - sizeof(*ref),
4527 BTRFS_NAME_LEN);
4528 } else {
4529 len = ref_namelen;
4530 }
4531
4532 read_extent_buffer(node, ref_namebuf, (unsigned long)(ref + 1),
4533 len);
4534
4535 if (len != namelen || strncmp(ref_namebuf, name, len))
4536 goto next_ref;
4537
4538 ret = 0;
4539 goto out;
4540 next_ref:
4541 len = sizeof(*ref) + ref_namelen;
4542 ref = (struct btrfs_inode_ref *)((char *)ref + len);
4543 cur += len;
4544 }
4545
4546 extref:
4547 /* Skip if not support EXTENDED_IREF feature */
4548 if (!ext_ref)
4549 goto out;
4550
4551 btrfs_release_path(&path);
4552 btrfs_init_path(&path);
4553
4554 dir_id = key->offset;
4555 key->type = BTRFS_INODE_EXTREF_KEY;
4556 key->offset = btrfs_extref_hash(dir_id, name, namelen);
4557
4558 ret = btrfs_search_slot(NULL, root, key, &path, 0, 0);
4559 if (ret) {
4560 ret = INODE_REF_MISSING;
4561 goto out;
4562 }
4563
4564 node = path.nodes[0];
4565 slot = path.slots[0];
4566
4567 extref = btrfs_item_ptr(node, slot, struct btrfs_inode_extref);
4568 cur = 0;
4569 total = btrfs_item_size_nr(node, slot);
4570
4571 /* Iterate all entry of INODE_EXTREF */
4572 while (cur < total) {
4573 ret = INODE_REF_MISSING;
4574
4575 ref_namelen = btrfs_inode_extref_name_len(node, extref);
4576 ref_index = btrfs_inode_extref_index(node, extref);
4577 parent = btrfs_inode_extref_parent(node, extref);
4578 if (index != (u64)-1 && index != ref_index)
4579 goto next_extref;
4580
4581 if (parent != dir_id)
4582 goto next_extref;
4583
4584 if (ref_namelen <= BTRFS_NAME_LEN) {
4585 len = ref_namelen;
4586 } else {
4587 len = BTRFS_NAME_LEN;
4588 warning("root %llu INODE %s[%llu %llu] name too long",
4589 root->objectid,
4590 key->type == BTRFS_INODE_REF_KEY ?
4591 "REF" : "EXTREF",
4592 key->objectid, key->offset);
4593 }
4594 read_extent_buffer(node, ref_namebuf,
4595 (unsigned long)(extref + 1), len);
4596
4597 if (len != namelen || strncmp(ref_namebuf, name, len))
4598 goto next_extref;
4599
4600 ret = 0;
4601 goto out;
4602
4603 next_extref:
4604 len = sizeof(*extref) + ref_namelen;
4605 extref = (struct btrfs_inode_extref *)((char *)extref + len);
4606 cur += len;
4607
4608 }
4609 out:
4610 btrfs_release_path(&path);
4611 return ret;
4612 }
4613
4614 /*
4615 * Traverse the given DIR_ITEM/DIR_INDEX and check related INODE_ITEM and
4616 * call find_inode_ref() to check related INODE_REF/INODE_EXTREF.
4617 *
4618 * @root: the root of the fs/file tree
4619 * @key: the key of the INODE_REF/INODE_EXTREF
4620 * @size: the st_size of the INODE_ITEM
4621 * @ext_ref: the EXTENDED_IREF feature
4622 *
4623 * Return 0 if no error occurred.
4624 */
4625 static int check_dir_item(struct btrfs_root *root, struct btrfs_key *key,
4626 struct extent_buffer *node, int slot, u64 *size,
4627 unsigned int ext_ref)
4628 {
4629 struct btrfs_dir_item *di;
4630 struct btrfs_inode_item *ii;
4631 struct btrfs_path path;
4632 struct btrfs_key location;
4633 char namebuf[BTRFS_NAME_LEN] = {0};
4634 u32 total;
4635 u32 cur = 0;
4636 u32 len;
4637 u32 name_len;
4638 u32 data_len;
4639 u8 filetype;
4640 u32 mode;
4641 u64 index;
4642 int ret;
4643 int err = 0;
4644
4645 /*
4646 * For DIR_ITEM set index to (u64)-1, so that find_inode_ref
4647 * ignore index check.
4648 */
4649 index = (key->type == BTRFS_DIR_INDEX_KEY) ? key->offset : (u64)-1;
4650
4651 di = btrfs_item_ptr(node, slot, struct btrfs_dir_item);
4652 total = btrfs_item_size_nr(node, slot);
4653
4654 while (cur < total) {
4655 data_len = btrfs_dir_data_len(node, di);
4656 if (data_len)
4657 error("root %llu %s[%llu %llu] data_len shouldn't be %u",
4658 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4659 "DIR_ITEM" : "DIR_INDEX",
4660 key->objectid, key->offset, data_len);
4661
4662 name_len = btrfs_dir_name_len(node, di);
4663 if (cur + sizeof(*di) + name_len > total ||
4664 name_len > BTRFS_NAME_LEN) {
4665 warning("root %llu %s[%llu %llu] name too long",
4666 root->objectid,
4667 key->type == BTRFS_DIR_ITEM_KEY ?
4668 "DIR_ITEM" : "DIR_INDEX",
4669 key->objectid, key->offset);
4670
4671 if (cur + sizeof(*di) > total)
4672 break;
4673 len = min_t(u32, total - cur - sizeof(*di),
4674 BTRFS_NAME_LEN);
4675 } else {
4676 len = name_len;
4677 }
4678 (*size) += name_len;
4679
4680 read_extent_buffer(node, namebuf, (unsigned long)(di + 1), len);
4681 filetype = btrfs_dir_type(node, di);
4682
4683 if (key->type == BTRFS_DIR_ITEM_KEY &&
4684 key->offset != btrfs_name_hash(namebuf, len)) {
4685 err |= -EIO;
4686 error("root %llu DIR_ITEM[%llu %llu] name %s namelen %u filetype %u mismatch with its hash, wanted %llu have %llu",
4687 root->objectid, key->objectid, key->offset,
4688 namebuf, len, filetype, key->offset,
4689 btrfs_name_hash(namebuf, len));
4690 }
4691
4692 btrfs_init_path(&path);
4693 btrfs_dir_item_key_to_cpu(node, di, &location);
4694
4695 /* Ignore related ROOT_ITEM check */
4696 if (location.type == BTRFS_ROOT_ITEM_KEY)
4697 goto next;
4698
4699 /* Check relative INODE_ITEM(existence/filetype) */
4700 ret = btrfs_search_slot(NULL, root, &location, &path, 0, 0);
4701 if (ret) {
4702 err |= INODE_ITEM_MISSING;
4703 error("root %llu %s[%llu %llu] couldn't find relative INODE_ITEM[%llu] namelen %u filename %s filetype %x",
4704 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4705 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4706 key->offset, location.objectid, name_len,
4707 namebuf, filetype);
4708 goto next;
4709 }
4710
4711 ii = btrfs_item_ptr(path.nodes[0], path.slots[0],
4712 struct btrfs_inode_item);
4713 mode = btrfs_inode_mode(path.nodes[0], ii);
4714
4715 if (imode_to_type(mode) != filetype) {
4716 err |= INODE_ITEM_MISMATCH;
4717 error("root %llu %s[%llu %llu] relative INODE_ITEM filetype mismatch namelen %u filename %s filetype %d",
4718 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4719 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4720 key->offset, name_len, namebuf, filetype);
4721 }
4722
4723 /* Check relative INODE_REF/INODE_EXTREF */
4724 location.type = BTRFS_INODE_REF_KEY;
4725 location.offset = key->objectid;
4726 ret = find_inode_ref(root, &location, namebuf, len,
4727 index, ext_ref);
4728 err |= ret;
4729 if (ret & INODE_REF_MISSING)
4730 error("root %llu %s[%llu %llu] relative INODE_REF missing namelen %u filename %s filetype %d",
4731 root->objectid, key->type == BTRFS_DIR_ITEM_KEY ?
4732 "DIR_ITEM" : "DIR_INDEX", key->objectid,
4733 key->offset, name_len, namebuf, filetype);
4734
4735 next:
4736 btrfs_release_path(&path);
4737 len = sizeof(*di) + name_len + data_len;
4738 di = (struct btrfs_dir_item *)((char *)di + len);
4739 cur += len;
4740
4741 if (key->type == BTRFS_DIR_INDEX_KEY && cur < total) {
4742 error("root %llu DIR_INDEX[%llu %llu] should contain only one entry",
4743 root->objectid, key->objectid, key->offset);
4744 break;
4745 }
4746 }
4747
4748 return err;
4749 }
4750
4751 /*
4752 * Check file extent datasum/hole, update the size of the file extents,
4753 * check and update the last offset of the file extent.
4754 *
4755 * @root: the root of fs/file tree.
4756 * @fkey: the key of the file extent.
4757 * @nodatasum: INODE_NODATASUM feature.
4758 * @size: the sum of all EXTENT_DATA items size for this inode.
4759 * @end: the offset of the last extent.
4760 *
4761 * Return 0 if no error occurred.
4762 */
4763 static int check_file_extent(struct btrfs_root *root, struct btrfs_key *fkey,
4764 struct extent_buffer *node, int slot,
4765 unsigned int nodatasum, u64 *size, u64 *end)
4766 {
4767 struct btrfs_file_extent_item *fi;
4768 u64 disk_bytenr;
4769 u64 disk_num_bytes;
4770 u64 extent_num_bytes;
4771 u64 extent_offset;
4772 u64 csum_found; /* In byte size, sectorsize aligned */
4773 u64 search_start; /* Logical range start we search for csum */
4774 u64 search_len; /* Logical range len we search for csum */
4775 unsigned int extent_type;
4776 unsigned int is_hole;
4777 int compressed = 0;
4778 int ret;
4779 int err = 0;
4780
4781 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
4782
4783 /* Check inline extent */
4784 extent_type = btrfs_file_extent_type(node, fi);
4785 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
4786 struct btrfs_item *e = btrfs_item_nr(slot);
4787 u32 item_inline_len;
4788
4789 item_inline_len = btrfs_file_extent_inline_item_len(node, e);
4790 extent_num_bytes = btrfs_file_extent_inline_len(node, slot, fi);
4791 compressed = btrfs_file_extent_compression(node, fi);
4792 if (extent_num_bytes == 0) {
4793 error(
4794 "root %llu EXTENT_DATA[%llu %llu] has empty inline extent",
4795 root->objectid, fkey->objectid, fkey->offset);
4796 err |= FILE_EXTENT_ERROR;
4797 }
4798 if (!compressed && extent_num_bytes != item_inline_len) {
4799 error(
4800 "root %llu EXTENT_DATA[%llu %llu] wrong inline size, have: %llu, expected: %u",
4801 root->objectid, fkey->objectid, fkey->offset,
4802 extent_num_bytes, item_inline_len);
4803 err |= FILE_EXTENT_ERROR;
4804 }
4805 *end += extent_num_bytes;
4806 *size += extent_num_bytes;
4807 return err;
4808 }
4809
4810 /* Check extent type */
4811 if (extent_type != BTRFS_FILE_EXTENT_REG &&
4812 extent_type != BTRFS_FILE_EXTENT_PREALLOC) {
4813 err |= FILE_EXTENT_ERROR;
4814 error("root %llu EXTENT_DATA[%llu %llu] type bad",
4815 root->objectid, fkey->objectid, fkey->offset);
4816 return err;
4817 }
4818
4819 /* Check REG_EXTENT/PREALLOC_EXTENT */
4820 disk_bytenr = btrfs_file_extent_disk_bytenr(node, fi);
4821 disk_num_bytes = btrfs_file_extent_disk_num_bytes(node, fi);
4822 extent_num_bytes = btrfs_file_extent_num_bytes(node, fi);
4823 extent_offset = btrfs_file_extent_offset(node, fi);
4824 compressed = btrfs_file_extent_compression(node, fi);
4825 is_hole = (disk_bytenr == 0) && (disk_num_bytes == 0);
4826
4827 /*
4828 * Check EXTENT_DATA csum
4829 *
4830 * For plain (uncompressed) extent, we should only check the range
4831 * we're referring to, as it's possible that part of prealloc extent
4832 * has been written, and has csum:
4833 *
4834 * |<--- Original large preallocated extent A ---->|
4835 * |<- Prealloc File Extent ->|<- Regular Extent ->|
4836 * No csum Has csum
4837 *
4838 * For compressed extent, we should check the whole range.
4839 */
4840 if (!compressed) {
4841 search_start = disk_bytenr + extent_offset;
4842 search_len = extent_num_bytes;
4843 } else {
4844 search_start = disk_bytenr;
4845 search_len = disk_num_bytes;
4846 }
4847 ret = count_csum_range(root, search_start, search_len, &csum_found);
4848 if (csum_found > 0 && nodatasum) {
4849 err |= ODD_CSUM_ITEM;
4850 error("root %llu EXTENT_DATA[%llu %llu] nodatasum shouldn't have datasum",
4851 root->objectid, fkey->objectid, fkey->offset);
4852 } else if (extent_type == BTRFS_FILE_EXTENT_REG && !nodatasum &&
4853 !is_hole && (ret < 0 || csum_found < search_len)) {
4854 err |= CSUM_ITEM_MISSING;
4855 error("root %llu EXTENT_DATA[%llu %llu] csum missing, have: %llu, expected: %llu",
4856 root->objectid, fkey->objectid, fkey->offset,
4857 csum_found, search_len);
4858 } else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC && csum_found > 0) {
4859 err |= ODD_CSUM_ITEM;
4860 error("root %llu EXTENT_DATA[%llu %llu] prealloc shouldn't have csum, but has: %llu",
4861 root->objectid, fkey->objectid, fkey->offset, csum_found);
4862 }
4863
4864 /* Check EXTENT_DATA hole */
4865 if (!no_holes && *end != fkey->offset) {
4866 err |= FILE_EXTENT_ERROR;
4867 error("root %llu EXTENT_DATA[%llu %llu] interrupt",
4868 root->objectid, fkey->objectid, fkey->offset);
4869 }
4870
4871 *end += extent_num_bytes;
4872 if (!is_hole)
4873 *size += extent_num_bytes;
4874
4875 return err;
4876 }
4877
4878 /*
4879 * Check INODE_ITEM and related ITEMs (the same inode number)
4880 * 1. check link count
4881 * 2. check inode ref/extref
4882 * 3. check dir item/index
4883 *
4884 * @ext_ref: the EXTENDED_IREF feature
4885 *
4886 * Return 0 if no error occurred.
4887 * Return >0 for error or hit the traversal is done(by error bitmap)
4888 */
4889 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
4890 unsigned int ext_ref)
4891 {
4892 struct extent_buffer *node;
4893 struct btrfs_inode_item *ii;
4894 struct btrfs_key key;
4895 u64 inode_id;
4896 u32 mode;
4897 u64 nlink;
4898 u64 nbytes;
4899 u64 isize;
4900 u64 size = 0;
4901 u64 refs = 0;
4902 u64 extent_end = 0;
4903 u64 extent_size = 0;
4904 unsigned int dir;
4905 unsigned int nodatasum;
4906 int slot;
4907 int ret;
4908 int err = 0;
4909
4910 node = path->nodes[0];
4911 slot = path->slots[0];
4912
4913 btrfs_item_key_to_cpu(node, &key, slot);
4914 inode_id = key.objectid;
4915
4916 if (inode_id == BTRFS_ORPHAN_OBJECTID) {
4917 ret = btrfs_next_item(root, path);
4918 if (ret > 0)
4919 err |= LAST_ITEM;
4920 return err;
4921 }
4922
4923 ii = btrfs_item_ptr(node, slot, struct btrfs_inode_item);
4924 isize = btrfs_inode_size(node, ii);
4925 nbytes = btrfs_inode_nbytes(node, ii);
4926 mode = btrfs_inode_mode(node, ii);
4927 dir = imode_to_type(mode) == BTRFS_FT_DIR;
4928 nlink = btrfs_inode_nlink(node, ii);
4929 nodatasum = btrfs_inode_flags(node, ii) & BTRFS_INODE_NODATASUM;
4930
4931 while (1) {
4932 ret = btrfs_next_item(root, path);
4933 if (ret < 0) {
4934 /* out will fill 'err' rusing current statistics */
4935 goto out;
4936 } else if (ret > 0) {
4937 err |= LAST_ITEM;
4938 goto out;
4939 }
4940
4941 node = path->nodes[0];
4942 slot = path->slots[0];
4943 btrfs_item_key_to_cpu(node, &key, slot);
4944 if (key.objectid != inode_id)
4945 goto out;
4946
4947 switch (key.type) {
4948 case BTRFS_INODE_REF_KEY:
4949 ret = check_inode_ref(root, &key, node, slot, &refs,
4950 mode);
4951 err |= ret;
4952 break;
4953 case BTRFS_INODE_EXTREF_KEY:
4954 if (key.type == BTRFS_INODE_EXTREF_KEY && !ext_ref)
4955 warning("root %llu EXTREF[%llu %llu] isn't supported",
4956 root->objectid, key.objectid,
4957 key.offset);
4958 ret = check_inode_extref(root, &key, node, slot, &refs,
4959 mode);
4960 err |= ret;
4961 break;
4962 case BTRFS_DIR_ITEM_KEY:
4963 case BTRFS_DIR_INDEX_KEY:
4964 if (!dir) {
4965 warning("root %llu INODE[%llu] mode %u shouldn't have DIR_INDEX[%llu %llu]",
4966 root->objectid, inode_id,
4967 imode_to_type(mode), key.objectid,
4968 key.offset);
4969 }
4970 ret = check_dir_item(root, &key, node, slot, &size,
4971 ext_ref);
4972 err |= ret;
4973 break;
4974 case BTRFS_EXTENT_DATA_KEY:
4975 if (dir) {
4976 warning("root %llu DIR INODE[%llu] shouldn't EXTENT_DATA[%llu %llu]",
4977 root->objectid, inode_id, key.objectid,
4978 key.offset);
4979 }
4980 ret = check_file_extent(root, &key, node, slot,
4981 nodatasum, &extent_size,
4982 &extent_end);
4983 err |= ret;
4984 break;
4985 case BTRFS_XATTR_ITEM_KEY:
4986 break;
4987 default:
4988 error("ITEM[%llu %u %llu] UNKNOWN TYPE",
4989 key.objectid, key.type, key.offset);
4990 }
4991 }
4992
4993 out:
4994 /* verify INODE_ITEM nlink/isize/nbytes */
4995 if (dir) {
4996 if (nlink != 1) {
4997 err |= LINK_COUNT_ERROR;
4998 error("root %llu DIR INODE[%llu] shouldn't have more than one link(%llu)",
4999 root->objectid, inode_id, nlink);
5000 }
5001
5002 /*
5003 * Just a warning, as dir inode nbytes is just an
5004 * instructive value.
5005 */
5006 if (!IS_ALIGNED(nbytes, root->fs_info->nodesize)) {
5007 warning("root %llu DIR INODE[%llu] nbytes should be aligned to %u",
5008 root->objectid, inode_id,
5009 root->fs_info->nodesize);
5010 }
5011
5012 if (isize != size) {
5013 err |= ISIZE_ERROR;
5014 error("root %llu DIR INODE [%llu] size(%llu) not equal to %llu",
5015 root->objectid, inode_id, isize, size);
5016 }
5017 } else {
5018 if (nlink != refs) {
5019 err |= LINK_COUNT_ERROR;
5020 error("root %llu INODE[%llu] nlink(%llu) not equal to inode_refs(%llu)",
5021 root->objectid, inode_id, nlink, refs);
5022 } else if (!nlink) {
5023 err |= ORPHAN_ITEM;
5024 }
5025
5026 if (!nbytes && !no_holes && extent_end < isize) {
5027 err |= NBYTES_ERROR;
5028 error("root %llu INODE[%llu] size (%llu) should have a file extent hole",
5029 root->objectid, inode_id, isize);
5030 }
5031
5032 if (nbytes != extent_size) {
5033 err |= NBYTES_ERROR;
5034 error("root %llu INODE[%llu] nbytes(%llu) not equal to extent_size(%llu)",
5035 root->objectid, inode_id, nbytes, extent_size);
5036 }
5037 }
5038
5039 return err;
5040 }
5041
5042 static int check_fs_first_inode(struct btrfs_root *root, unsigned int ext_ref)
5043 {
5044 struct btrfs_path path;
5045 struct btrfs_key key;
5046 int err = 0;
5047 int ret;
5048
5049 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
5050 key.type = BTRFS_INODE_ITEM_KEY;
5051 key.offset = 0;
5052
5053 /* For root being dropped, we don't need to check first inode */
5054 if (btrfs_root_refs(&root->root_item) == 0 &&
5055 btrfs_disk_key_objectid(&root->root_item.drop_progress) >=
5056 key.objectid)
5057 return 0;
5058
5059 btrfs_init_path(&path);
5060
5061 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
5062 if (ret < 0)
5063 goto out;
5064 if (ret > 0) {
5065 ret = 0;
5066 err |= INODE_ITEM_MISSING;
5067 error("first inode item of root %llu is missing",
5068 root->objectid);
5069 }
5070
5071 err |= check_inode_item(root, &path, ext_ref);
5072 err &= ~LAST_ITEM;
5073 if (err && !ret)
5074 ret = -EIO;
5075 out:
5076 btrfs_release_path(&path);
5077 return ret;
5078 }
5079
5080 /*
5081 * Iterate all item on the tree and call check_inode_item() to check.
5082 *
5083 * @root: the root of the tree to be checked.
5084 * @ext_ref: the EXTENDED_IREF feature
5085 *
5086 * Return 0 if no error found.
5087 * Return <0 for error.
5088 */
5089 static int check_fs_root_v2(struct btrfs_root *root, unsigned int ext_ref)
5090 {
5091 struct btrfs_path path;
5092 struct node_refs nrefs;
5093 struct btrfs_root_item *root_item = &root->root_item;
5094 int ret;
5095 int level;
5096 int err = 0;
5097
5098 /*
5099 * We need to manually check the first inode item(256)
5100 * As the following traversal function will only start from
5101 * the first inode item in the leaf, if inode item(256) is missing
5102 * we will just skip it forever.
5103 */
5104 ret = check_fs_first_inode(root, ext_ref);
5105 if (ret < 0)
5106 return ret;
5107
5108 memset(&nrefs, 0, sizeof(nrefs));
5109 level = btrfs_header_level(root->node);
5110 btrfs_init_path(&path);
5111
5112 if (btrfs_root_refs(root_item) > 0 ||
5113 btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
5114 path.nodes[level] = root->node;
5115 path.slots[level] = 0;
5116 extent_buffer_get(root->node);
5117 } else {
5118 struct btrfs_key key;
5119
5120 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
5121 level = root_item->drop_level;
5122 path.lowest_level = level;
5123 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
5124 if (ret < 0)
5125 goto out;
5126 ret = 0;
5127 }
5128
5129 while (1) {
5130 ret = walk_down_tree_v2(root, &path, &level, &nrefs, ext_ref);
5131 err |= !!ret;
5132
5133 /* if ret is negative, walk shall stop */
5134 if (ret < 0) {
5135 ret = err;
5136 break;
5137 }
5138
5139 ret = walk_up_tree_v2(root, &path, &level);
5140 if (ret != 0) {
5141 /* Normal exit, reset ret to err */
5142 ret = err;
5143 break;
5144 }
5145 }
5146
5147 out:
5148 btrfs_release_path(&path);
5149 return ret;
5150 }
5151
5152 /*
5153 * Find the relative ref for root_ref and root_backref.
5154 *
5155 * @root: the root of the root tree.
5156 * @ref_key: the key of the root ref.
5157 *
5158 * Return 0 if no error occurred.
5159 */
5160 static int check_root_ref(struct btrfs_root *root, struct btrfs_key *ref_key,
5161 struct extent_buffer *node, int slot)
5162 {
5163 struct btrfs_path path;
5164 struct btrfs_key key;
5165 struct btrfs_root_ref *ref;
5166 struct btrfs_root_ref *backref;
5167 char ref_name[BTRFS_NAME_LEN] = {0};
5168 char backref_name[BTRFS_NAME_LEN] = {0};
5169 u64 ref_dirid;
5170 u64 ref_seq;
5171 u32 ref_namelen;
5172 u64 backref_dirid;
5173 u64 backref_seq;
5174 u32 backref_namelen;
5175 u32 len;
5176 int ret;
5177 int err = 0;
5178
5179 ref = btrfs_item_ptr(node, slot, struct btrfs_root_ref);
5180 ref_dirid = btrfs_root_ref_dirid(node, ref);
5181 ref_seq = btrfs_root_ref_sequence(node, ref);
5182 ref_namelen = btrfs_root_ref_name_len(node, ref);
5183
5184 if (ref_namelen <= BTRFS_NAME_LEN) {
5185 len = ref_namelen;
5186 } else {
5187 len = BTRFS_NAME_LEN;
5188 warning("%s[%llu %llu] ref_name too long",
5189 ref_key->type == BTRFS_ROOT_REF_KEY ?
5190 "ROOT_REF" : "ROOT_BACKREF", ref_key->objectid,
5191 ref_key->offset);
5192 }
5193 read_extent_buffer(node, ref_name, (unsigned long)(ref + 1), len);
5194
5195 /* Find relative root_ref */
5196 key.objectid = ref_key->offset;
5197 key.type = BTRFS_ROOT_BACKREF_KEY + BTRFS_ROOT_REF_KEY - ref_key->type;
5198 key.offset = ref_key->objectid;
5199
5200 btrfs_init_path(&path);
5201 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
5202 if (ret) {
5203 err |= ROOT_REF_MISSING;
5204 error("%s[%llu %llu] couldn't find relative ref",
5205 ref_key->type == BTRFS_ROOT_REF_KEY ?
5206 "ROOT_REF" : "ROOT_BACKREF",
5207 ref_key->objectid, ref_key->offset);
5208 goto out;
5209 }
5210
5211 backref = btrfs_item_ptr(path.nodes[0], path.slots[0],
5212 struct btrfs_root_ref);
5213 backref_dirid = btrfs_root_ref_dirid(path.nodes[0], backref);
5214 backref_seq = btrfs_root_ref_sequence(path.nodes[0], backref);
5215 backref_namelen = btrfs_root_ref_name_len(path.nodes[0], backref);
5216
5217 if (backref_namelen <= BTRFS_NAME_LEN) {
5218 len = backref_namelen;
5219 } else {
5220 len = BTRFS_NAME_LEN;
5221 warning("%s[%llu %llu] ref_name too long",
5222 key.type == BTRFS_ROOT_REF_KEY ?
5223 "ROOT_REF" : "ROOT_BACKREF",
5224 key.objectid, key.offset);
5225 }
5226 read_extent_buffer(path.nodes[0], backref_name,
5227 (unsigned long)(backref + 1), len);
5228
5229 if (ref_dirid != backref_dirid || ref_seq != backref_seq ||
5230 ref_namelen != backref_namelen ||
5231 strncmp(ref_name, backref_name, len)) {
5232 err |= ROOT_REF_MISMATCH;
5233 error("%s[%llu %llu] mismatch relative ref",
5234 ref_key->type == BTRFS_ROOT_REF_KEY ?
5235 "ROOT_REF" : "ROOT_BACKREF",
5236 ref_key->objectid, ref_key->offset);
5237 }
5238 out:
5239 btrfs_release_path(&path);
5240 return err;
5241 }
5242
5243 /*
5244 * Check all fs/file tree in low_memory mode.
5245 *
5246 * 1. for fs tree root item, call check_fs_root_v2()
5247 * 2. for fs tree root ref/backref, call check_root_ref()
5248 *
5249 * Return 0 if no error occurred.
5250 */
5251 static int check_fs_roots_v2(struct btrfs_fs_info *fs_info)
5252 {
5253 struct btrfs_root *tree_root = fs_info->tree_root;
5254 struct btrfs_root *cur_root = NULL;
5255 struct btrfs_path path;
5256 struct btrfs_key key;
5257 struct extent_buffer *node;
5258 unsigned int ext_ref;
5259 int slot;
5260 int ret;
5261 int err = 0;
5262
5263 ext_ref = btrfs_fs_incompat(fs_info, EXTENDED_IREF);
5264
5265 btrfs_init_path(&path);
5266 key.objectid = BTRFS_FS_TREE_OBJECTID;
5267 key.offset = 0;
5268 key.type = BTRFS_ROOT_ITEM_KEY;
5269
5270 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
5271 if (ret < 0) {
5272 err = ret;
5273 goto out;
5274 } else if (ret > 0) {
5275 err = -ENOENT;
5276 goto out;
5277 }
5278
5279 while (1) {
5280 node = path.nodes[0];
5281 slot = path.slots[0];
5282 btrfs_item_key_to_cpu(node, &key, slot);
5283 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
5284 goto out;
5285 if (key.type == BTRFS_ROOT_ITEM_KEY &&
5286 fs_root_objectid(key.objectid)) {
5287 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID) {
5288 cur_root = btrfs_read_fs_root_no_cache(fs_info,
5289 &key);
5290 } else {
5291 key.offset = (u64)-1;
5292 cur_root = btrfs_read_fs_root(fs_info, &key);
5293 }
5294
5295 if (IS_ERR(cur_root)) {
5296 error("Fail to read fs/subvol tree: %lld",
5297 key.objectid);
5298 err = -EIO;
5299 goto next;
5300 }
5301
5302 ret = check_fs_root_v2(cur_root, ext_ref);
5303 err |= ret;
5304
5305 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
5306 btrfs_free_fs_root(cur_root);
5307 } else if (key.type == BTRFS_ROOT_REF_KEY ||
5308 key.type == BTRFS_ROOT_BACKREF_KEY) {
5309 ret = check_root_ref(tree_root, &key, node, slot);
5310 err |= ret;
5311 }
5312 next:
5313 ret = btrfs_next_item(tree_root, &path);
5314 if (ret > 0)
5315 goto out;
5316 if (ret < 0) {
5317 err = ret;
5318 goto out;
5319 }
5320 }
5321
5322 out:
5323 btrfs_release_path(&path);
5324 return err;
5325 }
5326
5327 static int all_backpointers_checked(struct extent_record *rec, int print_errs)
5328 {
5329 struct list_head *cur = rec->backrefs.next;
5330 struct extent_backref *back;
5331 struct tree_backref *tback;
5332 struct data_backref *dback;
5333 u64 found = 0;
5334 int err = 0;
5335
5336 while(cur != &rec->backrefs) {
5337 back = to_extent_backref(cur);
5338 cur = cur->next;
5339 if (!back->found_extent_tree) {
5340 err = 1;
5341 if (!print_errs)
5342 goto out;
5343 if (back->is_data) {
5344 dback = to_data_backref(back);
5345 fprintf(stderr, "Backref %llu %s %llu"
5346 " owner %llu offset %llu num_refs %lu"
5347 " not found in extent tree\n",
5348 (unsigned long long)rec->start,
5349 back->full_backref ?
5350 "parent" : "root",
5351 back->full_backref ?
5352 (unsigned long long)dback->parent:
5353 (unsigned long long)dback->root,
5354 (unsigned long long)dback->owner,
5355 (unsigned long long)dback->offset,
5356 (unsigned long)dback->num_refs);
5357 } else {
5358 tback = to_tree_backref(back);
5359 fprintf(stderr, "Backref %llu parent %llu"
5360 " root %llu not found in extent tree\n",
5361 (unsigned long long)rec->start,
5362 (unsigned long long)tback->parent,
5363 (unsigned long long)tback->root);
5364 }
5365 }
5366 if (!back->is_data && !back->found_ref) {
5367 err = 1;
5368 if (!print_errs)
5369 goto out;
5370 tback = to_tree_backref(back);
5371 fprintf(stderr, "Backref %llu %s %llu not referenced back %p\n",
5372 (unsigned long long)rec->start,
5373 back->full_backref ? "parent" : "root",
5374 back->full_backref ?
5375 (unsigned long long)tback->parent :
5376 (unsigned long long)tback->root, back);
5377 }
5378 if (back->is_data) {
5379 dback = to_data_backref(back);
5380 if (dback->found_ref != dback->num_refs) {
5381 err = 1;
5382 if (!print_errs)
5383 goto out;
5384 fprintf(stderr, "Incorrect local backref count"
5385 " on %llu %s %llu owner %llu"
5386 " offset %llu found %u wanted %u back %p\n",
5387 (unsigned long long)rec->start,
5388 back->full_backref ?
5389 "parent" : "root",
5390 back->full_backref ?
5391 (unsigned long long)dback->parent:
5392 (unsigned long long)dback->root,
5393 (unsigned long long)dback->owner,
5394 (unsigned long long)dback->offset,
5395 dback->found_ref, dback->num_refs, back);
5396 }
5397 if (dback->disk_bytenr != rec->start) {
5398 err = 1;
5399 if (!print_errs)
5400 goto out;
5401 fprintf(stderr, "Backref disk bytenr does not"
5402 " match extent record, bytenr=%llu, "
5403 "ref bytenr=%llu\n",
5404 (unsigned long long)rec->start,
5405 (unsigned long long)dback->disk_bytenr);
5406 }
5407
5408 if (dback->bytes != rec->nr) {
5409 err = 1;
5410 if (!print_errs)
5411 goto out;
5412 fprintf(stderr, "Backref bytes do not match "
5413 "extent backref, bytenr=%llu, ref "
5414 "bytes=%llu, backref bytes=%llu\n",
5415 (unsigned long long)rec->start,
5416 (unsigned long long)rec->nr,
5417 (unsigned long long)dback->bytes);
5418 }
5419 }
5420 if (!back->is_data) {
5421 found += 1;
5422 } else {
5423 dback = to_data_backref(back);
5424 found += dback->found_ref;
5425 }
5426 }
5427 if (found != rec->refs) {
5428 err = 1;
5429 if (!print_errs)
5430 goto out;
5431 fprintf(stderr, "Incorrect global backref count "
5432 "on %llu found %llu wanted %llu\n",
5433 (unsigned long long)rec->start,
5434 (unsigned long long)found,
5435 (unsigned long long)rec->refs);
5436 }
5437 out:
5438 return err;
5439 }
5440
5441 static int free_all_extent_backrefs(struct extent_record *rec)
5442 {
5443 struct extent_backref *back;
5444 struct list_head *cur;
5445 while (!list_empty(&rec->backrefs)) {
5446 cur = rec->backrefs.next;
5447 back = to_extent_backref(cur);
5448 list_del(cur);
5449 free(back);
5450 }
5451 return 0;
5452 }
5453
5454 static void free_extent_record_cache(struct cache_tree *extent_cache)
5455 {
5456 struct cache_extent *cache;
5457 struct extent_record *rec;
5458
5459 while (1) {
5460 cache = first_cache_extent(extent_cache);
5461 if (!cache)
5462 break;
5463 rec = container_of(cache, struct extent_record, cache);
5464 remove_cache_extent(extent_cache, cache);
5465 free_all_extent_backrefs(rec);
5466 free(rec);
5467 }
5468 }
5469
5470 static int maybe_free_extent_rec(struct cache_tree *extent_cache,
5471 struct extent_record *rec)
5472 {
5473 if (rec->content_checked && rec->owner_ref_checked &&
5474 rec->extent_item_refs == rec->refs && rec->refs > 0 &&
5475 rec->num_duplicates == 0 && !all_backpointers_checked(rec, 0) &&
5476 !rec->bad_full_backref && !rec->crossing_stripes &&
5477 !rec->wrong_chunk_type) {
5478 remove_cache_extent(extent_cache, &rec->cache);
5479 free_all_extent_backrefs(rec);
5480 list_del_init(&rec->list);
5481 free(rec);
5482 }
5483 return 0;
5484 }
5485
5486 static int check_owner_ref(struct btrfs_root *root,
5487 struct extent_record *rec,
5488 struct extent_buffer *buf)
5489 {
5490 struct extent_backref *node;
5491 struct tree_backref *back;
5492 struct btrfs_root *ref_root;
5493 struct btrfs_key key;
5494 struct btrfs_path path;
5495 struct extent_buffer *parent;
5496 int level;
5497 int found = 0;
5498 int ret;
5499
5500 list_for_each_entry(node, &rec->backrefs, list) {
5501 if (node->is_data)
5502 continue;
5503 if (!node->found_ref)
5504 continue;
5505 if (node->full_backref)
5506 continue;
5507 back = to_tree_backref(node);
5508 if (btrfs_header_owner(buf) == back->root)
5509 return 0;
5510 }
5511 BUG_ON(rec->is_root);
5512
5513 /* try to find the block by search corresponding fs tree */
5514 key.objectid = btrfs_header_owner(buf);
5515 key.type = BTRFS_ROOT_ITEM_KEY;
5516 key.offset = (u64)-1;
5517
5518 ref_root = btrfs_read_fs_root(root->fs_info, &key);
5519 if (IS_ERR(ref_root))
5520 return 1;
5521
5522 level = btrfs_header_level(buf);
5523 if (level == 0)
5524 btrfs_item_key_to_cpu(buf, &key, 0);
5525 else
5526 btrfs_node_key_to_cpu(buf, &key, 0);
5527
5528 btrfs_init_path(&path);
5529 path.lowest_level = level + 1;
5530 ret = btrfs_search_slot(NULL, ref_root, &key, &path, 0, 0);
5531 if (ret < 0)
5532 return 0;
5533
5534 parent = path.nodes[level + 1];
5535 if (parent && buf->start == btrfs_node_blockptr(parent,
5536 path.slots[level + 1]))
5537 found = 1;
5538
5539 btrfs_release_path(&path);
5540 return found ? 0 : 1;
5541 }
5542
5543 static int is_extent_tree_record(struct extent_record *rec)
5544 {
5545 struct list_head *cur = rec->backrefs.next;
5546 struct extent_backref *node;
5547 struct tree_backref *back;
5548 int is_extent = 0;
5549
5550 while(cur != &rec->backrefs) {
5551 node = to_extent_backref(cur);
5552 cur = cur->next;
5553 if (node->is_data)
5554 return 0;
5555 back = to_tree_backref(node);
5556 if (node->full_backref)
5557 return 0;
5558 if (back->root == BTRFS_EXTENT_TREE_OBJECTID)
5559 is_extent = 1;
5560 }
5561 return is_extent;
5562 }
5563
5564
5565 static int record_bad_block_io(struct btrfs_fs_info *info,
5566 struct cache_tree *extent_cache,
5567 u64 start, u64 len)
5568 {
5569 struct extent_record *rec;
5570 struct cache_extent *cache;
5571 struct btrfs_key key;
5572
5573 cache = lookup_cache_extent(extent_cache, start, len);
5574 if (!cache)
5575 return 0;
5576
5577 rec = container_of(cache, struct extent_record, cache);
5578 if (!is_extent_tree_record(rec))
5579 return 0;
5580
5581 btrfs_disk_key_to_cpu(&key, &rec->parent_key);
5582 return btrfs_add_corrupt_extent_record(info, &key, start, len, 0);
5583 }
5584
5585 static int swap_values(struct btrfs_root *root, struct btrfs_path *path,
5586 struct extent_buffer *buf, int slot)
5587 {
5588 if (btrfs_header_level(buf)) {
5589 struct btrfs_key_ptr ptr1, ptr2;
5590
5591 read_extent_buffer(buf, &ptr1, btrfs_node_key_ptr_offset(slot),
5592 sizeof(struct btrfs_key_ptr));
5593 read_extent_buffer(buf, &ptr2,
5594 btrfs_node_key_ptr_offset(slot + 1),
5595 sizeof(struct btrfs_key_ptr));
5596 write_extent_buffer(buf, &ptr1,
5597 btrfs_node_key_ptr_offset(slot + 1),
5598 sizeof(struct btrfs_key_ptr));
5599 write_extent_buffer(buf, &ptr2,
5600 btrfs_node_key_ptr_offset(slot),
5601 sizeof(struct btrfs_key_ptr));
5602 if (slot == 0) {
5603 struct btrfs_disk_key key;
5604 btrfs_node_key(buf, &key, 0);
5605 btrfs_fixup_low_keys(root, path, &key,
5606 btrfs_header_level(buf) + 1);
5607 }
5608 } else {
5609 struct btrfs_item *item1, *item2;
5610 struct btrfs_key k1, k2;
5611 char *item1_data, *item2_data;
5612 u32 item1_offset, item2_offset, item1_size, item2_size;
5613
5614 item1 = btrfs_item_nr(slot);
5615 item2 = btrfs_item_nr(slot + 1);
5616 btrfs_item_key_to_cpu(buf, &k1, slot);
5617 btrfs_item_key_to_cpu(buf, &k2, slot + 1);
5618 item1_offset = btrfs_item_offset(buf, item1);
5619 item2_offset = btrfs_item_offset(buf, item2);
5620 item1_size = btrfs_item_size(buf, item1);
5621 item2_size = btrfs_item_size(buf, item2);
5622
5623 item1_data = malloc(item1_size);
5624 if (!item1_data)
5625 return -ENOMEM;
5626 item2_data = malloc(item2_size);
5627 if (!item2_data) {
5628 free(item1_data);
5629 return -ENOMEM;
5630 }
5631
5632 read_extent_buffer(buf, item1_data, item1_offset, item1_size);
5633 read_extent_buffer(buf, item2_data, item2_offset, item2_size);
5634
5635 write_extent_buffer(buf, item1_data, item2_offset, item2_size);
5636 write_extent_buffer(buf, item2_data, item1_offset, item1_size);
5637 free(item1_data);
5638 free(item2_data);
5639
5640 btrfs_set_item_offset(buf, item1, item2_offset);
5641 btrfs_set_item_offset(buf, item2, item1_offset);
5642 btrfs_set_item_size(buf, item1, item2_size);
5643 btrfs_set_item_size(buf, item2, item1_size);
5644
5645 path->slots[0] = slot;
5646 btrfs_set_item_key_unsafe(root, path, &k2);
5647 path->slots[0] = slot + 1;
5648 btrfs_set_item_key_unsafe(root, path, &k1);
5649 }
5650 return 0;
5651 }
5652
5653 static int fix_key_order(struct btrfs_root *root, struct btrfs_path *path)
5654 {
5655 struct extent_buffer *buf;
5656 struct btrfs_key k1, k2;
5657 int i;
5658 int level = path->lowest_level;
5659 int ret = -EIO;
5660
5661 buf = path->nodes[level];
5662 for (i = 0; i < btrfs_header_nritems(buf) - 1; i++) {
5663 if (level) {
5664 btrfs_node_key_to_cpu(buf, &k1, i);
5665 btrfs_node_key_to_cpu(buf, &k2, i + 1);
5666 } else {
5667 btrfs_item_key_to_cpu(buf, &k1, i);
5668 btrfs_item_key_to_cpu(buf, &k2, i + 1);
5669 }
5670 if (btrfs_comp_cpu_keys(&k1, &k2) < 0)
5671 continue;
5672 ret = swap_values(root, path, buf, i);
5673 if (ret)
5674 break;
5675 btrfs_mark_buffer_dirty(buf);
5676 i = 0;
5677 }
5678 return ret;
5679 }
5680
5681 static int delete_bogus_item(struct btrfs_root *root,
5682 struct btrfs_path *path,
5683 struct extent_buffer *buf, int slot)
5684 {
5685 struct btrfs_key key;
5686 int nritems = btrfs_header_nritems(buf);
5687
5688 btrfs_item_key_to_cpu(buf, &key, slot);
5689
5690 /* These are all the keys we can deal with missing. */
5691 if (key.type != BTRFS_DIR_INDEX_KEY &&
5692 key.type != BTRFS_EXTENT_ITEM_KEY &&
5693 key.type != BTRFS_METADATA_ITEM_KEY &&
5694 key.type != BTRFS_TREE_BLOCK_REF_KEY &&
5695 key.type != BTRFS_EXTENT_DATA_REF_KEY)
5696 return -1;
5697
5698 printf("Deleting bogus item [%llu,%u,%llu] at slot %d on block %llu\n",
5699 (unsigned long long)key.objectid, key.type,
5700 (unsigned long long)key.offset, slot, buf->start);
5701 memmove_extent_buffer(buf, btrfs_item_nr_offset(slot),
5702 btrfs_item_nr_offset(slot + 1),
5703 sizeof(struct btrfs_item) *
5704 (nritems - slot - 1));
5705 btrfs_set_header_nritems(buf, nritems - 1);
5706 if (slot == 0) {
5707 struct btrfs_disk_key disk_key;
5708
5709 btrfs_item_key(buf, &disk_key, 0);
5710 btrfs_fixup_low_keys(root, path, &disk_key, 1);
5711 }
5712 btrfs_mark_buffer_dirty(buf);
5713 return 0;
5714 }
5715
5716 static int fix_item_offset(struct btrfs_root *root, struct btrfs_path *path)
5717 {
5718 struct extent_buffer *buf;
5719 int i;
5720 int ret = 0;
5721
5722 /* We should only get this for leaves */
5723 BUG_ON(path->lowest_level);
5724 buf = path->nodes[0];
5725 again:
5726 for (i = 0; i < btrfs_header_nritems(buf); i++) {
5727 unsigned int shift = 0, offset;
5728
5729 if (i == 0 && btrfs_item_end_nr(buf, i) !=
5730 BTRFS_LEAF_DATA_SIZE(root)) {
5731 if (btrfs_item_end_nr(buf, i) >
5732 BTRFS_LEAF_DATA_SIZE(root)) {
5733 ret = delete_bogus_item(root, path, buf, i);
5734 if (!ret)
5735 goto again;
5736 fprintf(stderr, "item is off the end of the "
5737 "leaf, can't fix\n");
5738 ret = -EIO;
5739 break;
5740 }
5741 shift = BTRFS_LEAF_DATA_SIZE(root) -
5742 btrfs_item_end_nr(buf, i);
5743 } else if (i > 0 && btrfs_item_end_nr(buf, i) !=
5744 btrfs_item_offset_nr(buf, i - 1)) {
5745 if (btrfs_item_end_nr(buf, i) >
5746 btrfs_item_offset_nr(buf, i - 1)) {
5747 ret = delete_bogus_item(root, path, buf, i);
5748 if (!ret)
5749 goto again;
5750 fprintf(stderr, "items overlap, can't fix\n");
5751 ret = -EIO;
5752 break;
5753 }
5754 shift = btrfs_item_offset_nr(buf, i - 1) -
5755 btrfs_item_end_nr(buf, i);
5756 }
5757 if (!shift)
5758 continue;
5759
5760 printf("Shifting item nr %d by %u bytes in block %llu\n",
5761 i, shift, (unsigned long long)buf->start);
5762 offset = btrfs_item_offset_nr(buf, i);
5763 memmove_extent_buffer(buf,
5764 btrfs_leaf_data(buf) + offset + shift,
5765 btrfs_leaf_data(buf) + offset,
5766 btrfs_item_size_nr(buf, i));
5767 btrfs_set_item_offset(buf, btrfs_item_nr(i),
5768 offset + shift);
5769 btrfs_mark_buffer_dirty(buf);
5770 }
5771
5772 /*
5773 * We may have moved things, in which case we want to exit so we don't
5774 * write those changes out. Once we have proper abort functionality in
5775 * progs this can be changed to something nicer.
5776 */
5777 BUG_ON(ret);
5778 return ret;
5779 }
5780
5781 /*
5782 * Attempt to fix basic block failures. If we can't fix it for whatever reason
5783 * then just return -EIO.
5784 */
5785 static int try_to_fix_bad_block(struct btrfs_root *root,
5786 struct extent_buffer *buf,
5787 enum btrfs_tree_block_status status)
5788 {
5789 struct btrfs_trans_handle *trans;
5790 struct ulist *roots;
5791 struct ulist_node *node;
5792 struct btrfs_root *search_root;
5793 struct btrfs_path path;
5794 struct ulist_iterator iter;
5795 struct btrfs_key root_key, key;
5796 int ret;
5797
5798 if (status != BTRFS_TREE_BLOCK_BAD_KEY_ORDER &&
5799 status != BTRFS_TREE_BLOCK_INVALID_OFFSETS)
5800 return -EIO;
5801
5802 ret = btrfs_find_all_roots(NULL, root->fs_info, buf->start, 0, &roots);
5803 if (ret)
5804 return -EIO;
5805
5806 btrfs_init_path(&path);
5807 ULIST_ITER_INIT(&iter);
5808 while ((node = ulist_next(roots, &iter))) {
5809 root_key.objectid = node->val;
5810 root_key.type = BTRFS_ROOT_ITEM_KEY;
5811 root_key.offset = (u64)-1;
5812
5813 search_root = btrfs_read_fs_root(root->fs_info, &root_key);
5814 if (IS_ERR(root)) {
5815 ret = -EIO;
5816 break;
5817 }
5818
5819
5820 trans = btrfs_start_transaction(search_root, 0);
5821 if (IS_ERR(trans)) {
5822 ret = PTR_ERR(trans);
5823 break;
5824 }
5825
5826 path.lowest_level = btrfs_header_level(buf);
5827 path.skip_check_block = 1;
5828 if (path.lowest_level)
5829 btrfs_node_key_to_cpu(buf, &key, 0);
5830 else
5831 btrfs_item_key_to_cpu(buf, &key, 0);
5832 ret = btrfs_search_slot(trans, search_root, &key, &path, 0, 1);
5833 if (ret) {
5834 ret = -EIO;
5835 btrfs_commit_transaction(trans, search_root);
5836 break;
5837 }
5838 if (status == BTRFS_TREE_BLOCK_BAD_KEY_ORDER)
5839 ret = fix_key_order(search_root, &path);
5840 else if (status == BTRFS_TREE_BLOCK_INVALID_OFFSETS)
5841 ret = fix_item_offset(search_root, &path);
5842 if (ret) {
5843 btrfs_commit_transaction(trans, search_root);
5844 break;
5845 }
5846 btrfs_release_path(&path);
5847 btrfs_commit_transaction(trans, search_root);
5848 }
5849 ulist_free(roots);
5850 btrfs_release_path(&path);
5851 return ret;
5852 }
5853
5854 static int check_block(struct btrfs_root *root,
5855 struct cache_tree *extent_cache,
5856 struct extent_buffer *buf, u64 flags)
5857 {
5858 struct extent_record *rec;
5859 struct cache_extent *cache;
5860 struct btrfs_key key;
5861 enum btrfs_tree_block_status status;
5862 int ret = 0;
5863 int level;
5864
5865 cache = lookup_cache_extent(extent_cache, buf->start, buf->len);
5866 if (!cache)
5867 return 1;
5868 rec = container_of(cache, struct extent_record, cache);
5869 rec->generation = btrfs_header_generation(buf);
5870
5871 level = btrfs_header_level(buf);
5872 if (btrfs_header_nritems(buf) > 0) {
5873
5874 if (level == 0)
5875 btrfs_item_key_to_cpu(buf, &key, 0);
5876 else
5877 btrfs_node_key_to_cpu(buf, &key, 0);
5878
5879 rec->info_objectid = key.objectid;
5880 }
5881 rec->info_level = level;
5882
5883 if (btrfs_is_leaf(buf))
5884 status = btrfs_check_leaf(root, &rec->parent_key, buf);
5885 else
5886 status = btrfs_check_node(root, &rec->parent_key, buf);
5887
5888 if (status != BTRFS_TREE_BLOCK_CLEAN) {
5889 if (repair)
5890 status = try_to_fix_bad_block(root, buf, status);
5891 if (status != BTRFS_TREE_BLOCK_CLEAN) {
5892 ret = -EIO;
5893 fprintf(stderr, "bad block %llu\n",
5894 (unsigned long long)buf->start);
5895 } else {
5896 /*
5897 * Signal to callers we need to start the scan over
5898 * again since we'll have cowed blocks.
5899 */
5900 ret = -EAGAIN;
5901 }
5902 } else {
5903 rec->content_checked = 1;
5904 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)
5905 rec->owner_ref_checked = 1;
5906 else {
5907 ret = check_owner_ref(root, rec, buf);
5908 if (!ret)
5909 rec->owner_ref_checked = 1;
5910 }
5911 }
5912 if (!ret)
5913 maybe_free_extent_rec(extent_cache, rec);
5914 return ret;
5915 }
5916
5917 static struct tree_backref *find_tree_backref(struct extent_record *rec,
5918 u64 parent, u64 root)
5919 {
5920 struct list_head *cur = rec->backrefs.next;
5921 struct extent_backref *node;
5922 struct tree_backref *back;
5923
5924 while(cur != &rec->backrefs) {
5925 node = to_extent_backref(cur);
5926 cur = cur->next;
5927 if (node->is_data)
5928 continue;
5929 back = to_tree_backref(node);
5930 if (parent > 0) {
5931 if (!node->full_backref)
5932 continue;
5933 if (parent == back->parent)
5934 return back;
5935 } else {
5936 if (node->full_backref)
5937 continue;
5938 if (back->root == root)
5939 return back;
5940 }
5941 }
5942 return NULL;
5943 }
5944
5945 static struct tree_backref *alloc_tree_backref(struct extent_record *rec,
5946 u64 parent, u64 root)
5947 {
5948 struct tree_backref *ref = malloc(sizeof(*ref));
5949
5950 if (!ref)
5951 return NULL;
5952 memset(&ref->node, 0, sizeof(ref->node));
5953 if (parent > 0) {
5954 ref->parent = parent;
5955 ref->node.full_backref = 1;
5956 } else {
5957 ref->root = root;
5958 ref->node.full_backref = 0;
5959 }
5960 list_add_tail(&ref->node.list, &rec->backrefs);
5961
5962 return ref;
5963 }
5964
5965 static struct data_backref *find_data_backref(struct extent_record *rec,
5966 u64 parent, u64 root,
5967 u64 owner, u64 offset,
5968 int found_ref,
5969 u64 disk_bytenr, u64 bytes)
5970 {
5971 struct list_head *cur = rec->backrefs.next;
5972 struct extent_backref *node;
5973 struct data_backref *back;
5974
5975 while(cur != &rec->backrefs) {
5976 node = to_extent_backref(cur);
5977 cur = cur->next;
5978 if (!node->is_data)
5979 continue;
5980 back = to_data_backref(node);
5981 if (parent > 0) {
5982 if (!node->full_backref)
5983 continue;
5984 if (parent == back->parent)
5985 return back;
5986 } else {
5987 if (node->full_backref)
5988 continue;
5989 if (back->root == root && back->owner == owner &&
5990 back->offset == offset) {
5991 if (found_ref && node->found_ref &&
5992 (back->bytes != bytes ||
5993 back->disk_bytenr != disk_bytenr))
5994 continue;
5995 return back;
5996 }
5997 }
5998 }
5999 return NULL;
6000 }
6001
6002 static struct data_backref *alloc_data_backref(struct extent_record *rec,
6003 u64 parent, u64 root,
6004 u64 owner, u64 offset,
6005 u64 max_size)
6006 {
6007 struct data_backref *ref = malloc(sizeof(*ref));
6008
6009 if (!ref)
6010 return NULL;
6011 memset(&ref->node, 0, sizeof(ref->node));
6012 ref->node.is_data = 1;
6013
6014 if (parent > 0) {
6015 ref->parent = parent;
6016 ref->owner = 0;
6017 ref->offset = 0;
6018 ref->node.full_backref = 1;
6019 } else {
6020 ref->root = root;
6021 ref->owner = owner;
6022 ref->offset = offset;
6023 ref->node.full_backref = 0;
6024 }
6025 ref->bytes = max_size;
6026 ref->found_ref = 0;
6027 ref->num_refs = 0;
6028 list_add_tail(&ref->node.list, &rec->backrefs);
6029 if (max_size > rec->max_size)
6030 rec->max_size = max_size;
6031 return ref;
6032 }
6033
6034 /* Check if the type of extent matches with its chunk */
6035 static void check_extent_type(struct extent_record *rec)
6036 {
6037 struct btrfs_block_group_cache *bg_cache;
6038
6039 bg_cache = btrfs_lookup_first_block_group(global_info, rec->start);
6040 if (!bg_cache)
6041 return;
6042
6043 /* data extent, check chunk directly*/
6044 if (!rec->metadata) {
6045 if (!(bg_cache->flags & BTRFS_BLOCK_GROUP_DATA))
6046 rec->wrong_chunk_type = 1;
6047 return;
6048 }
6049
6050 /* metadata extent, check the obvious case first */
6051 if (!(bg_cache->flags & (BTRFS_BLOCK_GROUP_SYSTEM |
6052 BTRFS_BLOCK_GROUP_METADATA))) {
6053 rec->wrong_chunk_type = 1;
6054 return;
6055 }
6056
6057 /*
6058 * Check SYSTEM extent, as it's also marked as metadata, we can only
6059 * make sure it's a SYSTEM extent by its backref
6060 */
6061 if (!list_empty(&rec->backrefs)) {
6062 struct extent_backref *node;
6063 struct tree_backref *tback;
6064 u64 bg_type;
6065
6066 node = to_extent_backref(rec->backrefs.next);
6067 if (node->is_data) {
6068 /* tree block shouldn't have data backref */
6069 rec->wrong_chunk_type = 1;
6070 return;
6071 }
6072 tback = container_of(node, struct tree_backref, node);
6073
6074 if (tback->root == BTRFS_CHUNK_TREE_OBJECTID)
6075 bg_type = BTRFS_BLOCK_GROUP_SYSTEM;
6076 else
6077 bg_type = BTRFS_BLOCK_GROUP_METADATA;
6078 if (!(bg_cache->flags & bg_type))
6079 rec->wrong_chunk_type = 1;
6080 }
6081 }
6082
6083 /*
6084 * Allocate a new extent record, fill default values from @tmpl and insert int
6085 * @extent_cache. Caller is supposed to make sure the [start,nr) is not in
6086 * the cache, otherwise it fails.
6087 */
6088 static int add_extent_rec_nolookup(struct cache_tree *extent_cache,
6089 struct extent_record *tmpl)
6090 {
6091 struct extent_record *rec;
6092 int ret = 0;
6093
6094 BUG_ON(tmpl->max_size == 0);
6095 rec = malloc(sizeof(*rec));
6096 if (!rec)
6097 return -ENOMEM;
6098 rec->start = tmpl->start;
6099 rec->max_size = tmpl->max_size;
6100 rec->nr = max(tmpl->nr, tmpl->max_size);
6101 rec->found_rec = tmpl->found_rec;
6102 rec->content_checked = tmpl->content_checked;
6103 rec->owner_ref_checked = tmpl->owner_ref_checked;
6104 rec->num_duplicates = 0;
6105 rec->metadata = tmpl->metadata;
6106 rec->flag_block_full_backref = FLAG_UNSET;
6107 rec->bad_full_backref = 0;
6108 rec->crossing_stripes = 0;
6109 rec->wrong_chunk_type = 0;
6110 rec->is_root = tmpl->is_root;
6111 rec->refs = tmpl->refs;
6112 rec->extent_item_refs = tmpl->extent_item_refs;
6113 rec->parent_generation = tmpl->parent_generation;
6114 INIT_LIST_HEAD(&rec->backrefs);
6115 INIT_LIST_HEAD(&rec->dups);
6116 INIT_LIST_HEAD(&rec->list);
6117 memcpy(&rec->parent_key, &tmpl->parent_key, sizeof(tmpl->parent_key));
6118 rec->cache.start = tmpl->start;
6119 rec->cache.size = tmpl->nr;
6120 ret = insert_cache_extent(extent_cache, &rec->cache);
6121 if (ret) {
6122 free(rec);
6123 return ret;
6124 }
6125 bytes_used += rec->nr;
6126
6127 if (tmpl->metadata)
6128 rec->crossing_stripes = check_crossing_stripes(global_info,
6129 rec->start, global_info->nodesize);
6130 check_extent_type(rec);
6131 return ret;
6132 }
6133
6134 /*
6135 * Lookup and modify an extent, some values of @tmpl are interpreted verbatim,
6136 * some are hints:
6137 * - refs - if found, increase refs
6138 * - is_root - if found, set
6139 * - content_checked - if found, set
6140 * - owner_ref_checked - if found, set
6141 *
6142 * If not found, create a new one, initialize and insert.
6143 */
6144 static int add_extent_rec(struct cache_tree *extent_cache,
6145 struct extent_record *tmpl)
6146 {
6147 struct extent_record *rec;
6148 struct cache_extent *cache;
6149 int ret = 0;
6150 int dup = 0;
6151
6152 cache = lookup_cache_extent(extent_cache, tmpl->start, tmpl->nr);
6153 if (cache) {
6154 rec = container_of(cache, struct extent_record, cache);
6155 if (tmpl->refs)
6156 rec->refs++;
6157 if (rec->nr == 1)
6158 rec->nr = max(tmpl->nr, tmpl->max_size);
6159
6160 /*
6161 * We need to make sure to reset nr to whatever the extent
6162 * record says was the real size, this way we can compare it to
6163 * the backrefs.
6164 */
6165 if (tmpl->found_rec) {
6166 if (tmpl->start != rec->start || rec->found_rec) {
6167 struct extent_record *tmp;
6168
6169 dup = 1;
6170 if (list_empty(&rec->list))
6171 list_add_tail(&rec->list,
6172 &duplicate_extents);
6173
6174 /*
6175 * We have to do this song and dance in case we
6176 * find an extent record that falls inside of
6177 * our current extent record but does not have
6178 * the same objectid.
6179 */
6180 tmp = malloc(sizeof(*tmp));
6181 if (!tmp)
6182 return -ENOMEM;
6183 tmp->start = tmpl->start;
6184 tmp->max_size = tmpl->max_size;
6185 tmp->nr = tmpl->nr;
6186 tmp->found_rec = 1;
6187 tmp->metadata = tmpl->metadata;
6188 tmp->extent_item_refs = tmpl->extent_item_refs;
6189 INIT_LIST_HEAD(&tmp->list);
6190 list_add_tail(&tmp->list, &rec->dups);
6191 rec->num_duplicates++;
6192 } else {
6193 rec->nr = tmpl->nr;
6194 rec->found_rec = 1;
6195 }
6196 }
6197
6198 if (tmpl->extent_item_refs && !dup) {
6199 if (rec->extent_item_refs) {
6200 fprintf(stderr, "block %llu rec "
6201 "extent_item_refs %llu, passed %llu\n",
6202 (unsigned long long)tmpl->start,
6203 (unsigned long long)
6204 rec->extent_item_refs,
6205 (unsigned long long)tmpl->extent_item_refs);
6206 }
6207 rec->extent_item_refs = tmpl->extent_item_refs;
6208 }
6209 if (tmpl->is_root)
6210 rec->is_root = 1;
6211 if (tmpl->content_checked)
6212 rec->content_checked = 1;
6213 if (tmpl->owner_ref_checked)
6214 rec->owner_ref_checked = 1;
6215 memcpy(&rec->parent_key, &tmpl->parent_key,
6216 sizeof(tmpl->parent_key));
6217 if (tmpl->parent_generation)
6218 rec->parent_generation = tmpl->parent_generation;
6219 if (rec->max_size < tmpl->max_size)
6220 rec->max_size = tmpl->max_size;
6221
6222 /*
6223 * A metadata extent can't cross stripe_len boundary, otherwise
6224 * kernel scrub won't be able to handle it.
6225 * As now stripe_len is fixed to BTRFS_STRIPE_LEN, just check
6226 * it.
6227 */
6228 if (tmpl->metadata)
6229 rec->crossing_stripes = check_crossing_stripes(
6230 global_info, rec->start,
6231 global_info->nodesize);
6232 check_extent_type(rec);
6233 maybe_free_extent_rec(extent_cache, rec);
6234 return ret;
6235 }
6236
6237 ret = add_extent_rec_nolookup(extent_cache, tmpl);
6238
6239 return ret;
6240 }
6241
6242 static int add_tree_backref(struct cache_tree *extent_cache, u64 bytenr,
6243 u64 parent, u64 root, int found_ref)
6244 {
6245 struct extent_record *rec;
6246 struct tree_backref *back;
6247 struct cache_extent *cache;
6248 int ret;
6249
6250 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6251 if (!cache) {
6252 struct extent_record tmpl;
6253
6254 memset(&tmpl, 0, sizeof(tmpl));
6255 tmpl.start = bytenr;
6256 tmpl.nr = 1;
6257 tmpl.metadata = 1;
6258 tmpl.max_size = 1;
6259
6260 ret = add_extent_rec_nolookup(extent_cache, &tmpl);
6261 if (ret)
6262 return ret;
6263
6264 /* really a bug in cache_extent implement now */
6265 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6266 if (!cache)
6267 return -ENOENT;
6268 }
6269
6270 rec = container_of(cache, struct extent_record, cache);
6271 if (rec->start != bytenr) {
6272 /*
6273 * Several cause, from unaligned bytenr to over lapping extents
6274 */
6275 return -EEXIST;
6276 }
6277
6278 back = find_tree_backref(rec, parent, root);
6279 if (!back) {
6280 back = alloc_tree_backref(rec, parent, root);
6281 if (!back)
6282 return -ENOMEM;
6283 }
6284
6285 if (found_ref) {
6286 if (back->node.found_ref) {
6287 fprintf(stderr, "Extent back ref already exists "
6288 "for %llu parent %llu root %llu \n",
6289 (unsigned long long)bytenr,
6290 (unsigned long long)parent,
6291 (unsigned long long)root);
6292 }
6293 back->node.found_ref = 1;
6294 } else {
6295 if (back->node.found_extent_tree) {
6296 fprintf(stderr, "Extent back ref already exists "
6297 "for %llu parent %llu root %llu \n",
6298 (unsigned long long)bytenr,
6299 (unsigned long long)parent,
6300 (unsigned long long)root);
6301 }
6302 back->node.found_extent_tree = 1;
6303 }
6304 check_extent_type(rec);
6305 maybe_free_extent_rec(extent_cache, rec);
6306 return 0;
6307 }
6308
6309 static int add_data_backref(struct cache_tree *extent_cache, u64 bytenr,
6310 u64 parent, u64 root, u64 owner, u64 offset,
6311 u32 num_refs, int found_ref, u64 max_size)
6312 {
6313 struct extent_record *rec;
6314 struct data_backref *back;
6315 struct cache_extent *cache;
6316 int ret;
6317
6318 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6319 if (!cache) {
6320 struct extent_record tmpl;
6321
6322 memset(&tmpl, 0, sizeof(tmpl));
6323 tmpl.start = bytenr;
6324 tmpl.nr = 1;
6325 tmpl.max_size = max_size;
6326
6327 ret = add_extent_rec_nolookup(extent_cache, &tmpl);
6328 if (ret)
6329 return ret;
6330
6331 cache = lookup_cache_extent(extent_cache, bytenr, 1);
6332 if (!cache)
6333 abort();
6334 }
6335
6336 rec = container_of(cache, struct extent_record, cache);
6337 if (rec->max_size < max_size)
6338 rec->max_size = max_size;
6339
6340 /*
6341 * If found_ref is set then max_size is the real size and must match the
6342 * existing refs. So if we have already found a ref then we need to
6343 * make sure that this ref matches the existing one, otherwise we need
6344 * to add a new backref so we can notice that the backrefs don't match
6345 * and we need to figure out who is telling the truth. This is to
6346 * account for that awful fsync bug I introduced where we'd end up with
6347 * a btrfs_file_extent_item that would have its length include multiple
6348 * prealloc extents or point inside of a prealloc extent.
6349 */
6350 back = find_data_backref(rec, parent, root, owner, offset, found_ref,
6351 bytenr, max_size);
6352 if (!back) {
6353 back = alloc_data_backref(rec, parent, root, owner, offset,
6354 max_size);
6355 BUG_ON(!back);
6356 }
6357
6358 if (found_ref) {
6359 BUG_ON(num_refs != 1);
6360 if (back->node.found_ref)
6361 BUG_ON(back->bytes != max_size);
6362 back->node.found_ref = 1;
6363 back->found_ref += 1;
6364 back->bytes = max_size;
6365 back->disk_bytenr = bytenr;
6366 rec->refs += 1;
6367 rec->content_checked = 1;
6368 rec->owner_ref_checked = 1;
6369 } else {
6370 if (back->node.found_extent_tree) {
6371 fprintf(stderr, "Extent back ref already exists "
6372 "for %llu parent %llu root %llu "
6373 "owner %llu offset %llu num_refs %lu\n",
6374 (unsigned long long)bytenr,
6375 (unsigned long long)parent,
6376 (unsigned long long)root,
6377 (unsigned long long)owner,
6378 (unsigned long long)offset,
6379 (unsigned long)num_refs);
6380 }
6381 back->num_refs = num_refs;
6382 back->node.found_extent_tree = 1;
6383 }
6384 maybe_free_extent_rec(extent_cache, rec);
6385 return 0;
6386 }
6387
6388 static int add_pending(struct cache_tree *pending,
6389 struct cache_tree *seen, u64 bytenr, u32 size)
6390 {
6391 int ret;
6392 ret = add_cache_extent(seen, bytenr, size);
6393 if (ret)
6394 return ret;
6395 add_cache_extent(pending, bytenr, size);
6396 return 0;
6397 }
6398
6399 static int pick_next_pending(struct cache_tree *pending,
6400 struct cache_tree *reada,
6401 struct cache_tree *nodes,
6402 u64 last, struct block_info *bits, int bits_nr,
6403 int *reada_bits)
6404 {
6405 unsigned long node_start = last;
6406 struct cache_extent *cache;
6407 int ret;
6408
6409 cache = search_cache_extent(reada, 0);
6410 if (cache) {
6411 bits[0].start = cache->start;
6412 bits[0].size = cache->size;
6413 *reada_bits = 1;
6414 return 1;
6415 }
6416 *reada_bits = 0;
6417 if (node_start > 32768)
6418 node_start -= 32768;
6419
6420 cache = search_cache_extent(nodes, node_start);
6421 if (!cache)
6422 cache = search_cache_extent(nodes, 0);
6423
6424 if (!cache) {
6425 cache = search_cache_extent(pending, 0);
6426 if (!cache)
6427 return 0;
6428 ret = 0;
6429 do {
6430 bits[ret].start = cache->start;
6431 bits[ret].size = cache->size;
6432 cache = next_cache_extent(cache);
6433 ret++;
6434 } while (cache && ret < bits_nr);
6435 return ret;
6436 }
6437
6438 ret = 0;
6439 do {
6440 bits[ret].start = cache->start;
6441 bits[ret].size = cache->size;
6442 cache = next_cache_extent(cache);
6443 ret++;
6444 } while (cache && ret < bits_nr);
6445
6446 if (bits_nr - ret > 8) {
6447 u64 lookup = bits[0].start + bits[0].size;
6448 struct cache_extent *next;
6449 next = search_cache_extent(pending, lookup);
6450 while(next) {
6451 if (next->start - lookup > 32768)
6452 break;
6453 bits[ret].start = next->start;
6454 bits[ret].size = next->size;
6455 lookup = next->start + next->size;
6456 ret++;
6457 if (ret == bits_nr)
6458 break;
6459 next = next_cache_extent(next);
6460 if (!next)
6461 break;
6462 }
6463 }
6464 return ret;
6465 }
6466
6467 static void free_chunk_record(struct cache_extent *cache)
6468 {
6469 struct chunk_record *rec;
6470
6471 rec = container_of(cache, struct chunk_record, cache);
6472 list_del_init(&rec->list);
6473 list_del_init(&rec->dextents);
6474 free(rec);
6475 }
6476
6477 void free_chunk_cache_tree(struct cache_tree *chunk_cache)
6478 {
6479 cache_tree_free_extents(chunk_cache, free_chunk_record);
6480 }
6481
6482 static void free_device_record(struct rb_node *node)
6483 {
6484 struct device_record *rec;
6485
6486 rec = container_of(node, struct device_record, node);
6487 free(rec);
6488 }
6489
6490 FREE_RB_BASED_TREE(device_cache, free_device_record);
6491
6492 int insert_block_group_record(struct block_group_tree *tree,
6493 struct block_group_record *bg_rec)
6494 {
6495 int ret;
6496
6497 ret = insert_cache_extent(&tree->tree, &bg_rec->cache);
6498 if (ret)
6499 return ret;
6500
6501 list_add_tail(&bg_rec->list, &tree->block_groups);
6502 return 0;
6503 }
6504
6505 static void free_block_group_record(struct cache_extent *cache)
6506 {
6507 struct block_group_record *rec;
6508
6509 rec = container_of(cache, struct block_group_record, cache);
6510 list_del_init(&rec->list);
6511 free(rec);
6512 }
6513
6514 void free_block_group_tree(struct block_group_tree *tree)
6515 {
6516 cache_tree_free_extents(&tree->tree, free_block_group_record);
6517 }
6518
6519 int insert_device_extent_record(struct device_extent_tree *tree,
6520 struct device_extent_record *de_rec)
6521 {
6522 int ret;
6523
6524 /*
6525 * Device extent is a bit different from the other extents, because
6526 * the extents which belong to the different devices may have the
6527 * same start and size, so we need use the special extent cache
6528 * search/insert functions.
6529 */
6530 ret = insert_cache_extent2(&tree->tree, &de_rec->cache);
6531 if (ret)
6532 return ret;
6533
6534 list_add_tail(&de_rec->chunk_list, &tree->no_chunk_orphans);
6535 list_add_tail(&de_rec->device_list, &tree->no_device_orphans);
6536 return 0;
6537 }
6538
6539 static void free_device_extent_record(struct cache_extent *cache)
6540 {
6541 struct device_extent_record *rec;
6542
6543 rec = container_of(cache, struct device_extent_record, cache);
6544 if (!list_empty(&rec->chunk_list))
6545 list_del_init(&rec->chunk_list);
6546 if (!list_empty(&rec->device_list))
6547 list_del_init(&rec->device_list);
6548 free(rec);
6549 }
6550
6551 void free_device_extent_tree(struct device_extent_tree *tree)
6552 {
6553 cache_tree_free_extents(&tree->tree, free_device_extent_record);
6554 }
6555
6556 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
6557 static int process_extent_ref_v0(struct cache_tree *extent_cache,
6558 struct extent_buffer *leaf, int slot)
6559 {
6560 struct btrfs_extent_ref_v0 *ref0;
6561 struct btrfs_key key;
6562 int ret;
6563
6564 btrfs_item_key_to_cpu(leaf, &key, slot);
6565 ref0 = btrfs_item_ptr(leaf, slot, struct btrfs_extent_ref_v0);
6566 if (btrfs_ref_objectid_v0(leaf, ref0) < BTRFS_FIRST_FREE_OBJECTID) {
6567 ret = add_tree_backref(extent_cache, key.objectid, key.offset,
6568 0, 0);
6569 } else {
6570 ret = add_data_backref(extent_cache, key.objectid, key.offset,
6571 0, 0, 0, btrfs_ref_count_v0(leaf, ref0), 0, 0);
6572 }
6573 return ret;
6574 }
6575 #endif
6576
6577 struct chunk_record *btrfs_new_chunk_record(struct extent_buffer *leaf,
6578 struct btrfs_key *key,
6579 int slot)
6580 {
6581 struct btrfs_chunk *ptr;
6582 struct chunk_record *rec;
6583 int num_stripes, i;
6584
6585 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_chunk);
6586 num_stripes = btrfs_chunk_num_stripes(leaf, ptr);
6587
6588 rec = calloc(1, btrfs_chunk_record_size(num_stripes));
6589 if (!rec) {
6590 fprintf(stderr, "memory allocation failed\n");
6591 exit(-1);
6592 }
6593
6594 INIT_LIST_HEAD(&rec->list);
6595 INIT_LIST_HEAD(&rec->dextents);
6596 rec->bg_rec = NULL;
6597
6598 rec->cache.start = key->offset;
6599 rec->cache.size = btrfs_chunk_length(leaf, ptr);
6600
6601 rec->generation = btrfs_header_generation(leaf);
6602
6603 rec->objectid = key->objectid;
6604 rec->type = key->type;
6605 rec->offset = key->offset;
6606
6607 rec->length = rec->cache.size;
6608 rec->owner = btrfs_chunk_owner(leaf, ptr);
6609 rec->stripe_len = btrfs_chunk_stripe_len(leaf, ptr);
6610 rec->type_flags = btrfs_chunk_type(leaf, ptr);
6611 rec->io_width = btrfs_chunk_io_width(leaf, ptr);
6612 rec->io_align = btrfs_chunk_io_align(leaf, ptr);
6613 rec->sector_size = btrfs_chunk_sector_size(leaf, ptr);
6614 rec->num_stripes = num_stripes;
6615 rec->sub_stripes = btrfs_chunk_sub_stripes(leaf, ptr);
6616
6617 for (i = 0; i < rec->num_stripes; ++i) {
6618 rec->stripes[i].devid =
6619 btrfs_stripe_devid_nr(leaf, ptr, i);
6620 rec->stripes[i].offset =
6621 btrfs_stripe_offset_nr(leaf, ptr, i);
6622 read_extent_buffer(leaf, rec->stripes[i].dev_uuid,
6623 (unsigned long)btrfs_stripe_dev_uuid_nr(ptr, i),
6624 BTRFS_UUID_SIZE);
6625 }
6626
6627 return rec;
6628 }
6629
6630 static int process_chunk_item(struct cache_tree *chunk_cache,
6631 struct btrfs_key *key, struct extent_buffer *eb,
6632 int slot)
6633 {
6634 struct chunk_record *rec;
6635 struct btrfs_chunk *chunk;
6636 int ret = 0;
6637
6638 chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
6639 /*
6640 * Do extra check for this chunk item,
6641 *
6642 * It's still possible one can craft a leaf with CHUNK_ITEM, with
6643 * wrong onwer(3) out of chunk tree, to pass both chunk tree check
6644 * and owner<->key_type check.
6645 */
6646 ret = btrfs_check_chunk_valid(global_info, eb, chunk, slot,
6647 key->offset);
6648 if (ret < 0) {
6649 error("chunk(%llu, %llu) is not valid, ignore it",
6650 key->offset, btrfs_chunk_length(eb, chunk));
6651 return 0;
6652 }
6653 rec = btrfs_new_chunk_record(eb, key, slot);
6654 ret = insert_cache_extent(chunk_cache, &rec->cache);
6655 if (ret) {
6656 fprintf(stderr, "Chunk[%llu, %llu] existed.\n",
6657 rec->offset, rec->length);
6658 free(rec);
6659 }
6660
6661 return ret;
6662 }
6663
6664 static int process_device_item(struct rb_root *dev_cache,
6665 struct btrfs_key *key, struct extent_buffer *eb, int slot)
6666 {
6667 struct btrfs_dev_item *ptr;
6668 struct device_record *rec;
6669 int ret = 0;
6670
6671 ptr = btrfs_item_ptr(eb,
6672 slot, struct btrfs_dev_item);
6673
6674 rec = malloc(sizeof(*rec));
6675 if (!rec) {
6676 fprintf(stderr, "memory allocation failed\n");
6677 return -ENOMEM;
6678 }
6679
6680 rec->devid = key->offset;
6681 rec->generation = btrfs_header_generation(eb);
6682
6683 rec->objectid = key->objectid;
6684 rec->type = key->type;
6685 rec->offset = key->offset;
6686
6687 rec->devid = btrfs_device_id(eb, ptr);
6688 rec->total_byte = btrfs_device_total_bytes(eb, ptr);
6689 rec->byte_used = btrfs_device_bytes_used(eb, ptr);
6690
6691 ret = rb_insert(dev_cache, &rec->node, device_record_compare);
6692 if (ret) {
6693 fprintf(stderr, "Device[%llu] existed.\n", rec->devid);
6694 free(rec);
6695 }
6696
6697 return ret;
6698 }
6699
6700 struct block_group_record *
6701 btrfs_new_block_group_record(struct extent_buffer *leaf, struct btrfs_key *key,
6702 int slot)
6703 {
6704 struct btrfs_block_group_item *ptr;
6705 struct block_group_record *rec;
6706
6707 rec = calloc(1, sizeof(*rec));
6708 if (!rec) {
6709 fprintf(stderr, "memory allocation failed\n");
6710 exit(-1);
6711 }
6712
6713 rec->cache.start = key->objectid;
6714 rec->cache.size = key->offset;
6715
6716 rec->generation = btrfs_header_generation(leaf);
6717
6718 rec->objectid = key->objectid;
6719 rec->type = key->type;
6720 rec->offset = key->offset;
6721
6722 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_block_group_item);
6723 rec->flags = btrfs_disk_block_group_flags(leaf, ptr);
6724
6725 INIT_LIST_HEAD(&rec->list);
6726
6727 return rec;
6728 }
6729
6730 static int process_block_group_item(struct block_group_tree *block_group_cache,
6731 struct btrfs_key *key,
6732 struct extent_buffer *eb, int slot)
6733 {
6734 struct block_group_record *rec;
6735 int ret = 0;
6736
6737 rec = btrfs_new_block_group_record(eb, key, slot);
6738 ret = insert_block_group_record(block_group_cache, rec);
6739 if (ret) {
6740 fprintf(stderr, "Block Group[%llu, %llu] existed.\n",
6741 rec->objectid, rec->offset);
6742 free(rec);
6743 }
6744
6745 return ret;
6746 }
6747
6748 struct device_extent_record *
6749 btrfs_new_device_extent_record(struct extent_buffer *leaf,
6750 struct btrfs_key *key, int slot)
6751 {
6752 struct device_extent_record *rec;
6753 struct btrfs_dev_extent *ptr;
6754
6755 rec = calloc(1, sizeof(*rec));
6756 if (!rec) {
6757 fprintf(stderr, "memory allocation failed\n");
6758 exit(-1);
6759 }
6760
6761 rec->cache.objectid = key->objectid;
6762 rec->cache.start = key->offset;
6763
6764 rec->generation = btrfs_header_generation(leaf);
6765
6766 rec->objectid = key->objectid;
6767 rec->type = key->type;
6768 rec->offset = key->offset;
6769
6770 ptr = btrfs_item_ptr(leaf, slot, struct btrfs_dev_extent);
6771 rec->chunk_objecteid =
6772 btrfs_dev_extent_chunk_objectid(leaf, ptr);
6773 rec->chunk_offset =
6774 btrfs_dev_extent_chunk_offset(leaf, ptr);
6775 rec->length = btrfs_dev_extent_length(leaf, ptr);
6776 rec->cache.size = rec->length;
6777
6778 INIT_LIST_HEAD(&rec->chunk_list);
6779 INIT_LIST_HEAD(&rec->device_list);
6780
6781 return rec;
6782 }
6783
6784 static int
6785 process_device_extent_item(struct device_extent_tree *dev_extent_cache,
6786 struct btrfs_key *key, struct extent_buffer *eb,
6787 int slot)
6788 {
6789 struct device_extent_record *rec;
6790 int ret;
6791
6792 rec = btrfs_new_device_extent_record(eb, key, slot);
6793 ret = insert_device_extent_record(dev_extent_cache, rec);
6794 if (ret) {
6795 fprintf(stderr,
6796 "Device extent[%llu, %llu, %llu] existed.\n",
6797 rec->objectid, rec->offset, rec->length);
6798 free(rec);
6799 }
6800
6801 return ret;
6802 }
6803
6804 static int process_extent_item(struct btrfs_root *root,
6805 struct cache_tree *extent_cache,
6806 struct extent_buffer *eb, int slot)
6807 {
6808 struct btrfs_extent_item *ei;
6809 struct btrfs_extent_inline_ref *iref;
6810 struct btrfs_extent_data_ref *dref;
6811 struct btrfs_shared_data_ref *sref;
6812 struct btrfs_key key;
6813 struct extent_record tmpl;
6814 unsigned long end;
6815 unsigned long ptr;
6816 int ret;
6817 int type;
6818 u32 item_size = btrfs_item_size_nr(eb, slot);
6819 u64 refs = 0;
6820 u64 offset;
6821 u64 num_bytes;
6822 int metadata = 0;
6823
6824 btrfs_item_key_to_cpu(eb, &key, slot);
6825
6826 if (key.type == BTRFS_METADATA_ITEM_KEY) {
6827 metadata = 1;
6828 num_bytes = root->fs_info->nodesize;
6829 } else {
6830 num_bytes = key.offset;
6831 }
6832
6833 if (!IS_ALIGNED(key.objectid, root->fs_info->sectorsize)) {
6834 error("ignoring invalid extent, bytenr %llu is not aligned to %u",
6835 key.objectid, root->fs_info->sectorsize);
6836 return -EIO;
6837 }
6838 if (item_size < sizeof(*ei)) {
6839 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
6840 struct btrfs_extent_item_v0 *ei0;
6841 BUG_ON(item_size != sizeof(*ei0));
6842 ei0 = btrfs_item_ptr(eb, slot, struct btrfs_extent_item_v0);
6843 refs = btrfs_extent_refs_v0(eb, ei0);
6844 #else
6845 BUG();
6846 #endif
6847 memset(&tmpl, 0, sizeof(tmpl));
6848 tmpl.start = key.objectid;
6849 tmpl.nr = num_bytes;
6850 tmpl.extent_item_refs = refs;
6851 tmpl.metadata = metadata;
6852 tmpl.found_rec = 1;
6853 tmpl.max_size = num_bytes;
6854
6855 return add_extent_rec(extent_cache, &tmpl);
6856 }
6857
6858 ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
6859 refs = btrfs_extent_refs(eb, ei);
6860 if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK)
6861 metadata = 1;
6862 else
6863 metadata = 0;
6864 if (metadata && num_bytes != root->fs_info->nodesize) {
6865 error("ignore invalid metadata extent, length %llu does not equal to %u",
6866 num_bytes, root->fs_info->nodesize);
6867 return -EIO;
6868 }
6869 if (!metadata && !IS_ALIGNED(num_bytes, root->fs_info->sectorsize)) {
6870 error("ignore invalid data extent, length %llu is not aligned to %u",
6871 num_bytes, root->fs_info->sectorsize);
6872 return -EIO;
6873 }
6874
6875 memset(&tmpl, 0, sizeof(tmpl));
6876 tmpl.start = key.objectid;
6877 tmpl.nr = num_bytes;
6878 tmpl.extent_item_refs = refs;
6879 tmpl.metadata = metadata;
6880 tmpl.found_rec = 1;
6881 tmpl.max_size = num_bytes;
6882 add_extent_rec(extent_cache, &tmpl);
6883
6884 ptr = (unsigned long)(ei + 1);
6885 if (btrfs_extent_flags(eb, ei) & BTRFS_EXTENT_FLAG_TREE_BLOCK &&
6886 key.type == BTRFS_EXTENT_ITEM_KEY)
6887 ptr += sizeof(struct btrfs_tree_block_info);
6888
6889 end = (unsigned long)ei + item_size;
6890 while (ptr < end) {
6891 iref = (struct btrfs_extent_inline_ref *)ptr;
6892 type = btrfs_extent_inline_ref_type(eb, iref);
6893 offset = btrfs_extent_inline_ref_offset(eb, iref);
6894 switch (type) {
6895 case BTRFS_TREE_BLOCK_REF_KEY:
6896 ret = add_tree_backref(extent_cache, key.objectid,
6897 0, offset, 0);
6898 if (ret < 0)
6899 error(
6900 "add_tree_backref failed (extent items tree block): %s",
6901 strerror(-ret));
6902 break;
6903 case BTRFS_SHARED_BLOCK_REF_KEY:
6904 ret = add_tree_backref(extent_cache, key.objectid,
6905 offset, 0, 0);
6906 if (ret < 0)
6907 error(
6908 "add_tree_backref failed (extent items shared block): %s",
6909 strerror(-ret));
6910 break;
6911 case BTRFS_EXTENT_DATA_REF_KEY:
6912 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
6913 add_data_backref(extent_cache, key.objectid, 0,
6914 btrfs_extent_data_ref_root(eb, dref),
6915 btrfs_extent_data_ref_objectid(eb,
6916 dref),
6917 btrfs_extent_data_ref_offset(eb, dref),
6918 btrfs_extent_data_ref_count(eb, dref),
6919 0, num_bytes);
6920 break;
6921 case BTRFS_SHARED_DATA_REF_KEY:
6922 sref = (struct btrfs_shared_data_ref *)(iref + 1);
6923 add_data_backref(extent_cache, key.objectid, offset,
6924 0, 0, 0,
6925 btrfs_shared_data_ref_count(eb, sref),
6926 0, num_bytes);
6927 break;
6928 default:
6929 fprintf(stderr, "corrupt extent record: key %Lu %u %Lu\n",
6930 key.objectid, key.type, num_bytes);
6931 goto out;
6932 }
6933 ptr += btrfs_extent_inline_ref_size(type);
6934 }
6935 WARN_ON(ptr > end);
6936 out:
6937 return 0;
6938 }
6939
6940 static int check_cache_range(struct btrfs_root *root,
6941 struct btrfs_block_group_cache *cache,
6942 u64 offset, u64 bytes)
6943 {
6944 struct btrfs_free_space *entry;
6945 u64 *logical;
6946 u64 bytenr;
6947 int stripe_len;
6948 int i, nr, ret;
6949
6950 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
6951 bytenr = btrfs_sb_offset(i);
6952 ret = btrfs_rmap_block(root->fs_info,
6953 cache->key.objectid, bytenr, 0,
6954 &logical, &nr, &stripe_len);
6955 if (ret)
6956 return ret;
6957
6958 while (nr--) {
6959 if (logical[nr] + stripe_len <= offset)
6960 continue;
6961 if (offset + bytes <= logical[nr])
6962 continue;
6963 if (logical[nr] == offset) {
6964 if (stripe_len >= bytes) {
6965 free(logical);
6966 return 0;
6967 }
6968 bytes -= stripe_len;
6969 offset += stripe_len;
6970 } else if (logical[nr] < offset) {
6971 if (logical[nr] + stripe_len >=
6972 offset + bytes) {
6973 free(logical);
6974 return 0;
6975 }
6976 bytes = (offset + bytes) -
6977 (logical[nr] + stripe_len);
6978 offset = logical[nr] + stripe_len;
6979 } else {
6980 /*
6981 * Could be tricky, the super may land in the
6982 * middle of the area we're checking. First
6983 * check the easiest case, it's at the end.
6984 */
6985 if (logical[nr] + stripe_len >=
6986 bytes + offset) {
6987 bytes = logical[nr] - offset;
6988 continue;
6989 }
6990
6991 /* Check the left side */
6992 ret = check_cache_range(root, cache,
6993 offset,
6994 logical[nr] - offset);
6995 if (ret) {
6996 free(logical);
6997 return ret;
6998 }
6999
7000 /* Now we continue with the right side */
7001 bytes = (offset + bytes) -
7002 (logical[nr] + stripe_len);
7003 offset = logical[nr] + stripe_len;
7004 }
7005 }
7006
7007 free(logical);
7008 }
7009
7010 entry = btrfs_find_free_space(cache->free_space_ctl, offset, bytes);
7011 if (!entry) {
7012 fprintf(stderr, "There is no free space entry for %Lu-%Lu\n",
7013 offset, offset+bytes);
7014 return -EINVAL;
7015 }
7016
7017 if (entry->offset != offset) {
7018 fprintf(stderr, "Wanted offset %Lu, found %Lu\n", offset,
7019 entry->offset);
7020 return -EINVAL;
7021 }
7022
7023 if (entry->bytes != bytes) {
7024 fprintf(stderr, "Wanted bytes %Lu, found %Lu for off %Lu\n",
7025 bytes, entry->bytes, offset);
7026 return -EINVAL;
7027 }
7028
7029 unlink_free_space(cache->free_space_ctl, entry);
7030 free(entry);
7031 return 0;
7032 }
7033
7034 static int verify_space_cache(struct btrfs_root *root,
7035 struct btrfs_block_group_cache *cache)
7036 {
7037 struct btrfs_path path;
7038 struct extent_buffer *leaf;
7039 struct btrfs_key key;
7040 u64 last;
7041 int ret = 0;
7042
7043 root = root->fs_info->extent_root;
7044
7045 last = max_t(u64, cache->key.objectid, BTRFS_SUPER_INFO_OFFSET);
7046
7047 btrfs_init_path(&path);
7048 key.objectid = last;
7049 key.offset = 0;
7050 key.type = BTRFS_EXTENT_ITEM_KEY;
7051 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
7052 if (ret < 0)
7053 goto out;
7054 ret = 0;
7055 while (1) {
7056 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
7057 ret = btrfs_next_leaf(root, &path);
7058 if (ret < 0)
7059 goto out;
7060 if (ret > 0) {
7061 ret = 0;
7062 break;
7063 }
7064 }
7065 leaf = path.nodes[0];
7066 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
7067 if (key.objectid >= cache->key.offset + cache->key.objectid)
7068 break;
7069 if (key.type != BTRFS_EXTENT_ITEM_KEY &&
7070 key.type != BTRFS_METADATA_ITEM_KEY) {
7071 path.slots[0]++;
7072 continue;
7073 }
7074
7075 if (last == key.objectid) {
7076 if (key.type == BTRFS_EXTENT_ITEM_KEY)
7077 last = key.objectid + key.offset;
7078 else
7079 last = key.objectid + root->fs_info->nodesize;
7080 path.slots[0]++;
7081 continue;
7082 }
7083
7084 ret = check_cache_range(root, cache, last,
7085 key.objectid - last);
7086 if (ret)
7087 break;
7088 if (key.type == BTRFS_EXTENT_ITEM_KEY)
7089 last = key.objectid + key.offset;
7090 else
7091 last = key.objectid + root->fs_info->nodesize;
7092 path.slots[0]++;
7093 }
7094
7095 if (last < cache->key.objectid + cache->key.offset)
7096 ret = check_cache_range(root, cache, last,
7097 cache->key.objectid +
7098 cache->key.offset - last);
7099
7100 out:
7101 btrfs_release_path(&path);
7102
7103 if (!ret &&
7104 !RB_EMPTY_ROOT(&cache->free_space_ctl->free_space_offset)) {
7105 fprintf(stderr, "There are still entries left in the space "
7106 "cache\n");
7107 ret = -EINVAL;
7108 }
7109
7110 return ret;
7111 }
7112
7113 static int check_space_cache(struct btrfs_root *root)
7114 {
7115 struct btrfs_block_group_cache *cache;
7116 u64 start = BTRFS_SUPER_INFO_OFFSET + BTRFS_SUPER_INFO_SIZE;
7117 int ret;
7118 int error = 0;
7119
7120 if (btrfs_super_cache_generation(root->fs_info->super_copy) != -1ULL &&
7121 btrfs_super_generation(root->fs_info->super_copy) !=
7122 btrfs_super_cache_generation(root->fs_info->super_copy)) {
7123 printf("cache and super generation don't match, space cache "
7124 "will be invalidated\n");
7125 return 0;
7126 }
7127
7128 if (ctx.progress_enabled) {
7129 ctx.tp = TASK_FREE_SPACE;
7130 task_start(ctx.info);
7131 }
7132
7133 while (1) {
7134 cache = btrfs_lookup_first_block_group(root->fs_info, start);
7135 if (!cache)
7136 break;
7137
7138 start = cache->key.objectid + cache->key.offset;
7139 if (!cache->free_space_ctl) {
7140 if (btrfs_init_free_space_ctl(cache,
7141 root->fs_info->sectorsize)) {
7142 ret = -ENOMEM;
7143 break;
7144 }
7145 } else {
7146 btrfs_remove_free_space_cache(cache);
7147 }
7148
7149 if (btrfs_fs_compat_ro(root->fs_info, FREE_SPACE_TREE)) {
7150 ret = exclude_super_stripes(root, cache);
7151 if (ret) {
7152 fprintf(stderr, "could not exclude super stripes: %s\n",
7153 strerror(-ret));
7154 error++;
7155 continue;
7156 }
7157 ret = load_free_space_tree(root->fs_info, cache);
7158 free_excluded_extents(root, cache);
7159 if (ret < 0) {
7160 fprintf(stderr, "could not load free space tree: %s\n",
7161 strerror(-ret));
7162 error++;
7163 continue;
7164 }
7165 error += ret;
7166 } else {
7167 ret = load_free_space_cache(root->fs_info, cache);
7168 if (!ret)
7169 continue;
7170 }
7171
7172 ret = verify_space_cache(root, cache);
7173 if (ret) {
7174 fprintf(stderr, "cache appears valid but isn't %Lu\n",
7175 cache->key.objectid);
7176 error++;
7177 }
7178 }
7179
7180 task_stop(ctx.info);
7181
7182 return error ? -EINVAL : 0;
7183 }
7184
7185 static int check_extent_csums(struct btrfs_root *root, u64 bytenr,
7186 u64 num_bytes, unsigned long leaf_offset,
7187 struct extent_buffer *eb) {
7188
7189 struct btrfs_fs_info *fs_info = root->fs_info;
7190 u64 offset = 0;
7191 u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
7192 char *data;
7193 unsigned long csum_offset;
7194 u32 csum;
7195 u32 csum_expected;
7196 u64 read_len;
7197 u64 data_checked = 0;
7198 u64 tmp;
7199 int ret = 0;
7200 int mirror;
7201 int num_copies;
7202
7203 if (num_bytes % fs_info->sectorsize)
7204 return -EINVAL;
7205
7206 data = malloc(num_bytes);
7207 if (!data)
7208 return -ENOMEM;
7209
7210 while (offset < num_bytes) {
7211 mirror = 0;
7212 again:
7213 read_len = num_bytes - offset;
7214 /* read as much space once a time */
7215 ret = read_extent_data(fs_info, data + offset,
7216 bytenr + offset, &read_len, mirror);
7217 if (ret)
7218 goto out;
7219 data_checked = 0;
7220 /* verify every 4k data's checksum */
7221 while (data_checked < read_len) {
7222 csum = ~(u32)0;
7223 tmp = offset + data_checked;
7224
7225 csum = btrfs_csum_data((char *)data + tmp,
7226 csum, fs_info->sectorsize);
7227 btrfs_csum_final(csum, (u8 *)&csum);
7228
7229 csum_offset = leaf_offset +
7230 tmp / fs_info->sectorsize * csum_size;
7231 read_extent_buffer(eb, (char *)&csum_expected,
7232 csum_offset, csum_size);
7233 /* try another mirror */
7234 if (csum != csum_expected) {
7235 fprintf(stderr, "mirror %d bytenr %llu csum %u expected csum %u\n",
7236 mirror, bytenr + tmp,
7237 csum, csum_expected);
7238 num_copies = btrfs_num_copies(root->fs_info,
7239 bytenr, num_bytes);
7240 if (mirror < num_copies - 1) {
7241 mirror += 1;
7242 goto again;
7243 }
7244 }
7245 data_checked += fs_info->sectorsize;
7246 }
7247 offset += read_len;
7248 }
7249 out:
7250 free(data);
7251 return ret;
7252 }
7253
7254 static int check_extent_exists(struct btrfs_root *root, u64 bytenr,
7255 u64 num_bytes)
7256 {
7257 struct btrfs_path path;
7258 struct extent_buffer *leaf;
7259 struct btrfs_key key;
7260 int ret;
7261
7262 btrfs_init_path(&path);
7263 key.objectid = bytenr;
7264 key.type = BTRFS_EXTENT_ITEM_KEY;
7265 key.offset = (u64)-1;
7266
7267 again:
7268 ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, &path,
7269 0, 0);
7270 if (ret < 0) {
7271 fprintf(stderr, "Error looking up extent record %d\n", ret);
7272 btrfs_release_path(&path);
7273 return ret;
7274 } else if (ret) {
7275 if (path.slots[0] > 0) {
7276 path.slots[0]--;
7277 } else {
7278 ret = btrfs_prev_leaf(root, &path);
7279 if (ret < 0) {
7280 goto out;
7281 } else if (ret > 0) {
7282 ret = 0;
7283 goto out;
7284 }
7285 }
7286 }
7287
7288 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
7289
7290 /*
7291 * Block group items come before extent items if they have the same
7292 * bytenr, so walk back one more just in case. Dear future traveller,
7293 * first congrats on mastering time travel. Now if it's not too much
7294 * trouble could you go back to 2006 and tell Chris to make the
7295 * BLOCK_GROUP_ITEM_KEY (and BTRFS_*_REF_KEY) lower than the
7296 * EXTENT_ITEM_KEY please?
7297 */
7298 while (key.type > BTRFS_EXTENT_ITEM_KEY) {
7299 if (path.slots[0] > 0) {
7300 path.slots[0]--;
7301 } else {
7302 ret = btrfs_prev_leaf(root, &path);
7303 if (ret < 0) {
7304 goto out;
7305 } else if (ret > 0) {
7306 ret = 0;
7307 goto out;
7308 }
7309 }
7310 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
7311 }
7312
7313 while (num_bytes) {
7314 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
7315 ret = btrfs_next_leaf(root, &path);
7316 if (ret < 0) {
7317 fprintf(stderr, "Error going to next leaf "
7318 "%d\n", ret);
7319 btrfs_release_path(&path);
7320 return ret;
7321 } else if (ret) {
7322 break;
7323 }
7324 }
7325 leaf = path.nodes[0];
7326 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
7327 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
7328 path.slots[0]++;
7329 continue;
7330 }
7331 if (key.objectid + key.offset < bytenr) {
7332 path.slots[0]++;
7333 continue;
7334 }
7335 if (key.objectid > bytenr + num_bytes)
7336 break;
7337
7338 if (key.objectid == bytenr) {
7339 if (key.offset >= num_bytes) {
7340 num_bytes = 0;
7341 break;
7342 }
7343 num_bytes -= key.offset;
7344 bytenr += key.offset;
7345 } else if (key.objectid < bytenr) {
7346 if (key.objectid + key.offset >= bytenr + num_bytes) {
7347 num_bytes = 0;
7348 break;
7349 }
7350 num_bytes = (bytenr + num_bytes) -
7351 (key.objectid + key.offset);
7352 bytenr = key.objectid + key.offset;
7353 } else {
7354 if (key.objectid + key.offset < bytenr + num_bytes) {
7355 u64 new_start = key.objectid + key.offset;
7356 u64 new_bytes = bytenr + num_bytes - new_start;
7357
7358 /*
7359 * Weird case, the extent is in the middle of
7360 * our range, we'll have to search one side
7361 * and then the other. Not sure if this happens
7362 * in real life, but no harm in coding it up
7363 * anyway just in case.
7364 */
7365 btrfs_release_path(&path);
7366 ret = check_extent_exists(root, new_start,
7367 new_bytes);
7368 if (ret) {
7369 fprintf(stderr, "Right section didn't "
7370 "have a record\n");
7371 break;
7372 }
7373 num_bytes = key.objectid - bytenr;
7374 goto again;
7375 }
7376 num_bytes = key.objectid - bytenr;
7377 }
7378 path.slots[0]++;
7379 }
7380 ret = 0;
7381
7382 out:
7383 if (num_bytes && !ret) {
7384 fprintf(stderr, "There are no extents for csum range "
7385 "%Lu-%Lu\n", bytenr, bytenr+num_bytes);
7386 ret = 1;
7387 }
7388
7389 btrfs_release_path(&path);
7390 return ret;
7391 }
7392
7393 static int check_csums(struct btrfs_root *root)
7394 {
7395 struct btrfs_path path;
7396 struct extent_buffer *leaf;
7397 struct btrfs_key key;
7398 u64 offset = 0, num_bytes = 0;
7399 u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
7400 int errors = 0;
7401 int ret;
7402 u64 data_len;
7403 unsigned long leaf_offset;
7404
7405 root = root->fs_info->csum_root;
7406 if (!extent_buffer_uptodate(root->node)) {
7407 fprintf(stderr, "No valid csum tree found\n");
7408 return -ENOENT;
7409 }
7410
7411 btrfs_init_path(&path);
7412 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
7413 key.type = BTRFS_EXTENT_CSUM_KEY;
7414 key.offset = 0;
7415 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
7416 if (ret < 0) {
7417 fprintf(stderr, "Error searching csum tree %d\n", ret);
7418 btrfs_release_path(&path);
7419 return ret;
7420 }
7421
7422 if (ret > 0 && path.slots[0])
7423 path.slots[0]--;
7424 ret = 0;
7425
7426 while (1) {
7427 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
7428 ret = btrfs_next_leaf(root, &path);
7429 if (ret < 0) {
7430 fprintf(stderr, "Error going to next leaf "
7431 "%d\n", ret);
7432 break;
7433 }
7434 if (ret)
7435 break;
7436 }
7437 leaf = path.nodes[0];
7438
7439 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
7440 if (key.type != BTRFS_EXTENT_CSUM_KEY) {
7441 path.slots[0]++;
7442 continue;
7443 }
7444
7445 data_len = (btrfs_item_size_nr(leaf, path.slots[0]) /
7446 csum_size) * root->fs_info->sectorsize;
7447 if (!check_data_csum)
7448 goto skip_csum_check;
7449 leaf_offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
7450 ret = check_extent_csums(root, key.offset, data_len,
7451 leaf_offset, leaf);
7452 if (ret)
7453 break;
7454 skip_csum_check:
7455 if (!num_bytes) {
7456 offset = key.offset;
7457 } else if (key.offset != offset + num_bytes) {
7458 ret = check_extent_exists(root, offset, num_bytes);
7459 if (ret) {
7460 fprintf(stderr, "Csum exists for %Lu-%Lu but "
7461 "there is no extent record\n",
7462 offset, offset+num_bytes);
7463 errors++;
7464 }
7465 offset = key.offset;
7466 num_bytes = 0;
7467 }
7468 num_bytes += data_len;
7469 path.slots[0]++;
7470 }
7471
7472 btrfs_release_path(&path);
7473 return errors;
7474 }
7475
7476 static int is_dropped_key(struct btrfs_key *key,
7477 struct btrfs_key *drop_key) {
7478 if (key->objectid < drop_key->objectid)
7479 return 1;
7480 else if (key->objectid == drop_key->objectid) {
7481 if (key->type < drop_key->type)
7482 return 1;
7483 else if (key->type == drop_key->type) {
7484 if (key->offset < drop_key->offset)
7485 return 1;
7486 }
7487 }
7488 return 0;
7489 }
7490
7491 /*
7492 * Here are the rules for FULL_BACKREF.
7493 *
7494 * 1) If BTRFS_HEADER_FLAG_RELOC is set then we have FULL_BACKREF set.
7495 * 2) If btrfs_header_owner(buf) no longer points to buf then we have
7496 * FULL_BACKREF set.
7497 * 3) We cowed the block walking down a reloc tree. This is impossible to tell
7498 * if it happened after the relocation occurred since we'll have dropped the
7499 * reloc root, so it's entirely possible to have FULL_BACKREF set on buf and
7500 * have no real way to know for sure.
7501 *
7502 * We process the blocks one root at a time, and we start from the lowest root
7503 * objectid and go to the highest. So we can just lookup the owner backref for
7504 * the record and if we don't find it then we know it doesn't exist and we have
7505 * a FULL BACKREF.
7506 *
7507 * FIXME: if we ever start reclaiming root objectid's then we need to fix this
7508 * assumption and simply indicate that we _think_ that the FULL BACKREF needs to
7509 * be set or not and then we can check later once we've gathered all the refs.
7510 */
7511 static int calc_extent_flag(struct cache_tree *extent_cache,
7512 struct extent_buffer *buf,
7513 struct root_item_record *ri,
7514 u64 *flags)
7515 {
7516 struct extent_record *rec;
7517 struct cache_extent *cache;
7518 struct tree_backref *tback;
7519 u64 owner = 0;
7520
7521 cache = lookup_cache_extent(extent_cache, buf->start, 1);
7522 /* we have added this extent before */
7523 if (!cache)
7524 return -ENOENT;
7525
7526 rec = container_of(cache, struct extent_record, cache);
7527
7528 /*
7529 * Except file/reloc tree, we can not have
7530 * FULL BACKREF MODE
7531 */
7532 if (ri->objectid < BTRFS_FIRST_FREE_OBJECTID)
7533 goto normal;
7534 /*
7535 * root node
7536 */
7537 if (buf->start == ri->bytenr)
7538 goto normal;
7539
7540 if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
7541 goto full_backref;
7542
7543 owner = btrfs_header_owner(buf);
7544 if (owner == ri->objectid)
7545 goto normal;
7546
7547 tback = find_tree_backref(rec, 0, owner);
7548 if (!tback)
7549 goto full_backref;
7550 normal:
7551 *flags = 0;
7552 if (rec->flag_block_full_backref != FLAG_UNSET &&
7553 rec->flag_block_full_backref != 0)
7554 rec->bad_full_backref = 1;
7555 return 0;
7556 full_backref:
7557 *flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7558 if (rec->flag_block_full_backref != FLAG_UNSET &&
7559 rec->flag_block_full_backref != 1)
7560 rec->bad_full_backref = 1;
7561 return 0;
7562 }
7563
7564 static void report_mismatch_key_root(u8 key_type, u64 rootid)
7565 {
7566 fprintf(stderr, "Invalid key type(");
7567 print_key_type(stderr, 0, key_type);
7568 fprintf(stderr, ") found in root(");
7569 print_objectid(stderr, rootid, 0);
7570 fprintf(stderr, ")\n");
7571 }
7572
7573 /*
7574 * Check if the key is valid with its extent buffer.
7575 *
7576 * This is a early check in case invalid key exists in a extent buffer
7577 * This is not comprehensive yet, but should prevent wrong key/item passed
7578 * further
7579 */
7580 static int check_type_with_root(u64 rootid, u8 key_type)
7581 {
7582 switch (key_type) {
7583 /* Only valid in chunk tree */
7584 case BTRFS_DEV_ITEM_KEY:
7585 case BTRFS_CHUNK_ITEM_KEY:
7586 if (rootid != BTRFS_CHUNK_TREE_OBJECTID)
7587 goto err;
7588 break;
7589 /* valid in csum and log tree */
7590 case BTRFS_CSUM_TREE_OBJECTID:
7591 if (!(rootid == BTRFS_TREE_LOG_OBJECTID ||
7592 is_fstree(rootid)))
7593 goto err;
7594 break;
7595 case BTRFS_EXTENT_ITEM_KEY:
7596 case BTRFS_METADATA_ITEM_KEY:
7597 case BTRFS_BLOCK_GROUP_ITEM_KEY:
7598 if (rootid != BTRFS_EXTENT_TREE_OBJECTID)
7599 goto err;
7600 break;
7601 case BTRFS_ROOT_ITEM_KEY:
7602 if (rootid != BTRFS_ROOT_TREE_OBJECTID)
7603 goto err;
7604 break;
7605 case BTRFS_DEV_EXTENT_KEY:
7606 if (rootid != BTRFS_DEV_TREE_OBJECTID)
7607 goto err;
7608 break;
7609 }
7610 return 0;
7611 err:
7612 report_mismatch_key_root(key_type, rootid);
7613 return -EINVAL;
7614 }
7615
7616 static int run_next_block(struct btrfs_root *root,
7617 struct block_info *bits,
7618 int bits_nr,
7619 u64 *last,
7620 struct cache_tree *pending,
7621 struct cache_tree *seen,
7622 struct cache_tree *reada,
7623 struct cache_tree *nodes,
7624 struct cache_tree *extent_cache,
7625 struct cache_tree *chunk_cache,
7626 struct rb_root *dev_cache,
7627 struct block_group_tree *block_group_cache,
7628 struct device_extent_tree *dev_extent_cache,
7629 struct root_item_record *ri)
7630 {
7631 struct btrfs_fs_info *fs_info = root->fs_info;
7632 struct extent_buffer *buf;
7633 struct extent_record *rec = NULL;
7634 u64 bytenr;
7635 u32 size;
7636 u64 parent;
7637 u64 owner;
7638 u64 flags;
7639 u64 ptr;
7640 u64 gen = 0;
7641 int ret = 0;
7642 int i;
7643 int nritems;
7644 struct btrfs_key key;
7645 struct cache_extent *cache;
7646 int reada_bits;
7647
7648 nritems = pick_next_pending(pending, reada, nodes, *last, bits,
7649 bits_nr, &reada_bits);
7650 if (nritems == 0)
7651 return 1;
7652
7653 if (!reada_bits) {
7654 for(i = 0; i < nritems; i++) {
7655 ret = add_cache_extent(reada, bits[i].start,
7656 bits[i].size);
7657 if (ret == -EEXIST)
7658 continue;
7659
7660 /* fixme, get the parent transid */
7661 readahead_tree_block(fs_info, bits[i].start,
7662 bits[i].size, 0);
7663 }
7664 }
7665 *last = bits[0].start;
7666 bytenr = bits[0].start;
7667 size = bits[0].size;
7668
7669 cache = lookup_cache_extent(pending, bytenr, size);
7670 if (cache) {
7671 remove_cache_extent(pending, cache);
7672 free(cache);
7673 }
7674 cache = lookup_cache_extent(reada, bytenr, size);
7675 if (cache) {
7676 remove_cache_extent(reada, cache);
7677 free(cache);
7678 }
7679 cache = lookup_cache_extent(nodes, bytenr, size);
7680 if (cache) {
7681 remove_cache_extent(nodes, cache);
7682 free(cache);
7683 }
7684 cache = lookup_cache_extent(extent_cache, bytenr, size);
7685 if (cache) {
7686 rec = container_of(cache, struct extent_record, cache);
7687 gen = rec->parent_generation;
7688 }
7689
7690 /* fixme, get the real parent transid */
7691 buf = read_tree_block(root->fs_info, bytenr, size, gen);
7692 if (!extent_buffer_uptodate(buf)) {
7693 record_bad_block_io(root->fs_info,
7694 extent_cache, bytenr, size);
7695 goto out;
7696 }
7697
7698 nritems = btrfs_header_nritems(buf);
7699
7700 flags = 0;
7701 if (!init_extent_tree) {
7702 ret = btrfs_lookup_extent_info(NULL, root, bytenr,
7703 btrfs_header_level(buf), 1, NULL,
7704 &flags);
7705 if (ret < 0) {
7706 ret = calc_extent_flag(extent_cache, buf, ri, &flags);
7707 if (ret < 0) {
7708 fprintf(stderr, "Couldn't calc extent flags\n");
7709 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7710 }
7711 }
7712 } else {
7713 flags = 0;
7714 ret = calc_extent_flag(extent_cache, buf, ri, &flags);
7715 if (ret < 0) {
7716 fprintf(stderr, "Couldn't calc extent flags\n");
7717 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7718 }
7719 }
7720
7721 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
7722 if (ri != NULL &&
7723 ri->objectid != BTRFS_TREE_RELOC_OBJECTID &&
7724 ri->objectid == btrfs_header_owner(buf)) {
7725 /*
7726 * Ok we got to this block from it's original owner and
7727 * we have FULL_BACKREF set. Relocation can leave
7728 * converted blocks over so this is altogether possible,
7729 * however it's not possible if the generation > the
7730 * last snapshot, so check for this case.
7731 */
7732 if (!btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC) &&
7733 btrfs_header_generation(buf) > ri->last_snapshot) {
7734 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
7735 rec->bad_full_backref = 1;
7736 }
7737 }
7738 } else {
7739 if (ri != NULL &&
7740 (ri->objectid == BTRFS_TREE_RELOC_OBJECTID ||
7741 btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))) {
7742 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
7743 rec->bad_full_backref = 1;
7744 }
7745 }
7746
7747 if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
7748 rec->flag_block_full_backref = 1;
7749 parent = bytenr;
7750 owner = 0;
7751 } else {
7752 rec->flag_block_full_backref = 0;
7753 parent = 0;
7754 owner = btrfs_header_owner(buf);
7755 }
7756
7757 ret = check_block(root, extent_cache, buf, flags);
7758 if (ret)
7759 goto out;
7760
7761 if (btrfs_is_leaf(buf)) {
7762 btree_space_waste += btrfs_leaf_free_space(root, buf);
7763 for (i = 0; i < nritems; i++) {
7764 struct btrfs_file_extent_item *fi;
7765 btrfs_item_key_to_cpu(buf, &key, i);
7766 /*
7767 * Check key type against the leaf owner.
7768 * Could filter quite a lot of early error if
7769 * owner is correct
7770 */
7771 if (check_type_with_root(btrfs_header_owner(buf),
7772 key.type)) {
7773 fprintf(stderr, "ignoring invalid key\n");
7774 continue;
7775 }
7776 if (key.type == BTRFS_EXTENT_ITEM_KEY) {
7777 process_extent_item(root, extent_cache, buf,
7778 i);
7779 continue;
7780 }
7781 if (key.type == BTRFS_METADATA_ITEM_KEY) {
7782 process_extent_item(root, extent_cache, buf,
7783 i);
7784 continue;
7785 }
7786 if (key.type == BTRFS_EXTENT_CSUM_KEY) {
7787 total_csum_bytes +=
7788 btrfs_item_size_nr(buf, i);
7789 continue;
7790 }
7791 if (key.type == BTRFS_CHUNK_ITEM_KEY) {
7792 process_chunk_item(chunk_cache, &key, buf, i);
7793 continue;
7794 }
7795 if (key.type == BTRFS_DEV_ITEM_KEY) {
7796 process_device_item(dev_cache, &key, buf, i);
7797 continue;
7798 }
7799 if (key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
7800 process_block_group_item(block_group_cache,
7801 &key, buf, i);
7802 continue;
7803 }
7804 if (key.type == BTRFS_DEV_EXTENT_KEY) {
7805 process_device_extent_item(dev_extent_cache,
7806 &key, buf, i);
7807 continue;
7808
7809 }
7810 if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
7811 #ifdef BTRFS_COMPAT_EXTENT_TREE_V0
7812 process_extent_ref_v0(extent_cache, buf, i);
7813 #else
7814 BUG();
7815 #endif
7816 continue;
7817 }
7818
7819 if (key.type == BTRFS_TREE_BLOCK_REF_KEY) {
7820 ret = add_tree_backref(extent_cache,
7821 key.objectid, 0, key.offset, 0);
7822 if (ret < 0)
7823 error(
7824 "add_tree_backref failed (leaf tree block): %s",
7825 strerror(-ret));
7826 continue;
7827 }
7828 if (key.type == BTRFS_SHARED_BLOCK_REF_KEY) {
7829 ret = add_tree_backref(extent_cache,
7830 key.objectid, key.offset, 0, 0);
7831 if (ret < 0)
7832 error(
7833 "add_tree_backref failed (leaf shared block): %s",
7834 strerror(-ret));
7835 continue;
7836 }
7837 if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
7838 struct btrfs_extent_data_ref *ref;
7839 ref = btrfs_item_ptr(buf, i,
7840 struct btrfs_extent_data_ref);
7841 add_data_backref(extent_cache,
7842 key.objectid, 0,
7843 btrfs_extent_data_ref_root(buf, ref),
7844 btrfs_extent_data_ref_objectid(buf,
7845 ref),
7846 btrfs_extent_data_ref_offset(buf, ref),
7847 btrfs_extent_data_ref_count(buf, ref),
7848 0, root->fs_info->sectorsize);
7849 continue;
7850 }
7851 if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
7852 struct btrfs_shared_data_ref *ref;
7853 ref = btrfs_item_ptr(buf, i,
7854 struct btrfs_shared_data_ref);
7855 add_data_backref(extent_cache,
7856 key.objectid, key.offset, 0, 0, 0,
7857 btrfs_shared_data_ref_count(buf, ref),
7858 0, root->fs_info->sectorsize);
7859 continue;
7860 }
7861 if (key.type == BTRFS_ORPHAN_ITEM_KEY) {
7862 struct bad_item *bad;
7863
7864 if (key.objectid == BTRFS_ORPHAN_OBJECTID)
7865 continue;
7866 if (!owner)
7867 continue;
7868 bad = malloc(sizeof(struct bad_item));
7869 if (!bad)
7870 continue;
7871 INIT_LIST_HEAD(&bad->list);
7872 memcpy(&bad->key, &key,
7873 sizeof(struct btrfs_key));
7874 bad->root_id = owner;
7875 list_add_tail(&bad->list, &delete_items);
7876 continue;
7877 }
7878 if (key.type != BTRFS_EXTENT_DATA_KEY)
7879 continue;
7880 fi = btrfs_item_ptr(buf, i,
7881 struct btrfs_file_extent_item);
7882 if (btrfs_file_extent_type(buf, fi) ==
7883 BTRFS_FILE_EXTENT_INLINE)
7884 continue;
7885 if (btrfs_file_extent_disk_bytenr(buf, fi) == 0)
7886 continue;
7887
7888 data_bytes_allocated +=
7889 btrfs_file_extent_disk_num_bytes(buf, fi);
7890 if (data_bytes_allocated < root->fs_info->sectorsize) {
7891 abort();
7892 }
7893 data_bytes_referenced +=
7894 btrfs_file_extent_num_bytes(buf, fi);
7895 add_data_backref(extent_cache,
7896 btrfs_file_extent_disk_bytenr(buf, fi),
7897 parent, owner, key.objectid, key.offset -
7898 btrfs_file_extent_offset(buf, fi), 1, 1,
7899 btrfs_file_extent_disk_num_bytes(buf, fi));
7900 }
7901 } else {
7902 int level;
7903 struct btrfs_key first_key;
7904
7905 first_key.objectid = 0;
7906
7907 if (nritems > 0)
7908 btrfs_item_key_to_cpu(buf, &first_key, 0);
7909 level = btrfs_header_level(buf);
7910 for (i = 0; i < nritems; i++) {
7911 struct extent_record tmpl;
7912
7913 ptr = btrfs_node_blockptr(buf, i);
7914 size = root->fs_info->nodesize;
7915 btrfs_node_key_to_cpu(buf, &key, i);
7916 if (ri != NULL) {
7917 if ((level == ri->drop_level)
7918 && is_dropped_key(&key, &ri->drop_key)) {
7919 continue;
7920 }
7921 }
7922
7923 memset(&tmpl, 0, sizeof(tmpl));
7924 btrfs_cpu_key_to_disk(&tmpl.parent_key, &key);
7925 tmpl.parent_generation = btrfs_node_ptr_generation(buf, i);
7926 tmpl.start = ptr;
7927 tmpl.nr = size;
7928 tmpl.refs = 1;
7929 tmpl.metadata = 1;
7930 tmpl.max_size = size;
7931 ret = add_extent_rec(extent_cache, &tmpl);
7932 if (ret < 0)
7933 goto out;
7934
7935 ret = add_tree_backref(extent_cache, ptr, parent,
7936 owner, 1);
7937 if (ret < 0) {
7938 error(
7939 "add_tree_backref failed (non-leaf block): %s",
7940 strerror(-ret));
7941 continue;
7942 }
7943
7944 if (level > 1) {
7945 add_pending(nodes, seen, ptr, size);
7946 } else {
7947 add_pending(pending, seen, ptr, size);
7948 }
7949 }
7950 btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) -
7951 nritems) * sizeof(struct btrfs_key_ptr);
7952 }
7953 total_btree_bytes += buf->len;
7954 if (fs_root_objectid(btrfs_header_owner(buf)))
7955 total_fs_tree_bytes += buf->len;
7956 if (btrfs_header_owner(buf) == BTRFS_EXTENT_TREE_OBJECTID)
7957 total_extent_tree_bytes += buf->len;
7958 if (!found_old_backref &&
7959 btrfs_header_owner(buf) == BTRFS_TREE_RELOC_OBJECTID &&
7960 btrfs_header_backref_rev(buf) == BTRFS_MIXED_BACKREF_REV &&
7961 !btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC))
7962 found_old_backref = 1;
7963 out:
7964 free_extent_buffer(buf);
7965 return ret;
7966 }
7967
7968 static int add_root_to_pending(struct extent_buffer *buf,
7969 struct cache_tree *extent_cache,
7970 struct cache_tree *pending,
7971 struct cache_tree *seen,
7972 struct cache_tree *nodes,
7973 u64 objectid)
7974 {
7975 struct extent_record tmpl;
7976 int ret;
7977
7978 if (btrfs_header_level(buf) > 0)
7979 add_pending(nodes, seen, buf->start, buf->len);
7980 else
7981 add_pending(pending, seen, buf->start, buf->len);
7982
7983 memset(&tmpl, 0, sizeof(tmpl));
7984 tmpl.start = buf->start;
7985 tmpl.nr = buf->len;
7986 tmpl.is_root = 1;
7987 tmpl.refs = 1;
7988 tmpl.metadata = 1;
7989 tmpl.max_size = buf->len;
7990 add_extent_rec(extent_cache, &tmpl);
7991
7992 if (objectid == BTRFS_TREE_RELOC_OBJECTID ||
7993 btrfs_header_backref_rev(buf) < BTRFS_MIXED_BACKREF_REV)
7994 ret = add_tree_backref(extent_cache, buf->start, buf->start,
7995 0, 1);
7996 else
7997 ret = add_tree_backref(extent_cache, buf->start, 0, objectid,
7998 1);
7999 return ret;
8000 }
8001
8002 /* as we fix the tree, we might be deleting blocks that
8003 * we're tracking for repair. This hook makes sure we
8004 * remove any backrefs for blocks as we are fixing them.
8005 */
8006 static int free_extent_hook(struct btrfs_trans_handle *trans,
8007 struct btrfs_root *root,
8008 u64 bytenr, u64 num_bytes, u64 parent,
8009 u64 root_objectid, u64 owner, u64 offset,
8010 int refs_to_drop)
8011 {
8012 struct extent_record *rec;
8013 struct cache_extent *cache;
8014 int is_data;
8015 struct cache_tree *extent_cache = root->fs_info->fsck_extent_cache;
8016
8017 is_data = owner >= BTRFS_FIRST_FREE_OBJECTID;
8018 cache = lookup_cache_extent(extent_cache, bytenr, num_bytes);
8019 if (!cache)
8020 return 0;
8021
8022 rec = container_of(cache, struct extent_record, cache);
8023 if (is_data) {
8024 struct data_backref *back;
8025 back = find_data_backref(rec, parent, root_objectid, owner,
8026 offset, 1, bytenr, num_bytes);
8027 if (!back)
8028 goto out;
8029 if (back->node.found_ref) {
8030 back->found_ref -= refs_to_drop;
8031 if (rec->refs)
8032 rec->refs -= refs_to_drop;
8033 }
8034 if (back->node.found_extent_tree) {
8035 back->num_refs -= refs_to_drop;
8036 if (rec->extent_item_refs)
8037 rec->extent_item_refs -= refs_to_drop;
8038 }
8039 if (back->found_ref == 0)
8040 back->node.found_ref = 0;
8041 if (back->num_refs == 0)
8042 back->node.found_extent_tree = 0;
8043
8044 if (!back->node.found_extent_tree && back->node.found_ref) {
8045 list_del(&back->node.list);
8046 free(back);
8047 }
8048 } else {
8049 struct tree_backref *back;
8050 back = find_tree_backref(rec, parent, root_objectid);
8051 if (!back)
8052 goto out;
8053 if (back->node.found_ref) {
8054 if (rec->refs)
8055 rec->refs--;
8056 back->node.found_ref = 0;
8057 }
8058 if (back->node.found_extent_tree) {
8059 if (rec->extent_item_refs)
8060 rec->extent_item_refs--;
8061 back->node.found_extent_tree = 0;
8062 }
8063 if (!back->node.found_extent_tree && back->node.found_ref) {
8064 list_del(&back->node.list);
8065 free(back);
8066 }
8067 }
8068 maybe_free_extent_rec(extent_cache, rec);
8069 out:
8070 return 0;
8071 }
8072
8073 static int delete_extent_records(struct btrfs_trans_handle *trans,
8074 struct btrfs_root *root,
8075 struct btrfs_path *path,
8076 u64 bytenr)
8077 {
8078 struct btrfs_key key;
8079 struct btrfs_key found_key;
8080 struct extent_buffer *leaf;
8081 int ret;
8082 int slot;
8083
8084
8085 key.objectid = bytenr;
8086 key.type = (u8)-1;
8087 key.offset = (u64)-1;
8088
8089 while(1) {
8090 ret = btrfs_search_slot(trans, root->fs_info->extent_root,
8091 &key, path, 0, 1);
8092 if (ret < 0)
8093 break;
8094
8095 if (ret > 0) {
8096 ret = 0;
8097 if (path->slots[0] == 0)
8098 break;
8099 path->slots[0]--;
8100 }
8101 ret = 0;
8102
8103 leaf = path->nodes[0];
8104 slot = path->slots[0];
8105
8106 btrfs_item_key_to_cpu(leaf, &found_key, slot);
8107 if (found_key.objectid != bytenr)
8108 break;
8109
8110 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
8111 found_key.type != BTRFS_METADATA_ITEM_KEY &&
8112 found_key.type != BTRFS_TREE_BLOCK_REF_KEY &&
8113 found_key.type != BTRFS_EXTENT_DATA_REF_KEY &&
8114 found_key.type != BTRFS_EXTENT_REF_V0_KEY &&
8115 found_key.type != BTRFS_SHARED_BLOCK_REF_KEY &&
8116 found_key.type != BTRFS_SHARED_DATA_REF_KEY) {
8117 btrfs_release_path(path);
8118 if (found_key.type == 0) {
8119 if (found_key.offset == 0)
8120 break;
8121 key.offset = found_key.offset - 1;
8122 key.type = found_key.type;
8123 }
8124 key.type = found_key.type - 1;
8125 key.offset = (u64)-1;
8126 continue;
8127 }
8128
8129 fprintf(stderr, "repair deleting extent record: key %Lu %u %Lu\n",
8130 found_key.objectid, found_key.type, found_key.offset);
8131
8132 ret = btrfs_del_item(trans, root->fs_info->extent_root, path);
8133 if (ret)
8134 break;
8135 btrfs_release_path(path);
8136
8137 if (found_key.type == BTRFS_EXTENT_ITEM_KEY ||
8138 found_key.type == BTRFS_METADATA_ITEM_KEY) {
8139 u64 bytes = (found_key.type == BTRFS_EXTENT_ITEM_KEY) ?
8140 found_key.offset : root->fs_info->nodesize;
8141
8142 ret = btrfs_update_block_group(trans, root, bytenr,
8143 bytes, 0, 0);
8144 if (ret)
8145 break;
8146 }
8147 }
8148
8149 btrfs_release_path(path);
8150 return ret;
8151 }
8152
8153 /*
8154 * for a single backref, this will allocate a new extent
8155 * and add the backref to it.
8156 */
8157 static int record_extent(struct btrfs_trans_handle *trans,
8158 struct btrfs_fs_info *info,
8159 struct btrfs_path *path,
8160 struct extent_record *rec,
8161 struct extent_backref *back,
8162 int allocated, u64 flags)
8163 {
8164 int ret = 0;
8165 struct btrfs_root *extent_root = info->extent_root;
8166 struct extent_buffer *leaf;
8167 struct btrfs_key ins_key;
8168 struct btrfs_extent_item *ei;
8169 struct data_backref *dback;
8170 struct btrfs_tree_block_info *bi;
8171
8172 if (!back->is_data)
8173 rec->max_size = max_t(u64, rec->max_size,
8174 info->nodesize);
8175
8176 if (!allocated) {
8177 u32 item_size = sizeof(*ei);
8178
8179 if (!back->is_data)
8180 item_size += sizeof(*bi);
8181
8182 ins_key.objectid = rec->start;
8183 ins_key.offset = rec->max_size;
8184 ins_key.type = BTRFS_EXTENT_ITEM_KEY;
8185
8186 ret = btrfs_insert_empty_item(trans, extent_root, path,
8187 &ins_key, item_size);
8188 if (ret)
8189 goto fail;
8190
8191 leaf = path->nodes[0];
8192 ei = btrfs_item_ptr(leaf, path->slots[0],
8193 struct btrfs_extent_item);
8194
8195 btrfs_set_extent_refs(leaf, ei, 0);
8196 btrfs_set_extent_generation(leaf, ei, rec->generation);
8197
8198 if (back->is_data) {
8199 btrfs_set_extent_flags(leaf, ei,
8200 BTRFS_EXTENT_FLAG_DATA);
8201 } else {
8202 struct btrfs_disk_key copy_key;;
8203
8204 bi = (struct btrfs_tree_block_info *)(ei + 1);
8205 memset_extent_buffer(leaf, 0, (unsigned long)bi,
8206 sizeof(*bi));
8207
8208 btrfs_set_disk_key_objectid(&copy_key,
8209 rec->info_objectid);
8210 btrfs_set_disk_key_type(&copy_key, 0);
8211 btrfs_set_disk_key_offset(&copy_key, 0);
8212
8213 btrfs_set_tree_block_level(leaf, bi, rec->info_level);
8214 btrfs_set_tree_block_key(leaf, bi, &copy_key);
8215
8216 btrfs_set_extent_flags(leaf, ei,
8217 BTRFS_EXTENT_FLAG_TREE_BLOCK | flags);
8218 }
8219
8220 btrfs_mark_buffer_dirty(leaf);
8221 ret = btrfs_update_block_group(trans, extent_root, rec->start,
8222 rec->max_size, 1, 0);
8223 if (ret)
8224 goto fail;
8225 btrfs_release_path(path);
8226 }
8227
8228 if (back->is_data) {
8229 u64 parent;
8230 int i;
8231
8232 dback = to_data_backref(back);
8233 if (back->full_backref)
8234 parent = dback->parent;
8235 else
8236 parent = 0;
8237
8238 for (i = 0; i < dback->found_ref; i++) {
8239 /* if parent != 0, we're doing a full backref
8240 * passing BTRFS_FIRST_FREE_OBJECTID as the owner
8241 * just makes the backref allocator create a data
8242 * backref
8243 */
8244 ret = btrfs_inc_extent_ref(trans, info->extent_root,
8245 rec->start, rec->max_size,
8246 parent,
8247 dback->root,
8248 parent ?
8249 BTRFS_FIRST_FREE_OBJECTID :
8250 dback->owner,
8251 dback->offset);
8252 if (ret)
8253 break;
8254 }
8255 fprintf(stderr, "adding new data backref"
8256 " on %llu %s %llu owner %llu"
8257 " offset %llu found %d\n",
8258 (unsigned long long)rec->start,
8259 back->full_backref ?
8260 "parent" : "root",
8261 back->full_backref ?
8262 (unsigned long long)parent :
8263 (unsigned long long)dback->root,
8264 (unsigned long long)dback->owner,
8265 (unsigned long long)dback->offset,
8266 dback->found_ref);
8267 } else {
8268 u64 parent;
8269 struct tree_backref *tback;
8270
8271 tback = to_tree_backref(back);
8272 if (back->full_backref)
8273 parent = tback->parent;
8274 else
8275 parent = 0;
8276
8277 ret = btrfs_inc_extent_ref(trans, info->extent_root,
8278 rec->start, rec->max_size,
8279 parent, tback->root, 0, 0);
8280 fprintf(stderr, "adding new tree backref on "
8281 "start %llu len %llu parent %llu root %llu\n",
8282 rec->start, rec->max_size, parent, tback->root);
8283 }
8284 fail:
8285 btrfs_release_path(path);
8286 return ret;
8287 }
8288
8289 static struct extent_entry *find_entry(struct list_head *entries,
8290 u64 bytenr, u64 bytes)
8291 {
8292 struct extent_entry *entry = NULL;
8293
8294 list_for_each_entry(entry, entries, list) {
8295 if (entry->bytenr == bytenr && entry->bytes == bytes)
8296 return entry;
8297 }
8298
8299 return NULL;
8300 }
8301
8302 static struct extent_entry *find_most_right_entry(struct list_head *entries)
8303 {
8304 struct extent_entry *entry, *best = NULL, *prev = NULL;
8305
8306 list_for_each_entry(entry, entries, list) {
8307 /*
8308 * If there are as many broken entries as entries then we know
8309 * not to trust this particular entry.
8310 */
8311 if (entry->broken == entry->count)
8312 continue;
8313
8314 /*
8315 * Special case, when there are only two entries and 'best' is
8316 * the first one
8317 */
8318 if (!prev) {
8319 best = entry;
8320 prev = entry;
8321 continue;
8322 }
8323
8324 /*
8325 * If our current entry == best then we can't be sure our best
8326 * is really the best, so we need to keep searching.
8327 */
8328 if (best && best->count == entry->count) {
8329 prev = entry;
8330 best = NULL;
8331 continue;
8332 }
8333
8334 /* Prev == entry, not good enough, have to keep searching */
8335 if (!prev->broken && prev->count == entry->count)
8336 continue;
8337
8338 if (!best)
8339 best = (prev->count > entry->count) ? prev : entry;
8340 else if (best->count < entry->count)
8341 best = entry;
8342 prev = entry;
8343 }
8344
8345 return best;
8346 }
8347
8348 static int repair_ref(struct btrfs_fs_info *info, struct btrfs_path *path,
8349 struct data_backref *dback, struct extent_entry *entry)
8350 {
8351 struct btrfs_trans_handle *trans;
8352 struct btrfs_root *root;
8353 struct btrfs_file_extent_item *fi;
8354 struct extent_buffer *leaf;
8355 struct btrfs_key key;
8356 u64 bytenr, bytes;
8357 int ret, err;
8358
8359 key.objectid = dback->root;
8360 key.type = BTRFS_ROOT_ITEM_KEY;
8361 key.offset = (u64)-1;
8362 root = btrfs_read_fs_root(info, &key);
8363 if (IS_ERR(root)) {
8364 fprintf(stderr, "Couldn't find root for our ref\n");
8365 return -EINVAL;
8366 }
8367
8368 /*
8369 * The backref points to the original offset of the extent if it was
8370 * split, so we need to search down to the offset we have and then walk
8371 * forward until we find the backref we're looking for.
8372 */
8373 key.objectid = dback->owner;
8374 key.type = BTRFS_EXTENT_DATA_KEY;
8375 key.offset = dback->offset;
8376 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
8377 if (ret < 0) {
8378 fprintf(stderr, "Error looking up ref %d\n", ret);
8379 return ret;
8380 }
8381
8382 while (1) {
8383 if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
8384 ret = btrfs_next_leaf(root, path);
8385 if (ret) {
8386 fprintf(stderr, "Couldn't find our ref, next\n");
8387 return -EINVAL;
8388 }
8389 }
8390 leaf = path->nodes[0];
8391 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
8392 if (key.objectid != dback->owner ||
8393 key.type != BTRFS_EXTENT_DATA_KEY) {
8394 fprintf(stderr, "Couldn't find our ref, search\n");
8395 return -EINVAL;
8396 }
8397 fi = btrfs_item_ptr(leaf, path->slots[0],
8398 struct btrfs_file_extent_item);
8399 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
8400 bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
8401
8402 if (bytenr == dback->disk_bytenr && bytes == dback->bytes)
8403 break;
8404 path->slots[0]++;
8405 }
8406
8407 btrfs_release_path(path);
8408
8409 trans = btrfs_start_transaction(root, 1);
8410 if (IS_ERR(trans))
8411 return PTR_ERR(trans);
8412
8413 /*
8414 * Ok we have the key of the file extent we want to fix, now we can cow
8415 * down to the thing and fix it.
8416 */
8417 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
8418 if (ret < 0) {
8419 fprintf(stderr, "Error cowing down to ref [%Lu, %u, %Lu]: %d\n",
8420 key.objectid, key.type, key.offset, ret);
8421 goto out;
8422 }
8423 if (ret > 0) {
8424 fprintf(stderr, "Well that's odd, we just found this key "
8425 "[%Lu, %u, %Lu]\n", key.objectid, key.type,
8426 key.offset);
8427 ret = -EINVAL;
8428 goto out;
8429 }
8430 leaf = path->nodes[0];
8431 fi = btrfs_item_ptr(leaf, path->slots[0],
8432 struct btrfs_file_extent_item);
8433
8434 if (btrfs_file_extent_compression(leaf, fi) &&
8435 dback->disk_bytenr != entry->bytenr) {
8436 fprintf(stderr, "Ref doesn't match the record start and is "
8437 "compressed, please take a btrfs-image of this file "
8438 "system and send it to a btrfs developer so they can "
8439 "complete this functionality for bytenr %Lu\n",
8440 dback->disk_bytenr);
8441 ret = -EINVAL;
8442 goto out;
8443 }
8444
8445 if (dback->node.broken && dback->disk_bytenr != entry->bytenr) {
8446 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8447 } else if (dback->disk_bytenr > entry->bytenr) {
8448 u64 off_diff, offset;
8449
8450 off_diff = dback->disk_bytenr - entry->bytenr;
8451 offset = btrfs_file_extent_offset(leaf, fi);
8452 if (dback->disk_bytenr + offset +
8453 btrfs_file_extent_num_bytes(leaf, fi) >
8454 entry->bytenr + entry->bytes) {
8455 fprintf(stderr, "Ref is past the entry end, please "
8456 "take a btrfs-image of this file system and "
8457 "send it to a btrfs developer, ref %Lu\n",
8458 dback->disk_bytenr);
8459 ret = -EINVAL;
8460 goto out;
8461 }
8462 offset += off_diff;
8463 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8464 btrfs_set_file_extent_offset(leaf, fi, offset);
8465 } else if (dback->disk_bytenr < entry->bytenr) {
8466 u64 offset;
8467
8468 offset = btrfs_file_extent_offset(leaf, fi);
8469 if (dback->disk_bytenr + offset < entry->bytenr) {
8470 fprintf(stderr, "Ref is before the entry start, please"
8471 " take a btrfs-image of this file system and "
8472 "send it to a btrfs developer, ref %Lu\n",
8473 dback->disk_bytenr);
8474 ret = -EINVAL;
8475 goto out;
8476 }
8477
8478 offset += dback->disk_bytenr;
8479 offset -= entry->bytenr;
8480 btrfs_set_file_extent_disk_bytenr(leaf, fi, entry->bytenr);
8481 btrfs_set_file_extent_offset(leaf, fi, offset);
8482 }
8483
8484 btrfs_set_file_extent_disk_num_bytes(leaf, fi, entry->bytes);
8485
8486 /*
8487 * Chances are if disk_num_bytes were wrong then so is ram_bytes, but
8488 * only do this if we aren't using compression, otherwise it's a
8489 * trickier case.
8490 */
8491 if (!btrfs_file_extent_compression(leaf, fi))
8492 btrfs_set_file_extent_ram_bytes(leaf, fi, entry->bytes);
8493 else
8494 printf("ram bytes may be wrong?\n");
8495 btrfs_mark_buffer_dirty(leaf);
8496 out:
8497 err = btrfs_commit_transaction(trans, root);
8498 btrfs_release_path(path);
8499 return ret ? ret : err;
8500 }
8501
8502 static int verify_backrefs(struct btrfs_fs_info *info, struct btrfs_path *path,
8503 struct extent_record *rec)
8504 {
8505 struct extent_backref *back;
8506 struct data_backref *dback;
8507 struct extent_entry *entry, *best = NULL;
8508 LIST_HEAD(entries);
8509 int nr_entries = 0;
8510 int broken_entries = 0;
8511 int ret = 0;
8512 short mismatch = 0;
8513
8514 /*
8515 * Metadata is easy and the backrefs should always agree on bytenr and
8516 * size, if not we've got bigger issues.
8517 */
8518 if (rec->metadata)
8519 return 0;
8520
8521 list_for_each_entry(back, &rec->backrefs, list) {
8522 if (back->full_backref || !back->is_data)
8523 continue;
8524
8525 dback = to_data_backref(back);
8526
8527 /*
8528 * We only pay attention to backrefs that we found a real
8529 * backref for.
8530 */
8531 if (dback->found_ref == 0)
8532 continue;
8533
8534 /*
8535 * For now we only catch when the bytes don't match, not the
8536 * bytenr. We can easily do this at the same time, but I want
8537 * to have a fs image to test on before we just add repair
8538 * functionality willy-nilly so we know we won't screw up the
8539 * repair.
8540 */
8541
8542 entry = find_entry(&entries, dback->disk_bytenr,
8543 dback->bytes);
8544 if (!entry) {
8545 entry = malloc(sizeof(struct extent_entry));
8546 if (!entry) {
8547 ret = -ENOMEM;
8548 goto out;
8549 }
8550 memset(entry, 0, sizeof(*entry));
8551 entry->bytenr = dback->disk_bytenr;
8552 entry->bytes = dback->bytes;
8553 list_add_tail(&entry->list, &entries);
8554 nr_entries++;
8555 }
8556
8557 /*
8558 * If we only have on entry we may think the entries agree when
8559 * in reality they don't so we have to do some extra checking.
8560 */
8561 if (dback->disk_bytenr != rec->start ||
8562 dback->bytes != rec->nr || back->broken)
8563 mismatch = 1;
8564
8565 if (back->broken) {
8566 entry->broken++;
8567 broken_entries++;
8568 }
8569
8570 entry->count++;
8571 }
8572
8573 /* Yay all the backrefs agree, carry on good sir */
8574 if (nr_entries <= 1 && !mismatch)
8575 goto out;
8576
8577 fprintf(stderr, "attempting to repair backref discrepency for bytenr "
8578 "%Lu\n", rec->start);
8579
8580 /*
8581 * First we want to see if the backrefs can agree amongst themselves who
8582 * is right, so figure out which one of the entries has the highest
8583 * count.
8584 */
8585 best = find_most_right_entry(&entries);
8586
8587 /*
8588 * Ok so we may have an even split between what the backrefs think, so
8589 * this is where we use the extent ref to see what it thinks.
8590 */
8591 if (!best) {
8592 entry = find_entry(&entries, rec->start, rec->nr);
8593 if (!entry && (!broken_entries || !rec->found_rec)) {
8594 fprintf(stderr, "Backrefs don't agree with each other "
8595 "and extent record doesn't agree with anybody,"
8596 " so we can't fix bytenr %Lu bytes %Lu\n",
8597 rec->start, rec->nr);
8598 ret = -EINVAL;
8599 goto out;
8600 } else if (!entry) {
8601 /*
8602 * Ok our backrefs were broken, we'll assume this is the
8603 * correct value and add an entry for this range.
8604 */
8605 entry = malloc(sizeof(struct extent_entry));
8606 if (!entry) {
8607 ret = -ENOMEM;
8608 goto out;
8609 }
8610 memset(entry, 0, sizeof(*entry));
8611 entry->bytenr = rec->start;
8612 entry->bytes = rec->nr;
8613 list_add_tail(&entry->list, &entries);
8614 nr_entries++;
8615 }
8616 entry->count++;
8617 best = find_most_right_entry(&entries);
8618 if (!best) {
8619 fprintf(stderr, "Backrefs and extent record evenly "
8620 "split on who is right, this is going to "
8621 "require user input to fix bytenr %Lu bytes "
8622 "%Lu\n", rec->start, rec->nr);
8623 ret = -EINVAL;
8624 goto out;
8625 }
8626 }
8627
8628 /*
8629 * I don't think this can happen currently as we'll abort() if we catch
8630 * this case higher up, but in case somebody removes that we still can't
8631 * deal with it properly here yet, so just bail out of that's the case.
8632 */
8633 if (best->bytenr != rec->start) {
8634 fprintf(stderr, "Extent start and backref starts don't match, "
8635 "please use btrfs-image on this file system and send "
8636 "it to a btrfs developer so they can make fsck fix "
8637 "this particular case. bytenr is %Lu, bytes is %Lu\n",
8638 rec->start, rec->nr);
8639 ret = -EINVAL;
8640 goto out;
8641 }
8642
8643 /*
8644 * Ok great we all agreed on an extent record, let's go find the real
8645 * references and fix up the ones that don't match.
8646 */
8647 list_for_each_entry(back, &rec->backrefs, list) {
8648 if (back->full_backref || !back->is_data)
8649 continue;
8650
8651 dback = to_data_backref(back);
8652
8653 /*
8654 * Still ignoring backrefs that don't have a real ref attached
8655 * to them.
8656 */
8657 if (dback->found_ref == 0)
8658 continue;
8659
8660 if (dback->bytes == best->bytes &&
8661 dback->disk_bytenr == best->bytenr)
8662 continue;
8663
8664 ret = repair_ref(info, path, dback, best);
8665 if (ret)
8666 goto out;
8667 }
8668
8669 /*
8670 * Ok we messed with the actual refs, which means we need to drop our
8671 * entire cache and go back and rescan. I know this is a huge pain and
8672 * adds a lot of extra work, but it's the only way to be safe. Once all
8673 * the backrefs agree we may not need to do anything to the extent
8674 * record itself.
8675 */
8676 ret = -EAGAIN;
8677 out:
8678 while (!list_empty(&entries)) {
8679 entry = list_entry(entries.next, struct extent_entry, list);
8680 list_del_init(&entry->list);
8681 free(entry);
8682 }
8683 return ret;
8684 }
8685
8686 static int process_duplicates(struct cache_tree *extent_cache,
8687 struct extent_record *rec)
8688 {
8689 struct extent_record *good, *tmp;
8690 struct cache_extent *cache;
8691 int ret;
8692
8693 /*
8694 * If we found a extent record for this extent then return, or if we
8695 * have more than one duplicate we are likely going to need to delete
8696 * something.
8697 */
8698 if (rec->found_rec || rec->num_duplicates > 1)
8699 return 0;
8700
8701 /* Shouldn't happen but just in case */
8702 BUG_ON(!rec->num_duplicates);
8703
8704 /*
8705 * So this happens if we end up with a backref that doesn't match the
8706 * actual extent entry. So either the backref is bad or the extent
8707 * entry is bad. Either way we want to have the extent_record actually
8708 * reflect what we found in the extent_tree, so we need to take the
8709 * duplicate out and use that as the extent_record since the only way we
8710 * get a duplicate is if we find a real life BTRFS_EXTENT_ITEM_KEY.
8711 */
8712 remove_cache_extent(extent_cache, &rec->cache);
8713
8714 good = to_extent_record(rec->dups.next);
8715 list_del_init(&good->list);
8716 INIT_LIST_HEAD(&good->backrefs);
8717 INIT_LIST_HEAD(&good->dups);
8718 good->cache.start = good->start;
8719 good->cache.size = good->nr;
8720 good->content_checked = 0;
8721 good->owner_ref_checked = 0;
8722 good->num_duplicates = 0;
8723 good->refs = rec->refs;
8724 list_splice_init(&rec->backrefs, &good->backrefs);
8725 while (1) {
8726 cache = lookup_cache_extent(extent_cache, good->start,
8727 good->nr);
8728 if (!cache)
8729 break;
8730 tmp = container_of(cache, struct extent_record, cache);
8731
8732 /*
8733 * If we find another overlapping extent and it's found_rec is
8734 * set then it's a duplicate and we need to try and delete
8735 * something.
8736 */
8737 if (tmp->found_rec || tmp->num_duplicates > 0) {
8738 if (list_empty(&good->list))
8739 list_add_tail(&good->list,
8740 &duplicate_extents);
8741 good->num_duplicates += tmp->num_duplicates + 1;
8742 list_splice_init(&tmp->dups, &good->dups);
8743 list_del_init(&tmp->list);
8744 list_add_tail(&tmp->list, &good->dups);
8745 remove_cache_extent(extent_cache, &tmp->cache);
8746 continue;
8747 }
8748
8749 /*
8750 * Ok we have another non extent item backed extent rec, so lets
8751 * just add it to this extent and carry on like we did above.
8752 */
8753 good->refs += tmp->refs;
8754 list_splice_init(&tmp->backrefs, &good->backrefs);
8755 remove_cache_extent(extent_cache, &tmp->cache);
8756 free(tmp);
8757 }
8758 ret = insert_cache_extent(extent_cache, &good->cache);
8759 BUG_ON(ret);
8760 free(rec);
8761 return good->num_duplicates ? 0 : 1;
8762 }
8763
8764 static int delete_duplicate_records(struct btrfs_root *root,
8765 struct extent_record *rec)
8766 {
8767 struct btrfs_trans_handle *trans;
8768 LIST_HEAD(delete_list);
8769 struct btrfs_path path;
8770 struct extent_record *tmp, *good, *n;
8771 int nr_del = 0;
8772 int ret = 0, err;
8773 struct btrfs_key key;
8774
8775 btrfs_init_path(&path);
8776
8777 good = rec;
8778 /* Find the record that covers all of the duplicates. */
8779 list_for_each_entry(tmp, &rec->dups, list) {
8780 if (good->start < tmp->start)
8781 continue;
8782 if (good->nr > tmp->nr)
8783 continue;
8784
8785 if (tmp->start + tmp->nr < good->start + good->nr) {
8786 fprintf(stderr, "Ok we have overlapping extents that "
8787 "aren't completely covered by each other, this "
8788 "is going to require more careful thought. "
8789 "The extents are [%Lu-%Lu] and [%Lu-%Lu]\n",
8790 tmp->start, tmp->nr, good->start, good->nr);
8791 abort();
8792 }
8793 good = tmp;
8794 }
8795
8796 if (good != rec)
8797 list_add_tail(&rec->list, &delete_list);
8798
8799 list_for_each_entry_safe(tmp, n, &rec->dups, list) {
8800 if (tmp == good)
8801 continue;
8802 list_move_tail(&tmp->list, &delete_list);
8803 }
8804
8805 root = root->fs_info->extent_root;
8806 trans = btrfs_start_transaction(root, 1);
8807 if (IS_ERR(trans)) {
8808 ret = PTR_ERR(trans);
8809 goto out;
8810 }
8811
8812 list_for_each_entry(tmp, &delete_list, list) {
8813 if (tmp->found_rec == 0)
8814 continue;
8815 key.objectid = tmp->start;
8816 key.type = BTRFS_EXTENT_ITEM_KEY;
8817 key.offset = tmp->nr;
8818
8819 /* Shouldn't happen but just in case */
8820 if (tmp->metadata) {
8821 fprintf(stderr, "Well this shouldn't happen, extent "
8822 "record overlaps but is metadata? "
8823 "[%Lu, %Lu]\n", tmp->start, tmp->nr);
8824 abort();
8825 }
8826
8827 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
8828 if (ret) {
8829 if (ret > 0)
8830 ret = -EINVAL;
8831 break;
8832 }
8833 ret = btrfs_del_item(trans, root, &path);
8834 if (ret)
8835 break;
8836 btrfs_release_path(&path);
8837 nr_del++;
8838 }
8839 err = btrfs_commit_transaction(trans, root);
8840 if (err && !ret)
8841 ret = err;
8842 out:
8843 while (!list_empty(&delete_list)) {
8844 tmp = to_extent_record(delete_list.next);
8845 list_del_init(&tmp->list);
8846 if (tmp == rec)
8847 continue;
8848 free(tmp);
8849 }
8850
8851 while (!list_empty(&rec->dups)) {
8852 tmp = to_extent_record(rec->dups.next);
8853 list_del_init(&tmp->list);
8854 free(tmp);
8855 }
8856
8857 btrfs_release_path(&path);
8858
8859 if (!ret && !nr_del)
8860 rec->num_duplicates = 0;
8861
8862 return ret ? ret : nr_del;
8863 }
8864
8865 static int find_possible_backrefs(struct btrfs_fs_info *info,
8866 struct btrfs_path *path,
8867 struct cache_tree *extent_cache,
8868 struct extent_record *rec)
8869 {
8870 struct btrfs_root *root;
8871 struct extent_backref *back;
8872 struct data_backref *dback;
8873 struct cache_extent *cache;
8874 struct btrfs_file_extent_item *fi;
8875 struct btrfs_key key;
8876 u64 bytenr, bytes;
8877 int ret;
8878
8879 list_for_each_entry(back, &rec->backrefs, list) {
8880 /* Don't care about full backrefs (poor unloved backrefs) */
8881 if (back->full_backref || !back->is_data)
8882 continue;
8883
8884 dback = to_data_backref(back);
8885
8886 /* We found this one, we don't need to do a lookup */
8887 if (dback->found_ref)
8888 continue;
8889
8890 key.objectid = dback->root;
8891 key.type = BTRFS_ROOT_ITEM_KEY;
8892 key.offset = (u64)-1;
8893
8894 root = btrfs_read_fs_root(info, &key);
8895
8896 /* No root, definitely a bad ref, skip */
8897 if (IS_ERR(root) && PTR_ERR(root) == -ENOENT)
8898 continue;
8899 /* Other err, exit */
8900 if (IS_ERR(root))
8901 return PTR_ERR(root);
8902
8903 key.objectid = dback->owner;
8904 key.type = BTRFS_EXTENT_DATA_KEY;
8905 key.offset = dback->offset;
8906 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
8907 if (ret) {
8908 btrfs_release_path(path);
8909 if (ret < 0)
8910 return ret;
8911 /* Didn't find it, we can carry on */
8912 ret = 0;
8913 continue;
8914 }
8915
8916 fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
8917 struct btrfs_file_extent_item);
8918 bytenr = btrfs_file_extent_disk_bytenr(path->nodes[0], fi);
8919 bytes = btrfs_file_extent_disk_num_bytes(path->nodes[0], fi);
8920 btrfs_release_path(path);
8921 cache = lookup_cache_extent(extent_cache, bytenr, 1);
8922 if (cache) {
8923 struct extent_record *tmp;
8924 tmp = container_of(cache, struct extent_record, cache);
8925
8926 /*
8927 * If we found an extent record for the bytenr for this
8928 * particular backref then we can't add it to our
8929 * current extent record. We only want to add backrefs
8930 * that don't have a corresponding extent item in the
8931 * extent tree since they likely belong to this record
8932 * and we need to fix it if it doesn't match bytenrs.
8933 */
8934 if (tmp->found_rec)
8935 continue;
8936 }
8937
8938 dback->found_ref += 1;
8939 dback->disk_bytenr = bytenr;
8940 dback->bytes = bytes;
8941
8942 /*
8943 * Set this so the verify backref code knows not to trust the
8944 * values in this backref.
8945 */
8946 back->broken = 1;
8947 }
8948
8949 return 0;
8950 }
8951
8952 /*
8953 * Record orphan data ref into corresponding root.
8954 *
8955 * Return 0 if the extent item contains data ref and recorded.
8956 * Return 1 if the extent item contains no useful data ref
8957 * On that case, it may contains only shared_dataref or metadata backref
8958 * or the file extent exists(this should be handled by the extent bytenr
8959 * recovery routine)
8960 * Return <0 if something goes wrong.
8961 */
8962 static int record_orphan_data_extents(struct btrfs_fs_info *fs_info,
8963 struct extent_record *rec)
8964 {
8965 struct btrfs_key key;
8966 struct btrfs_root *dest_root;
8967 struct extent_backref *back;
8968 struct data_backref *dback;
8969 struct orphan_data_extent *orphan;
8970 struct btrfs_path path;
8971 int recorded_data_ref = 0;
8972 int ret = 0;
8973
8974 if (rec->metadata)
8975 return 1;
8976 btrfs_init_path(&path);
8977 list_for_each_entry(back, &rec->backrefs, list) {
8978 if (back->full_backref || !back->is_data ||
8979 !back->found_extent_tree)
8980 continue;
8981 dback = to_data_backref(back);
8982 if (dback->found_ref)
8983 continue;
8984 key.objectid = dback->root;
8985 key.type = BTRFS_ROOT_ITEM_KEY;
8986 key.offset = (u64)-1;
8987
8988 dest_root = btrfs_read_fs_root(fs_info, &key);
8989
8990 /* For non-exist root we just skip it */
8991 if (IS_ERR(dest_root) || !dest_root)
8992 continue;
8993
8994 key.objectid = dback->owner;
8995 key.type = BTRFS_EXTENT_DATA_KEY;
8996 key.offset = dback->offset;
8997
8998 ret = btrfs_search_slot(NULL, dest_root, &key, &path, 0, 0);
8999 btrfs_release_path(&path);
9000 /*
9001 * For ret < 0, it's OK since the fs-tree may be corrupted,
9002 * we need to record it for inode/file extent rebuild.
9003 * For ret > 0, we record it only for file extent rebuild.
9004 * For ret == 0, the file extent exists but only bytenr
9005 * mismatch, let the original bytenr fix routine to handle,
9006 * don't record it.
9007 */
9008 if (ret == 0)
9009 continue;
9010 ret = 0;
9011 orphan = malloc(sizeof(*orphan));
9012 if (!orphan) {
9013 ret = -ENOMEM;
9014 goto out;
9015 }
9016 INIT_LIST_HEAD(&orphan->list);
9017 orphan->root = dback->root;
9018 orphan->objectid = dback->owner;
9019 orphan->offset = dback->offset;
9020 orphan->disk_bytenr = rec->cache.start;
9021 orphan->disk_len = rec->cache.size;
9022 list_add(&dest_root->orphan_data_extents, &orphan->list);
9023 recorded_data_ref = 1;
9024 }
9025 out:
9026 btrfs_release_path(&path);
9027 if (!ret)
9028 return !recorded_data_ref;
9029 else
9030 return ret;
9031 }
9032
9033 /*
9034 * when an incorrect extent item is found, this will delete
9035 * all of the existing entries for it and recreate them
9036 * based on what the tree scan found.
9037 */
9038 static int fixup_extent_refs(struct btrfs_fs_info *info,
9039 struct cache_tree *extent_cache,
9040 struct extent_record *rec)
9041 {
9042 struct btrfs_trans_handle *trans = NULL;
9043 int ret;
9044 struct btrfs_path path;
9045 struct list_head *cur = rec->backrefs.next;
9046 struct cache_extent *cache;
9047 struct extent_backref *back;
9048 int allocated = 0;
9049 u64 flags = 0;
9050
9051 if (rec->flag_block_full_backref)
9052 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
9053
9054 btrfs_init_path(&path);
9055 if (rec->refs != rec->extent_item_refs && !rec->metadata) {
9056 /*
9057 * Sometimes the backrefs themselves are so broken they don't
9058 * get attached to any meaningful rec, so first go back and
9059 * check any of our backrefs that we couldn't find and throw
9060 * them into the list if we find the backref so that
9061 * verify_backrefs can figure out what to do.
9062 */
9063 ret = find_possible_backrefs(info, &path, extent_cache, rec);
9064 if (ret < 0)
9065 goto out;
9066 }
9067
9068 /* step one, make sure all of the backrefs agree */
9069 ret = verify_backrefs(info, &path, rec);
9070 if (ret < 0)
9071 goto out;
9072
9073 trans = btrfs_start_transaction(info->extent_root, 1);
9074 if (IS_ERR(trans)) {
9075 ret = PTR_ERR(trans);
9076 goto out;
9077 }
9078
9079 /* step two, delete all the existing records */
9080 ret = delete_extent_records(trans, info->extent_root, &path,
9081 rec->start);
9082
9083 if (ret < 0)
9084 goto out;
9085
9086 /* was this block corrupt? If so, don't add references to it */
9087 cache = lookup_cache_extent(info->corrupt_blocks,
9088 rec->start, rec->max_size);
9089 if (cache) {
9090 ret = 0;
9091 goto out;
9092 }
9093
9094 /* step three, recreate all the refs we did find */
9095 while(cur != &rec->backrefs) {
9096 back = to_extent_backref(cur);
9097 cur = cur->next;
9098
9099 /*
9100 * if we didn't find any references, don't create a
9101 * new extent record
9102 */
9103 if (!back->found_ref)
9104 continue;
9105
9106 rec->bad_full_backref = 0;
9107 ret = record_extent(trans, info, &path, rec, back, allocated, flags);
9108 allocated = 1;
9109
9110 if (ret)
9111 goto out;
9112 }
9113 out:
9114 if (trans) {
9115 int err = btrfs_commit_transaction(trans, info->extent_root);
9116 if (!ret)
9117 ret = err;
9118 }
9119
9120 if (!ret)
9121 fprintf(stderr, "Repaired extent references for %llu\n",
9122 (unsigned long long)rec->start);
9123
9124 btrfs_release_path(&path);
9125 return ret;
9126 }
9127
9128 static int fixup_extent_flags(struct btrfs_fs_info *fs_info,
9129 struct extent_record *rec)
9130 {
9131 struct btrfs_trans_handle *trans;
9132 struct btrfs_root *root = fs_info->extent_root;
9133 struct btrfs_path path;
9134 struct btrfs_extent_item *ei;
9135 struct btrfs_key key;
9136 u64 flags;
9137 int ret = 0;
9138
9139 key.objectid = rec->start;
9140 if (rec->metadata) {
9141 key.type = BTRFS_METADATA_ITEM_KEY;
9142 key.offset = rec->info_level;
9143 } else {
9144 key.type = BTRFS_EXTENT_ITEM_KEY;
9145 key.offset = rec->max_size;
9146 }
9147
9148 trans = btrfs_start_transaction(root, 0);
9149 if (IS_ERR(trans))
9150 return PTR_ERR(trans);
9151
9152 btrfs_init_path(&path);
9153 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
9154 if (ret < 0) {
9155 btrfs_release_path(&path);
9156 btrfs_commit_transaction(trans, root);
9157 return ret;
9158 } else if (ret) {
9159 fprintf(stderr, "Didn't find extent for %llu\n",
9160 (unsigned long long)rec->start);
9161 btrfs_release_path(&path);
9162 btrfs_commit_transaction(trans, root);
9163 return -ENOENT;
9164 }
9165
9166 ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
9167 struct btrfs_extent_item);
9168 flags = btrfs_extent_flags(path.nodes[0], ei);
9169 if (rec->flag_block_full_backref) {
9170 fprintf(stderr, "setting full backref on %llu\n",
9171 (unsigned long long)key.objectid);
9172 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
9173 } else {
9174 fprintf(stderr, "clearing full backref on %llu\n",
9175 (unsigned long long)key.objectid);
9176 flags &= ~BTRFS_BLOCK_FLAG_FULL_BACKREF;
9177 }
9178 btrfs_set_extent_flags(path.nodes[0], ei, flags);
9179 btrfs_mark_buffer_dirty(path.nodes[0]);
9180 btrfs_release_path(&path);
9181 ret = btrfs_commit_transaction(trans, root);
9182 if (!ret)
9183 fprintf(stderr, "Repaired extent flags for %llu\n",
9184 (unsigned long long)rec->start);
9185
9186 return ret;
9187 }
9188
9189 /* right now we only prune from the extent allocation tree */
9190 static int prune_one_block(struct btrfs_trans_handle *trans,
9191 struct btrfs_fs_info *info,
9192 struct btrfs_corrupt_block *corrupt)
9193 {
9194 int ret;
9195 struct btrfs_path path;
9196 struct extent_buffer *eb;
9197 u64 found;
9198 int slot;
9199 int nritems;
9200 int level = corrupt->level + 1;
9201
9202 btrfs_init_path(&path);
9203 again:
9204 /* we want to stop at the parent to our busted block */
9205 path.lowest_level = level;
9206
9207 ret = btrfs_search_slot(trans, info->extent_root,
9208 &corrupt->key, &path, -1, 1);
9209
9210 if (ret < 0)
9211 goto out;
9212
9213 eb = path.nodes[level];
9214 if (!eb) {
9215 ret = -ENOENT;
9216 goto out;
9217 }
9218
9219 /*
9220 * hopefully the search gave us the block we want to prune,
9221 * lets try that first
9222 */
9223 slot = path.slots[level];
9224 found = btrfs_node_blockptr(eb, slot);
9225 if (found == corrupt->cache.start)
9226 goto del_ptr;
9227
9228 nritems = btrfs_header_nritems(eb);
9229
9230 /* the search failed, lets scan this node and hope we find it */
9231 for (slot = 0; slot < nritems; slot++) {
9232 found = btrfs_node_blockptr(eb, slot);
9233 if (found == corrupt->cache.start)
9234 goto del_ptr;
9235 }
9236 /*
9237 * we couldn't find the bad block. TODO, search all the nodes for pointers
9238 * to this block
9239 */
9240 if (eb == info->extent_root->node) {
9241 ret = -ENOENT;
9242 goto out;
9243 } else {
9244 level++;
9245 btrfs_release_path(&path);
9246 goto again;
9247 }
9248
9249 del_ptr:
9250 printk("deleting pointer to block %Lu\n", corrupt->cache.start);
9251 ret = btrfs_del_ptr(info->extent_root, &path, level, slot);
9252
9253 out:
9254 btrfs_release_path(&path);
9255 return ret;
9256 }
9257
9258 static int prune_corrupt_blocks(struct btrfs_fs_info *info)
9259 {
9260 struct btrfs_trans_handle *trans = NULL;
9261 struct cache_extent *cache;
9262 struct btrfs_corrupt_block *corrupt;
9263
9264 while (1) {
9265 cache = search_cache_extent(info->corrupt_blocks, 0);
9266 if (!cache)
9267 break;
9268 if (!trans) {
9269 trans = btrfs_start_transaction(info->extent_root, 1);
9270 if (IS_ERR(trans))
9271 return PTR_ERR(trans);
9272 }
9273 corrupt = container_of(cache, struct btrfs_corrupt_block, cache);
9274 prune_one_block(trans, info, corrupt);
9275 remove_cache_extent(info->corrupt_blocks, cache);
9276 }
9277 if (trans)
9278 return btrfs_commit_transaction(trans, info->extent_root);
9279 return 0;
9280 }
9281
9282 static void reset_cached_block_groups(struct btrfs_fs_info *fs_info)
9283 {
9284 struct btrfs_block_group_cache *cache;
9285 u64 start, end;
9286 int ret;
9287
9288 while (1) {
9289 ret = find_first_extent_bit(&fs_info->free_space_cache, 0,
9290 &start, &end, EXTENT_DIRTY);
9291 if (ret)
9292 break;
9293 clear_extent_dirty(&fs_info->free_space_cache, start, end);
9294 }
9295
9296 start = 0;
9297 while (1) {
9298 cache = btrfs_lookup_first_block_group(fs_info, start);
9299 if (!cache)
9300 break;
9301 if (cache->cached)
9302 cache->cached = 0;
9303 start = cache->key.objectid + cache->key.offset;
9304 }
9305 }
9306
9307 static int check_extent_refs(struct btrfs_root *root,
9308 struct cache_tree *extent_cache)
9309 {
9310 struct extent_record *rec;
9311 struct cache_extent *cache;
9312 int ret = 0;
9313 int had_dups = 0;
9314
9315 if (repair) {
9316 /*
9317 * if we're doing a repair, we have to make sure
9318 * we don't allocate from the problem extents.
9319 * In the worst case, this will be all the
9320 * extents in the FS
9321 */
9322 cache = search_cache_extent(extent_cache, 0);
9323 while(cache) {
9324 rec = container_of(cache, struct extent_record, cache);
9325 set_extent_dirty(root->fs_info->excluded_extents,
9326 rec->start,
9327 rec->start + rec->max_size - 1);
9328 cache = next_cache_extent(cache);
9329 }
9330
9331 /* pin down all the corrupted blocks too */
9332 cache = search_cache_extent(root->fs_info->corrupt_blocks, 0);
9333 while(cache) {
9334 set_extent_dirty(root->fs_info->excluded_extents,
9335 cache->start,
9336 cache->start + cache->size - 1);
9337 cache = next_cache_extent(cache);
9338 }
9339 prune_corrupt_blocks(root->fs_info);
9340 reset_cached_block_groups(root->fs_info);
9341 }
9342
9343 reset_cached_block_groups(root->fs_info);
9344
9345 /*
9346 * We need to delete any duplicate entries we find first otherwise we
9347 * could mess up the extent tree when we have backrefs that actually
9348 * belong to a different extent item and not the weird duplicate one.
9349 */
9350 while (repair && !list_empty(&duplicate_extents)) {
9351 rec = to_extent_record(duplicate_extents.next);
9352 list_del_init(&rec->list);
9353
9354 /* Sometimes we can find a backref before we find an actual
9355 * extent, so we need to process it a little bit to see if there
9356 * truly are multiple EXTENT_ITEM_KEY's for the same range, or
9357 * if this is a backref screwup. If we need to delete stuff
9358 * process_duplicates() will return 0, otherwise it will return
9359 * 1 and we
9360 */
9361 if (process_duplicates(extent_cache, rec))
9362 continue;
9363 ret = delete_duplicate_records(root, rec);
9364 if (ret < 0)
9365 return ret;
9366 /*
9367 * delete_duplicate_records will return the number of entries
9368 * deleted, so if it's greater than 0 then we know we actually
9369 * did something and we need to remove.
9370 */
9371 if (ret)
9372 had_dups = 1;
9373 }
9374
9375 if (had_dups)
9376 return -EAGAIN;
9377
9378 while(1) {
9379 int cur_err = 0;
9380 int fix = 0;
9381
9382 cache = search_cache_extent(extent_cache, 0);
9383 if (!cache)
9384 break;
9385 rec = container_of(cache, struct extent_record, cache);
9386 if (rec->num_duplicates) {
9387 fprintf(stderr, "extent item %llu has multiple extent "
9388 "items\n", (unsigned long long)rec->start);
9389 cur_err = 1;
9390 }
9391
9392 if (rec->refs != rec->extent_item_refs) {
9393 fprintf(stderr, "ref mismatch on [%llu %llu] ",
9394 (unsigned long long)rec->start,
9395 (unsigned long long)rec->nr);
9396 fprintf(stderr, "extent item %llu, found %llu\n",
9397 (unsigned long long)rec->extent_item_refs,
9398 (unsigned long long)rec->refs);
9399 ret = record_orphan_data_extents(root->fs_info, rec);
9400 if (ret < 0)
9401 goto repair_abort;
9402 fix = ret;
9403 cur_err = 1;
9404 }
9405 if (all_backpointers_checked(rec, 1)) {
9406 fprintf(stderr, "backpointer mismatch on [%llu %llu]\n",
9407 (unsigned long long)rec->start,
9408 (unsigned long long)rec->nr);
9409 fix = 1;
9410 cur_err = 1;
9411 }
9412 if (!rec->owner_ref_checked) {
9413 fprintf(stderr, "owner ref check failed [%llu %llu]\n",
9414 (unsigned long long)rec->start,
9415 (unsigned long long)rec->nr);
9416 fix = 1;
9417 cur_err = 1;
9418 }
9419
9420 if (repair && fix) {
9421 ret = fixup_extent_refs(root->fs_info, extent_cache, rec);
9422 if (ret)
9423 goto repair_abort;
9424 }
9425
9426
9427 if (rec->bad_full_backref) {
9428 fprintf(stderr, "bad full backref, on [%llu]\n",
9429 (unsigned long long)rec->start);
9430 if (repair) {
9431 ret = fixup_extent_flags(root->fs_info, rec);
9432 if (ret)
9433 goto repair_abort;
9434 fix = 1;
9435 }
9436 cur_err = 1;
9437 }
9438 /*
9439 * Although it's not a extent ref's problem, we reuse this
9440 * routine for error reporting.
9441 * No repair function yet.
9442 */
9443 if (rec->crossing_stripes) {
9444 fprintf(stderr,
9445 "bad metadata [%llu, %llu) crossing stripe boundary\n",
9446 rec->start, rec->start + rec->max_size);
9447 cur_err = 1;
9448 }
9449
9450 if (rec->wrong_chunk_type) {
9451 fprintf(stderr,
9452 "bad extent [%llu, %llu), type mismatch with chunk\n",
9453 rec->start, rec->start + rec->max_size);
9454 cur_err = 1;
9455 }
9456
9457 remove_cache_extent(extent_cache, cache);
9458 free_all_extent_backrefs(rec);
9459 if (!init_extent_tree && repair && (!cur_err || fix))
9460 clear_extent_dirty(root->fs_info->excluded_extents,
9461 rec->start,
9462 rec->start + rec->max_size - 1);
9463 free(rec);
9464 }
9465 repair_abort:
9466 if (repair) {
9467 if (ret && ret != -EAGAIN) {
9468 fprintf(stderr, "failed to repair damaged filesystem, aborting\n");
9469 exit(1);
9470 } else if (!ret) {
9471 struct btrfs_trans_handle *trans;
9472
9473 root = root->fs_info->extent_root;
9474 trans = btrfs_start_transaction(root, 1);
9475 if (IS_ERR(trans)) {
9476 ret = PTR_ERR(trans);
9477 goto repair_abort;
9478 }
9479
9480 btrfs_fix_block_accounting(trans, root);
9481 ret = btrfs_commit_transaction(trans, root);
9482 if (ret)
9483 goto repair_abort;
9484 }
9485 return ret;
9486 }
9487 return 0;
9488 }
9489
9490 u64 calc_stripe_length(u64 type, u64 length, int num_stripes)
9491 {
9492 u64 stripe_size;
9493
9494 if (type & BTRFS_BLOCK_GROUP_RAID0) {
9495 stripe_size = length;
9496 stripe_size /= num_stripes;
9497 } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
9498 stripe_size = length * 2;
9499 stripe_size /= num_stripes;
9500 } else if (type & BTRFS_BLOCK_GROUP_RAID5) {
9501 stripe_size = length;
9502 stripe_size /= (num_stripes - 1);
9503 } else if (type & BTRFS_BLOCK_GROUP_RAID6) {
9504 stripe_size = length;
9505 stripe_size /= (num_stripes - 2);
9506 } else {
9507 stripe_size = length;
9508 }
9509 return stripe_size;
9510 }
9511
9512 /*
9513 * Check the chunk with its block group/dev list ref:
9514 * Return 0 if all refs seems valid.
9515 * Return 1 if part of refs seems valid, need later check for rebuild ref
9516 * like missing block group and needs to search extent tree to rebuild them.
9517 * Return -1 if essential refs are missing and unable to rebuild.
9518 */
9519 static int check_chunk_refs(struct chunk_record *chunk_rec,
9520 struct block_group_tree *block_group_cache,
9521 struct device_extent_tree *dev_extent_cache,
9522 int silent)
9523 {
9524 struct cache_extent *block_group_item;
9525 struct block_group_record *block_group_rec;
9526 struct cache_extent *dev_extent_item;
9527 struct device_extent_record *dev_extent_rec;
9528 u64 devid;
9529 u64 offset;
9530 u64 length;
9531 int metadump_v2 = 0;
9532 int i;
9533 int ret = 0;
9534
9535 block_group_item = lookup_cache_extent(&block_group_cache->tree,
9536 chunk_rec->offset,
9537 chunk_rec->length);
9538 if (block_group_item) {
9539 block_group_rec = container_of(block_group_item,
9540 struct block_group_record,
9541 cache);
9542 if (chunk_rec->length != block_group_rec->offset ||
9543 chunk_rec->offset != block_group_rec->objectid ||
9544 (!metadump_v2 &&
9545 chunk_rec->type_flags != block_group_rec->flags)) {
9546 if (!silent)
9547 fprintf(stderr,
9548 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) mismatch with block group[%llu, %u, %llu]: offset(%llu), objectid(%llu), flags(%llu)\n",
9549 chunk_rec->objectid,
9550 chunk_rec->type,
9551 chunk_rec->offset,
9552 chunk_rec->length,
9553 chunk_rec->offset,
9554 chunk_rec->type_flags,
9555 block_group_rec->objectid,
9556 block_group_rec->type,
9557 block_group_rec->offset,
9558 block_group_rec->offset,
9559 block_group_rec->objectid,
9560 block_group_rec->flags);
9561 ret = -1;
9562 } else {
9563 list_del_init(&block_group_rec->list);
9564 chunk_rec->bg_rec = block_group_rec;
9565 }
9566 } else {
9567 if (!silent)
9568 fprintf(stderr,
9569 "Chunk[%llu, %u, %llu]: length(%llu), offset(%llu), type(%llu) is not found in block group\n",
9570 chunk_rec->objectid,
9571 chunk_rec->type,
9572 chunk_rec->offset,
9573 chunk_rec->length,
9574 chunk_rec->offset,
9575 chunk_rec->type_flags);
9576 ret = 1;
9577 }
9578
9579 if (metadump_v2)
9580 return ret;
9581
9582 length = calc_stripe_length(chunk_rec->type_flags, chunk_rec->length,
9583 chunk_rec->num_stripes);
9584 for (i = 0; i < chunk_rec->num_stripes; ++i) {
9585 devid = chunk_rec->stripes[i].devid;
9586 offset = chunk_rec->stripes[i].offset;
9587 dev_extent_item = lookup_cache_extent2(&dev_extent_cache->tree,
9588 devid, offset, length);
9589 if (dev_extent_item) {
9590 dev_extent_rec = container_of(dev_extent_item,
9591 struct device_extent_record,
9592 cache);
9593 if (dev_extent_rec->objectid != devid ||
9594 dev_extent_rec->offset != offset ||
9595 dev_extent_rec->chunk_offset != chunk_rec->offset ||
9596 dev_extent_rec->length != length) {
9597 if (!silent)
9598 fprintf(stderr,
9599 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] dismatch dev extent[%llu, %llu, %llu]\n",
9600 chunk_rec->objectid,
9601 chunk_rec->type,
9602 chunk_rec->offset,
9603 chunk_rec->stripes[i].devid,
9604 chunk_rec->stripes[i].offset,
9605 dev_extent_rec->objectid,
9606 dev_extent_rec->offset,
9607 dev_extent_rec->length);
9608 ret = -1;
9609 } else {
9610 list_move(&dev_extent_rec->chunk_list,
9611 &chunk_rec->dextents);
9612 }
9613 } else {
9614 if (!silent)
9615 fprintf(stderr,
9616 "Chunk[%llu, %u, %llu] stripe[%llu, %llu] is not found in dev extent\n",
9617 chunk_rec->objectid,
9618 chunk_rec->type,
9619 chunk_rec->offset,
9620 chunk_rec->stripes[i].devid,
9621 chunk_rec->stripes[i].offset);
9622 ret = -1;
9623 }
9624 }
9625 return ret;
9626 }
9627
9628 /* check btrfs_chunk -> btrfs_dev_extent / btrfs_block_group_item */
9629 int check_chunks(struct cache_tree *chunk_cache,
9630 struct block_group_tree *block_group_cache,
9631 struct device_extent_tree *dev_extent_cache,
9632 struct list_head *good, struct list_head *bad,
9633 struct list_head *rebuild, int silent)
9634 {
9635 struct cache_extent *chunk_item;
9636 struct chunk_record *chunk_rec;
9637 struct block_group_record *bg_rec;
9638 struct device_extent_record *dext_rec;
9639 int err;
9640 int ret = 0;
9641
9642 chunk_item = first_cache_extent(chunk_cache);
9643 while (chunk_item) {
9644 chunk_rec = container_of(chunk_item, struct chunk_record,
9645 cache);
9646 err = check_chunk_refs(chunk_rec, block_group_cache,
9647 dev_extent_cache, silent);
9648 if (err < 0)
9649 ret = err;
9650 if (err == 0 && good)
9651 list_add_tail(&chunk_rec->list, good);
9652 if (err > 0 && rebuild)
9653 list_add_tail(&chunk_rec->list, rebuild);
9654 if (err < 0 && bad)
9655 list_add_tail(&chunk_rec->list, bad);
9656 chunk_item = next_cache_extent(chunk_item);
9657 }
9658
9659 list_for_each_entry(bg_rec, &block_group_cache->block_groups, list) {
9660 if (!silent)
9661 fprintf(stderr,
9662 "Block group[%llu, %llu] (flags = %llu) didn't find the relative chunk.\n",
9663 bg_rec->objectid,
9664 bg_rec->offset,
9665 bg_rec->flags);
9666 if (!ret)
9667 ret = 1;
9668 }
9669
9670 list_for_each_entry(dext_rec, &dev_extent_cache->no_chunk_orphans,
9671 chunk_list) {
9672 if (!silent)
9673 fprintf(stderr,
9674 "Device extent[%llu, %llu, %llu] didn't find the relative chunk.\n",
9675 dext_rec->objectid,
9676 dext_rec->offset,
9677 dext_rec->length);
9678 if (!ret)
9679 ret = 1;
9680 }
9681 return ret;
9682 }
9683
9684
9685 static int check_device_used(struct device_record *dev_rec,
9686 struct device_extent_tree *dext_cache)
9687 {
9688 struct cache_extent *cache;
9689 struct device_extent_record *dev_extent_rec;
9690 u64 total_byte = 0;
9691
9692 cache = search_cache_extent2(&dext_cache->tree, dev_rec->devid, 0);
9693 while (cache) {
9694 dev_extent_rec = container_of(cache,
9695 struct device_extent_record,
9696 cache);
9697 if (dev_extent_rec->objectid != dev_rec->devid)
9698 break;
9699
9700 list_del_init(&dev_extent_rec->device_list);
9701 total_byte += dev_extent_rec->length;
9702 cache = next_cache_extent(cache);
9703 }
9704
9705 if (total_byte != dev_rec->byte_used) {
9706 fprintf(stderr,
9707 "Dev extent's total-byte(%llu) is not equal to byte-used(%llu) in dev[%llu, %u, %llu]\n",
9708 total_byte, dev_rec->byte_used, dev_rec->objectid,
9709 dev_rec->type, dev_rec->offset);
9710 return -1;
9711 } else {
9712 return 0;
9713 }
9714 }
9715
9716 /* check btrfs_dev_item -> btrfs_dev_extent */
9717 static int check_devices(struct rb_root *dev_cache,
9718 struct device_extent_tree *dev_extent_cache)
9719 {
9720 struct rb_node *dev_node;
9721 struct device_record *dev_rec;
9722 struct device_extent_record *dext_rec;
9723 int err;
9724 int ret = 0;
9725
9726 dev_node = rb_first(dev_cache);
9727 while (dev_node) {
9728 dev_rec = container_of(dev_node, struct device_record, node);
9729 err = check_device_used(dev_rec, dev_extent_cache);
9730 if (err)
9731 ret = err;
9732
9733 dev_node = rb_next(dev_node);
9734 }
9735 list_for_each_entry(dext_rec, &dev_extent_cache->no_device_orphans,
9736 device_list) {
9737 fprintf(stderr,
9738 "Device extent[%llu, %llu, %llu] didn't find its device.\n",
9739 dext_rec->objectid, dext_rec->offset, dext_rec->length);
9740 if (!ret)
9741 ret = 1;
9742 }
9743 return ret;
9744 }
9745
9746 static int add_root_item_to_list(struct list_head *head,
9747 u64 objectid, u64 bytenr, u64 last_snapshot,
9748 u8 level, u8 drop_level,
9749 int level_size, struct btrfs_key *drop_key)
9750 {
9751
9752 struct root_item_record *ri_rec;
9753 ri_rec = malloc(sizeof(*ri_rec));
9754 if (!ri_rec)
9755 return -ENOMEM;
9756 ri_rec->bytenr = bytenr;
9757 ri_rec->objectid = objectid;
9758 ri_rec->level = level;
9759 ri_rec->level_size = level_size;
9760 ri_rec->drop_level = drop_level;
9761 ri_rec->last_snapshot = last_snapshot;
9762 if (drop_key)
9763 memcpy(&ri_rec->drop_key, drop_key, sizeof(*drop_key));
9764 list_add_tail(&ri_rec->list, head);
9765
9766 return 0;
9767 }
9768
9769 static void free_root_item_list(struct list_head *list)
9770 {
9771 struct root_item_record *ri_rec;
9772
9773 while (!list_empty(list)) {
9774 ri_rec = list_first_entry(list, struct root_item_record,
9775 list);
9776 list_del_init(&ri_rec->list);
9777 free(ri_rec);
9778 }
9779 }
9780
9781 static int deal_root_from_list(struct list_head *list,
9782 struct btrfs_root *root,
9783 struct block_info *bits,
9784 int bits_nr,
9785 struct cache_tree *pending,
9786 struct cache_tree *seen,
9787 struct cache_tree *reada,
9788 struct cache_tree *nodes,
9789 struct cache_tree *extent_cache,
9790 struct cache_tree *chunk_cache,
9791 struct rb_root *dev_cache,
9792 struct block_group_tree *block_group_cache,
9793 struct device_extent_tree *dev_extent_cache)
9794 {
9795 int ret = 0;
9796 u64 last;
9797
9798 while (!list_empty(list)) {
9799 struct root_item_record *rec;
9800 struct extent_buffer *buf;
9801 rec = list_entry(list->next,
9802 struct root_item_record, list);
9803 last = 0;
9804 buf = read_tree_block(root->fs_info,
9805 rec->bytenr, rec->level_size, 0);
9806 if (!extent_buffer_uptodate(buf)) {
9807 free_extent_buffer(buf);
9808 ret = -EIO;
9809 break;
9810 }
9811 ret = add_root_to_pending(buf, extent_cache, pending,
9812 seen, nodes, rec->objectid);
9813 if (ret < 0)
9814 break;
9815 /*
9816 * To rebuild extent tree, we need deal with snapshot
9817 * one by one, otherwise we deal with node firstly which
9818 * can maximize readahead.
9819 */
9820 while (1) {
9821 ret = run_next_block(root, bits, bits_nr, &last,
9822 pending, seen, reada, nodes,
9823 extent_cache, chunk_cache,
9824 dev_cache, block_group_cache,
9825 dev_extent_cache, rec);
9826 if (ret != 0)
9827 break;
9828 }
9829 free_extent_buffer(buf);
9830 list_del(&rec->list);
9831 free(rec);
9832 if (ret < 0)
9833 break;
9834 }
9835 while (ret >= 0) {
9836 ret = run_next_block(root, bits, bits_nr, &last, pending, seen,
9837 reada, nodes, extent_cache, chunk_cache,
9838 dev_cache, block_group_cache,
9839 dev_extent_cache, NULL);
9840 if (ret != 0) {
9841 if (ret > 0)
9842 ret = 0;
9843 break;
9844 }
9845 }
9846 return ret;
9847 }
9848
9849 static int check_chunks_and_extents(struct btrfs_root *root)
9850 {
9851 struct rb_root dev_cache;
9852 struct cache_tree chunk_cache;
9853 struct block_group_tree block_group_cache;
9854 struct device_extent_tree dev_extent_cache;
9855 struct cache_tree extent_cache;
9856 struct cache_tree seen;
9857 struct cache_tree pending;
9858 struct cache_tree reada;
9859 struct cache_tree nodes;
9860 struct extent_io_tree excluded_extents;
9861 struct cache_tree corrupt_blocks;
9862 struct btrfs_path path;
9863 struct btrfs_key key;
9864 struct btrfs_key found_key;
9865 int ret, err = 0;
9866 struct block_info *bits;
9867 int bits_nr;
9868 struct extent_buffer *leaf;
9869 int slot;
9870 struct btrfs_root_item ri;
9871 struct list_head dropping_trees;
9872 struct list_head normal_trees;
9873 struct btrfs_root *root1;
9874 u64 objectid;
9875 u32 level_size;
9876 u8 level;
9877
9878 dev_cache = RB_ROOT;
9879 cache_tree_init(&chunk_cache);
9880 block_group_tree_init(&block_group_cache);
9881 device_extent_tree_init(&dev_extent_cache);
9882
9883 cache_tree_init(&extent_cache);
9884 cache_tree_init(&seen);
9885 cache_tree_init(&pending);
9886 cache_tree_init(&nodes);
9887 cache_tree_init(&reada);
9888 cache_tree_init(&corrupt_blocks);
9889 extent_io_tree_init(&excluded_extents);
9890 INIT_LIST_HEAD(&dropping_trees);
9891 INIT_LIST_HEAD(&normal_trees);
9892
9893 if (repair) {
9894 root->fs_info->excluded_extents = &excluded_extents;
9895 root->fs_info->fsck_extent_cache = &extent_cache;
9896 root->fs_info->free_extent_hook = free_extent_hook;
9897 root->fs_info->corrupt_blocks = &corrupt_blocks;
9898 }
9899
9900 bits_nr = 1024;
9901 bits = malloc(bits_nr * sizeof(struct block_info));
9902 if (!bits) {
9903 perror("malloc");
9904 exit(1);
9905 }
9906
9907 if (ctx.progress_enabled) {
9908 ctx.tp = TASK_EXTENTS;
9909 task_start(ctx.info);
9910 }
9911
9912 again:
9913 root1 = root->fs_info->tree_root;
9914 level = btrfs_header_level(root1->node);
9915 ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
9916 root1->node->start, 0, level, 0,
9917 root1->fs_info->nodesize, NULL);
9918 if (ret < 0)
9919 goto out;
9920 root1 = root->fs_info->chunk_root;
9921 level = btrfs_header_level(root1->node);
9922 ret = add_root_item_to_list(&normal_trees, root1->root_key.objectid,
9923 root1->node->start, 0, level, 0,
9924 root1->fs_info->nodesize, NULL);
9925 if (ret < 0)
9926 goto out;
9927 btrfs_init_path(&path);
9928 key.offset = 0;
9929 key.objectid = 0;
9930 key.type = BTRFS_ROOT_ITEM_KEY;
9931 ret = btrfs_search_slot(NULL, root->fs_info->tree_root,
9932 &key, &path, 0, 0);
9933 if (ret < 0)
9934 goto out;
9935 while(1) {
9936 leaf = path.nodes[0];
9937 slot = path.slots[0];
9938 if (slot >= btrfs_header_nritems(path.nodes[0])) {
9939 ret = btrfs_next_leaf(root, &path);
9940 if (ret != 0)
9941 break;
9942 leaf = path.nodes[0];
9943 slot = path.slots[0];
9944 }
9945 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
9946 if (found_key.type == BTRFS_ROOT_ITEM_KEY) {
9947 unsigned long offset;
9948 u64 last_snapshot;
9949
9950 offset = btrfs_item_ptr_offset(leaf, path.slots[0]);
9951 read_extent_buffer(leaf, &ri, offset, sizeof(ri));
9952 last_snapshot = btrfs_root_last_snapshot(&ri);
9953 if (btrfs_disk_key_objectid(&ri.drop_progress) == 0) {
9954 level = btrfs_root_level(&ri);
9955 level_size = root->fs_info->nodesize;
9956 ret = add_root_item_to_list(&normal_trees,
9957 found_key.objectid,
9958 btrfs_root_bytenr(&ri),
9959 last_snapshot, level,
9960 0, level_size, NULL);
9961 if (ret < 0)
9962 goto out;
9963 } else {
9964 level = btrfs_root_level(&ri);
9965 level_size = root->fs_info->nodesize;
9966 objectid = found_key.objectid;
9967 btrfs_disk_key_to_cpu(&found_key,
9968 &ri.drop_progress);
9969 ret = add_root_item_to_list(&dropping_trees,
9970 objectid,
9971 btrfs_root_bytenr(&ri),
9972 last_snapshot, level,
9973 ri.drop_level,
9974 level_size, &found_key);
9975 if (ret < 0)
9976 goto out;
9977 }
9978 }
9979 path.slots[0]++;
9980 }
9981 btrfs_release_path(&path);
9982
9983 /*
9984 * check_block can return -EAGAIN if it fixes something, please keep
9985 * this in mind when dealing with return values from these functions, if
9986 * we get -EAGAIN we want to fall through and restart the loop.
9987 */
9988 ret = deal_root_from_list(&normal_trees, root, bits, bits_nr, &pending,
9989 &seen, &reada, &nodes, &extent_cache,
9990 &chunk_cache, &dev_cache, &block_group_cache,
9991 &dev_extent_cache);
9992 if (ret < 0) {
9993 if (ret == -EAGAIN)
9994 goto loop;
9995 goto out;
9996 }
9997 ret = deal_root_from_list(&dropping_trees, root, bits, bits_nr,
9998 &pending, &seen, &reada, &nodes,
9999 &extent_cache, &chunk_cache, &dev_cache,
10000 &block_group_cache, &dev_extent_cache);
10001 if (ret < 0) {
10002 if (ret == -EAGAIN)
10003 goto loop;
10004 goto out;
10005 }
10006
10007 ret = check_chunks(&chunk_cache, &block_group_cache,
10008 &dev_extent_cache, NULL, NULL, NULL, 0);
10009 if (ret) {
10010 if (ret == -EAGAIN)
10011 goto loop;
10012 err = ret;
10013 }
10014
10015 ret = check_extent_refs(root, &extent_cache);
10016 if (ret < 0) {
10017 if (ret == -EAGAIN)
10018 goto loop;
10019 goto out;
10020 }
10021
10022 ret = check_devices(&dev_cache, &dev_extent_cache);
10023 if (ret && err)
10024 ret = err;
10025
10026 out:
10027 task_stop(ctx.info);
10028 if (repair) {
10029 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
10030 extent_io_tree_cleanup(&excluded_extents);
10031 root->fs_info->fsck_extent_cache = NULL;
10032 root->fs_info->free_extent_hook = NULL;
10033 root->fs_info->corrupt_blocks = NULL;
10034 root->fs_info->excluded_extents = NULL;
10035 }
10036 free(bits);
10037 free_chunk_cache_tree(&chunk_cache);
10038 free_device_cache_tree(&dev_cache);
10039 free_block_group_tree(&block_group_cache);
10040 free_device_extent_tree(&dev_extent_cache);
10041 free_extent_cache_tree(&seen);
10042 free_extent_cache_tree(&pending);
10043 free_extent_cache_tree(&reada);
10044 free_extent_cache_tree(&nodes);
10045 free_root_item_list(&normal_trees);
10046 free_root_item_list(&dropping_trees);
10047 return ret;
10048 loop:
10049 free_corrupt_blocks_tree(root->fs_info->corrupt_blocks);
10050 free_extent_cache_tree(&seen);
10051 free_extent_cache_tree(&pending);
10052 free_extent_cache_tree(&reada);
10053 free_extent_cache_tree(&nodes);
10054 free_chunk_cache_tree(&chunk_cache);
10055 free_block_group_tree(&block_group_cache);
10056 free_device_cache_tree(&dev_cache);
10057 free_device_extent_tree(&dev_extent_cache);
10058 free_extent_record_cache(&extent_cache);
10059 free_root_item_list(&normal_trees);
10060 free_root_item_list(&dropping_trees);
10061 extent_io_tree_cleanup(&excluded_extents);
10062 goto again;
10063 }
10064
10065 /*
10066 * Check backrefs of a tree block given by @bytenr or @eb.
10067 *
10068 * @root: the root containing the @bytenr or @eb
10069 * @eb: tree block extent buffer, can be NULL
10070 * @bytenr: bytenr of the tree block to search
10071 * @level: tree level of the tree block
10072 * @owner: owner of the tree block
10073 *
10074 * Return >0 for any error found and output error message
10075 * Return 0 for no error found
10076 */
10077 static int check_tree_block_ref(struct btrfs_root *root,
10078 struct extent_buffer *eb, u64 bytenr,
10079 int level, u64 owner)
10080 {
10081 struct btrfs_key key;
10082 struct btrfs_root *extent_root = root->fs_info->extent_root;
10083 struct btrfs_path path;
10084 struct btrfs_extent_item *ei;
10085 struct btrfs_extent_inline_ref *iref;
10086 struct extent_buffer *leaf;
10087 unsigned long end;
10088 unsigned long ptr;
10089 int slot;
10090 int skinny_level;
10091 int type;
10092 u32 nodesize = root->fs_info->nodesize;
10093 u32 item_size;
10094 u64 offset;
10095 int tree_reloc_root = 0;
10096 int found_ref = 0;
10097 int err = 0;
10098 int ret;
10099
10100 if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID &&
10101 btrfs_header_bytenr(root->node) == bytenr)
10102 tree_reloc_root = 1;
10103
10104 btrfs_init_path(&path);
10105 key.objectid = bytenr;
10106 if (btrfs_fs_incompat(root->fs_info, SKINNY_METADATA))
10107 key.type = BTRFS_METADATA_ITEM_KEY;
10108 else
10109 key.type = BTRFS_EXTENT_ITEM_KEY;
10110 key.offset = (u64)-1;
10111
10112 /* Search for the backref in extent tree */
10113 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10114 if (ret < 0) {
10115 err |= BACKREF_MISSING;
10116 goto out;
10117 }
10118 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
10119 if (ret) {
10120 err |= BACKREF_MISSING;
10121 goto out;
10122 }
10123
10124 leaf = path.nodes[0];
10125 slot = path.slots[0];
10126 btrfs_item_key_to_cpu(leaf, &key, slot);
10127
10128 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
10129
10130 if (key.type == BTRFS_METADATA_ITEM_KEY) {
10131 skinny_level = (int)key.offset;
10132 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
10133 } else {
10134 struct btrfs_tree_block_info *info;
10135
10136 info = (struct btrfs_tree_block_info *)(ei + 1);
10137 skinny_level = btrfs_tree_block_level(leaf, info);
10138 iref = (struct btrfs_extent_inline_ref *)(info + 1);
10139 }
10140
10141 if (eb) {
10142 u64 header_gen;
10143 u64 extent_gen;
10144
10145 if (!(btrfs_extent_flags(leaf, ei) &
10146 BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
10147 error(
10148 "extent[%llu %u] backref type mismatch, missing bit: %llx",
10149 key.objectid, nodesize,
10150 BTRFS_EXTENT_FLAG_TREE_BLOCK);
10151 err = BACKREF_MISMATCH;
10152 }
10153 header_gen = btrfs_header_generation(eb);
10154 extent_gen = btrfs_extent_generation(leaf, ei);
10155 if (header_gen != extent_gen) {
10156 error(
10157 "extent[%llu %u] backref generation mismatch, wanted: %llu, have: %llu",
10158 key.objectid, nodesize, header_gen,
10159 extent_gen);
10160 err = BACKREF_MISMATCH;
10161 }
10162 if (level != skinny_level) {
10163 error(
10164 "extent[%llu %u] level mismatch, wanted: %u, have: %u",
10165 key.objectid, nodesize, level, skinny_level);
10166 err = BACKREF_MISMATCH;
10167 }
10168 if (!is_fstree(owner) && btrfs_extent_refs(leaf, ei) != 1) {
10169 error(
10170 "extent[%llu %u] is referred by other roots than %llu",
10171 key.objectid, nodesize, root->objectid);
10172 err = BACKREF_MISMATCH;
10173 }
10174 }
10175
10176 /*
10177 * Iterate the extent/metadata item to find the exact backref
10178 */
10179 item_size = btrfs_item_size_nr(leaf, slot);
10180 ptr = (unsigned long)iref;
10181 end = (unsigned long)ei + item_size;
10182 while (ptr < end) {
10183 iref = (struct btrfs_extent_inline_ref *)ptr;
10184 type = btrfs_extent_inline_ref_type(leaf, iref);
10185 offset = btrfs_extent_inline_ref_offset(leaf, iref);
10186
10187 if (type == BTRFS_TREE_BLOCK_REF_KEY &&
10188 (offset == root->objectid || offset == owner)) {
10189 found_ref = 1;
10190 } else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
10191 /*
10192 * Backref of tree reloc root points to itself, no need
10193 * to check backref any more.
10194 */
10195 if (tree_reloc_root)
10196 found_ref = 1;
10197 else
10198 /* Check if the backref points to valid referencer */
10199 found_ref = !check_tree_block_ref(root, NULL,
10200 offset, level + 1, owner);
10201 }
10202
10203 if (found_ref)
10204 break;
10205 ptr += btrfs_extent_inline_ref_size(type);
10206 }
10207
10208 /*
10209 * Inlined extent item doesn't have what we need, check
10210 * TREE_BLOCK_REF_KEY
10211 */
10212 if (!found_ref) {
10213 btrfs_release_path(&path);
10214 key.objectid = bytenr;
10215 key.type = BTRFS_TREE_BLOCK_REF_KEY;
10216 key.offset = root->objectid;
10217
10218 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10219 if (!ret)
10220 found_ref = 1;
10221 }
10222 if (!found_ref)
10223 err |= BACKREF_MISSING;
10224 out:
10225 btrfs_release_path(&path);
10226 if (eb && (err & BACKREF_MISSING))
10227 error("extent[%llu %u] backref lost (owner: %llu, level: %u)",
10228 bytenr, nodesize, owner, level);
10229 return err;
10230 }
10231
10232 /*
10233 * Check EXTENT_DATA item, mainly for its dbackref in extent tree
10234 *
10235 * Return >0 any error found and output error message
10236 * Return 0 for no error found
10237 */
10238 static int check_extent_data_item(struct btrfs_root *root,
10239 struct extent_buffer *eb, int slot)
10240 {
10241 struct btrfs_file_extent_item *fi;
10242 struct btrfs_path path;
10243 struct btrfs_root *extent_root = root->fs_info->extent_root;
10244 struct btrfs_key fi_key;
10245 struct btrfs_key dbref_key;
10246 struct extent_buffer *leaf;
10247 struct btrfs_extent_item *ei;
10248 struct btrfs_extent_inline_ref *iref;
10249 struct btrfs_extent_data_ref *dref;
10250 u64 owner;
10251 u64 disk_bytenr;
10252 u64 disk_num_bytes;
10253 u64 extent_num_bytes;
10254 u64 extent_flags;
10255 u32 item_size;
10256 unsigned long end;
10257 unsigned long ptr;
10258 int type;
10259 u64 ref_root;
10260 int found_dbackref = 0;
10261 int err = 0;
10262 int ret;
10263
10264 btrfs_item_key_to_cpu(eb, &fi_key, slot);
10265 fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
10266
10267 /* Nothing to check for hole and inline data extents */
10268 if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE ||
10269 btrfs_file_extent_disk_bytenr(eb, fi) == 0)
10270 return 0;
10271
10272 disk_bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
10273 disk_num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
10274 extent_num_bytes = btrfs_file_extent_num_bytes(eb, fi);
10275
10276 /* Check unaligned disk_num_bytes and num_bytes */
10277 if (!IS_ALIGNED(disk_num_bytes, root->fs_info->sectorsize)) {
10278 error(
10279 "file extent [%llu, %llu] has unaligned disk num bytes: %llu, should be aligned to %u",
10280 fi_key.objectid, fi_key.offset, disk_num_bytes,
10281 root->fs_info->sectorsize);
10282 err |= BYTES_UNALIGNED;
10283 } else {
10284 data_bytes_allocated += disk_num_bytes;
10285 }
10286 if (!IS_ALIGNED(extent_num_bytes, root->fs_info->sectorsize)) {
10287 error(
10288 "file extent [%llu, %llu] has unaligned num bytes: %llu, should be aligned to %u",
10289 fi_key.objectid, fi_key.offset, extent_num_bytes,
10290 root->fs_info->sectorsize);
10291 err |= BYTES_UNALIGNED;
10292 } else {
10293 data_bytes_referenced += extent_num_bytes;
10294 }
10295 owner = btrfs_header_owner(eb);
10296
10297 /* Check the extent item of the file extent in extent tree */
10298 btrfs_init_path(&path);
10299 dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
10300 dbref_key.type = BTRFS_EXTENT_ITEM_KEY;
10301 dbref_key.offset = btrfs_file_extent_disk_num_bytes(eb, fi);
10302
10303 ret = btrfs_search_slot(NULL, extent_root, &dbref_key, &path, 0, 0);
10304 if (ret)
10305 goto out;
10306
10307 leaf = path.nodes[0];
10308 slot = path.slots[0];
10309 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
10310
10311 extent_flags = btrfs_extent_flags(leaf, ei);
10312
10313 if (!(extent_flags & BTRFS_EXTENT_FLAG_DATA)) {
10314 error(
10315 "extent[%llu %llu] backref type mismatch, wanted bit: %llx",
10316 disk_bytenr, disk_num_bytes,
10317 BTRFS_EXTENT_FLAG_DATA);
10318 err |= BACKREF_MISMATCH;
10319 }
10320
10321 /* Check data backref inside that extent item */
10322 item_size = btrfs_item_size_nr(leaf, path.slots[0]);
10323 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
10324 ptr = (unsigned long)iref;
10325 end = (unsigned long)ei + item_size;
10326 while (ptr < end) {
10327 iref = (struct btrfs_extent_inline_ref *)ptr;
10328 type = btrfs_extent_inline_ref_type(leaf, iref);
10329 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
10330
10331 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
10332 ref_root = btrfs_extent_data_ref_root(leaf, dref);
10333 if (ref_root == owner || ref_root == root->objectid)
10334 found_dbackref = 1;
10335 } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
10336 found_dbackref = !check_tree_block_ref(root, NULL,
10337 btrfs_extent_inline_ref_offset(leaf, iref),
10338 0, owner);
10339 }
10340
10341 if (found_dbackref)
10342 break;
10343 ptr += btrfs_extent_inline_ref_size(type);
10344 }
10345
10346 if (!found_dbackref) {
10347 btrfs_release_path(&path);
10348
10349 /* Didn't find inlined data backref, try EXTENT_DATA_REF_KEY */
10350 dbref_key.objectid = btrfs_file_extent_disk_bytenr(eb, fi);
10351 dbref_key.type = BTRFS_EXTENT_DATA_REF_KEY;
10352 dbref_key.offset = hash_extent_data_ref(root->objectid,
10353 fi_key.objectid, fi_key.offset);
10354
10355 ret = btrfs_search_slot(NULL, root->fs_info->extent_root,
10356 &dbref_key, &path, 0, 0);
10357 if (!ret) {
10358 found_dbackref = 1;
10359 goto out;
10360 }
10361
10362 btrfs_release_path(&path);
10363
10364 /*
10365 * Neither inlined nor EXTENT_DATA_REF found, try
10366 * SHARED_DATA_REF as last chance.
10367 */
10368 dbref_key.objectid = disk_bytenr;
10369 dbref_key.type = BTRFS_SHARED_DATA_REF_KEY;
10370 dbref_key.offset = eb->start;
10371
10372 ret = btrfs_search_slot(NULL, root->fs_info->extent_root,
10373 &dbref_key, &path, 0, 0);
10374 if (!ret) {
10375 found_dbackref = 1;
10376 goto out;
10377 }
10378 }
10379
10380 out:
10381 if (!found_dbackref)
10382 err |= BACKREF_MISSING;
10383 btrfs_release_path(&path);
10384 if (err & BACKREF_MISSING) {
10385 error("data extent[%llu %llu] backref lost",
10386 disk_bytenr, disk_num_bytes);
10387 }
10388 return err;
10389 }
10390
10391 /*
10392 * Get real tree block level for the case like shared block
10393 * Return >= 0 as tree level
10394 * Return <0 for error
10395 */
10396 static int query_tree_block_level(struct btrfs_fs_info *fs_info, u64 bytenr)
10397 {
10398 struct extent_buffer *eb;
10399 struct btrfs_path path;
10400 struct btrfs_key key;
10401 struct btrfs_extent_item *ei;
10402 u64 flags;
10403 u64 transid;
10404 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10405 u8 backref_level;
10406 u8 header_level;
10407 int ret;
10408
10409 /* Search extent tree for extent generation and level */
10410 key.objectid = bytenr;
10411 key.type = BTRFS_METADATA_ITEM_KEY;
10412 key.offset = (u64)-1;
10413
10414 btrfs_init_path(&path);
10415 ret = btrfs_search_slot(NULL, fs_info->extent_root, &key, &path, 0, 0);
10416 if (ret < 0)
10417 goto release_out;
10418 ret = btrfs_previous_extent_item(fs_info->extent_root, &path, bytenr);
10419 if (ret < 0)
10420 goto release_out;
10421 if (ret > 0) {
10422 ret = -ENOENT;
10423 goto release_out;
10424 }
10425
10426 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10427 ei = btrfs_item_ptr(path.nodes[0], path.slots[0],
10428 struct btrfs_extent_item);
10429 flags = btrfs_extent_flags(path.nodes[0], ei);
10430 if (!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)) {
10431 ret = -ENOENT;
10432 goto release_out;
10433 }
10434
10435 /* Get transid for later read_tree_block() check */
10436 transid = btrfs_extent_generation(path.nodes[0], ei);
10437
10438 /* Get backref level as one source */
10439 if (key.type == BTRFS_METADATA_ITEM_KEY) {
10440 backref_level = key.offset;
10441 } else {
10442 struct btrfs_tree_block_info *info;
10443
10444 info = (struct btrfs_tree_block_info *)(ei + 1);
10445 backref_level = btrfs_tree_block_level(path.nodes[0], info);
10446 }
10447 btrfs_release_path(&path);
10448
10449 /* Get level from tree block as an alternative source */
10450 eb = read_tree_block(fs_info, bytenr, nodesize, transid);
10451 if (!extent_buffer_uptodate(eb)) {
10452 free_extent_buffer(eb);
10453 return -EIO;
10454 }
10455 header_level = btrfs_header_level(eb);
10456 free_extent_buffer(eb);
10457
10458 if (header_level != backref_level)
10459 return -EIO;
10460 return header_level;
10461
10462 release_out:
10463 btrfs_release_path(&path);
10464 return ret;
10465 }
10466
10467 /*
10468 * Check if a tree block backref is valid (points to a valid tree block)
10469 * if level == -1, level will be resolved
10470 * Return >0 for any error found and print error message
10471 */
10472 static int check_tree_block_backref(struct btrfs_fs_info *fs_info, u64 root_id,
10473 u64 bytenr, int level)
10474 {
10475 struct btrfs_root *root;
10476 struct btrfs_key key;
10477 struct btrfs_path path;
10478 struct extent_buffer *eb;
10479 struct extent_buffer *node;
10480 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10481 int err = 0;
10482 int ret;
10483
10484 /* Query level for level == -1 special case */
10485 if (level == -1)
10486 level = query_tree_block_level(fs_info, bytenr);
10487 if (level < 0) {
10488 err |= REFERENCER_MISSING;
10489 goto out;
10490 }
10491
10492 key.objectid = root_id;
10493 key.type = BTRFS_ROOT_ITEM_KEY;
10494 key.offset = (u64)-1;
10495
10496 root = btrfs_read_fs_root(fs_info, &key);
10497 if (IS_ERR(root)) {
10498 err |= REFERENCER_MISSING;
10499 goto out;
10500 }
10501
10502 /* Read out the tree block to get item/node key */
10503 eb = read_tree_block(fs_info, bytenr, root->fs_info->nodesize, 0);
10504 if (!extent_buffer_uptodate(eb)) {
10505 err |= REFERENCER_MISSING;
10506 free_extent_buffer(eb);
10507 goto out;
10508 }
10509
10510 /* Empty tree, no need to check key */
10511 if (!btrfs_header_nritems(eb) && !level) {
10512 free_extent_buffer(eb);
10513 goto out;
10514 }
10515
10516 if (level)
10517 btrfs_node_key_to_cpu(eb, &key, 0);
10518 else
10519 btrfs_item_key_to_cpu(eb, &key, 0);
10520
10521 free_extent_buffer(eb);
10522
10523 btrfs_init_path(&path);
10524 path.lowest_level = level;
10525 /* Search with the first key, to ensure we can reach it */
10526 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
10527 if (ret < 0) {
10528 err |= REFERENCER_MISSING;
10529 goto release_out;
10530 }
10531
10532 node = path.nodes[level];
10533 if (btrfs_header_bytenr(node) != bytenr) {
10534 error(
10535 "extent [%llu %d] referencer bytenr mismatch, wanted: %llu, have: %llu",
10536 bytenr, nodesize, bytenr,
10537 btrfs_header_bytenr(node));
10538 err |= REFERENCER_MISMATCH;
10539 }
10540 if (btrfs_header_level(node) != level) {
10541 error(
10542 "extent [%llu %d] referencer level mismatch, wanted: %d, have: %d",
10543 bytenr, nodesize, level,
10544 btrfs_header_level(node));
10545 err |= REFERENCER_MISMATCH;
10546 }
10547
10548 release_out:
10549 btrfs_release_path(&path);
10550 out:
10551 if (err & REFERENCER_MISSING) {
10552 if (level < 0)
10553 error("extent [%llu %d] lost referencer (owner: %llu)",
10554 bytenr, nodesize, root_id);
10555 else
10556 error(
10557 "extent [%llu %d] lost referencer (owner: %llu, level: %u)",
10558 bytenr, nodesize, root_id, level);
10559 }
10560
10561 return err;
10562 }
10563
10564 /*
10565 * Check if tree block @eb is tree reloc root.
10566 * Return 0 if it's not or any problem happens
10567 * Return 1 if it's a tree reloc root
10568 */
10569 static int is_tree_reloc_root(struct btrfs_fs_info *fs_info,
10570 struct extent_buffer *eb)
10571 {
10572 struct btrfs_root *tree_reloc_root;
10573 struct btrfs_key key;
10574 u64 bytenr = btrfs_header_bytenr(eb);
10575 u64 owner = btrfs_header_owner(eb);
10576 int ret = 0;
10577
10578 key.objectid = BTRFS_TREE_RELOC_OBJECTID;
10579 key.offset = owner;
10580 key.type = BTRFS_ROOT_ITEM_KEY;
10581
10582 tree_reloc_root = btrfs_read_fs_root_no_cache(fs_info, &key);
10583 if (IS_ERR(tree_reloc_root))
10584 return 0;
10585
10586 if (bytenr == btrfs_header_bytenr(tree_reloc_root->node))
10587 ret = 1;
10588 btrfs_free_fs_root(tree_reloc_root);
10589 return ret;
10590 }
10591
10592 /*
10593 * Check referencer for shared block backref
10594 * If level == -1, this function will resolve the level.
10595 */
10596 static int check_shared_block_backref(struct btrfs_fs_info *fs_info,
10597 u64 parent, u64 bytenr, int level)
10598 {
10599 struct extent_buffer *eb;
10600 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10601 u32 nr;
10602 int found_parent = 0;
10603 int i;
10604
10605 eb = read_tree_block(fs_info, parent, nodesize, 0);
10606 if (!extent_buffer_uptodate(eb))
10607 goto out;
10608
10609 if (level == -1)
10610 level = query_tree_block_level(fs_info, bytenr);
10611 if (level < 0)
10612 goto out;
10613
10614 /* It's possible it's a tree reloc root */
10615 if (parent == bytenr) {
10616 if (is_tree_reloc_root(fs_info, eb))
10617 found_parent = 1;
10618 goto out;
10619 }
10620
10621 if (level + 1 != btrfs_header_level(eb))
10622 goto out;
10623
10624 nr = btrfs_header_nritems(eb);
10625 for (i = 0; i < nr; i++) {
10626 if (bytenr == btrfs_node_blockptr(eb, i)) {
10627 found_parent = 1;
10628 break;
10629 }
10630 }
10631 out:
10632 free_extent_buffer(eb);
10633 if (!found_parent) {
10634 error(
10635 "shared extent[%llu %u] lost its parent (parent: %llu, level: %u)",
10636 bytenr, nodesize, parent, level);
10637 return REFERENCER_MISSING;
10638 }
10639 return 0;
10640 }
10641
10642 /*
10643 * Check referencer for normal (inlined) data ref
10644 * If len == 0, it will be resolved by searching in extent tree
10645 */
10646 static int check_extent_data_backref(struct btrfs_fs_info *fs_info,
10647 u64 root_id, u64 objectid, u64 offset,
10648 u64 bytenr, u64 len, u32 count)
10649 {
10650 struct btrfs_root *root;
10651 struct btrfs_root *extent_root = fs_info->extent_root;
10652 struct btrfs_key key;
10653 struct btrfs_path path;
10654 struct extent_buffer *leaf;
10655 struct btrfs_file_extent_item *fi;
10656 u32 found_count = 0;
10657 int slot;
10658 int ret = 0;
10659
10660 if (!len) {
10661 key.objectid = bytenr;
10662 key.type = BTRFS_EXTENT_ITEM_KEY;
10663 key.offset = (u64)-1;
10664
10665 btrfs_init_path(&path);
10666 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
10667 if (ret < 0)
10668 goto out;
10669 ret = btrfs_previous_extent_item(extent_root, &path, bytenr);
10670 if (ret)
10671 goto out;
10672 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
10673 if (key.objectid != bytenr ||
10674 key.type != BTRFS_EXTENT_ITEM_KEY)
10675 goto out;
10676 len = key.offset;
10677 btrfs_release_path(&path);
10678 }
10679 key.objectid = root_id;
10680 key.type = BTRFS_ROOT_ITEM_KEY;
10681 key.offset = (u64)-1;
10682 btrfs_init_path(&path);
10683
10684 root = btrfs_read_fs_root(fs_info, &key);
10685 if (IS_ERR(root))
10686 goto out;
10687
10688 key.objectid = objectid;
10689 key.type = BTRFS_EXTENT_DATA_KEY;
10690 /*
10691 * It can be nasty as data backref offset is
10692 * file offset - file extent offset, which is smaller or
10693 * equal to original backref offset. The only special case is
10694 * overflow. So we need to special check and do further search.
10695 */
10696 key.offset = offset & (1ULL << 63) ? 0 : offset;
10697
10698 ret = btrfs_search_slot(NULL, root, &key, &path, 0, 0);
10699 if (ret < 0)
10700 goto out;
10701
10702 /*
10703 * Search afterwards to get correct one
10704 * NOTE: As we must do a comprehensive check on the data backref to
10705 * make sure the dref count also matches, we must iterate all file
10706 * extents for that inode.
10707 */
10708 while (1) {
10709 leaf = path.nodes[0];
10710 slot = path.slots[0];
10711
10712 if (slot >= btrfs_header_nritems(leaf))
10713 goto next;
10714 btrfs_item_key_to_cpu(leaf, &key, slot);
10715 if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY)
10716 break;
10717 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
10718 /*
10719 * Except normal disk bytenr and disk num bytes, we still
10720 * need to do extra check on dbackref offset as
10721 * dbackref offset = file_offset - file_extent_offset
10722 */
10723 if (btrfs_file_extent_disk_bytenr(leaf, fi) == bytenr &&
10724 btrfs_file_extent_disk_num_bytes(leaf, fi) == len &&
10725 (u64)(key.offset - btrfs_file_extent_offset(leaf, fi)) ==
10726 offset)
10727 found_count++;
10728
10729 next:
10730 ret = btrfs_next_item(root, &path);
10731 if (ret)
10732 break;
10733 }
10734 out:
10735 btrfs_release_path(&path);
10736 if (found_count != count) {
10737 error(
10738 "extent[%llu, %llu] referencer count mismatch (root: %llu, owner: %llu, offset: %llu) wanted: %u, have: %u",
10739 bytenr, len, root_id, objectid, offset, count, found_count);
10740 return REFERENCER_MISSING;
10741 }
10742 return 0;
10743 }
10744
10745 /*
10746 * Check if the referencer of a shared data backref exists
10747 */
10748 static int check_shared_data_backref(struct btrfs_fs_info *fs_info,
10749 u64 parent, u64 bytenr)
10750 {
10751 struct extent_buffer *eb;
10752 struct btrfs_key key;
10753 struct btrfs_file_extent_item *fi;
10754 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10755 u32 nr;
10756 int found_parent = 0;
10757 int i;
10758
10759 eb = read_tree_block(fs_info, parent, nodesize, 0);
10760 if (!extent_buffer_uptodate(eb))
10761 goto out;
10762
10763 nr = btrfs_header_nritems(eb);
10764 for (i = 0; i < nr; i++) {
10765 btrfs_item_key_to_cpu(eb, &key, i);
10766 if (key.type != BTRFS_EXTENT_DATA_KEY)
10767 continue;
10768
10769 fi = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item);
10770 if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE)
10771 continue;
10772
10773 if (btrfs_file_extent_disk_bytenr(eb, fi) == bytenr) {
10774 found_parent = 1;
10775 break;
10776 }
10777 }
10778
10779 out:
10780 free_extent_buffer(eb);
10781 if (!found_parent) {
10782 error("shared extent %llu referencer lost (parent: %llu)",
10783 bytenr, parent);
10784 return REFERENCER_MISSING;
10785 }
10786 return 0;
10787 }
10788
10789 /*
10790 * This function will check a given extent item, including its backref and
10791 * itself (like crossing stripe boundary and type)
10792 *
10793 * Since we don't use extent_record anymore, introduce new error bit
10794 */
10795 static int check_extent_item(struct btrfs_fs_info *fs_info,
10796 struct extent_buffer *eb, int slot)
10797 {
10798 struct btrfs_extent_item *ei;
10799 struct btrfs_extent_inline_ref *iref;
10800 struct btrfs_extent_data_ref *dref;
10801 unsigned long end;
10802 unsigned long ptr;
10803 int type;
10804 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
10805 u32 item_size = btrfs_item_size_nr(eb, slot);
10806 u64 flags;
10807 u64 offset;
10808 int metadata = 0;
10809 int level;
10810 struct btrfs_key key;
10811 int ret;
10812 int err = 0;
10813
10814 btrfs_item_key_to_cpu(eb, &key, slot);
10815 if (key.type == BTRFS_EXTENT_ITEM_KEY)
10816 bytes_used += key.offset;
10817 else
10818 bytes_used += nodesize;
10819
10820 if (item_size < sizeof(*ei)) {
10821 /*
10822 * COMPAT_EXTENT_TREE_V0 case, but it's already a super
10823 * old thing when on disk format is still un-determined.
10824 * No need to care about it anymore
10825 */
10826 error("unsupported COMPAT_EXTENT_TREE_V0 detected");
10827 return -ENOTTY;
10828 }
10829
10830 ei = btrfs_item_ptr(eb, slot, struct btrfs_extent_item);
10831 flags = btrfs_extent_flags(eb, ei);
10832
10833 if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK)
10834 metadata = 1;
10835 if (metadata && check_crossing_stripes(global_info, key.objectid,
10836 eb->len)) {
10837 error("bad metadata [%llu, %llu) crossing stripe boundary",
10838 key.objectid, key.objectid + nodesize);
10839 err |= CROSSING_STRIPE_BOUNDARY;
10840 }
10841
10842 ptr = (unsigned long)(ei + 1);
10843
10844 if (metadata && key.type == BTRFS_EXTENT_ITEM_KEY) {
10845 /* Old EXTENT_ITEM metadata */
10846 struct btrfs_tree_block_info *info;
10847
10848 info = (struct btrfs_tree_block_info *)ptr;
10849 level = btrfs_tree_block_level(eb, info);
10850 ptr += sizeof(struct btrfs_tree_block_info);
10851 } else {
10852 /* New METADATA_ITEM */
10853 level = key.offset;
10854 }
10855 end = (unsigned long)ei + item_size;
10856
10857 next:
10858 /* Reached extent item end normally */
10859 if (ptr == end)
10860 goto out;
10861
10862 /* Beyond extent item end, wrong item size */
10863 if (ptr > end) {
10864 err |= ITEM_SIZE_MISMATCH;
10865 error("extent item at bytenr %llu slot %d has wrong size",
10866 eb->start, slot);
10867 goto out;
10868 }
10869
10870 /* Now check every backref in this extent item */
10871 iref = (struct btrfs_extent_inline_ref *)ptr;
10872 type = btrfs_extent_inline_ref_type(eb, iref);
10873 offset = btrfs_extent_inline_ref_offset(eb, iref);
10874 switch (type) {
10875 case BTRFS_TREE_BLOCK_REF_KEY:
10876 ret = check_tree_block_backref(fs_info, offset, key.objectid,
10877 level);
10878 err |= ret;
10879 break;
10880 case BTRFS_SHARED_BLOCK_REF_KEY:
10881 ret = check_shared_block_backref(fs_info, offset, key.objectid,
10882 level);
10883 err |= ret;
10884 break;
10885 case BTRFS_EXTENT_DATA_REF_KEY:
10886 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
10887 ret = check_extent_data_backref(fs_info,
10888 btrfs_extent_data_ref_root(eb, dref),
10889 btrfs_extent_data_ref_objectid(eb, dref),
10890 btrfs_extent_data_ref_offset(eb, dref),
10891 key.objectid, key.offset,
10892 btrfs_extent_data_ref_count(eb, dref));
10893 err |= ret;
10894 break;
10895 case BTRFS_SHARED_DATA_REF_KEY:
10896 ret = check_shared_data_backref(fs_info, offset, key.objectid);
10897 err |= ret;
10898 break;
10899 default:
10900 error("extent[%llu %d %llu] has unknown ref type: %d",
10901 key.objectid, key.type, key.offset, type);
10902 err |= UNKNOWN_TYPE;
10903 goto out;
10904 }
10905
10906 ptr += btrfs_extent_inline_ref_size(type);
10907 goto next;
10908
10909 out:
10910 return err;
10911 }
10912
10913 /*
10914 * Check if a dev extent item is referred correctly by its chunk
10915 */
10916 static int check_dev_extent_item(struct btrfs_fs_info *fs_info,
10917 struct extent_buffer *eb, int slot)
10918 {
10919 struct btrfs_root *chunk_root = fs_info->chunk_root;
10920 struct btrfs_dev_extent *ptr;
10921 struct btrfs_path path;
10922 struct btrfs_key chunk_key;
10923 struct btrfs_key devext_key;
10924 struct btrfs_chunk *chunk;
10925 struct extent_buffer *l;
10926 int num_stripes;
10927 u64 length;
10928 int i;
10929 int found_chunk = 0;
10930 int ret;
10931
10932 btrfs_item_key_to_cpu(eb, &devext_key, slot);
10933 ptr = btrfs_item_ptr(eb, slot, struct btrfs_dev_extent);
10934 length = btrfs_dev_extent_length(eb, ptr);
10935
10936 chunk_key.objectid = btrfs_dev_extent_chunk_objectid(eb, ptr);
10937 chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
10938 chunk_key.offset = btrfs_dev_extent_chunk_offset(eb, ptr);
10939
10940 btrfs_init_path(&path);
10941 ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
10942 if (ret)
10943 goto out;
10944
10945 l = path.nodes[0];
10946 chunk = btrfs_item_ptr(l, path.slots[0], struct btrfs_chunk);
10947 ret = btrfs_check_chunk_valid(fs_info, l, chunk, path.slots[0],
10948 chunk_key.offset);
10949 if (ret < 0)
10950 goto out;
10951
10952 if (btrfs_stripe_length(fs_info, l, chunk) != length)
10953 goto out;
10954
10955 num_stripes = btrfs_chunk_num_stripes(l, chunk);
10956 for (i = 0; i < num_stripes; i++) {
10957 u64 devid = btrfs_stripe_devid_nr(l, chunk, i);
10958 u64 offset = btrfs_stripe_offset_nr(l, chunk, i);
10959
10960 if (devid == devext_key.objectid &&
10961 offset == devext_key.offset) {
10962 found_chunk = 1;
10963 break;
10964 }
10965 }
10966 out:
10967 btrfs_release_path(&path);
10968 if (!found_chunk) {
10969 error(
10970 "device extent[%llu, %llu, %llu] did not find the related chunk",
10971 devext_key.objectid, devext_key.offset, length);
10972 return REFERENCER_MISSING;
10973 }
10974 return 0;
10975 }
10976
10977 /*
10978 * Check if the used space is correct with the dev item
10979 */
10980 static int check_dev_item(struct btrfs_fs_info *fs_info,
10981 struct extent_buffer *eb, int slot)
10982 {
10983 struct btrfs_root *dev_root = fs_info->dev_root;
10984 struct btrfs_dev_item *dev_item;
10985 struct btrfs_path path;
10986 struct btrfs_key key;
10987 struct btrfs_dev_extent *ptr;
10988 u64 dev_id;
10989 u64 used;
10990 u64 total = 0;
10991 int ret;
10992
10993 dev_item = btrfs_item_ptr(eb, slot, struct btrfs_dev_item);
10994 dev_id = btrfs_device_id(eb, dev_item);
10995 used = btrfs_device_bytes_used(eb, dev_item);
10996
10997 key.objectid = dev_id;
10998 key.type = BTRFS_DEV_EXTENT_KEY;
10999 key.offset = 0;
11000
11001 btrfs_init_path(&path);
11002 ret = btrfs_search_slot(NULL, dev_root, &key, &path, 0, 0);
11003 if (ret < 0) {
11004 btrfs_item_key_to_cpu(eb, &key, slot);
11005 error("cannot find any related dev extent for dev[%llu, %u, %llu]",
11006 key.objectid, key.type, key.offset);
11007 btrfs_release_path(&path);
11008 return REFERENCER_MISSING;
11009 }
11010
11011 /* Iterate dev_extents to calculate the used space of a device */
11012 while (1) {
11013 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0]))
11014 goto next;
11015
11016 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
11017 if (key.objectid > dev_id)
11018 break;
11019 if (key.type != BTRFS_DEV_EXTENT_KEY || key.objectid != dev_id)
11020 goto next;
11021
11022 ptr = btrfs_item_ptr(path.nodes[0], path.slots[0],
11023 struct btrfs_dev_extent);
11024 total += btrfs_dev_extent_length(path.nodes[0], ptr);
11025 next:
11026 ret = btrfs_next_item(dev_root, &path);
11027 if (ret)
11028 break;
11029 }
11030 btrfs_release_path(&path);
11031
11032 if (used != total) {
11033 btrfs_item_key_to_cpu(eb, &key, slot);
11034 error(
11035 "Dev extent's total-byte %llu is not equal to bytes-used %llu in dev[%llu, %u, %llu]",
11036 total, used, BTRFS_ROOT_TREE_OBJECTID,
11037 BTRFS_DEV_EXTENT_KEY, dev_id);
11038 return ACCOUNTING_MISMATCH;
11039 }
11040 return 0;
11041 }
11042
11043 /*
11044 * Check a block group item with its referener (chunk) and its used space
11045 * with extent/metadata item
11046 */
11047 static int check_block_group_item(struct btrfs_fs_info *fs_info,
11048 struct extent_buffer *eb, int slot)
11049 {
11050 struct btrfs_root *extent_root = fs_info->extent_root;
11051 struct btrfs_root *chunk_root = fs_info->chunk_root;
11052 struct btrfs_block_group_item *bi;
11053 struct btrfs_block_group_item bg_item;
11054 struct btrfs_path path;
11055 struct btrfs_key bg_key;
11056 struct btrfs_key chunk_key;
11057 struct btrfs_key extent_key;
11058 struct btrfs_chunk *chunk;
11059 struct extent_buffer *leaf;
11060 struct btrfs_extent_item *ei;
11061 u32 nodesize = btrfs_super_nodesize(fs_info->super_copy);
11062 u64 flags;
11063 u64 bg_flags;
11064 u64 used;
11065 u64 total = 0;
11066 int ret;
11067 int err = 0;
11068
11069 btrfs_item_key_to_cpu(eb, &bg_key, slot);
11070 bi = btrfs_item_ptr(eb, slot, struct btrfs_block_group_item);
11071 read_extent_buffer(eb, &bg_item, (unsigned long)bi, sizeof(bg_item));
11072 used = btrfs_block_group_used(&bg_item);
11073 bg_flags = btrfs_block_group_flags(&bg_item);
11074
11075 chunk_key.objectid = BTRFS_FIRST_CHUNK_TREE_OBJECTID;
11076 chunk_key.type = BTRFS_CHUNK_ITEM_KEY;
11077 chunk_key.offset = bg_key.objectid;
11078
11079 btrfs_init_path(&path);
11080 /* Search for the referencer chunk */
11081 ret = btrfs_search_slot(NULL, chunk_root, &chunk_key, &path, 0, 0);
11082 if (ret) {
11083 error(
11084 "block group[%llu %llu] did not find the related chunk item",
11085 bg_key.objectid, bg_key.offset);
11086 err |= REFERENCER_MISSING;
11087 } else {
11088 chunk = btrfs_item_ptr(path.nodes[0], path.slots[0],
11089 struct btrfs_chunk);
11090 if (btrfs_chunk_length(path.nodes[0], chunk) !=
11091 bg_key.offset) {
11092 error(
11093 "block group[%llu %llu] related chunk item length does not match",
11094 bg_key.objectid, bg_key.offset);
11095 err |= REFERENCER_MISMATCH;
11096 }
11097 }
11098 btrfs_release_path(&path);
11099
11100 /* Search from the block group bytenr */
11101 extent_key.objectid = bg_key.objectid;
11102 extent_key.type = 0;
11103 extent_key.offset = 0;
11104
11105 btrfs_init_path(&path);
11106 ret = btrfs_search_slot(NULL, extent_root, &extent_key, &path, 0, 0);
11107 if (ret < 0)
11108 goto out;
11109
11110 /* Iterate extent tree to account used space */
11111 while (1) {
11112 leaf = path.nodes[0];
11113
11114 /* Search slot can point to the last item beyond leaf nritems */
11115 if (path.slots[0] >= btrfs_header_nritems(leaf))
11116 goto next;
11117
11118 btrfs_item_key_to_cpu(leaf, &extent_key, path.slots[0]);
11119 if (extent_key.objectid >= bg_key.objectid + bg_key.offset)
11120 break;
11121
11122 if (extent_key.type != BTRFS_METADATA_ITEM_KEY &&
11123 extent_key.type != BTRFS_EXTENT_ITEM_KEY)
11124 goto next;
11125 if (extent_key.objectid < bg_key.objectid)
11126 goto next;
11127
11128 if (extent_key.type == BTRFS_METADATA_ITEM_KEY)
11129 total += nodesize;
11130 else
11131 total += extent_key.offset;
11132
11133 ei = btrfs_item_ptr(leaf, path.slots[0],
11134 struct btrfs_extent_item);
11135 flags = btrfs_extent_flags(leaf, ei);
11136 if (flags & BTRFS_EXTENT_FLAG_DATA) {
11137 if (!(bg_flags & BTRFS_BLOCK_GROUP_DATA)) {
11138 error(
11139 "bad extent[%llu, %llu) type mismatch with chunk",
11140 extent_key.objectid,
11141 extent_key.objectid + extent_key.offset);
11142 err |= CHUNK_TYPE_MISMATCH;
11143 }
11144 } else if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
11145 if (!(bg_flags & (BTRFS_BLOCK_GROUP_SYSTEM |
11146 BTRFS_BLOCK_GROUP_METADATA))) {
11147 error(
11148 "bad extent[%llu, %llu) type mismatch with chunk",
11149 extent_key.objectid,
11150 extent_key.objectid + nodesize);
11151 err |= CHUNK_TYPE_MISMATCH;
11152 }
11153 }
11154 next:
11155 ret = btrfs_next_item(extent_root, &path);
11156 if (ret)
11157 break;
11158 }
11159
11160 out:
11161 btrfs_release_path(&path);
11162
11163 if (total != used) {
11164 error(
11165 "block group[%llu %llu] used %llu but extent items used %llu",
11166 bg_key.objectid, bg_key.offset, used, total);
11167 err |= ACCOUNTING_MISMATCH;
11168 }
11169 return err;
11170 }
11171
11172 /*
11173 * Check a chunk item.
11174 * Including checking all referred dev_extents and block group
11175 */
11176 static int check_chunk_item(struct btrfs_fs_info *fs_info,
11177 struct extent_buffer *eb, int slot)
11178 {
11179 struct btrfs_root *extent_root = fs_info->extent_root;
11180 struct btrfs_root *dev_root = fs_info->dev_root;
11181 struct btrfs_path path;
11182 struct btrfs_key chunk_key;
11183 struct btrfs_key bg_key;
11184 struct btrfs_key devext_key;
11185 struct btrfs_chunk *chunk;
11186 struct extent_buffer *leaf;
11187 struct btrfs_block_group_item *bi;
11188 struct btrfs_block_group_item bg_item;
11189 struct btrfs_dev_extent *ptr;
11190 u64 length;
11191 u64 chunk_end;
11192 u64 stripe_len;
11193 u64 type;
11194 int num_stripes;
11195 u64 offset;
11196 u64 objectid;
11197 int i;
11198 int ret;
11199 int err = 0;
11200
11201 btrfs_item_key_to_cpu(eb, &chunk_key, slot);
11202 chunk = btrfs_item_ptr(eb, slot, struct btrfs_chunk);
11203 length = btrfs_chunk_length(eb, chunk);
11204 chunk_end = chunk_key.offset + length;
11205 ret = btrfs_check_chunk_valid(fs_info, eb, chunk, slot,
11206 chunk_key.offset);
11207 if (ret < 0) {
11208 error("chunk[%llu %llu) is invalid", chunk_key.offset,
11209 chunk_end);
11210 err |= BYTES_UNALIGNED | UNKNOWN_TYPE;
11211 goto out;
11212 }
11213 type = btrfs_chunk_type(eb, chunk);
11214
11215 bg_key.objectid = chunk_key.offset;
11216 bg_key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
11217 bg_key.offset = length;
11218
11219 btrfs_init_path(&path);
11220 ret = btrfs_search_slot(NULL, extent_root, &bg_key, &path, 0, 0);
11221 if (ret) {
11222 error(
11223 "chunk[%llu %llu) did not find the related block group item",
11224 chunk_key.offset, chunk_end);
11225 err |= REFERENCER_MISSING;
11226 } else{
11227 leaf = path.nodes[0];
11228 bi = btrfs_item_ptr(leaf, path.slots[0],
11229 struct btrfs_block_group_item);
11230 read_extent_buffer(leaf, &bg_item, (unsigned long)bi,
11231 sizeof(bg_item));
11232 if (btrfs_block_group_flags(&bg_item) != type) {
11233 error(
11234 "chunk[%llu %llu) related block group item flags mismatch, wanted: %llu, have: %llu",
11235 chunk_key.offset, chunk_end, type,
11236 btrfs_block_group_flags(&bg_item));
11237 err |= REFERENCER_MISSING;
11238 }
11239 }
11240
11241 num_stripes = btrfs_chunk_num_stripes(eb, chunk);
11242 stripe_len = btrfs_stripe_length(fs_info, eb, chunk);
11243 for (i = 0; i < num_stripes; i++) {
11244 btrfs_release_path(&path);
11245 btrfs_init_path(&path);
11246 devext_key.objectid = btrfs_stripe_devid_nr(eb, chunk, i);
11247 devext_key.type = BTRFS_DEV_EXTENT_KEY;
11248 devext_key.offset = btrfs_stripe_offset_nr(eb, chunk, i);
11249
11250 ret = btrfs_search_slot(NULL, dev_root, &devext_key, &path,
11251 0, 0);
11252 if (ret)
11253 goto not_match_dev;
11254
11255 leaf = path.nodes[0];
11256 ptr = btrfs_item_ptr(leaf, path.slots[0],
11257 struct btrfs_dev_extent);
11258 objectid = btrfs_dev_extent_chunk_objectid(leaf, ptr);
11259 offset = btrfs_dev_extent_chunk_offset(leaf, ptr);
11260 if (objectid != chunk_key.objectid ||
11261 offset != chunk_key.offset ||
11262 btrfs_dev_extent_length(leaf, ptr) != stripe_len)
11263 goto not_match_dev;
11264 continue;
11265 not_match_dev:
11266 err |= BACKREF_MISSING;
11267 error(
11268 "chunk[%llu %llu) stripe %d did not find the related dev extent",
11269 chunk_key.objectid, chunk_end, i);
11270 continue;
11271 }
11272 btrfs_release_path(&path);
11273 out:
11274 return err;
11275 }
11276
11277 /*
11278 * Main entry function to check known items and update related accounting info
11279 */
11280 static int check_leaf_items(struct btrfs_root *root, struct extent_buffer *eb)
11281 {
11282 struct btrfs_fs_info *fs_info = root->fs_info;
11283 struct btrfs_key key;
11284 int slot = 0;
11285 int type;
11286 struct btrfs_extent_data_ref *dref;
11287 int ret;
11288 int err = 0;
11289
11290 next:
11291 btrfs_item_key_to_cpu(eb, &key, slot);
11292 type = key.type;
11293
11294 switch (type) {
11295 case BTRFS_EXTENT_DATA_KEY:
11296 ret = check_extent_data_item(root, eb, slot);
11297 err |= ret;
11298 break;
11299 case BTRFS_BLOCK_GROUP_ITEM_KEY:
11300 ret = check_block_group_item(fs_info, eb, slot);
11301 err |= ret;
11302 break;
11303 case BTRFS_DEV_ITEM_KEY:
11304 ret = check_dev_item(fs_info, eb, slot);
11305 err |= ret;
11306 break;
11307 case BTRFS_CHUNK_ITEM_KEY:
11308 ret = check_chunk_item(fs_info, eb, slot);
11309 err |= ret;
11310 break;
11311 case BTRFS_DEV_EXTENT_KEY:
11312 ret = check_dev_extent_item(fs_info, eb, slot);
11313 err |= ret;
11314 break;
11315 case BTRFS_EXTENT_ITEM_KEY:
11316 case BTRFS_METADATA_ITEM_KEY:
11317 ret = check_extent_item(fs_info, eb, slot);
11318 err |= ret;
11319 break;
11320 case BTRFS_EXTENT_CSUM_KEY:
11321 total_csum_bytes += btrfs_item_size_nr(eb, slot);
11322 break;
11323 case BTRFS_TREE_BLOCK_REF_KEY:
11324 ret = check_tree_block_backref(fs_info, key.offset,
11325 key.objectid, -1);
11326 err |= ret;
11327 break;
11328 case BTRFS_EXTENT_DATA_REF_KEY:
11329 dref = btrfs_item_ptr(eb, slot, struct btrfs_extent_data_ref);
11330 ret = check_extent_data_backref(fs_info,
11331 btrfs_extent_data_ref_root(eb, dref),
11332 btrfs_extent_data_ref_objectid(eb, dref),
11333 btrfs_extent_data_ref_offset(eb, dref),
11334 key.objectid, 0,
11335 btrfs_extent_data_ref_count(eb, dref));
11336 err |= ret;
11337 break;
11338 case BTRFS_SHARED_BLOCK_REF_KEY:
11339 ret = check_shared_block_backref(fs_info, key.offset,
11340 key.objectid, -1);
11341 err |= ret;
11342 break;
11343 case BTRFS_SHARED_DATA_REF_KEY:
11344 ret = check_shared_data_backref(fs_info, key.offset,
11345 key.objectid);
11346 err |= ret;
11347 break;
11348 default:
11349 break;
11350 }
11351
11352 if (++slot < btrfs_header_nritems(eb))
11353 goto next;
11354
11355 return err;
11356 }
11357
11358 /*
11359 * Helper function for later fs/subvol tree check. To determine if a tree
11360 * block should be checked.
11361 * This function will ensure only the direct referencer with lowest rootid to
11362 * check a fs/subvolume tree block.
11363 *
11364 * Backref check at extent tree would detect errors like missing subvolume
11365 * tree, so we can do aggressive check to reduce duplicated checks.
11366 */
11367 static int should_check(struct btrfs_root *root, struct extent_buffer *eb)
11368 {
11369 struct btrfs_root *extent_root = root->fs_info->extent_root;
11370 struct btrfs_key key;
11371 struct btrfs_path path;
11372 struct extent_buffer *leaf;
11373 int slot;
11374 struct btrfs_extent_item *ei;
11375 unsigned long ptr;
11376 unsigned long end;
11377 int type;
11378 u32 item_size;
11379 u64 offset;
11380 struct btrfs_extent_inline_ref *iref;
11381 int ret;
11382
11383 btrfs_init_path(&path);
11384 key.objectid = btrfs_header_bytenr(eb);
11385 key.type = BTRFS_METADATA_ITEM_KEY;
11386 key.offset = (u64)-1;
11387
11388 /*
11389 * Any failure in backref resolving means we can't determine
11390 * whom the tree block belongs to.
11391 * So in that case, we need to check that tree block
11392 */
11393 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
11394 if (ret < 0)
11395 goto need_check;
11396
11397 ret = btrfs_previous_extent_item(extent_root, &path,
11398 btrfs_header_bytenr(eb));
11399 if (ret)
11400 goto need_check;
11401
11402 leaf = path.nodes[0];
11403 slot = path.slots[0];
11404 btrfs_item_key_to_cpu(leaf, &key, slot);
11405 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
11406
11407 if (key.type == BTRFS_METADATA_ITEM_KEY) {
11408 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
11409 } else {
11410 struct btrfs_tree_block_info *info;
11411
11412 info = (struct btrfs_tree_block_info *)(ei + 1);
11413 iref = (struct btrfs_extent_inline_ref *)(info + 1);
11414 }
11415
11416 item_size = btrfs_item_size_nr(leaf, slot);
11417 ptr = (unsigned long)iref;
11418 end = (unsigned long)ei + item_size;
11419 while (ptr < end) {
11420 iref = (struct btrfs_extent_inline_ref *)ptr;
11421 type = btrfs_extent_inline_ref_type(leaf, iref);
11422 offset = btrfs_extent_inline_ref_offset(leaf, iref);
11423
11424 /*
11425 * We only check the tree block if current root is
11426 * the lowest referencer of it.
11427 */
11428 if (type == BTRFS_TREE_BLOCK_REF_KEY &&
11429 offset < root->objectid) {
11430 btrfs_release_path(&path);
11431 return 0;
11432 }
11433
11434 ptr += btrfs_extent_inline_ref_size(type);
11435 }
11436 /*
11437 * Normally we should also check keyed tree block ref, but that may be
11438 * very time consuming. Inlined ref should already make us skip a lot
11439 * of refs now. So skip search keyed tree block ref.
11440 */
11441
11442 need_check:
11443 btrfs_release_path(&path);
11444 return 1;
11445 }
11446
11447 /*
11448 * Traversal function for tree block. We will do:
11449 * 1) Skip shared fs/subvolume tree blocks
11450 * 2) Update related bytes accounting
11451 * 3) Pre-order traversal
11452 */
11453 static int traverse_tree_block(struct btrfs_root *root,
11454 struct extent_buffer *node)
11455 {
11456 struct extent_buffer *eb;
11457 struct btrfs_key key;
11458 struct btrfs_key drop_key;
11459 int level;
11460 u64 nr;
11461 int i;
11462 int err = 0;
11463 int ret;
11464
11465 /*
11466 * Skip shared fs/subvolume tree block, in that case they will
11467 * be checked by referencer with lowest rootid
11468 */
11469 if (is_fstree(root->objectid) && !should_check(root, node))
11470 return 0;
11471
11472 /* Update bytes accounting */
11473 total_btree_bytes += node->len;
11474 if (fs_root_objectid(btrfs_header_owner(node)))
11475 total_fs_tree_bytes += node->len;
11476 if (btrfs_header_owner(node) == BTRFS_EXTENT_TREE_OBJECTID)
11477 total_extent_tree_bytes += node->len;
11478 if (!found_old_backref &&
11479 btrfs_header_owner(node) == BTRFS_TREE_RELOC_OBJECTID &&
11480 btrfs_header_backref_rev(node) == BTRFS_MIXED_BACKREF_REV &&
11481 !btrfs_header_flag(node, BTRFS_HEADER_FLAG_RELOC))
11482 found_old_backref = 1;
11483
11484 /* pre-order tranversal, check itself first */
11485 level = btrfs_header_level(node);
11486 ret = check_tree_block_ref(root, node, btrfs_header_bytenr(node),
11487 btrfs_header_level(node),
11488 btrfs_header_owner(node));
11489 err |= ret;
11490 if (err)
11491 error(
11492 "check %s failed root %llu bytenr %llu level %d, force continue check",
11493 level ? "node":"leaf", root->objectid,
11494 btrfs_header_bytenr(node), btrfs_header_level(node));
11495
11496 if (!level) {
11497 btree_space_waste += btrfs_leaf_free_space(root, node);
11498 ret = check_leaf_items(root, node);
11499 err |= ret;
11500 return err;
11501 }
11502
11503 nr = btrfs_header_nritems(node);
11504 btrfs_disk_key_to_cpu(&drop_key, &root->root_item.drop_progress);
11505 btree_space_waste += (BTRFS_NODEPTRS_PER_BLOCK(root) - nr) *
11506 sizeof(struct btrfs_key_ptr);
11507
11508 /* Then check all its children */
11509 for (i = 0; i < nr; i++) {
11510 u64 blocknr = btrfs_node_blockptr(node, i);
11511
11512 btrfs_node_key_to_cpu(node, &key, i);
11513 if (level == root->root_item.drop_level &&
11514 is_dropped_key(&key, &drop_key))
11515 continue;
11516
11517 /*
11518 * As a btrfs tree has most 8 levels (0..7), so it's quite safe
11519 * to call the function itself.
11520 */
11521 eb = read_tree_block(root->fs_info, blocknr,
11522 root->fs_info->nodesize, 0);
11523 if (extent_buffer_uptodate(eb)) {
11524 ret = traverse_tree_block(root, eb);
11525 err |= ret;
11526 }
11527 free_extent_buffer(eb);
11528 }
11529
11530 return err;
11531 }
11532
11533 /*
11534 * Low memory usage version check_chunks_and_extents.
11535 */
11536 static int check_chunks_and_extents_v2(struct btrfs_root *root)
11537 {
11538 struct btrfs_path path;
11539 struct btrfs_key key;
11540 struct btrfs_root *root1;
11541 struct btrfs_root *cur_root;
11542 int err = 0;
11543 int ret;
11544
11545 root1 = root->fs_info->chunk_root;
11546 ret = traverse_tree_block(root1, root1->node);
11547 err |= ret;
11548
11549 root1 = root->fs_info->tree_root;
11550 ret = traverse_tree_block(root1, root1->node);
11551 err |= ret;
11552
11553 btrfs_init_path(&path);
11554 key.objectid = BTRFS_EXTENT_TREE_OBJECTID;
11555 key.offset = 0;
11556 key.type = BTRFS_ROOT_ITEM_KEY;
11557
11558 ret = btrfs_search_slot(NULL, root1, &key, &path, 0, 0);
11559 if (ret) {
11560 error("cannot find extent treet in tree_root");
11561 goto out;
11562 }
11563
11564 while (1) {
11565 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
11566 if (key.type != BTRFS_ROOT_ITEM_KEY)
11567 goto next;
11568 key.offset = (u64)-1;
11569
11570 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
11571 cur_root = btrfs_read_fs_root_no_cache(root->fs_info,
11572 &key);
11573 else
11574 cur_root = btrfs_read_fs_root(root->fs_info, &key);
11575 if (IS_ERR(cur_root) || !cur_root) {
11576 error("failed to read tree: %lld", key.objectid);
11577 goto next;
11578 }
11579
11580 ret = traverse_tree_block(cur_root, cur_root->node);
11581 err |= ret;
11582
11583 if (key.objectid == BTRFS_TREE_RELOC_OBJECTID)
11584 btrfs_free_fs_root(cur_root);
11585 next:
11586 ret = btrfs_next_item(root1, &path);
11587 if (ret)
11588 goto out;
11589 }
11590
11591 out:
11592 btrfs_release_path(&path);
11593 return err;
11594 }
11595
11596 static int btrfs_fsck_reinit_root(struct btrfs_trans_handle *trans,
11597 struct btrfs_root *root, int overwrite)
11598 {
11599 struct extent_buffer *c;
11600 struct extent_buffer *old = root->node;
11601 int level;
11602 int ret;
11603 struct btrfs_disk_key disk_key = {0,0,0};
11604
11605 level = 0;
11606
11607 if (overwrite) {
11608 c = old;
11609 extent_buffer_get(c);
11610 goto init;
11611 }
11612 c = btrfs_alloc_free_block(trans, root,
11613 root->fs_info->nodesize,
11614 root->root_key.objectid,
11615 &disk_key, level, 0, 0);
11616 if (IS_ERR(c)) {
11617 c = old;
11618 extent_buffer_get(c);
11619 overwrite = 1;
11620 }
11621 init:
11622 memset_extent_buffer(c, 0, 0, sizeof(struct btrfs_header));
11623 btrfs_set_header_level(c, level);
11624 btrfs_set_header_bytenr(c, c->start);
11625 btrfs_set_header_generation(c, trans->transid);
11626 btrfs_set_header_backref_rev(c, BTRFS_MIXED_BACKREF_REV);
11627 btrfs_set_header_owner(c, root->root_key.objectid);
11628
11629 write_extent_buffer(c, root->fs_info->fsid,
11630 btrfs_header_fsid(), BTRFS_FSID_SIZE);
11631
11632 write_extent_buffer(c, root->fs_info->chunk_tree_uuid,
11633 btrfs_header_chunk_tree_uuid(c),
11634 BTRFS_UUID_SIZE);
11635
11636 btrfs_mark_buffer_dirty(c);
11637 /*
11638 * this case can happen in the following case:
11639 *
11640 * 1.overwrite previous root.
11641 *
11642 * 2.reinit reloc data root, this is because we skip pin
11643 * down reloc data tree before which means we can allocate
11644 * same block bytenr here.
11645 */
11646 if (old->start == c->start) {
11647 btrfs_set_root_generation(&root->root_item,
11648 trans->transid);
11649 root->root_item.level = btrfs_header_level(root->node);
11650 ret = btrfs_update_root(trans, root->fs_info->tree_root,
11651 &root->root_key, &root->root_item);
11652 if (ret) {
11653 free_extent_buffer(c);
11654 return ret;
11655 }
11656 }
11657 free_extent_buffer(old);
11658 root->node = c;
11659 add_root_to_dirty_list(root);
11660 return 0;
11661 }
11662
11663 static int pin_down_tree_blocks(struct btrfs_fs_info *fs_info,
11664 struct extent_buffer *eb, int tree_root)
11665 {
11666 struct extent_buffer *tmp;
11667 struct btrfs_root_item *ri;
11668 struct btrfs_key key;
11669 u64 bytenr;
11670 u32 nodesize;
11671 int level = btrfs_header_level(eb);
11672 int nritems;
11673 int ret;
11674 int i;
11675
11676 /*
11677 * If we have pinned this block before, don't pin it again.
11678 * This can not only avoid forever loop with broken filesystem
11679 * but also give us some speedups.
11680 */
11681 if (test_range_bit(&fs_info->pinned_extents, eb->start,
11682 eb->start + eb->len - 1, EXTENT_DIRTY, 0))
11683 return 0;
11684
11685 btrfs_pin_extent(fs_info, eb->start, eb->len);
11686
11687 nodesize = btrfs_super_nodesize(fs_info->super_copy);
11688 nritems = btrfs_header_nritems(eb);
11689 for (i = 0; i < nritems; i++) {
11690 if (level == 0) {
11691 btrfs_item_key_to_cpu(eb, &key, i);
11692 if (key.type != BTRFS_ROOT_ITEM_KEY)
11693 continue;
11694 /* Skip the extent root and reloc roots */
11695 if (key.objectid == BTRFS_EXTENT_TREE_OBJECTID ||
11696 key.objectid == BTRFS_TREE_RELOC_OBJECTID ||
11697 key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
11698 continue;
11699 ri = btrfs_item_ptr(eb, i, struct btrfs_root_item);
11700 bytenr = btrfs_disk_root_bytenr(eb, ri);
11701
11702 /*
11703 * If at any point we start needing the real root we
11704 * will have to build a stump root for the root we are
11705 * in, but for now this doesn't actually use the root so
11706 * just pass in extent_root.
11707 */
11708 tmp = read_tree_block(fs_info, bytenr, nodesize, 0);
11709 if (!extent_buffer_uptodate(tmp)) {
11710 fprintf(stderr, "Error reading root block\n");
11711 return -EIO;
11712 }
11713 ret = pin_down_tree_blocks(fs_info, tmp, 0);
11714 free_extent_buffer(tmp);
11715 if (ret)
11716 return ret;
11717 } else {
11718 bytenr = btrfs_node_blockptr(eb, i);
11719
11720 /* If we aren't the tree root don't read the block */
11721 if (level == 1 && !tree_root) {
11722 btrfs_pin_extent(fs_info, bytenr, nodesize);
11723 continue;
11724 }
11725
11726 tmp = read_tree_block(fs_info, bytenr,
11727 nodesize, 0);
11728 if (!extent_buffer_uptodate(tmp)) {
11729 fprintf(stderr, "Error reading tree block\n");
11730 return -EIO;
11731 }
11732 ret = pin_down_tree_blocks(fs_info, tmp, tree_root);
11733 free_extent_buffer(tmp);
11734 if (ret)
11735 return ret;
11736 }
11737 }
11738
11739 return 0;
11740 }
11741
11742 static int pin_metadata_blocks(struct btrfs_fs_info *fs_info)
11743 {
11744 int ret;
11745
11746 ret = pin_down_tree_blocks(fs_info, fs_info->chunk_root->node, 0);
11747 if (ret)
11748 return ret;
11749
11750 return pin_down_tree_blocks(fs_info, fs_info->tree_root->node, 1);
11751 }
11752
11753 static int reset_block_groups(struct btrfs_fs_info *fs_info)
11754 {
11755 struct btrfs_block_group_cache *cache;
11756 struct btrfs_path path;
11757 struct extent_buffer *leaf;
11758 struct btrfs_chunk *chunk;
11759 struct btrfs_key key;
11760 int ret;
11761 u64 start;
11762
11763 btrfs_init_path(&path);
11764 key.objectid = 0;
11765 key.type = BTRFS_CHUNK_ITEM_KEY;
11766 key.offset = 0;
11767 ret = btrfs_search_slot(NULL, fs_info->chunk_root, &key, &path, 0, 0);
11768 if (ret < 0) {
11769 btrfs_release_path(&path);
11770 return ret;
11771 }
11772
11773 /*
11774 * We do this in case the block groups were screwed up and had alloc
11775 * bits that aren't actually set on the chunks. This happens with
11776 * restored images every time and could happen in real life I guess.
11777 */
11778 fs_info->avail_data_alloc_bits = 0;
11779 fs_info->avail_metadata_alloc_bits = 0;
11780 fs_info->avail_system_alloc_bits = 0;
11781
11782 /* First we need to create the in-memory block groups */
11783 while (1) {
11784 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
11785 ret = btrfs_next_leaf(fs_info->chunk_root, &path);
11786 if (ret < 0) {
11787 btrfs_release_path(&path);
11788 return ret;
11789 }
11790 if (ret) {
11791 ret = 0;
11792 break;
11793 }
11794 }
11795 leaf = path.nodes[0];
11796 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
11797 if (key.type != BTRFS_CHUNK_ITEM_KEY) {
11798 path.slots[0]++;
11799 continue;
11800 }
11801
11802 chunk = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_chunk);
11803 btrfs_add_block_group(fs_info, 0,
11804 btrfs_chunk_type(leaf, chunk),
11805 key.objectid, key.offset,
11806 btrfs_chunk_length(leaf, chunk));
11807 set_extent_dirty(&fs_info->free_space_cache, key.offset,
11808 key.offset + btrfs_chunk_length(leaf, chunk));
11809 path.slots[0]++;
11810 }
11811 start = 0;
11812 while (1) {
11813 cache = btrfs_lookup_first_block_group(fs_info, start);
11814 if (!cache)
11815 break;
11816 cache->cached = 1;
11817 start = cache->key.objectid + cache->key.offset;
11818 }
11819
11820 btrfs_release_path(&path);
11821 return 0;
11822 }
11823
11824 static int reset_balance(struct btrfs_trans_handle *trans,
11825 struct btrfs_fs_info *fs_info)
11826 {
11827 struct btrfs_root *root = fs_info->tree_root;
11828 struct btrfs_path path;
11829 struct extent_buffer *leaf;
11830 struct btrfs_key key;
11831 int del_slot, del_nr = 0;
11832 int ret;
11833 int found = 0;
11834
11835 btrfs_init_path(&path);
11836 key.objectid = BTRFS_BALANCE_OBJECTID;
11837 key.type = BTRFS_BALANCE_ITEM_KEY;
11838 key.offset = 0;
11839 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
11840 if (ret) {
11841 if (ret > 0)
11842 ret = 0;
11843 if (!ret)
11844 goto reinit_data_reloc;
11845 else
11846 goto out;
11847 }
11848
11849 ret = btrfs_del_item(trans, root, &path);
11850 if (ret)
11851 goto out;
11852 btrfs_release_path(&path);
11853
11854 key.objectid = BTRFS_TREE_RELOC_OBJECTID;
11855 key.type = BTRFS_ROOT_ITEM_KEY;
11856 key.offset = 0;
11857 ret = btrfs_search_slot(trans, root, &key, &path, -1, 1);
11858 if (ret < 0)
11859 goto out;
11860 while (1) {
11861 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
11862 if (!found)
11863 break;
11864
11865 if (del_nr) {
11866 ret = btrfs_del_items(trans, root, &path,
11867 del_slot, del_nr);
11868 del_nr = 0;
11869 if (ret)
11870 goto out;
11871 }
11872 key.offset++;
11873 btrfs_release_path(&path);
11874
11875 found = 0;
11876 ret = btrfs_search_slot(trans, root, &key, &path,
11877 -1, 1);
11878 if (ret < 0)
11879 goto out;
11880 continue;
11881 }
11882 found = 1;
11883 leaf = path.nodes[0];
11884 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
11885 if (key.objectid > BTRFS_TREE_RELOC_OBJECTID)
11886 break;
11887 if (key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
11888 path.slots[0]++;
11889 continue;
11890 }
11891 if (!del_nr) {
11892 del_slot = path.slots[0];
11893 del_nr = 1;
11894 } else {
11895 del_nr++;
11896 }
11897 path.slots[0]++;
11898 }
11899
11900 if (del_nr) {
11901 ret = btrfs_del_items(trans, root, &path, del_slot, del_nr);
11902 if (ret)
11903 goto out;
11904 }
11905 btrfs_release_path(&path);
11906
11907 reinit_data_reloc:
11908 key.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
11909 key.type = BTRFS_ROOT_ITEM_KEY;
11910 key.offset = (u64)-1;
11911 root = btrfs_read_fs_root(fs_info, &key);
11912 if (IS_ERR(root)) {
11913 fprintf(stderr, "Error reading data reloc tree\n");
11914 ret = PTR_ERR(root);
11915 goto out;
11916 }
11917 record_root_in_trans(trans, root);
11918 ret = btrfs_fsck_reinit_root(trans, root, 0);
11919 if (ret)
11920 goto out;
11921 ret = btrfs_make_root_dir(trans, root, BTRFS_FIRST_FREE_OBJECTID);
11922 out:
11923 btrfs_release_path(&path);
11924 return ret;
11925 }
11926
11927 static int reinit_extent_tree(struct btrfs_trans_handle *trans,
11928 struct btrfs_fs_info *fs_info)
11929 {
11930 u64 start = 0;
11931 int ret;
11932
11933 /*
11934 * The only reason we don't do this is because right now we're just
11935 * walking the trees we find and pinning down their bytes, we don't look
11936 * at any of the leaves. In order to do mixed groups we'd have to check
11937 * the leaves of any fs roots and pin down the bytes for any file
11938 * extents we find. Not hard but why do it if we don't have to?
11939 */
11940 if (btrfs_fs_incompat(fs_info, MIXED_GROUPS)) {
11941 fprintf(stderr, "We don't support re-initing the extent tree "
11942 "for mixed block groups yet, please notify a btrfs "
11943 "developer you want to do this so they can add this "
11944 "functionality.\n");
11945 return -EINVAL;
11946 }
11947
11948 /*
11949 * first we need to walk all of the trees except the extent tree and pin
11950 * down the bytes that are in use so we don't overwrite any existing
11951 * metadata.
11952 */
11953 ret = pin_metadata_blocks(fs_info);
11954 if (ret) {
11955 fprintf(stderr, "error pinning down used bytes\n");
11956 return ret;
11957 }
11958
11959 /*
11960 * Need to drop all the block groups since we're going to recreate all
11961 * of them again.
11962 */
11963 btrfs_free_block_groups(fs_info);
11964 ret = reset_block_groups(fs_info);
11965 if (ret) {
11966 fprintf(stderr, "error resetting the block groups\n");
11967 return ret;
11968 }
11969
11970 /* Ok we can allocate now, reinit the extent root */
11971 ret = btrfs_fsck_reinit_root(trans, fs_info->extent_root, 0);
11972 if (ret) {
11973 fprintf(stderr, "extent root initialization failed\n");
11974 /*
11975 * When the transaction code is updated we should end the
11976 * transaction, but for now progs only knows about commit so
11977 * just return an error.
11978 */
11979 return ret;
11980 }
11981
11982 /*
11983 * Now we have all the in-memory block groups setup so we can make
11984 * allocations properly, and the metadata we care about is safe since we
11985 * pinned all of it above.
11986 */
11987 while (1) {
11988 struct btrfs_block_group_cache *cache;
11989
11990 cache = btrfs_lookup_first_block_group(fs_info, start);
11991 if (!cache)
11992 break;
11993 start = cache->key.objectid + cache->key.offset;
11994 ret = btrfs_insert_item(trans, fs_info->extent_root,
11995 &cache->key, &cache->item,
11996 sizeof(cache->item));
11997 if (ret) {
11998 fprintf(stderr, "Error adding block group\n");
11999 return ret;
12000 }
12001 btrfs_extent_post_op(trans, fs_info->extent_root);
12002 }
12003
12004 ret = reset_balance(trans, fs_info);
12005 if (ret)
12006 fprintf(stderr, "error resetting the pending balance\n");
12007
12008 return ret;
12009 }
12010
12011 static int recow_extent_buffer(struct btrfs_root *root, struct extent_buffer *eb)
12012 {
12013 struct btrfs_path path;
12014 struct btrfs_trans_handle *trans;
12015 struct btrfs_key key;
12016 int ret;
12017
12018 printf("Recowing metadata block %llu\n", eb->start);
12019 key.objectid = btrfs_header_owner(eb);
12020 key.type = BTRFS_ROOT_ITEM_KEY;
12021 key.offset = (u64)-1;
12022
12023 root = btrfs_read_fs_root(root->fs_info, &key);
12024 if (IS_ERR(root)) {
12025 fprintf(stderr, "Couldn't find owner root %llu\n",
12026 key.objectid);
12027 return PTR_ERR(root);
12028 }
12029
12030 trans = btrfs_start_transaction(root, 1);
12031 if (IS_ERR(trans))
12032 return PTR_ERR(trans);
12033
12034 btrfs_init_path(&path);
12035 path.lowest_level = btrfs_header_level(eb);
12036 if (path.lowest_level)
12037 btrfs_node_key_to_cpu(eb, &key, 0);
12038 else
12039 btrfs_item_key_to_cpu(eb, &key, 0);
12040
12041 ret = btrfs_search_slot(trans, root, &key, &path, 0, 1);
12042 btrfs_commit_transaction(trans, root);
12043 btrfs_release_path(&path);
12044 return ret;
12045 }
12046
12047 static int delete_bad_item(struct btrfs_root *root, struct bad_item *bad)
12048 {
12049 struct btrfs_path path;
12050 struct btrfs_trans_handle *trans;
12051 struct btrfs_key key;
12052 int ret;
12053
12054 printf("Deleting bad item [%llu,%u,%llu]\n", bad->key.objectid,
12055 bad->key.type, bad->key.offset);
12056 key.objectid = bad->root_id;
12057 key.type = BTRFS_ROOT_ITEM_KEY;
12058 key.offset = (u64)-1;
12059
12060 root = btrfs_read_fs_root(root->fs_info, &key);
12061 if (IS_ERR(root)) {
12062 fprintf(stderr, "Couldn't find owner root %llu\n",
12063 key.objectid);
12064 return PTR_ERR(root);
12065 }
12066
12067 trans = btrfs_start_transaction(root, 1);
12068 if (IS_ERR(trans))
12069 return PTR_ERR(trans);
12070
12071 btrfs_init_path(&path);
12072 ret = btrfs_search_slot(trans, root, &bad->key, &path, -1, 1);
12073 if (ret) {
12074 if (ret > 0)
12075 ret = 0;
12076 goto out;
12077 }
12078 ret = btrfs_del_item(trans, root, &path);
12079 out:
12080 btrfs_commit_transaction(trans, root);
12081 btrfs_release_path(&path);
12082 return ret;
12083 }
12084
12085 static int zero_log_tree(struct btrfs_root *root)
12086 {
12087 struct btrfs_trans_handle *trans;
12088 int ret;
12089
12090 trans = btrfs_start_transaction(root, 1);
12091 if (IS_ERR(trans)) {
12092 ret = PTR_ERR(trans);
12093 return ret;
12094 }
12095 btrfs_set_super_log_root(root->fs_info->super_copy, 0);
12096 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
12097 ret = btrfs_commit_transaction(trans, root);
12098 return ret;
12099 }
12100
12101 static int populate_csum(struct btrfs_trans_handle *trans,
12102 struct btrfs_root *csum_root, char *buf, u64 start,
12103 u64 len)
12104 {
12105 struct btrfs_fs_info *fs_info = csum_root->fs_info;
12106 u64 offset = 0;
12107 u64 sectorsize;
12108 int ret = 0;
12109
12110 while (offset < len) {
12111 sectorsize = fs_info->sectorsize;
12112 ret = read_extent_data(fs_info, buf, start + offset,
12113 &sectorsize, 0);
12114 if (ret)
12115 break;
12116 ret = btrfs_csum_file_block(trans, csum_root, start + len,
12117 start + offset, buf, sectorsize);
12118 if (ret)
12119 break;
12120 offset += sectorsize;
12121 }
12122 return ret;
12123 }
12124
12125 static int fill_csum_tree_from_one_fs_root(struct btrfs_trans_handle *trans,
12126 struct btrfs_root *csum_root,
12127 struct btrfs_root *cur_root)
12128 {
12129 struct btrfs_path path;
12130 struct btrfs_key key;
12131 struct extent_buffer *node;
12132 struct btrfs_file_extent_item *fi;
12133 char *buf = NULL;
12134 u64 start = 0;
12135 u64 len = 0;
12136 int slot = 0;
12137 int ret = 0;
12138
12139 buf = malloc(cur_root->fs_info->sectorsize);
12140 if (!buf)
12141 return -ENOMEM;
12142
12143 btrfs_init_path(&path);
12144 key.objectid = 0;
12145 key.offset = 0;
12146 key.type = 0;
12147 ret = btrfs_search_slot(NULL, cur_root, &key, &path, 0, 0);
12148 if (ret < 0)
12149 goto out;
12150 /* Iterate all regular file extents and fill its csum */
12151 while (1) {
12152 btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
12153
12154 if (key.type != BTRFS_EXTENT_DATA_KEY)
12155 goto next;
12156 node = path.nodes[0];
12157 slot = path.slots[0];
12158 fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
12159 if (btrfs_file_extent_type(node, fi) != BTRFS_FILE_EXTENT_REG)
12160 goto next;
12161 start = btrfs_file_extent_disk_bytenr(node, fi);
12162 len = btrfs_file_extent_disk_num_bytes(node, fi);
12163
12164 ret = populate_csum(trans, csum_root, buf, start, len);
12165 if (ret == -EEXIST)
12166 ret = 0;
12167 if (ret < 0)
12168 goto out;
12169 next:
12170 /*
12171 * TODO: if next leaf is corrupted, jump to nearest next valid
12172 * leaf.
12173 */
12174 ret = btrfs_next_item(cur_root, &path);
12175 if (ret < 0)
12176 goto out;
12177 if (ret > 0) {
12178 ret = 0;
12179 goto out;
12180 }
12181 }
12182
12183 out:
12184 btrfs_release_path(&path);
12185 free(buf);
12186 return ret;
12187 }
12188
12189 static int fill_csum_tree_from_fs(struct btrfs_trans_handle *trans,
12190 struct btrfs_root *csum_root)
12191 {
12192 struct btrfs_fs_info *fs_info = csum_root->fs_info;
12193 struct btrfs_path path;
12194 struct btrfs_root *tree_root = fs_info->tree_root;
12195 struct btrfs_root *cur_root;
12196 struct extent_buffer *node;
12197 struct btrfs_key key;
12198 int slot = 0;
12199 int ret = 0;
12200
12201 btrfs_init_path(&path);
12202 key.objectid = BTRFS_FS_TREE_OBJECTID;
12203 key.offset = 0;
12204 key.type = BTRFS_ROOT_ITEM_KEY;
12205 ret = btrfs_search_slot(NULL, tree_root, &key, &path, 0, 0);
12206 if (ret < 0)
12207 goto out;
12208 if (ret > 0) {
12209 ret = -ENOENT;
12210 goto out;
12211 }
12212
12213 while (1) {
12214 node = path.nodes[0];
12215 slot = path.slots[0];
12216 btrfs_item_key_to_cpu(node, &key, slot);
12217 if (key.objectid > BTRFS_LAST_FREE_OBJECTID)
12218 goto out;
12219 if (key.type != BTRFS_ROOT_ITEM_KEY)
12220 goto next;
12221 if (!is_fstree(key.objectid))
12222 goto next;
12223 key.offset = (u64)-1;
12224
12225 cur_root = btrfs_read_fs_root(fs_info, &key);
12226 if (IS_ERR(cur_root) || !cur_root) {
12227 fprintf(stderr, "Fail to read fs/subvol tree: %lld\n",
12228 key.objectid);
12229 goto out;
12230 }
12231 ret = fill_csum_tree_from_one_fs_root(trans, csum_root,
12232 cur_root);
12233 if (ret < 0)
12234 goto out;
12235 next:
12236 ret = btrfs_next_item(tree_root, &path);
12237 if (ret > 0) {
12238 ret = 0;
12239 goto out;
12240 }
12241 if (ret < 0)
12242 goto out;
12243 }
12244
12245 out:
12246 btrfs_release_path(&path);
12247 return ret;
12248 }
12249
12250 static int fill_csum_tree_from_extent(struct btrfs_trans_handle *trans,
12251 struct btrfs_root *csum_root)
12252 {
12253 struct btrfs_root *extent_root = csum_root->fs_info->extent_root;
12254 struct btrfs_path path;
12255 struct btrfs_extent_item *ei;
12256 struct extent_buffer *leaf;
12257 char *buf;
12258 struct btrfs_key key;
12259 int ret;
12260
12261 btrfs_init_path(&path);
12262 key.objectid = 0;
12263 key.type = BTRFS_EXTENT_ITEM_KEY;
12264 key.offset = 0;
12265 ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
12266 if (ret < 0) {
12267 btrfs_release_path(&path);
12268 return ret;
12269 }
12270
12271 buf = malloc(csum_root->fs_info->sectorsize);
12272 if (!buf) {
12273 btrfs_release_path(&path);
12274 return -ENOMEM;
12275 }
12276
12277 while (1) {
12278 if (path.slots[0] >= btrfs_header_nritems(path.nodes[0])) {
12279 ret = btrfs_next_leaf(extent_root, &path);
12280 if (ret < 0)
12281 break;
12282 if (ret) {
12283 ret = 0;
12284 break;
12285 }
12286 }
12287 leaf = path.nodes[0];
12288
12289 btrfs_item_key_to_cpu(leaf, &key, path.slots[0]);
12290 if (key.type != BTRFS_EXTENT_ITEM_KEY) {
12291 path.slots[0]++;
12292 continue;
12293 }
12294
12295 ei = btrfs_item_ptr(leaf, path.slots[0],
12296 struct btrfs_extent_item);
12297 if (!(btrfs_extent_flags(leaf, ei) &
12298 BTRFS_EXTENT_FLAG_DATA)) {
12299 path.slots[0]++;
12300 continue;
12301 }
12302
12303 ret = populate_csum(trans, csum_root, buf, key.objectid,
12304 key.offset);
12305 if (ret)
12306 break;
12307 path.slots[0]++;
12308 }
12309
12310 btrfs_release_path(&path);
12311 free(buf);
12312 return ret;
12313 }
12314
12315 /*
12316 * Recalculate the csum and put it into the csum tree.
12317 *
12318 * Extent tree init will wipe out all the extent info, so in that case, we
12319 * can't depend on extent tree, but use fs tree. If search_fs_tree is set, we
12320 * will use fs/subvol trees to init the csum tree.
12321 */
12322 static int fill_csum_tree(struct btrfs_trans_handle *trans,
12323 struct btrfs_root *csum_root,
12324 int search_fs_tree)
12325 {
12326 if (search_fs_tree)
12327 return fill_csum_tree_from_fs(trans, csum_root);
12328 else
12329 return fill_csum_tree_from_extent(trans, csum_root);
12330 }
12331
12332 static void free_roots_info_cache(void)
12333 {
12334 if (!roots_info_cache)
12335 return;
12336
12337 while (!cache_tree_empty(roots_info_cache)) {
12338 struct cache_extent *entry;
12339 struct root_item_info *rii;
12340
12341 entry = first_cache_extent(roots_info_cache);
12342 if (!entry)
12343 break;
12344 remove_cache_extent(roots_info_cache, entry);
12345 rii = container_of(entry, struct root_item_info, cache_extent);
12346 free(rii);
12347 }
12348
12349 free(roots_info_cache);
12350 roots_info_cache = NULL;
12351 }
12352
12353 static int build_roots_info_cache(struct btrfs_fs_info *info)
12354 {
12355 int ret = 0;
12356 struct btrfs_key key;
12357 struct extent_buffer *leaf;
12358 struct btrfs_path path;
12359
12360 if (!roots_info_cache) {
12361 roots_info_cache = malloc(sizeof(*roots_info_cache));
12362 if (!roots_info_cache)
12363 return -ENOMEM;
12364 cache_tree_init(roots_info_cache);
12365 }
12366
12367 btrfs_init_path(&path);
12368 key.objectid = 0;
12369 key.type = BTRFS_EXTENT_ITEM_KEY;
12370 key.offset = 0;
12371 ret = btrfs_search_slot(NULL, info->extent_root, &key, &path, 0, 0);
12372 if (ret < 0)
12373 goto out;
12374 leaf = path.nodes[0];
12375
12376 while (1) {
12377 struct btrfs_key found_key;
12378 struct btrfs_extent_item *ei;
12379 struct btrfs_extent_inline_ref *iref;
12380 int slot = path.slots[0];
12381 int type;
12382 u64 flags;
12383 u64 root_id;
12384 u8 level;
12385 struct cache_extent *entry;
12386 struct root_item_info *rii;
12387
12388 if (slot >= btrfs_header_nritems(leaf)) {
12389 ret = btrfs_next_leaf(info->extent_root, &path);
12390 if (ret < 0) {
12391 break;
12392 } else if (ret) {
12393 ret = 0;
12394 break;
12395 }
12396 leaf = path.nodes[0];
12397 slot = path.slots[0];
12398 }
12399
12400 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
12401
12402 if (found_key.type != BTRFS_EXTENT_ITEM_KEY &&
12403 found_key.type != BTRFS_METADATA_ITEM_KEY)
12404 goto next;
12405
12406 ei = btrfs_item_ptr(leaf, slot, struct btrfs_extent_item);
12407 flags = btrfs_extent_flags(leaf, ei);
12408
12409 if (found_key.type == BTRFS_EXTENT_ITEM_KEY &&
12410 !(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK))
12411 goto next;
12412
12413 if (found_key.type == BTRFS_METADATA_ITEM_KEY) {
12414 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
12415 level = found_key.offset;
12416 } else {
12417 struct btrfs_tree_block_info *binfo;
12418
12419 binfo = (struct btrfs_tree_block_info *)(ei + 1);
12420 iref = (struct btrfs_extent_inline_ref *)(binfo + 1);
12421 level = btrfs_tree_block_level(leaf, binfo);
12422 }
12423
12424 /*
12425 * For a root extent, it must be of the following type and the
12426 * first (and only one) iref in the item.
12427 */
12428 type = btrfs_extent_inline_ref_type(leaf, iref);
12429 if (type != BTRFS_TREE_BLOCK_REF_KEY)
12430 goto next;
12431
12432 root_id = btrfs_extent_inline_ref_offset(leaf, iref);
12433 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
12434 if (!entry) {
12435 rii = malloc(sizeof(struct root_item_info));
12436 if (!rii) {
12437 ret = -ENOMEM;
12438 goto out;
12439 }
12440 rii->cache_extent.start = root_id;
12441 rii->cache_extent.size = 1;
12442 rii->level = (u8)-1;
12443 entry = &rii->cache_extent;
12444 ret = insert_cache_extent(roots_info_cache, entry);
12445 ASSERT(ret == 0);
12446 } else {
12447 rii = container_of(entry, struct root_item_info,
12448 cache_extent);
12449 }
12450
12451 ASSERT(rii->cache_extent.start == root_id);
12452 ASSERT(rii->cache_extent.size == 1);
12453
12454 if (level > rii->level || rii->level == (u8)-1) {
12455 rii->level = level;
12456 rii->bytenr = found_key.objectid;
12457 rii->gen = btrfs_extent_generation(leaf, ei);
12458 rii->node_count = 1;
12459 } else if (level == rii->level) {
12460 rii->node_count++;
12461 }
12462 next:
12463 path.slots[0]++;
12464 }
12465
12466 out:
12467 btrfs_release_path(&path);
12468
12469 return ret;
12470 }
12471
12472 static int maybe_repair_root_item(struct btrfs_path *path,
12473 const struct btrfs_key *root_key,
12474 const int read_only_mode)
12475 {
12476 const u64 root_id = root_key->objectid;
12477 struct cache_extent *entry;
12478 struct root_item_info *rii;
12479 struct btrfs_root_item ri;
12480 unsigned long offset;
12481
12482 entry = lookup_cache_extent(roots_info_cache, root_id, 1);
12483 if (!entry) {
12484 fprintf(stderr,
12485 "Error: could not find extent items for root %llu\n",
12486 root_key->objectid);
12487 return -ENOENT;
12488 }
12489
12490 rii = container_of(entry, struct root_item_info, cache_extent);
12491 ASSERT(rii->cache_extent.start == root_id);
12492 ASSERT(rii->cache_extent.size == 1);
12493
12494 if (rii->node_count != 1) {
12495 fprintf(stderr,
12496 "Error: could not find btree root extent for root %llu\n",
12497 root_id);
12498 return -ENOENT;
12499 }
12500
12501 offset = btrfs_item_ptr_offset(path->nodes[0], path->slots[0]);
12502 read_extent_buffer(path->nodes[0], &ri, offset, sizeof(ri));
12503
12504 if (btrfs_root_bytenr(&ri) != rii->bytenr ||
12505 btrfs_root_level(&ri) != rii->level ||
12506 btrfs_root_generation(&ri) != rii->gen) {
12507
12508 /*
12509 * If we're in repair mode but our caller told us to not update
12510 * the root item, i.e. just check if it needs to be updated, don't
12511 * print this message, since the caller will call us again shortly
12512 * for the same root item without read only mode (the caller will
12513 * open a transaction first).
12514 */
12515 if (!(read_only_mode && repair))
12516 fprintf(stderr,
12517 "%sroot item for root %llu,"
12518 " current bytenr %llu, current gen %llu, current level %u,"
12519 " new bytenr %llu, new gen %llu, new level %u\n",
12520 (read_only_mode ? "" : "fixing "),
12521 root_id,
12522 btrfs_root_bytenr(&ri), btrfs_root_generation(&ri),
12523 btrfs_root_level(&ri),
12524 rii->bytenr, rii->gen, rii->level);
12525
12526 if (btrfs_root_generation(&ri) > rii->gen) {
12527 fprintf(stderr,
12528 "root %llu has a root item with a more recent gen (%llu) compared to the found root node (%llu)\n",
12529 root_id, btrfs_root_generation(&ri), rii->gen);
12530 return -EINVAL;
12531 }
12532
12533 if (!read_only_mode) {
12534 btrfs_set_root_bytenr(&ri, rii->bytenr);
12535 btrfs_set_root_level(&ri, rii->level);
12536 btrfs_set_root_generation(&ri, rii->gen);
12537 write_extent_buffer(path->nodes[0], &ri,
12538 offset, sizeof(ri));
12539 }
12540
12541 return 1;
12542 }
12543
12544 return 0;
12545 }
12546
12547 /*
12548 * A regression introduced in the 3.17 kernel (more specifically in 3.17-rc2),
12549 * caused read-only snapshots to be corrupted if they were created at a moment
12550 * when the source subvolume/snapshot had orphan items. The issue was that the
12551 * on-disk root items became incorrect, referring to the pre orphan cleanup root
12552 * node instead of the post orphan cleanup root node.
12553 * So this function, and its callees, just detects and fixes those cases. Even
12554 * though the regression was for read-only snapshots, this function applies to
12555 * any snapshot/subvolume root.
12556 * This must be run before any other repair code - not doing it so, makes other
12557 * repair code delete or modify backrefs in the extent tree for example, which
12558 * will result in an inconsistent fs after repairing the root items.
12559 */
12560 static int repair_root_items(struct btrfs_fs_info *info)
12561 {
12562 struct btrfs_path path;
12563 struct btrfs_key key;
12564 struct extent_buffer *leaf;
12565 struct btrfs_trans_handle *trans = NULL;
12566 int ret = 0;
12567 int bad_roots = 0;
12568 int need_trans = 0;
12569
12570 btrfs_init_path(&path);
12571
12572 ret = build_roots_info_cache(info);
12573 if (ret)
12574 goto out;
12575
12576 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
12577 key.type = BTRFS_ROOT_ITEM_KEY;
12578 key.offset = 0;
12579
12580 again:
12581 /*
12582 * Avoid opening and committing transactions if a leaf doesn't have
12583 * any root items that need to be fixed, so that we avoid rotating
12584 * backup roots unnecessarily.
12585 */
12586 if (need_trans) {
12587 trans = btrfs_start_transaction(info->tree_root, 1);
12588 if (IS_ERR(trans)) {
12589 ret = PTR_ERR(trans);
12590 goto out;
12591 }
12592 }
12593
12594 ret = btrfs_search_slot(trans, info->tree_root, &key, &path,
12595 0, trans ? 1 : 0);
12596 if (ret < 0)
12597 goto out;
12598 leaf = path.nodes[0];
12599
12600 while (1) {
12601 struct btrfs_key found_key;
12602
12603 if (path.slots[0] >= btrfs_header_nritems(leaf)) {
12604 int no_more_keys = find_next_key(&path, &key);
12605
12606 btrfs_release_path(&path);
12607 if (trans) {
12608 ret = btrfs_commit_transaction(trans,
12609 info->tree_root);
12610 trans = NULL;
12611 if (ret < 0)
12612 goto out;
12613 }
12614 need_trans = 0;
12615 if (no_more_keys)
12616 break;
12617 goto again;
12618 }
12619
12620 btrfs_item_key_to_cpu(leaf, &found_key, path.slots[0]);
12621
12622 if (found_key.type != BTRFS_ROOT_ITEM_KEY)
12623 goto next;
12624 if (found_key.objectid == BTRFS_TREE_RELOC_OBJECTID)
12625 goto next;
12626
12627 ret = maybe_repair_root_item(&path, &found_key, trans ? 0 : 1);
12628 if (ret < 0)
12629 goto out;
12630 if (ret) {
12631 if (!trans && repair) {
12632 need_trans = 1;
12633 key = found_key;
12634 btrfs_release_path(&path);
12635 goto again;
12636 }
12637 bad_roots++;
12638 }
12639 next:
12640 path.slots[0]++;
12641 }
12642 ret = 0;
12643 out:
12644 free_roots_info_cache();
12645 btrfs_release_path(&path);
12646 if (trans)
12647 btrfs_commit_transaction(trans, info->tree_root);
12648 if (ret < 0)
12649 return ret;
12650
12651 return bad_roots;
12652 }
12653
12654 static int clear_free_space_cache(struct btrfs_fs_info *fs_info)
12655 {
12656 struct btrfs_trans_handle *trans;
12657 struct btrfs_block_group_cache *bg_cache;
12658 u64 current = 0;
12659 int ret = 0;
12660
12661 /* Clear all free space cache inodes and its extent data */
12662 while (1) {
12663 bg_cache = btrfs_lookup_first_block_group(fs_info, current);
12664 if (!bg_cache)
12665 break;
12666 ret = btrfs_clear_free_space_cache(fs_info, bg_cache);
12667 if (ret < 0)
12668 return ret;
12669 current = bg_cache->key.objectid + bg_cache->key.offset;
12670 }
12671
12672 /* Don't forget to set cache_generation to -1 */
12673 trans = btrfs_start_transaction(fs_info->tree_root, 0);
12674 if (IS_ERR(trans)) {
12675 error("failed to update super block cache generation");
12676 return PTR_ERR(trans);
12677 }
12678 btrfs_set_super_cache_generation(fs_info->super_copy, (u64)-1);
12679 btrfs_commit_transaction(trans, fs_info->tree_root);
12680
12681 return ret;
12682 }
12683
12684 const char * const cmd_check_usage[] = {
12685 "btrfs check [options] <device>",
12686 "Check structural integrity of a filesystem (unmounted).",
12687 "Check structural integrity of an unmounted filesystem. Verify internal",
12688 "trees' consistency and item connectivity. In the repair mode try to",
12689 "fix the problems found. ",
12690 "WARNING: the repair mode is considered dangerous",
12691 "",
12692 "-s|--super <superblock> use this superblock copy",
12693 "-b|--backup use the first valid backup root copy",
12694 "--repair try to repair the filesystem",
12695 "--readonly run in read-only mode (default)",
12696 "--init-csum-tree create a new CRC tree",
12697 "--init-extent-tree create a new extent tree",
12698 "--mode <MODE> allows choice of memory/IO trade-offs",
12699 " where MODE is one of:",
12700 " original - read inodes and extents to memory (requires",
12701 " more memory, does less IO)",
12702 " lowmem - try to use less memory but read blocks again",
12703 " when needed",
12704 "--check-data-csum verify checksums of data blocks",
12705 "-Q|--qgroup-report print a report on qgroup consistency",
12706 "-E|--subvol-extents <subvolid>",
12707 " print subvolume extents and sharing state",
12708 "-r|--tree-root <bytenr> use the given bytenr for the tree root",
12709 "--chunk-root <bytenr> use the given bytenr for the chunk tree root",
12710 "-p|--progress indicate progress",
12711 "--clear-space-cache v1|v2 clear space cache for v1 or v2",
12712 NULL
12713 };
12714
12715 int cmd_check(int argc, char **argv)
12716 {
12717 struct cache_tree root_cache;
12718 struct btrfs_root *root;
12719 struct btrfs_fs_info *info;
12720 u64 bytenr = 0;
12721 u64 subvolid = 0;
12722 u64 tree_root_bytenr = 0;
12723 u64 chunk_root_bytenr = 0;
12724 char uuidbuf[BTRFS_UUID_UNPARSED_SIZE];
12725 int ret;
12726 int err = 0;
12727 u64 num;
12728 int init_csum_tree = 0;
12729 int readonly = 0;
12730 int clear_space_cache = 0;
12731 int qgroup_report = 0;
12732 int qgroups_repaired = 0;
12733 unsigned ctree_flags = OPEN_CTREE_EXCLUSIVE;
12734
12735 while(1) {
12736 int c;
12737 enum { GETOPT_VAL_REPAIR = 257, GETOPT_VAL_INIT_CSUM,
12738 GETOPT_VAL_INIT_EXTENT, GETOPT_VAL_CHECK_CSUM,
12739 GETOPT_VAL_READONLY, GETOPT_VAL_CHUNK_TREE,
12740 GETOPT_VAL_MODE, GETOPT_VAL_CLEAR_SPACE_CACHE };
12741 static const struct option long_options[] = {
12742 { "super", required_argument, NULL, 's' },
12743 { "repair", no_argument, NULL, GETOPT_VAL_REPAIR },
12744 { "readonly", no_argument, NULL, GETOPT_VAL_READONLY },
12745 { "init-csum-tree", no_argument, NULL,
12746 GETOPT_VAL_INIT_CSUM },
12747 { "init-extent-tree", no_argument, NULL,
12748 GETOPT_VAL_INIT_EXTENT },
12749 { "check-data-csum", no_argument, NULL,
12750 GETOPT_VAL_CHECK_CSUM },
12751 { "backup", no_argument, NULL, 'b' },
12752 { "subvol-extents", required_argument, NULL, 'E' },
12753 { "qgroup-report", no_argument, NULL, 'Q' },
12754 { "tree-root", required_argument, NULL, 'r' },
12755 { "chunk-root", required_argument, NULL,
12756 GETOPT_VAL_CHUNK_TREE },
12757 { "progress", no_argument, NULL, 'p' },
12758 { "mode", required_argument, NULL,
12759 GETOPT_VAL_MODE },
12760 { "clear-space-cache", required_argument, NULL,
12761 GETOPT_VAL_CLEAR_SPACE_CACHE},
12762 { NULL, 0, NULL, 0}
12763 };
12764
12765 c = getopt_long(argc, argv, "as:br:pEQ", long_options, NULL);
12766 if (c < 0)
12767 break;
12768 switch(c) {
12769 case 'a': /* ignored */ break;
12770 case 'b':
12771 ctree_flags |= OPEN_CTREE_BACKUP_ROOT;
12772 break;
12773 case 's':
12774 num = arg_strtou64(optarg);
12775 if (num >= BTRFS_SUPER_MIRROR_MAX) {
12776 error(
12777 "super mirror should be less than %d",
12778 BTRFS_SUPER_MIRROR_MAX);
12779 exit(1);
12780 }
12781 bytenr = btrfs_sb_offset(((int)num));
12782 printf("using SB copy %llu, bytenr %llu\n", num,
12783 (unsigned long long)bytenr);
12784 break;
12785 case 'Q':
12786 qgroup_report = 1;
12787 break;
12788 case 'E':
12789 subvolid = arg_strtou64(optarg);
12790 break;
12791 case 'r':
12792 tree_root_bytenr = arg_strtou64(optarg);
12793 break;
12794 case GETOPT_VAL_CHUNK_TREE:
12795 chunk_root_bytenr = arg_strtou64(optarg);
12796 break;
12797 case 'p':
12798 ctx.progress_enabled = true;
12799 break;
12800 case '?':
12801 case 'h':
12802 usage(cmd_check_usage);
12803 case GETOPT_VAL_REPAIR:
12804 printf("enabling repair mode\n");
12805 repair = 1;
12806 ctree_flags |= OPEN_CTREE_WRITES;
12807 break;
12808 case GETOPT_VAL_READONLY:
12809 readonly = 1;
12810 break;
12811 case GETOPT_VAL_INIT_CSUM:
12812 printf("Creating a new CRC tree\n");
12813 init_csum_tree = 1;
12814 repair = 1;
12815 ctree_flags |= OPEN_CTREE_WRITES;
12816 break;
12817 case GETOPT_VAL_INIT_EXTENT:
12818 init_extent_tree = 1;
12819 ctree_flags |= (OPEN_CTREE_WRITES |
12820 OPEN_CTREE_NO_BLOCK_GROUPS);
12821 repair = 1;
12822 break;
12823 case GETOPT_VAL_CHECK_CSUM:
12824 check_data_csum = 1;
12825 break;
12826 case GETOPT_VAL_MODE:
12827 check_mode = parse_check_mode(optarg);
12828 if (check_mode == CHECK_MODE_UNKNOWN) {
12829 error("unknown mode: %s", optarg);
12830 exit(1);
12831 }
12832 break;
12833 case GETOPT_VAL_CLEAR_SPACE_CACHE:
12834 if (strcmp(optarg, "v1") == 0) {
12835 clear_space_cache = 1;
12836 } else if (strcmp(optarg, "v2") == 0) {
12837 clear_space_cache = 2;
12838 ctree_flags |= OPEN_CTREE_INVALIDATE_FST;
12839 } else {
12840 error(
12841 "invalid argument to --clear-space-cache, must be v1 or v2");
12842 exit(1);
12843 }
12844 ctree_flags |= OPEN_CTREE_WRITES;
12845 break;
12846 }
12847 }
12848
12849 if (check_argc_exact(argc - optind, 1))
12850 usage(cmd_check_usage);
12851
12852 if (ctx.progress_enabled) {
12853 ctx.tp = TASK_NOTHING;
12854 ctx.info = task_init(print_status_check, print_status_return, &ctx);
12855 }
12856
12857 /* This check is the only reason for --readonly to exist */
12858 if (readonly && repair) {
12859 error("repair options are not compatible with --readonly");
12860 exit(1);
12861 }
12862
12863 /*
12864 * Not supported yet
12865 */
12866 if (repair && check_mode == CHECK_MODE_LOWMEM) {
12867 error("low memory mode doesn't support repair yet");
12868 exit(1);
12869 }
12870
12871 radix_tree_init();
12872 cache_tree_init(&root_cache);
12873
12874 if((ret = check_mounted(argv[optind])) < 0) {
12875 error("could not check mount status: %s", strerror(-ret));
12876 err |= !!ret;
12877 goto err_out;
12878 } else if(ret) {
12879 error("%s is currently mounted, aborting", argv[optind]);
12880 ret = -EBUSY;
12881 err |= !!ret;
12882 goto err_out;
12883 }
12884
12885 /* only allow partial opening under repair mode */
12886 if (repair)
12887 ctree_flags |= OPEN_CTREE_PARTIAL;
12888
12889 info = open_ctree_fs_info(argv[optind], bytenr, tree_root_bytenr,
12890 chunk_root_bytenr, ctree_flags);
12891 if (!info) {
12892 error("cannot open file system");
12893 ret = -EIO;
12894 err |= !!ret;
12895 goto err_out;
12896 }
12897
12898 global_info = info;
12899 root = info->fs_root;
12900 if (clear_space_cache == 1) {
12901 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE)) {
12902 error(
12903 "free space cache v2 detected, use --clear-space-cache v2");
12904 ret = 1;
12905 goto close_out;
12906 }
12907 printf("Clearing free space cache\n");
12908 ret = clear_free_space_cache(info);
12909 if (ret) {
12910 error("failed to clear free space cache");
12911 ret = 1;
12912 } else {
12913 printf("Free space cache cleared\n");
12914 }
12915 goto close_out;
12916 } else if (clear_space_cache == 2) {
12917 if (!btrfs_fs_compat_ro(info, FREE_SPACE_TREE)) {
12918 printf("no free space cache v2 to clear\n");
12919 ret = 0;
12920 goto close_out;
12921 }
12922 printf("Clear free space cache v2\n");
12923 ret = btrfs_clear_free_space_tree(info);
12924 if (ret) {
12925 error("failed to clear free space cache v2: %d", ret);
12926 ret = 1;
12927 } else {
12928 printf("free space cache v2 cleared\n");
12929 }
12930 goto close_out;
12931 }
12932
12933 /*
12934 * repair mode will force us to commit transaction which
12935 * will make us fail to load log tree when mounting.
12936 */
12937 if (repair && btrfs_super_log_root(info->super_copy)) {
12938 ret = ask_user("repair mode will force to clear out log tree, are you sure?");
12939 if (!ret) {
12940 ret = 1;
12941 err |= !!ret;
12942 goto close_out;
12943 }
12944 ret = zero_log_tree(root);
12945 err |= !!ret;
12946 if (ret) {
12947 error("failed to zero log tree: %d", ret);
12948 goto close_out;
12949 }
12950 }
12951
12952 uuid_unparse(info->super_copy->fsid, uuidbuf);
12953 if (qgroup_report) {
12954 printf("Print quota groups for %s\nUUID: %s\n", argv[optind],
12955 uuidbuf);
12956 ret = qgroup_verify_all(info);
12957 err |= !!ret;
12958 if (ret == 0)
12959 report_qgroups(1);
12960 goto close_out;
12961 }
12962 if (subvolid) {
12963 printf("Print extent state for subvolume %llu on %s\nUUID: %s\n",
12964 subvolid, argv[optind], uuidbuf);
12965 ret = print_extent_state(info, subvolid);
12966 err |= !!ret;
12967 goto close_out;
12968 }
12969 printf("Checking filesystem on %s\nUUID: %s\n", argv[optind], uuidbuf);
12970
12971 if (!extent_buffer_uptodate(info->tree_root->node) ||
12972 !extent_buffer_uptodate(info->dev_root->node) ||
12973 !extent_buffer_uptodate(info->chunk_root->node)) {
12974 error("critical roots corrupted, unable to check the filesystem");
12975 err |= !!ret;
12976 ret = -EIO;
12977 goto close_out;
12978 }
12979
12980 if (init_extent_tree || init_csum_tree) {
12981 struct btrfs_trans_handle *trans;
12982
12983 trans = btrfs_start_transaction(info->extent_root, 0);
12984 if (IS_ERR(trans)) {
12985 error("error starting transaction");
12986 ret = PTR_ERR(trans);
12987 err |= !!ret;
12988 goto close_out;
12989 }
12990
12991 if (init_extent_tree) {
12992 printf("Creating a new extent tree\n");
12993 ret = reinit_extent_tree(trans, info);
12994 err |= !!ret;
12995 if (ret)
12996 goto close_out;
12997 }
12998
12999 if (init_csum_tree) {
13000 printf("Reinitialize checksum tree\n");
13001 ret = btrfs_fsck_reinit_root(trans, info->csum_root, 0);
13002 if (ret) {
13003 error("checksum tree initialization failed: %d",
13004 ret);
13005 ret = -EIO;
13006 err |= !!ret;
13007 goto close_out;
13008 }
13009
13010 ret = fill_csum_tree(trans, info->csum_root,
13011 init_extent_tree);
13012 err |= !!ret;
13013 if (ret) {
13014 error("checksum tree refilling failed: %d", ret);
13015 return -EIO;
13016 }
13017 }
13018 /*
13019 * Ok now we commit and run the normal fsck, which will add
13020 * extent entries for all of the items it finds.
13021 */
13022 ret = btrfs_commit_transaction(trans, info->extent_root);
13023 err |= !!ret;
13024 if (ret)
13025 goto close_out;
13026 }
13027 if (!extent_buffer_uptodate(info->extent_root->node)) {
13028 error("critical: extent_root, unable to check the filesystem");
13029 ret = -EIO;
13030 err |= !!ret;
13031 goto close_out;
13032 }
13033 if (!extent_buffer_uptodate(info->csum_root->node)) {
13034 error("critical: csum_root, unable to check the filesystem");
13035 ret = -EIO;
13036 err |= !!ret;
13037 goto close_out;
13038 }
13039
13040 if (!ctx.progress_enabled)
13041 fprintf(stderr, "checking extents\n");
13042 if (check_mode == CHECK_MODE_LOWMEM)
13043 ret = check_chunks_and_extents_v2(root);
13044 else
13045 ret = check_chunks_and_extents(root);
13046 err |= !!ret;
13047 if (ret)
13048 error(
13049 "errors found in extent allocation tree or chunk allocation");
13050
13051 ret = repair_root_items(info);
13052 err |= !!ret;
13053 if (ret < 0) {
13054 error("failed to repair root items: %s", strerror(-ret));
13055 goto close_out;
13056 }
13057 if (repair) {
13058 fprintf(stderr, "Fixed %d roots.\n", ret);
13059 ret = 0;
13060 } else if (ret > 0) {
13061 fprintf(stderr,
13062 "Found %d roots with an outdated root item.\n",
13063 ret);
13064 fprintf(stderr,
13065 "Please run a filesystem check with the option --repair to fix them.\n");
13066 ret = 1;
13067 err |= !!ret;
13068 goto close_out;
13069 }
13070
13071 if (!ctx.progress_enabled) {
13072 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
13073 fprintf(stderr, "checking free space tree\n");
13074 else
13075 fprintf(stderr, "checking free space cache\n");
13076 }
13077 ret = check_space_cache(root);
13078 err |= !!ret;
13079 if (ret) {
13080 if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
13081 error("errors found in free space tree");
13082 else
13083 error("errors found in free space cache");
13084 goto out;
13085 }
13086
13087 /*
13088 * We used to have to have these hole extents in between our real
13089 * extents so if we don't have this flag set we need to make sure there
13090 * are no gaps in the file extents for inodes, otherwise we can just
13091 * ignore it when this happens.
13092 */
13093 no_holes = btrfs_fs_incompat(root->fs_info, NO_HOLES);
13094 if (!ctx.progress_enabled)
13095 fprintf(stderr, "checking fs roots\n");
13096 if (check_mode == CHECK_MODE_LOWMEM)
13097 ret = check_fs_roots_v2(root->fs_info);
13098 else
13099 ret = check_fs_roots(root, &root_cache);
13100 err |= !!ret;
13101 if (ret) {
13102 error("errors found in fs roots");
13103 goto out;
13104 }
13105
13106 fprintf(stderr, "checking csums\n");
13107 ret = check_csums(root);
13108 err |= !!ret;
13109 if (ret) {
13110 error("errors found in csum tree");
13111 goto out;
13112 }
13113
13114 fprintf(stderr, "checking root refs\n");
13115 /* For low memory mode, check_fs_roots_v2 handles root refs */
13116 if (check_mode != CHECK_MODE_LOWMEM) {
13117 ret = check_root_refs(root, &root_cache);
13118 err |= !!ret;
13119 if (ret) {
13120 error("errors found in root refs");
13121 goto out;
13122 }
13123 }
13124
13125 while (repair && !list_empty(&root->fs_info->recow_ebs)) {
13126 struct extent_buffer *eb;
13127
13128 eb = list_first_entry(&root->fs_info->recow_ebs,
13129 struct extent_buffer, recow);
13130 list_del_init(&eb->recow);
13131 ret = recow_extent_buffer(root, eb);
13132 err |= !!ret;
13133 if (ret) {
13134 error("fails to fix transid errors");
13135 break;
13136 }
13137 }
13138
13139 while (!list_empty(&delete_items)) {
13140 struct bad_item *bad;
13141
13142 bad = list_first_entry(&delete_items, struct bad_item, list);
13143 list_del_init(&bad->list);
13144 if (repair) {
13145 ret = delete_bad_item(root, bad);
13146 err |= !!ret;
13147 }
13148 free(bad);
13149 }
13150
13151 if (info->quota_enabled) {
13152 fprintf(stderr, "checking quota groups\n");
13153 ret = qgroup_verify_all(info);
13154 err |= !!ret;
13155 if (ret) {
13156 error("failed to check quota groups");
13157 goto out;
13158 }
13159 report_qgroups(0);
13160 ret = repair_qgroups(info, &qgroups_repaired);
13161 err |= !!ret;
13162 if (err) {
13163 error("failed to repair quota groups");
13164 goto out;
13165 }
13166 ret = 0;
13167 }
13168
13169 if (!list_empty(&root->fs_info->recow_ebs)) {
13170 error("transid errors in file system");
13171 ret = 1;
13172 err |= !!ret;
13173 }
13174 out:
13175 if (found_old_backref) { /*
13176 * there was a disk format change when mixed
13177 * backref was in testing tree. The old format
13178 * existed about one week.
13179 */
13180 printf("\n * Found old mixed backref format. "
13181 "The old format is not supported! *"
13182 "\n * Please mount the FS in readonly mode, "
13183 "backup data and re-format the FS. *\n\n");
13184 err |= 1;
13185 }
13186 printf("found %llu bytes used, ",
13187 (unsigned long long)bytes_used);
13188 if (err)
13189 printf("error(s) found\n");
13190 else
13191 printf("no error found\n");
13192 printf("total csum bytes: %llu\n",(unsigned long long)total_csum_bytes);
13193 printf("total tree bytes: %llu\n",
13194 (unsigned long long)total_btree_bytes);
13195 printf("total fs tree bytes: %llu\n",
13196 (unsigned long long)total_fs_tree_bytes);
13197 printf("total extent tree bytes: %llu\n",
13198 (unsigned long long)total_extent_tree_bytes);
13199 printf("btree space waste bytes: %llu\n",
13200 (unsigned long long)btree_space_waste);
13201 printf("file data blocks allocated: %llu\n referenced %llu\n",
13202 (unsigned long long)data_bytes_allocated,
13203 (unsigned long long)data_bytes_referenced);
13204
13205 free_qgroup_counts();
13206 free_root_recs_tree(&root_cache);
13207 close_out:
13208 close_ctree(root);
13209 err_out:
13210 if (ctx.progress_enabled)
13211 task_deinit(ctx.info);
13212
13213 return err;
13214 }
(deprecated) Btrfs progs developments and patch integration