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