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